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 "transform.h"

Data Structures
struct	IntMotionVector

struct	MotionVector

struct	Transform

struct	DeshakeContext

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	CMP(i, j)

Enumerations
enum	SearchMethod { EXHAUSTIVE, SMART_EXHAUSTIVE, SEARCH_COUNT }

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)

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.

static int	block_contrast (uint8_t *src, int x, int y, int stride, int blocksize)
	Find the contrast of a given block.

static double	block_angle (int x, int y, int cx, int cy, IntMotionVector *shift)
	Find the rotation for a given block.

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.

static av_cold int	init (AVFilterContext ctx, const char args)

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, AVFilterBufferRef 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_WIDTH ( link ) -((-link->w) >> av_pix_fmt_desc_get(link->format)->log2_chroma_w)

Definition at line 64 of file vf_deshake.c.

Referenced by filter_frame().

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

Definition at line 65 of file vf_deshake.c.

Referenced by filter_frame().

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

Definition at line 111 of file vf_deshake.c.

#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

Definition at line 112 of file vf_deshake.c.

#define CMP	(	i,
		j
	)

Value:

deshake->c.sad[0](deshake, src1 + cy * stride + cx, \
                                        src2 + (j) * stride + (i), stride, \
                                        deshake->blocksize)

Referenced by find_block_motion().

Enumeration Type Documentation

enum SearchMethod

Enumerator:

EXHAUSTIVE	Search all possible positions.
SMART_EXHAUSTIVE	Search most possible positions (faster)
SEARCH_COUNT

Definition at line 67 of file vf_deshake.c.

Function Documentation

AVFILTER_DEFINE_CLASS ( deshake )

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

static

Definition at line 137 of file vf_deshake.c.

Referenced by clean_mean().

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 145 of file vf_deshake.c.

Referenced by find_motion().

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 166 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 237 of file vf_deshake.c.

Referenced by find_motion().

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 261 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 282 of file vf_deshake.c.

Referenced by filter_frame().

static av_cold int init	(	AVFilterContext *	ctx,
		const char *	args
	)

static

Definition at line 363 of file vf_deshake.c.

static int query_formats ( AVFilterContext * ctx )

static

Definition at line 404 of file vf_deshake.c.

static int config_props ( AVFilterLink * link )

static

Definition at line 417 of file vf_deshake.c.

static av_cold void uninit ( AVFilterContext * ctx )

static

Definition at line 433 of file vf_deshake.c.

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

static

Definition at line 446 of file vf_deshake.c.

Variable Documentation

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, 64, .flags = FLAGS },
    { "ry", "set y for the rectangular search area",     OFFSET(ry), AV_OPT_TYPE_INT, {.i64=16}, 0, 64, .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 },
    { NULL }
}

Definition at line 114 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,
        .min_perms    = AV_PERM_READ | AV_PERM_PRESERVE,
    },
    { NULL }
}

Definition at line 557 of file vf_deshake.c.

const AVFilterPad deshake_outputs[]

static

Initial value:

= {
    {
        .name = "default",
        .type = AVMEDIA_TYPE_VIDEO,
    },
    { NULL }
}

Definition at line 568 of file vf_deshake.c.

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,
}

Definition at line 576 of file vf_deshake.c.

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation