From patchwork Mon Nov 28 18:19:48 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Paul B Mahol X-Patchwork-Id: 1583 Delivered-To: ffmpegpatchwork@gmail.com Received: by 10.103.90.1 with SMTP id o1csp1985169vsb; Mon, 28 Nov 2016 10:20:00 -0800 (PST) X-Received: by 10.194.66.101 with SMTP id e5mr19629231wjt.172.1480357200173; Mon, 28 Nov 2016 10:20:00 -0800 (PST) Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id az4si55714380wjb.37.2016.11.28.10.19.58; Mon, 28 Nov 2016 10:20:00 -0800 (PST) Received-SPF: pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) client-ip=79.124.17.100; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@gmail.com; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org; dmarc=fail (p=NONE dis=NONE) header.from=gmail.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id EE53F689DF2; Mon, 28 Nov 2016 20:19:50 +0200 (EET) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-wm0-f41.google.com (mail-wm0-f41.google.com [74.125.82.41]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 474D9689A5C for ; Mon, 28 Nov 2016 20:19:44 +0200 (EET) Received: by mail-wm0-f41.google.com with SMTP id t79so163623721wmt.0 for ; Mon, 28 Nov 2016 10:19:50 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=mime-version:from:date:message-id:subject:to; bh=qDgByAYKmlokJ6AGCGbWioUPkkURfSOL4on8bbmH5rI=; b=tREhqdbfvyheKf9WaVJQNgXsgtdKQb000SPsELg8nLFNyIzYTbDhOVQkZ3kPg6kJXA atYg5YZfwk6ZR0VZqx35wQYxI7Dyi0Wa7Be5IUCKs9rk06N5qjnTwCaIaG8OOjhI45cU JmBEPqAVI+eUniccLq6X1HuSQ7nfN8NJEJ5f6Bs4dsQWt4Gp7g3zEZD6wbGTVYeLa58M yMoHUXHQiLX0GkIogVexlfSKoOPOTHKoFjzLz6pJEmiFASBKjXnwwgUrCQI7Z1zY4LzA saeZUzTCpnqoE0bi/Bch0hb4VScElnEnlpVQ5gECW5Xx/gtXePirahc2hC3dfu0DoeAJ V9qw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:mime-version:from:date:message-id:subject:to; bh=qDgByAYKmlokJ6AGCGbWioUPkkURfSOL4on8bbmH5rI=; b=mvdmC27m00ZjHyb7eYVdLS4rk2fZ6I1nWT0+oEEDMl7Kw1W3SBciZjwEzT0IGGhjtL xSwSkhnNHs7ifneKfR5jsg1rLUQaEQuW2KiECtdtZP4oJtfFiMZdxmzOeRkyuCwg7OAT oS3RG7TDZpRahkg4jdhYEeYHl30qT3XMI1z9hoPMU/s54voCNaNsffXyFo8tdFZA1nKF X4Ofsur36nnkaSAB0CeqH6hEqkweV8ac1WseEanCHkHlYhUw85EIGszGwOHXbpF+KhDL C99kMCOISat/PiNc32YzDdbOp50edbmpgVgIw5xRrIQRtSdQZZPRlLlExvxQ90hbhz/3 MVLw== X-Gm-Message-State: AKaTC01zxSbseXB/2+y/g/9yXsf/Ah7LEBWyupfUeGEEkYIfsA5Qun+Ht6qpOJrbttzvE5r9QB7F8Lrldt+rzg== X-Received: by 10.28.24.74 with SMTP id 71mr20971275wmy.74.1480357189333; Mon, 28 Nov 2016 10:19:49 -0800 (PST) MIME-Version: 1.0 Received: by 10.28.48.12 with HTTP; Mon, 28 Nov 2016 10:19:48 -0800 (PST) From: Paul B Mahol Date: Mon, 28 Nov 2016 19:19:48 +0100 Message-ID: To: ffmpeg-devel@ffmpeg.org Subject: [FFmpeg-devel] [PATCH] avfilter: add premultiply filter X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" Hi, patch attached. From a5f6dad7abb279ba1d57c1b7ee68c61b7381199c Mon Sep 17 00:00:00 2001 From: Paul B Mahol Date: Mon, 28 Nov 2016 17:28:59 +0100 Subject: [PATCH] avfilter: add premultiply filter Signed-off-by: Paul B Mahol --- doc/filters.texi | 5 + libavfilter/Makefile | 1 + libavfilter/allfilters.c | 1 + libavfilter/vf_premultiply.c | 403 +++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 410 insertions(+) create mode 100644 libavfilter/vf_premultiply.c diff --git a/doc/filters.texi b/doc/filters.texi index b3899b2..4a826a1 100644 --- a/doc/filters.texi +++ b/doc/filters.texi @@ -10982,6 +10982,11 @@ Set medium thresholding (good results, default). @end table @end table +@section premultiply +Apply premultiply effect to input video stream using first plane of second stream. + +Both streams must have same dimensions and same pixel format. + @section prewitt Apply prewitt operator to input video stream. diff --git a/libavfilter/Makefile b/libavfilter/Makefile index cdddb1b..cb614c9 100644 --- a/libavfilter/Makefile +++ b/libavfilter/Makefile @@ -240,6 +240,7 @@ OBJS-$(CONFIG_PHASE_FILTER) += vf_phase.o OBJS-$(CONFIG_PIXDESCTEST_FILTER) += vf_pixdesctest.o OBJS-$(CONFIG_PP_FILTER) += vf_pp.o OBJS-$(CONFIG_PP7_FILTER) += vf_pp7.o +OBJS-$(CONFIG_PREMULTIPLY_FILTER) += vf_premultiply.o framesync.o OBJS-$(CONFIG_PREWITT_FILTER) += vf_convolution.o OBJS-$(CONFIG_PSNR_FILTER) += vf_psnr.o dualinput.o framesync.o OBJS-$(CONFIG_PULLUP_FILTER) += vf_pullup.o diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c index 82a65ee..2c37818 100644 --- a/libavfilter/allfilters.c +++ b/libavfilter/allfilters.c @@ -256,6 +256,7 @@ void avfilter_register_all(void) REGISTER_FILTER(PIXDESCTEST, pixdesctest, vf); REGISTER_FILTER(PP, pp, vf); REGISTER_FILTER(PP7, pp7, vf); + REGISTER_FILTER(PREMULTIPLY, premultiply, vf); REGISTER_FILTER(PREWITT, prewitt, vf); REGISTER_FILTER(PSNR, psnr, vf); REGISTER_FILTER(PULLUP, pullup, vf); diff --git a/libavfilter/vf_premultiply.c b/libavfilter/vf_premultiply.c new file mode 100644 index 0000000..7b74f7d --- /dev/null +++ b/libavfilter/vf_premultiply.c @@ -0,0 +1,403 @@ +/* + * Copyright (c) 2016 Paul B Mahol + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "libavutil/imgutils.h" +#include "libavutil/pixdesc.h" +#include "libavutil/opt.h" +#include "avfilter.h" +#include "formats.h" +#include "framesync.h" +#include "internal.h" +#include "video.h" + +typedef struct PreMultiplyContext { + const AVClass *class; + int width[4], height[4]; + int nb_planes; + int planes; + int half, depth, offset; + FFFrameSync fs; + + void (*premultiply[4])(const uint8_t *msrc, const uint8_t *asrc, + uint8_t *dst, + ptrdiff_t mlinesize, ptrdiff_t alinesize, + ptrdiff_t dlinesize, + int w, int h, + int half, int shift, int offset); +} PreMultiplyContext; + +#define OFFSET(x) offsetof(PreMultiplyContext, x) +#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM + +static const AVOption premultiply_options[] = { + { NULL } +}; + +AVFILTER_DEFINE_CLASS(premultiply); + +static int query_formats(AVFilterContext *ctx) +{ + static const enum AVPixelFormat pix_fmts[] = { + AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P, + AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10, + AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14, + AV_PIX_FMT_YUV444P16, + AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, + AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16, + AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16, + AV_PIX_FMT_NONE + }; + + return ff_set_common_formats(ctx, ff_make_format_list(pix_fmts)); +} + +static int process_frame(FFFrameSync *fs) +{ + AVFilterContext *ctx = fs->parent; + PreMultiplyContext *s = fs->opaque; + AVFilterLink *outlink = ctx->outputs[0]; + AVFrame *out, *base, *alpha; + int ret; + + if ((ret = ff_framesync_get_frame(&s->fs, 0, &base, 0)) < 0 || + (ret = ff_framesync_get_frame(&s->fs, 1, &alpha, 0)) < 0) + return ret; + + if (ctx->is_disabled) { + out = av_frame_clone(base); + if (!out) + return AVERROR(ENOMEM); + } else { + int p; + + out = ff_get_video_buffer(outlink, outlink->w, outlink->h); + if (!out) + return AVERROR(ENOMEM); + av_frame_copy_props(out, base); + + for (p = 0; p < s->nb_planes; p++) { + s->premultiply[p](base->data[p], alpha->data[0], + out->data[p], + base->linesize[p], alpha->linesize[0], + out->linesize[p], + s->width[p], s->height[p], + s->half, s->depth, s->offset); + } + } + out->pts = av_rescale_q(base->pts, s->fs.time_base, outlink->time_base); + + return ff_filter_frame(outlink, out); +} + +static void premultiply8(const uint8_t *msrc, const uint8_t *asrc, + uint8_t *dst, + ptrdiff_t mlinesize, ptrdiff_t alinesize, + ptrdiff_t dlinesize, + int w, int h, + int half, int shift, int offset) +{ + int x, y; + + for (y = 0; y < h; y++) { + for (x = 0; x < w; x++) { + dst[x] = ((msrc[x] * (((asrc[x] >> 1) & 1) + asrc[x])) + 128) >> 8; + } + + dst += dlinesize; + msrc += mlinesize; + asrc += alinesize; + } +} + +static void premultiply8yuv(const uint8_t *msrc, const uint8_t *asrc, + uint8_t *dst, + ptrdiff_t mlinesize, ptrdiff_t alinesize, + ptrdiff_t dlinesize, + int w, int h, + int half, int shift, int offset) +{ + int x, y; + + for (y = 0; y < h; y++) { + for (x = 0; x < w; x++) { + dst[x] = ((((msrc[x] - 128) * (((asrc[x] >> 1) & 1) + asrc[x]))) >> 8) + 128;; + } + + dst += dlinesize; + msrc += mlinesize; + asrc += alinesize; + } +} + +static void premultiply8offset(const uint8_t *msrc, const uint8_t *asrc, + uint8_t *dst, + ptrdiff_t mlinesize, ptrdiff_t alinesize, + ptrdiff_t dlinesize, + int w, int h, + int half, int shift, int offset) +{ + int x, y; + + for (y = 0; y < h; y++) { + for (x = 0; x < w; x++) { + dst[x] = ((((msrc[x] - offset) * (((asrc[x] >> 1) & 1) + asrc[x])) + 128) >> 8) + offset; + } + + dst += dlinesize; + msrc += mlinesize; + asrc += alinesize; + } +} + +static void premultiply16(const uint8_t *mmsrc, const uint8_t *aasrc, + uint8_t *ddst, + ptrdiff_t mlinesize, ptrdiff_t alinesize, + ptrdiff_t dlinesize, + int w, int h, + int half, int shift, int offset) +{ + const uint16_t *msrc = (const uint16_t *)mmsrc; + const uint16_t *asrc = (const uint16_t *)aasrc; + uint16_t *dst = (uint16_t *)ddst; + int x, y; + + for (y = 0; y < h; y++) { + for (x = 0; x < w; x++) { + dst[x] = ((msrc[x] * (((asrc[x] >> 1) & 1) + asrc[x])) + half) >> shift; + } + + dst += dlinesize / 2; + msrc += mlinesize / 2; + asrc += alinesize / 2; + } +} + +static void premultiply16yuv(const uint8_t *mmsrc, const uint8_t *aasrc, + uint8_t *ddst, + ptrdiff_t mlinesize, ptrdiff_t alinesize, + ptrdiff_t dlinesize, + int w, int h, + int half, int shift, int offset) +{ + const uint16_t *msrc = (const uint16_t *)mmsrc; + const uint16_t *asrc = (const uint16_t *)aasrc; + uint16_t *dst = (uint16_t *)ddst; + int x, y; + + for (y = 0; y < h; y++) { + for (x = 0; x < w; x++) { + dst[x] = ((((msrc[x] - half) * (((asrc[x] >> 1) & 1) + asrc[x]))) >> shift) + half;; + } + + dst += dlinesize / 2; + msrc += mlinesize / 2; + asrc += alinesize / 2; + } +} + +static void premultiply16offset(const uint8_t *mmsrc, const uint8_t *aasrc, + uint8_t *ddst, + ptrdiff_t mlinesize, ptrdiff_t alinesize, + ptrdiff_t dlinesize, + int w, int h, + int half, int shift, int offset) +{ + const uint16_t *msrc = (const uint16_t *)mmsrc; + const uint16_t *asrc = (const uint16_t *)aasrc; + uint16_t *dst = (uint16_t *)ddst; + int x, y; + + for (y = 0; y < h; y++) { + for (x = 0; x < w; x++) { + dst[x] = ((((msrc[x] - offset) * (((asrc[x] >> 1) & 1) + asrc[x])) + half) >> shift) + offset; + } + + dst += dlinesize / 2; + msrc += mlinesize / 2; + asrc += alinesize / 2; + } +} + +static int config_input(AVFilterLink *inlink) +{ + AVFilterContext *ctx = inlink->dst; + PreMultiplyContext *s = ctx->priv; + const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format); + int vsub, hsub; + + s->nb_planes = av_pix_fmt_count_planes(inlink->format); + + hsub = desc->log2_chroma_w; + vsub = desc->log2_chroma_h; + s->height[1] = s->height[2] = AV_CEIL_RSHIFT(inlink->h, vsub); + s->height[0] = s->height[3] = inlink->h; + s->width[1] = s->width[2] = AV_CEIL_RSHIFT(inlink->w, hsub); + s->width[0] = s->width[3] = inlink->w; + + s->depth = desc->comp[0].depth; + s->half = (1 << s->depth) / 2; + s->offset = 16 << (s->depth - 8); + + switch (inlink->format) { + case AV_PIX_FMT_YUV444P: + s->premultiply[0] = premultiply8offset; + s->premultiply[1] = premultiply8yuv; + s->premultiply[2] = premultiply8yuv; + break; + case AV_PIX_FMT_YUVJ444P: + s->premultiply[0] = premultiply8; + s->premultiply[1] = premultiply8yuv; + s->premultiply[2] = premultiply8yuv; + break; + case AV_PIX_FMT_GBRP: + s->premultiply[0] = premultiply8; + s->premultiply[1] = premultiply8; + s->premultiply[2] = premultiply8; + break; + case AV_PIX_FMT_YUV444P9: + case AV_PIX_FMT_YUV444P10: + case AV_PIX_FMT_YUV444P12: + case AV_PIX_FMT_YUV444P14: + case AV_PIX_FMT_YUV444P16: + s->premultiply[0] = premultiply16offset; + s->premultiply[1] = premultiply16yuv; + s->premultiply[2] = premultiply16yuv; + break; + case AV_PIX_FMT_GBRP9: + case AV_PIX_FMT_GBRP10: + case AV_PIX_FMT_GBRP12: + case AV_PIX_FMT_GBRP14: + case AV_PIX_FMT_GBRP16: + s->premultiply[0] = premultiply16; + s->premultiply[1] = premultiply16; + s->premultiply[2] = premultiply16; + break; + case AV_PIX_FMT_GRAY8: + s->premultiply[0] = premultiply8; + break; + case AV_PIX_FMT_GRAY16: + s->premultiply[0] = premultiply16; + break; + } + return 0; +} + +static int config_output(AVFilterLink *outlink) +{ + AVFilterContext *ctx = outlink->src; + PreMultiplyContext *s = ctx->priv; + AVFilterLink *base = ctx->inputs[0]; + AVFilterLink *alpha = ctx->inputs[1]; + FFFrameSyncIn *in; + int ret; + + if (base->format != alpha->format) { + av_log(ctx, AV_LOG_ERROR, "inputs must be of same pixel format\n"); + return AVERROR(EINVAL); + } + if (base->w != alpha->w || + base->h != alpha->h) { + av_log(ctx, AV_LOG_ERROR, "First input link %s parameters " + "(size %dx%d) do not match the corresponding " + "second input link %s parameters (%dx%d) ", + ctx->input_pads[0].name, base->w, base->h, + ctx->input_pads[1].name, alpha->w, alpha->h); + return AVERROR(EINVAL); + } + + outlink->w = base->w; + outlink->h = base->h; + outlink->time_base = base->time_base; + outlink->sample_aspect_ratio = base->sample_aspect_ratio; + outlink->frame_rate = base->frame_rate; + + if ((ret = ff_framesync_init(&s->fs, ctx, 2)) < 0) + return ret; + + in = s->fs.in; + in[0].time_base = base->time_base; + in[1].time_base = alpha->time_base; + in[0].sync = 1; + in[0].before = EXT_STOP; + in[0].after = EXT_INFINITY; + in[1].sync = 1; + in[1].before = EXT_STOP; + in[1].after = EXT_INFINITY; + s->fs.opaque = s; + s->fs.on_event = process_frame; + + return ff_framesync_configure(&s->fs); +} + +static int filter_frame(AVFilterLink *inlink, AVFrame *buf) +{ + PreMultiplyContext *s = inlink->dst->priv; + return ff_framesync_filter_frame(&s->fs, inlink, buf); +} + +static int request_frame(AVFilterLink *outlink) +{ + PreMultiplyContext *s = outlink->src->priv; + return ff_framesync_request_frame(&s->fs, outlink); +} + +static av_cold void uninit(AVFilterContext *ctx) +{ + PreMultiplyContext *s = ctx->priv; + + ff_framesync_uninit(&s->fs); +} + +static const AVFilterPad premultiply_inputs[] = { + { + .name = "main", + .type = AVMEDIA_TYPE_VIDEO, + .filter_frame = filter_frame, + .config_props = config_input, + }, + { + .name = "alpha", + .type = AVMEDIA_TYPE_VIDEO, + .filter_frame = filter_frame, + }, + { NULL } +}; + +static const AVFilterPad premultiply_outputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .config_props = config_output, + .request_frame = request_frame, + }, + { NULL } +}; + +AVFilter ff_vf_premultiply = { + .name = "premultiply", + .description = NULL_IF_CONFIG_SMALL("PreMultiply first stream with first plane of second stream."), + .priv_size = sizeof(PreMultiplyContext), + .uninit = uninit, + .query_formats = query_formats, + .inputs = premultiply_inputs, + .outputs = premultiply_outputs, + .priv_class = &premultiply_class, + .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL, +}; -- 2.5.0