Merge commit '4753f802c00853859b7b4b8fdb79c35e082cb7f8'
authorMichael Niedermayer <michaelni@gmx.at>
Thu, 16 May 2013 14:36:59 +0000 (16:36 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Thu, 16 May 2013 14:45:43 +0000 (16:45 +0200)
* commit '4753f802c00853859b7b4b8fdb79c35e082cb7f8':
  vf_libopencv: use the name 's' for the pointer to the private context
  vf_hqdn3d: use the name 's' for the pointer to the private context
  vf_hflip: use the name 's' for the pointer to the private context
  vf_gradfun: use the name 's' for the pointer to the private context

Conflicts:
libavfilter/vf_gradfun.c
libavfilter/vf_hflip.c
libavfilter/vf_hqdn3d.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavfilter/vf_gradfun.c
libavfilter/vf_hflip.c
libavfilter/vf_hqdn3d.c
libavfilter/vf_libopencv.c

diff --combined libavfilter/vf_gradfun.c
@@@ -2,20 -2,20 +2,20 @@@
   * Copyright (c) 2010 Nolan Lum <nol888@gmail.com>
   * Copyright (c) 2009 Loren Merritt <lorenm@u.washignton.edu>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * 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 Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -37,7 -37,6 +37,7 @@@
  #include "libavutil/cpu.h"
  #include "libavutil/opt.h"
  #include "libavutil/pixdesc.h"
 +#include "libavutil/opt.h"
  #include "avfilter.h"
  #include "formats.h"
  #include "gradfun.h"
@@@ -55,7 -54,7 +55,7 @@@ DECLARE_ALIGNED(16, static const uint16
      {0x54,0x34,0x4C,0x2C,0x52,0x32,0x4A,0x2A},
  };
  
 -void ff_gradfun_filter_line_c(uint8_t *dst, uint8_t *src, uint16_t *dc, int width, int thresh, const uint16_t *dithers)
 +void ff_gradfun_filter_line_c(uint8_t *dst, const uint8_t *src, const uint16_t *dc, int width, int thresh, const uint16_t *dithers)
  {
      int x;
      for (x = 0; x < width; dc += x & 1, x++) {
@@@ -69,7 -68,7 +69,7 @@@
      }
  }
  
 -void ff_gradfun_blur_line_c(uint16_t *dc, uint16_t *buf, uint16_t *buf1, uint8_t *src, int src_linesize, int width)
 +void ff_gradfun_blur_line_c(uint16_t *dc, uint16_t *buf, const uint16_t *buf1, const uint8_t *src, int src_linesize, int width)
  {
      int x, v, old;
      for (x = 0; x < width; x++) {
@@@ -80,7 -79,7 +80,7 @@@
      }
  }
  
 -static void filter(GradFunContext *ctx, uint8_t *dst, uint8_t *src, int width, int height, int dst_linesize, int src_linesize, int r)
 +static void filter(GradFunContext *ctx, uint8_t *dst, const uint8_t *src, int width, int height, int dst_linesize, int src_linesize, int r)
  {
      int bstride = FFALIGN(width, 16) / 2;
      int y;
  
  static av_cold int init(AVFilterContext *ctx)
  {
-     GradFunContext *gf = ctx->priv;
+     GradFunContext *s = ctx->priv;
  
-     gf->thresh  = (1 << 15) / gf->strength;
-     gf->radius  = av_clip((gf->radius + 1) & ~1, 4, 32);
+     s->thresh  = (1 << 15) / s->strength;
 -    s->radius &= ~1;
++    s->radius  = av_clip((s->radius + 1) & ~1, 4, 32);
  
-     gf->blur_line   = ff_gradfun_blur_line_c;
-     gf->filter_line = ff_gradfun_filter_line_c;
 -    s->blur_line = ff_gradfun_blur_line_c;
++    s->blur_line   = ff_gradfun_blur_line_c;
+     s->filter_line = ff_gradfun_filter_line_c;
  
      if (ARCH_X86)
-         ff_gradfun_init_x86(gf);
+         ff_gradfun_init_x86(s);
  
-     av_log(ctx, AV_LOG_VERBOSE, "threshold:%.2f radius:%d\n", gf->strength, gf->radius);
+     av_log(ctx, AV_LOG_VERBOSE, "threshold:%.2f radius:%d\n", s->strength, s->radius);
  
      return 0;
  }
  
  static av_cold void uninit(AVFilterContext *ctx)
  {
-     GradFunContext *gf = ctx->priv;
-     av_freep(&gf->buf);
+     GradFunContext *s = ctx->priv;
+     av_freep(&s->buf);
  }
  
  static int query_formats(AVFilterContext *ctx)
          AV_PIX_FMT_GRAY8,              AV_PIX_FMT_NV12,
          AV_PIX_FMT_NV21,               AV_PIX_FMT_YUV444P,
          AV_PIX_FMT_YUV422P,            AV_PIX_FMT_YUV411P,
 +        AV_PIX_FMT_YUV440P,
          AV_PIX_FMT_NONE
      };
  
  
  static int config_input(AVFilterLink *inlink)
  {
-     GradFunContext *gf = inlink->dst->priv;
+     GradFunContext *s = inlink->dst->priv;
      const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
      int hsub = desc->log2_chroma_w;
      int vsub = desc->log2_chroma_h;
  
-     gf->buf = av_mallocz((FFALIGN(inlink->w, 16) * (gf->radius + 1) / 2 + 32) * sizeof(uint16_t));
-     if (!gf->buf)
+     s->buf = av_mallocz((FFALIGN(inlink->w, 16) * (s->radius + 1) / 2 + 32) * sizeof(uint16_t));
+     if (!s->buf)
          return AVERROR(ENOMEM);
  
-     gf->chroma_w = FF_CEIL_RSHIFT(inlink->w, hsub);
-     gf->chroma_h = FF_CEIL_RSHIFT(inlink->h, vsub);
-     gf->chroma_r = av_clip(((((gf->radius >> hsub) + (gf->radius >> vsub)) / 2 ) + 1) & ~1, 4, 32);
 -    s->chroma_w = -((-inlink->w) >> hsub);
 -    s->chroma_h = -((-inlink->h) >> vsub);
++    s->chroma_w = FF_CEIL_RSHIFT(inlink->w, hsub);
++    s->chroma_h = FF_CEIL_RSHIFT(inlink->h, vsub);
+     s->chroma_r = av_clip(((((s->radius >> hsub) + (s->radius >> vsub)) / 2 ) + 1) & ~1, 4, 32);
  
      return 0;
  }
  
  static int filter_frame(AVFilterLink *inlink, AVFrame *in)
  {
-     GradFunContext *gf = inlink->dst->priv;
+     GradFunContext *s = inlink->dst->priv;
      AVFilterLink *outlink = inlink->dst->outputs[0];
      AVFrame *out;
      int p, direct;
              av_frame_free(&in);
              return AVERROR(ENOMEM);
          }
 -
          av_frame_copy_props(out, in);
 -        out->width  = outlink->w;
 -        out->height = outlink->h;
      }
  
      for (p = 0; p < 4 && in->data[p]; p++) {
          int w = inlink->w;
          int h = inlink->h;
-         int r = gf->radius;
+         int r = s->radius;
          if (p) {
-             w = gf->chroma_w;
-             h = gf->chroma_h;
-             r = gf->chroma_r;
+             w = s->chroma_w;
+             h = s->chroma_h;
+             r = s->chroma_r;
          }
  
          if (FFMIN(w, h) > 2 * r)
-             filter(gf, out->data[p], in->data[p], w, h, out->linesize[p], in->linesize[p], r);
+             filter(s, out->data[p], in->data[p], w, h, out->linesize[p], in->linesize[p], r);
          else if (out->data[p] != in->data[p])
              av_image_copy_plane(out->data[p], out->linesize[p], in->data[p], in->linesize[p], w, h);
      }
  }
  
  #define OFFSET(x) offsetof(GradFunContext, x)
 -#define FLAGS AV_OPT_FLAG_VIDEO_PARAM
 -static const AVOption options[] = {
 +#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 +
 +static const AVOption gradfun_options[] = {
      { "strength", "The maximum amount by which the filter will change any one pixel.", OFFSET(strength), AV_OPT_TYPE_FLOAT, { .dbl = 1.2 }, 0.51, 64, FLAGS },
      { "radius",   "The neighborhood to fit the gradient to.",                          OFFSET(radius),   AV_OPT_TYPE_INT,   { .i64 = 16  }, 4,    32, FLAGS },
      { NULL },
  };
  
 -static const AVClass gradfun_class = {
 -    .class_name = "gradfun",
 -    .item_name  = av_default_item_name,
 -    .option     = options,
 -    .version    = LIBAVUTIL_VERSION_INT,
 -};
 +AVFILTER_DEFINE_CLASS(gradfun);
  
  static const AVFilterPad avfilter_vf_gradfun_inputs[] = {
      {
@@@ -258,7 -263,7 +258,7 @@@ AVFilter avfilter_vf_gradfun = 
      .init          = init,
      .uninit        = uninit,
      .query_formats = query_formats,
 -
 -    .inputs    = avfilter_vf_gradfun_inputs,
 -    .outputs   = avfilter_vf_gradfun_outputs,
 +    .inputs        = avfilter_vf_gradfun_inputs,
 +    .outputs       = avfilter_vf_gradfun_outputs,
 +    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
  };
diff --combined libavfilter/vf_hflip.c
@@@ -2,20 -2,20 +2,20 @@@
   * Copyright (c) 2007 Benoit Fouet
   * Copyright (c) 2010 Stefano Sabatini
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * 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 Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -42,30 -42,44 +42,30 @@@ typedef struct 
  
  static int query_formats(AVFilterContext *ctx)
  {
 -    static const enum AVPixelFormat pix_fmts[] = {
 -        AV_PIX_FMT_RGB48BE,      AV_PIX_FMT_RGB48LE,
 -        AV_PIX_FMT_BGR48BE,      AV_PIX_FMT_BGR48LE,
 -        AV_PIX_FMT_ARGB,         AV_PIX_FMT_RGBA,
 -        AV_PIX_FMT_ABGR,         AV_PIX_FMT_BGRA,
 -        AV_PIX_FMT_RGB24,        AV_PIX_FMT_BGR24,
 -        AV_PIX_FMT_RGB565BE,     AV_PIX_FMT_RGB565LE,
 -        AV_PIX_FMT_RGB555BE,     AV_PIX_FMT_RGB555LE,
 -        AV_PIX_FMT_BGR565BE,     AV_PIX_FMT_BGR565LE,
 -        AV_PIX_FMT_BGR555BE,     AV_PIX_FMT_BGR555LE,
 -        AV_PIX_FMT_GRAY16BE,     AV_PIX_FMT_GRAY16LE,
 -        AV_PIX_FMT_YUV420P16LE,  AV_PIX_FMT_YUV420P16BE,
 -        AV_PIX_FMT_YUV422P16LE,  AV_PIX_FMT_YUV422P16BE,
 -        AV_PIX_FMT_YUV444P16LE,  AV_PIX_FMT_YUV444P16BE,
 -        AV_PIX_FMT_YUV444P,      AV_PIX_FMT_YUV422P,
 -        AV_PIX_FMT_YUV420P,      AV_PIX_FMT_YUV411P,
 -        AV_PIX_FMT_YUV410P,      AV_PIX_FMT_YUV440P,
 -        AV_PIX_FMT_YUVJ444P,     AV_PIX_FMT_YUVJ422P,
 -        AV_PIX_FMT_YUVJ420P,     AV_PIX_FMT_YUVJ440P,
 -        AV_PIX_FMT_YUVA420P,
 -        AV_PIX_FMT_RGB8,         AV_PIX_FMT_BGR8,
 -        AV_PIX_FMT_RGB4_BYTE,    AV_PIX_FMT_BGR4_BYTE,
 -        AV_PIX_FMT_PAL8,         AV_PIX_FMT_GRAY8,
 -        AV_PIX_FMT_NONE
 -    };
 -
 -    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
 +    AVFilterFormats *pix_fmts = NULL;
 +    int fmt;
 +
 +    for (fmt = 0; fmt < AV_PIX_FMT_NB; fmt++) {
 +        const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
 +        if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL ||
 +              desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ||
 +              (desc->log2_chroma_w != desc->log2_chroma_h &&
 +               desc->comp[0].plane == desc->comp[1].plane)))
 +            ff_add_format(&pix_fmts, fmt);
 +    }
 +
 +    ff_set_common_formats(ctx, pix_fmts);
      return 0;
  }
  
  static int config_props(AVFilterLink *inlink)
  {
-     FlipContext *flip = inlink->dst->priv;
+     FlipContext *s = inlink->dst->priv;
      const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(inlink->format);
  
-     av_image_fill_max_pixsteps(flip->max_step, NULL, pix_desc);
-     flip->hsub = pix_desc->log2_chroma_w;
-     flip->vsub = pix_desc->log2_chroma_h;
+     av_image_fill_max_pixsteps(s->max_step, NULL, pix_desc);
+     s->hsub = pix_desc->log2_chroma_w;
+     s->vsub = pix_desc->log2_chroma_h;
  
      return 0;
  }
  static int filter_frame(AVFilterLink *inlink, AVFrame *in)
  {
      AVFilterContext *ctx  = inlink->dst;
-     FlipContext *flip     = ctx->priv;
+     FlipContext *s     = ctx->priv;
      AVFilterLink *outlink = ctx->outputs[0];
      AVFrame *out;
      uint8_t *inrow, *outrow;
 -    int i, j, plane, step, hsub, vsub;
 +    int i, j, plane, step;
  
      out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
      if (!out) {
      }
      av_frame_copy_props(out, in);
  
 +    /* copy palette if required */
 +    if (av_pix_fmt_desc_get(inlink->format)->flags & AV_PIX_FMT_FLAG_PAL)
 +        memcpy(out->data[1], in->data[1], AVPALETTE_SIZE);
 +
      for (plane = 0; plane < 4 && in->data[plane]; plane++) {
-         const int width  = (plane == 1 || plane == 2) ? FF_CEIL_RSHIFT(inlink->w, flip->hsub) : inlink->w;
-         const int height = (plane == 1 || plane == 2) ? FF_CEIL_RSHIFT(inlink->h, flip->vsub) : inlink->h;
-         step = flip->max_step[plane];
++        const int width  = (plane == 1 || plane == 2) ? FF_CEIL_RSHIFT(inlink->w, s->hsub) : inlink->w;
++        const int height = (plane == 1 || plane == 2) ? FF_CEIL_RSHIFT(inlink->h, s->vsub) : inlink->h;
+         step = s->max_step[plane];
 -        hsub = (plane == 1 || plane == 2) ? s->hsub : 0;
 -        vsub = (plane == 1 || plane == 2) ? s->vsub : 0;
  
          outrow = out->data[plane];
 -        inrow  = in ->data[plane] + ((inlink->w >> hsub) - 1) * step;
 -        for (i = 0; i < in->height >> vsub; i++) {
 +        inrow  = in ->data[plane] + (width - 1) * step;
 +        for (i = 0; i < height; i++) {
              switch (step) {
              case 1:
 -                for (j = 0; j < (inlink->w >> hsub); j++)
 +                for (j = 0; j < width; j++)
                      outrow[j] = inrow[-j];
              break;
  
              {
                  uint16_t *outrow16 = (uint16_t *)outrow;
                  uint16_t * inrow16 = (uint16_t *) inrow;
 -                for (j = 0; j < (inlink->w >> hsub); j++)
 +                for (j = 0; j < width; j++)
                      outrow16[j] = inrow16[-j];
              }
              break;
              {
                  uint8_t *in  =  inrow;
                  uint8_t *out = outrow;
 -                for (j = 0; j < (inlink->w >> hsub); j++, out += 3, in -= 3) {
 +                for (j = 0; j < width; j++, out += 3, in -= 3) {
                      int32_t v = AV_RB24(in);
                      AV_WB24(out, v);
                  }
              {
                  uint32_t *outrow32 = (uint32_t *)outrow;
                  uint32_t * inrow32 = (uint32_t *) inrow;
 -                for (j = 0; j < (inlink->w >> hsub); j++)
 +                for (j = 0; j < width; j++)
                      outrow32[j] = inrow32[-j];
              }
              break;
  
              default:
 -                for (j = 0; j < (inlink->w >> hsub); j++)
 +                for (j = 0; j < width; j++)
                      memcpy(outrow + j*step, inrow - j*step, step);
              }
  
diff --combined libavfilter/vf_hqdn3d.c
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2010 Baptiste Coudurier
   * Copyright (c) 2012 Loren Merritt
   *
 - * This file is part of Libav, ported from MPlayer.
 + * This file is part of FFmpeg, ported from MPlayer.
   *
 - * Libav is free software; you can redistribute it and/or modify
 + * FFmpeg is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
   * the Free Software Foundation; either version 2 of the License, or
   * (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * 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 General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License along
 - * with Libav; if not, write to the Free Software Foundation, Inc.,
 + * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
   * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
   */
  
@@@ -77,7 -77,7 +77,7 @@@ static void denoise_temporal(uint8_t *s
  }
  
  av_always_inline
- static void denoise_spatial(HQDN3DContext *hqdn3d,
+ static void denoise_spatial(HQDN3DContext *s,
                              uint8_t *src, uint8_t *dst,
                              uint16_t *line_ant, uint16_t *frame_ant,
                              int w, int h, int sstride, int dstride,
          src += sstride;
          dst += dstride;
          frame_ant += w;
-         if (hqdn3d->denoise_row[depth]) {
-             hqdn3d->denoise_row[depth](src, dst, line_ant, frame_ant, w, spatial, temporal);
+         if (s->denoise_row[depth]) {
+             s->denoise_row[depth](src, dst, line_ant, frame_ant, w, spatial, temporal);
              continue;
          }
          pixel_ant = LOAD(0);
  }
  
  av_always_inline
- static void denoise_depth(HQDN3DContext *hqdn3d,
+ static void denoise_depth(HQDN3DContext *s,
                            uint8_t *src, uint8_t *dst,
                            uint16_t *line_ant, uint16_t **frame_ant_ptr,
                            int w, int h, int sstride, int dstride,
      }
  
      if (spatial[0])
-         denoise_spatial(hqdn3d, src, dst, line_ant, frame_ant,
+         denoise_spatial(s, src, dst, line_ant, frame_ant,
                          w, h, sstride, dstride, spatial, temporal, depth);
      else
          denoise_temporal(src, dst, frame_ant,
  }
  
  #define denoise(...) \
-     switch (hqdn3d->depth) {\
+     switch (s->depth) {\
          case  8: denoise_depth(__VA_ARGS__,  8); break;\
          case  9: denoise_depth(__VA_ARGS__,  9); break;\
          case 10: denoise_depth(__VA_ARGS__, 10); break;\
@@@ -184,36 -184,36 +184,36 @@@ static int16_t *precalc_coefs(double di
  
  static av_cold int init(AVFilterContext *ctx)
  {
-     HQDN3DContext *hqdn3d = ctx->priv;
+     HQDN3DContext *s = ctx->priv;
  
-     if (!hqdn3d->strength[LUMA_SPATIAL])
-         hqdn3d->strength[LUMA_SPATIAL] = PARAM1_DEFAULT;
-     if (!hqdn3d->strength[CHROMA_SPATIAL])
-         hqdn3d->strength[CHROMA_SPATIAL] = PARAM2_DEFAULT * hqdn3d->strength[LUMA_SPATIAL] / PARAM1_DEFAULT;
-     if (!hqdn3d->strength[LUMA_TMP])
-         hqdn3d->strength[LUMA_TMP]   = PARAM3_DEFAULT * hqdn3d->strength[LUMA_SPATIAL] / PARAM1_DEFAULT;
-     if (!hqdn3d->strength[CHROMA_TMP])
-         hqdn3d->strength[CHROMA_TMP] = hqdn3d->strength[LUMA_TMP] * hqdn3d->strength[CHROMA_SPATIAL] / hqdn3d->strength[LUMA_SPATIAL];
+     if (!s->strength[LUMA_SPATIAL])
+         s->strength[LUMA_SPATIAL] = PARAM1_DEFAULT;
+     if (!s->strength[CHROMA_SPATIAL])
+         s->strength[CHROMA_SPATIAL] = PARAM2_DEFAULT * s->strength[LUMA_SPATIAL] / PARAM1_DEFAULT;
+     if (!s->strength[LUMA_TMP])
+         s->strength[LUMA_TMP]   = PARAM3_DEFAULT * s->strength[LUMA_SPATIAL] / PARAM1_DEFAULT;
+     if (!s->strength[CHROMA_TMP])
+         s->strength[CHROMA_TMP] = s->strength[LUMA_TMP] * s->strength[CHROMA_SPATIAL] / s->strength[LUMA_SPATIAL];
  
      av_log(ctx, AV_LOG_VERBOSE, "ls:%f cs:%f lt:%f ct:%f\n",
-            hqdn3d->strength[LUMA_SPATIAL], hqdn3d->strength[CHROMA_SPATIAL],
-            hqdn3d->strength[LUMA_TMP], hqdn3d->strength[CHROMA_TMP]);
+            s->strength[LUMA_SPATIAL], s->strength[CHROMA_SPATIAL],
+            s->strength[LUMA_TMP], s->strength[CHROMA_TMP]);
  
      return 0;
  }
  
  static av_cold void uninit(AVFilterContext *ctx)
  {
-     HQDN3DContext *hqdn3d = ctx->priv;
-     av_freep(&hqdn3d->coefs[0]);
-     av_freep(&hqdn3d->coefs[1]);
-     av_freep(&hqdn3d->coefs[2]);
-     av_freep(&hqdn3d->coefs[3]);
-     av_freep(&hqdn3d->line);
-     av_freep(&hqdn3d->frame_prev[0]);
-     av_freep(&hqdn3d->frame_prev[1]);
-     av_freep(&hqdn3d->frame_prev[2]);
+     HQDN3DContext *s = ctx->priv;
+     av_freep(&s->coefs[0]);
+     av_freep(&s->coefs[1]);
+     av_freep(&s->coefs[2]);
+     av_freep(&s->coefs[3]);
+     av_freep(&s->line);
+     av_freep(&s->frame_prev[0]);
+     av_freep(&s->frame_prev[1]);
+     av_freep(&s->frame_prev[2]);
  }
  
  static int query_formats(AVFilterContext *ctx)
  
  static int config_input(AVFilterLink *inlink)
  {
-     HQDN3DContext *hqdn3d = inlink->dst->priv;
+     HQDN3DContext *s = inlink->dst->priv;
      const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
      int i;
  
-     hqdn3d->hsub  = desc->log2_chroma_w;
-     hqdn3d->vsub  = desc->log2_chroma_h;
-     hqdn3d->depth = desc->comp[0].depth_minus1+1;
+     s->hsub  = desc->log2_chroma_w;
+     s->vsub  = desc->log2_chroma_h;
+     s->depth = desc->comp[0].depth_minus1+1;
  
-     hqdn3d->line = av_malloc(inlink->w * sizeof(*hqdn3d->line));
-     if (!hqdn3d->line)
+     s->line = av_malloc(inlink->w * sizeof(*s->line));
+     if (!s->line)
          return AVERROR(ENOMEM);
  
      for (i = 0; i < 4; i++) {
-         hqdn3d->coefs[i] = precalc_coefs(hqdn3d->strength[i], hqdn3d->depth);
-         if (!hqdn3d->coefs[i])
+         s->coefs[i] = precalc_coefs(s->strength[i], s->depth);
+         if (!s->coefs[i])
              return AVERROR(ENOMEM);
      }
  
      if (ARCH_X86)
-         ff_hqdn3d_init_x86(hqdn3d);
+         ff_hqdn3d_init_x86(s);
  
      return 0;
  }
  
  static int filter_frame(AVFilterLink *inlink, AVFrame *in)
  {
 -    HQDN3DContext *s = inlink->dst->priv;
 -    AVFilterLink *outlink = inlink->dst->outputs[0];
 +    AVFilterContext *ctx  = inlink->dst;
-     HQDN3DContext *hqdn3d = ctx->priv;
++    HQDN3DContext *s = ctx->priv;
 +    AVFilterLink *outlink = ctx->outputs[0];
 +
      AVFrame *out;
      int direct, c;
  
 -    if (av_frame_is_writable(in)) {
 +    if (av_frame_is_writable(in) && !ctx->is_disabled) {
          direct = 1;
          out = in;
      } else {
          }
  
          av_frame_copy_props(out, in);
 -        out->width  = outlink->w;
 -        out->height = outlink->h;
      }
  
      for (c = 0; c < 3; c++) {
-         denoise(hqdn3d, in->data[c], out->data[c],
-                 hqdn3d->line, &hqdn3d->frame_prev[c],
-                 FF_CEIL_RSHIFT(in->width,  (!!c * hqdn3d->hsub)),
-                 FF_CEIL_RSHIFT(in->height, (!!c * hqdn3d->vsub)),
+         denoise(s, in->data[c], out->data[c],
+                 s->line, &s->frame_prev[c],
 -                in->width  >> (!!c * s->hsub),
 -                in->height >> (!!c * s->vsub),
++                FF_CEIL_RSHIFT(in->width,  (!!c * s->hsub)),
++                FF_CEIL_RSHIFT(in->height, (!!c * s->vsub)),
                  in->linesize[c], out->linesize[c],
-                 hqdn3d->coefs[c ? CHROMA_SPATIAL : LUMA_SPATIAL],
-                 hqdn3d->coefs[c ? CHROMA_TMP     : LUMA_TMP]);
 -                s->coefs[c?2:0], s->coefs[c?3:1]);
++                s->coefs[c ? CHROMA_SPATIAL : LUMA_SPATIAL],
++                s->coefs[c ? CHROMA_TMP     : LUMA_TMP]);
 +    }
 +
 +    if (ctx->is_disabled) {
 +        av_frame_free(&out);
 +        return ff_filter_frame(outlink, in);
      }
  
      if (!direct)
  }
  
  #define OFFSET(x) offsetof(HQDN3DContext, x)
 -#define FLAGS AV_OPT_FLAG_VIDEO_PARAM
 +#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
  static const AVOption options[] = {
      { "luma_spatial",   "spatial luma strength",    OFFSET(strength[LUMA_SPATIAL]),   AV_OPT_TYPE_DOUBLE, { .dbl = 0.0 }, 0, DBL_MAX, FLAGS },
      { "chroma_spatial", "spatial chroma strength",  OFFSET(strength[CHROMA_SPATIAL]), AV_OPT_TYPE_DOUBLE, { .dbl = 0.0 }, 0, DBL_MAX, FLAGS },
@@@ -343,7 -337,6 +343,7 @@@ static const AVFilterPad avfilter_vf_hq
      { NULL }
  };
  
 +
  static const AVFilterPad avfilter_vf_hqdn3d_outputs[] = {
      {
          .name = "default",
@@@ -363,6 -356,6 +363,6 @@@ AVFilter avfilter_vf_hqdn3d = 
      .query_formats = query_formats,
  
      .inputs    = avfilter_vf_hqdn3d_inputs,
 -
      .outputs   = avfilter_vf_hqdn3d_outputs,
 +    .flags     = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
  };
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * Copyright (c) 2010 Stefano Sabatini
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * 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 Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -86,8 -86,8 +86,8 @@@ typedef struct 
  
  static av_cold int smooth_init(AVFilterContext *ctx, const char *args)
  {
-     OCVContext *ocv = ctx->priv;
-     SmoothContext *smooth = ocv->priv;
+     OCVContext *s = ctx->priv;
+     SmoothContext *smooth = s->priv;
      char type_str[128] = "gaussian";
  
      smooth->param1 = 3;
  
  static void smooth_end_frame_filter(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
  {
-     OCVContext *ocv = ctx->priv;
-     SmoothContext *smooth = ocv->priv;
+     OCVContext *s = ctx->priv;
+     SmoothContext *smooth = s->priv;
      cvSmooth(inimg, outimg, smooth->type, smooth->param1, smooth->param2, smooth->param3, smooth->param4);
  }
  
@@@ -252,25 -252,24 +252,25 @@@ typedef struct 
  
  static av_cold int dilate_init(AVFilterContext *ctx, const char *args)
  {
-     OCVContext *ocv = ctx->priv;
-     DilateContext *dilate = ocv->priv;
+     OCVContext *s = ctx->priv;
+     DilateContext *dilate = s->priv;
      char default_kernel_str[] = "3x3+0x0/rect";
      char *kernel_str;
      const char *buf = args;
      int ret;
  
 -    dilate->nb_iterations = 1;
 -
      if (args)
          kernel_str = av_get_token(&buf, "|");
 -    if ((ret = parse_iplconvkernel(&dilate->kernel,
 -                                   *kernel_str ? kernel_str : default_kernel_str,
 -                                   ctx)) < 0)
 +    else
 +        kernel_str = av_strdup(default_kernel_str);
 +    if (!kernel_str)
 +        return AVERROR(ENOMEM);
 +    if ((ret = parse_iplconvkernel(&dilate->kernel, kernel_str, ctx)) < 0)
          return ret;
      av_free(kernel_str);
  
 -    sscanf(buf, "|%d", &dilate->nb_iterations);
 +    if (!buf || sscanf(buf, "|%d", &dilate->nb_iterations) != 1)
 +        dilate->nb_iterations = 1;
      av_log(ctx, AV_LOG_VERBOSE, "iterations_nb:%d\n", dilate->nb_iterations);
      if (dilate->nb_iterations <= 0) {
          av_log(ctx, AV_LOG_ERROR, "Invalid non-positive value '%d' for nb_iterations\n",
  
  static av_cold void dilate_uninit(AVFilterContext *ctx)
  {
-     OCVContext *ocv = ctx->priv;
-     DilateContext *dilate = ocv->priv;
+     OCVContext *s = ctx->priv;
+     DilateContext *dilate = s->priv;
  
      cvReleaseStructuringElement(&dilate->kernel);
  }
  
  static void dilate_end_frame_filter(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
  {
-     OCVContext *ocv = ctx->priv;
-     DilateContext *dilate = ocv->priv;
+     OCVContext *s = ctx->priv;
+     DilateContext *dilate = s->priv;
      cvDilate(inimg, outimg, dilate->kernel, dilate->nb_iterations);
  }
  
  static void erode_end_frame_filter(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
  {
-     OCVContext *ocv = ctx->priv;
-     DilateContext *dilate = ocv->priv;
+     OCVContext *s = ctx->priv;
+     DilateContext *dilate = s->priv;
      cvErode(inimg, outimg, dilate->kernel, dilate->nb_iterations);
  }
  
@@@ -318,43 -317,39 +318,43 @@@ static OCVFilterEntry ocv_filter_entrie
  
  static av_cold int init(AVFilterContext *ctx)
  {
-     OCVContext *ocv = ctx->priv;
+     OCVContext *s = ctx->priv;
      int i;
  
-     if (!ocv->name) {
++    if (!s->name) {
 +        av_log(ctx, AV_LOG_ERROR, "No libopencv filter name specified\n");
 +        return AVERROR(EINVAL);
 +    }
      for (i = 0; i < FF_ARRAY_ELEMS(ocv_filter_entries); i++) {
          OCVFilterEntry *entry = &ocv_filter_entries[i];
-         if (!strcmp(ocv->name, entry->name)) {
-             ocv->init             = entry->init;
-             ocv->uninit           = entry->uninit;
-             ocv->end_frame_filter = entry->end_frame_filter;
+         if (!strcmp(s->name, entry->name)) {
+             s->init             = entry->init;
+             s->uninit           = entry->uninit;
+             s->end_frame_filter = entry->end_frame_filter;
  
-             if (!(ocv->priv = av_mallocz(entry->priv_size)))
+             if (!(s->priv = av_mallocz(entry->priv_size)))
                  return AVERROR(ENOMEM);
-             return ocv->init(ctx, ocv->params);
+             return s->init(ctx, s->params);
          }
      }
  
-     av_log(ctx, AV_LOG_ERROR, "No libopencv filter named '%s'\n", ocv->name);
+     av_log(ctx, AV_LOG_ERROR, "No libopencv filter named '%s'\n", s->name);
      return AVERROR(EINVAL);
  }
  
  static av_cold void uninit(AVFilterContext *ctx)
  {
-     OCVContext *ocv = ctx->priv;
+     OCVContext *s = ctx->priv;
  
-     if (ocv->uninit)
-         ocv->uninit(ctx);
-     av_free(ocv->priv);
+     if (s->uninit)
+         s->uninit(ctx);
+     av_free(s->priv);
  }
  
  static int filter_frame(AVFilterLink *inlink, AVFrame *in)
  {
      AVFilterContext *ctx = inlink->dst;
-     OCVContext *ocv = ctx->priv;
+     OCVContext *s = ctx->priv;
      AVFilterLink *outlink= inlink->dst->outputs[0];
      AVFrame *out;
      IplImage inimg, outimg;
  
      fill_iplimage_from_frame(&inimg , in , inlink->format);
      fill_iplimage_from_frame(&outimg, out, inlink->format);
-     ocv->end_frame_filter(ctx, &inimg, &outimg);
+     s->end_frame_filter(ctx, &inimg, &outimg);
      fill_frame_from_iplimage(out, &outimg, inlink->format);
  
      av_frame_free(&in);
  }
  
  #define OFFSET(x) offsetof(OCVContext, x)
 -#define FLAGS AV_OPT_FLAG_VIDEO_PARAM
 +#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
  static const AVOption options[] = {
      { "filter_name",   NULL, OFFSET(name),   AV_OPT_TYPE_STRING, .flags = FLAGS },
      { "filter_params", NULL, OFFSET(params), AV_OPT_TYPE_STRING, .flags = FLAGS },