Macros | Functions | Variables
vf_deshake.c File Reference

fast deshake / depan video filter More...

#include "avfilter.h"
#include "formats.h"
#include "internal.h"
#include "video.h"
#include "libavutil/common.h"
#include "libavutil/mem.h"
#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"
#include "libavcodec/dsputil.h"
#include "deshake.h"
#include "deshake_opencl.h"
Include dependency graph for vf_deshake.c:

Go to the source code of this file.

Macros

#define CHROMA_WIDTH(link)   -((-link->w) >> av_pix_fmt_desc_get(link->format)->log2_chroma_w)
 
#define CHROMA_HEIGHT(link)   -((-link->h) >> av_pix_fmt_desc_get(link->format)->log2_chroma_h)
 
#define OFFSET(x)   offsetof(DeshakeContext, x)
 
#define FLAGS   AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 
#define MAX_R   64
 
#define CMP(i, j)
 

Functions

 AVFILTER_DEFINE_CLASS (deshake)
 
static int cmp (const double *a, const double *b)
 
static double clean_mean (double *values, int count)
 Cleaned mean (cuts off 20% of values to remove outliers and then averages) More...
 
static void find_block_motion (DeshakeContext *deshake, uint8_t *src1, uint8_t *src2, int cx, int cy, int stride, IntMotionVector *mv)
 Find the most likely shift in motion between two frames for a given macroblock. More...
 
static int block_contrast (uint8_t *src, int x, int y, int stride, int blocksize)
 Find the contrast of a given block. More...
 
static double block_angle (int x, int y, int cx, int cy, IntMotionVector *shift)
 Find the rotation for a given block. More...
 
static void find_motion (DeshakeContext *deshake, uint8_t *src1, uint8_t *src2, int width, int height, int stride, Transform *t)
 Find the estimated global motion for a scene given the most likely shift for each block in the frame. More...
 
static int deshake_transform_c (AVFilterContext *ctx, int width, int height, int cw, int ch, const float *matrix_y, const float *matrix_uv, enum InterpolateMethod interpolate, enum FillMethod fill, AVFrame *in, AVFrame *out)
 
static av_cold int init (AVFilterContext *ctx)
 
static int query_formats (AVFilterContext *ctx)
 
static int config_props (AVFilterLink *link)
 
static av_cold void uninit (AVFilterContext *ctx)
 
static int filter_frame (AVFilterLink *link, AVFrame *in)
 

Variables

static const AVOption deshake_options []
 
static const AVFilterPad deshake_inputs []
 
static const AVFilterPad deshake_outputs []
 
AVFilter avfilter_vf_deshake
 

Detailed Description

fast deshake / depan video filter

SAD block-matching motion compensation to fix small changes in horizontal and/or vertical shift. This filter helps remove camera shake from hand-holding a camera, bumping a tripod, moving on a vehicle, etc.

Algorithm:

  • For each frame with one previous reference frame
    • For each block in the frame
      • If contrast > threshold then find likely motion vector
    • For all found motion vectors
      • Find most common, store as global motion vector
    • Find most likely rotation angle
    • Transform image along global motion

TODO:

  • Fill frame edges based on previous/next reference frames
  • Fill frame edges by stretching image near the edges?
    • Can this be done quickly and look decent?

Dark Shikari links to http://wiki.videolan.org/SoC_x264_2010#GPU_Motion_Estimation_2 for an algorithm similar to what could be used here to get the gmv It requires only a couple diamond searches + fast downscaling

Special thanks to Jason Kotenko for his help with the algorithm and my inability to see simple errors in C code.

Definition in file vf_deshake.c.

Macro Definition Documentation

#define CHROMA_HEIGHT (   link)    -((-link->h) >> av_pix_fmt_desc_get(link->format)->log2_chroma_h)

Definition at line 66 of file vf_deshake.c.

Referenced by filter_frame().

#define CHROMA_WIDTH (   link)    -((-link->w) >> av_pix_fmt_desc_get(link->format)->log2_chroma_w)

Definition at line 65 of file vf_deshake.c.

Referenced by filter_frame().

#define CMP (   i,
  j 
)
Value:
deshake->c.sad[0](deshake, src1 + cy * stride + cx, \
src2 + (j) * stride + (i), stride, \
deshake->blocksize)
stride
int stride
Definition: mace.c:144
i
synthesis window for stochastic i
Definition: code Kat/hpsmodel.m:34

Referenced by find_block_motion().

#define FLAGS   AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

Definition at line 69 of file vf_deshake.c.

#define MAX_R   64

Definition at line 71 of file vf_deshake.c.

Referenced by find_motion().

#define OFFSET (   x)    offsetof(DeshakeContext, x)

Definition at line 68 of file vf_deshake.c.

Function Documentation

AVFILTER_DEFINE_CLASS ( deshake  )
static double block_angle ( int  x,
int  y,
int  cx,
int  cy,
IntMotionVector *  shift 
)
static

Find the rotation for a given block.

Definition at line 221 of file vf_deshake.c.

Referenced by find_motion().

static int block_contrast ( uint8_t *  src,
int  x,
int  y,
int  stride,
int  blocksize 
)
static

Find the contrast of a given block.

When searching for global motion we really only care about the high contrast blocks, so using this method we can actually skip blocks we don't care much about.

Definition at line 197 of file vf_deshake.c.

Referenced by find_motion().

static double clean_mean ( double *  values,
int  count 
)
static

Cleaned mean (cuts off 20% of values to remove outliers and then averages)

Definition at line 105 of file vf_deshake.c.

Referenced by find_motion().

static int cmp ( const double *  a,
const double *  b 
)
static

Definition at line 97 of file vf_deshake.c.

Referenced by clean_mean().

static int config_props ( AVFilterLink *  link)
static

Definition at line 401 of file vf_deshake.c.

static int deshake_transform_c ( AVFilterContext *  ctx,
int  width,
int  height,
int  cw,
int  ch,
const float *  matrix_y,
const float *  matrix_uv,
enum InterpolateMethod  interpolate,
enum FillMethod  fill,
AVFrame *  in,
AVFrame *  out 
)
static

Definition at line 323 of file vf_deshake.c.

Referenced by init().

static int filter_frame ( AVFilterLink *  link,
AVFrame *  in 
)
static

Definition at line 431 of file vf_deshake.c.

static void find_block_motion ( DeshakeContext *  deshake,
uint8_t *  src1,
uint8_t *  src2,
int  cx,
int  cy,
int  stride,
IntMotionVector *  mv 
)
static

Find the most likely shift in motion between two frames for a given macroblock.

Test each block against several shifts given by the rx and ry attributes. Searches using a simple matrix of those shifts and chooses the most likely shift by the smallest difference in blocks.

Definition at line 126 of file vf_deshake.c.

Referenced by find_motion().

static void find_motion ( DeshakeContext *  deshake,
uint8_t *  src1,
uint8_t *  src2,
int  width,
int  height,
int  stride,
Transform *  t 
)
static

Find the estimated global motion for a scene given the most likely shift for each block in the frame.

The global motion is estimated to be the same as the motion from most blocks in the frame, so if most blocks move one pixel to the right and two pixels down, this would yield a motion vector (1, -2).

Definition at line 242 of file vf_deshake.c.

Referenced by filter_frame().

static av_cold int init ( AVFilterContext *  ctx)
static

Definition at line 349 of file vf_deshake.c.

static int query_formats ( AVFilterContext *  ctx)
static

Definition at line 388 of file vf_deshake.c.

static av_cold void uninit ( AVFilterContext *  ctx)
static

Definition at line 417 of file vf_deshake.c.

Variable Documentation

AVFilter avfilter_vf_deshake
Initial value:
= {
.name = "deshake",
.description = NULL_IF_CONFIG_SMALL("Stabilize shaky video."),
.priv_size = sizeof(DeshakeContext),
.init = init,
.uninit = uninit,
.query_formats = query_formats,
.inputs = deshake_inputs,
.outputs = deshake_outputs,
.priv_class = &deshake_class,
}
outputs
static const AVFilterPad outputs[]
Definition: af_ashowinfo.c:117
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: libavutil/internal.h:123
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_deshake.c:388
deshake_inputs
static const AVFilterPad deshake_inputs[]
Definition: vf_deshake.c:547
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_deshake.c:349
deshake_outputs
static const AVFilterPad deshake_outputs[]
Definition: vf_deshake.c:557
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:216
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_deshake.c:417

Definition at line 565 of file vf_deshake.c.

const AVFilterPad deshake_inputs[]
static
Initial value:
= {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
.filter_frame = filter_frame,
.config_props = config_props,
},
{ NULL }
}
filter_frame
static int filter_frame(AVFilterLink *link, AVFrame *in)
Definition: vf_deshake.c:431
NULL
NULL
Definition: eval.c:55
config_props
static int config_props(AVFilterLink *link)
Definition: vf_deshake.c:401
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:143

Definition at line 547 of file vf_deshake.c.

const AVOption deshake_options[]
static
Initial value:
= {
{ "x", "set x for the rectangular search area", OFFSET(cx), AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX, .flags = FLAGS },
{ "y", "set y for the rectangular search area", OFFSET(cy), AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX, .flags = FLAGS },
{ "w", "set width for the rectangular search area", OFFSET(cw), AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX, .flags = FLAGS },
{ "h", "set height for the rectangular search area", OFFSET(ch), AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX, .flags = FLAGS },
{ "rx", "set x for the rectangular search area", OFFSET(rx), AV_OPT_TYPE_INT, {.i64=16}, 0, MAX_R, .flags = FLAGS },
{ "ry", "set y for the rectangular search area", OFFSET(ry), AV_OPT_TYPE_INT, {.i64=16}, 0, MAX_R, .flags = FLAGS },
{ "edge", "set edge mode", OFFSET(edge), AV_OPT_TYPE_INT, {.i64=FILL_MIRROR}, FILL_BLANK, FILL_COUNT-1, FLAGS, "edge"},
{ "blank", "fill zeroes at blank locations", 0, AV_OPT_TYPE_CONST, {.i64=FILL_BLANK}, INT_MIN, INT_MAX, FLAGS, "edge" },
{ "original", "original image at blank locations", 0, AV_OPT_TYPE_CONST, {.i64=FILL_ORIGINAL}, INT_MIN, INT_MAX, FLAGS, "edge" },
{ "clamp", "extruded edge value at blank locations", 0, AV_OPT_TYPE_CONST, {.i64=FILL_CLAMP}, INT_MIN, INT_MAX, FLAGS, "edge" },
{ "mirror", "mirrored edge at blank locations", 0, AV_OPT_TYPE_CONST, {.i64=FILL_MIRROR}, INT_MIN, INT_MAX, FLAGS, "edge" },
{ "blocksize", "set motion search blocksize", OFFSET(blocksize), AV_OPT_TYPE_INT, {.i64=8}, 4, 128, .flags = FLAGS },
{ "contrast", "set contrast threshold for blocks", OFFSET(contrast), AV_OPT_TYPE_INT, {.i64=125}, 1, 255, .flags = FLAGS },
{ "search", "set search strategy", OFFSET(search), AV_OPT_TYPE_INT, {.i64=EXHAUSTIVE}, EXHAUSTIVE, SEARCH_COUNT-1, FLAGS, "smode" },
{ "exhaustive", "exhaustive search", 0, AV_OPT_TYPE_CONST, {.i64=EXHAUSTIVE}, INT_MIN, INT_MAX, FLAGS, "smode" },
{ "less", "less exhaustive search", 0, AV_OPT_TYPE_CONST, {.i64=SMART_EXHAUSTIVE}, INT_MIN, INT_MAX, FLAGS, "smode" },
{ "filename", "set motion search detailed log file name", OFFSET(filename), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },
{ "opencl", "use OpenCL filtering capabilities", OFFSET(opencl), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, .flags = FLAGS },
{ NULL }
}
OFFSET
#define OFFSET(x)
Definition: vf_deshake.c:68
FLAGS
#define FLAGS
Definition: vf_deshake.c:69
AV_OPT_TYPE_INT
Definition: opt.h:222
AV_OPT_TYPE_CONST
Definition: opt.h:229
AV_OPT_TYPE_STRING
Definition: opt.h:226
MAX_R
#define MAX_R
Definition: vf_deshake.c:71
EXHAUSTIVE
Search all possible positions.
Definition: deshake.h:34
NULL
NULL
Definition: eval.c:55
SMART_EXHAUSTIVE
Search most possible positions (faster)
Definition: deshake.h:35

Definition at line 73 of file vf_deshake.c.

const AVFilterPad deshake_outputs[]
static
Initial value:
= {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
{ NULL }
}
NULL
NULL
Definition: eval.c:55
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:143

Definition at line 557 of file vf_deshake.c.

Generated on Wed May 8 2024 06:52:21 for FFmpeg by   doxygen 1.8.11