vf_shufflepixels.c File Reference

#include "libavutil/avassert.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/imgutils.h"
#include "libavutil/lfg.h"
#include "libavutil/mem.h"
#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"
#include "libavutil/random_seed.h"
#include "avfilter.h"
#include "filters.h"
#include "video.h"

Go to the source code of this file.

Data Structures
struct	ShufflePixelsContext
struct	ThreadData
	Used for passing data between threads. More...

Macros
#define	SHUFFLE_HORIZONTAL(name, type)
#define	SHUFFLE_VERTICAL(name, type)
#define	SHUFFLE_BLOCK(name, type)
#define	OFFSET(x)
#define	FLAGS   (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)

Functions
static void	make_horizontal_map (AVFilterContext *ctx)
static void	make_vertical_map (AVFilterContext *ctx)
static void	make_block_map (AVFilterContext *ctx)
static int	config_output (AVFilterLink *outlink)
static int	filter_frame (AVFilterLink *inlink, AVFrame *in)
static av_cold void	uninit (AVFilterContext *ctx)
	AVFILTER_DEFINE_CLASS (shufflepixels)

Variables
static enum AVPixelFormat	pix_fmts []
static const AVOption	shufflepixels_options []
static const AVFilterPad	shufflepixels_inputs []
static const AVFilterPad	shufflepixels_outputs []
const FFFilter	ff_vf_shufflepixels

Macro Definition Documentation

SHUFFLE_HORIZONTAL

#define SHUFFLE_HORIZONTAL	(		name,
			type )

Value:

static int shuffle_horizontal## name(AVFilterContext *ctx, void *arg,        \
                                     int jobnr, int nb_jobs)                 \
{                                                                            \
    ShufflePixelsContext *s = ctx->priv;                                     \
    ThreadData *td = arg;                                                    \
    AVFrame *in = td->in;                                                    \
    AVFrame *out = td->out;                                                  \
                                                                             \
    for (int p = 0; p < s->nb_planes; p++) {                                 \
        const int slice_start = ff_slice_pos(s->planeheight[p], jobnr, nb_jobs); \
        const int slice_end = ff_slice_pos(s->planeheight[p], jobnr + 1, nb_jobs); \
        type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
        const type *src = (const type *)(in->data[p] +                       \
                                         slice_start * in->linesize[p]);     \
        const int32_t *map = s->map;                                         \
                                                                             \
        for (int y = slice_start; y < slice_end; y++) {                      \
            for (int x = 0; x < s->planewidth[p]; x++) {                     \
                dst[x] = src[map[x]];                                        \
            }                                                                \
                                                                             \
            dst += out->linesize[p] / sizeof(type);                          \
            src += in->linesize[p] / sizeof(type);                           \
        }                                                                    \
    }                                                                        \
                                                                             \
    return 0;                                                                \
}

Definition at line 197 of file vf_shufflepixels.c.

SHUFFLE_VERTICAL

#define SHUFFLE_VERTICAL	(		name,
			type )

Value:

static int shuffle_vertical## name(AVFilterContext *ctx, void *arg,          \
                            int jobnr, int nb_jobs)                          \
{                                                                            \
    ShufflePixelsContext *s = ctx->priv;                                     \
    ThreadData *td = arg;                                                    \
    AVFrame *in = td->in;                                                    \
    AVFrame *out = td->out;                                                  \
                                                                             \
    for (int p = 0; p < s->nb_planes; p++) {                                 \
        const int slice_start = ff_slice_pos(s->planeheight[p], jobnr, nb_jobs); \
        const int slice_end = ff_slice_pos(s->planeheight[p], jobnr + 1, nb_jobs); \
        type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
        const int32_t *map = s->map;                                         \
                                                                             \
        for (int y = slice_start; y < slice_end; y++) {                      \
            const type *src = (const type *)(in->data[p] +                   \
                                             map[y] * in->linesize[p]);      \
                                                                             \
            memcpy(dst, src, s->linesize[p]);                                \
            dst += out->linesize[p] / sizeof(type);                          \
        }                                                                    \
    }                                                                        \
                                                                             \
    return 0;                                                                \
}

Definition at line 230 of file vf_shufflepixels.c.

SHUFFLE_BLOCK

#define SHUFFLE_BLOCK	(		name,
			type )

Value:

static int shuffle_block## name(AVFilterContext *ctx, void *arg,             \
                         int jobnr, int nb_jobs)                             \
{                                                                            \
    ShufflePixelsContext *s = ctx->priv;                                     \
    ThreadData *td = arg;                                                    \
    AVFrame *in = td->in;                                                    \
    AVFrame *out = td->out;                                                  \
                                                                             \
    for (int p = 0; p < s->nb_planes; p++) {                                 \
        const int slice_start = ff_slice_pos(s->planeheight[p], jobnr, nb_jobs); \
        const int slice_end = ff_slice_pos(s->planeheight[p], jobnr + 1, nb_jobs); \
        type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
        const type *src = (const type *)in->data[p];                         \
        const int32_t *map = s->map + slice_start * s->planewidth[p];        \
                                                                             \
        for (int y = slice_start; y < slice_end; y++) {                      \
            for (int x = 0; x < s->planewidth[p]; x++) {                     \
                int ymap = map[x] / s->planewidth[p];                        \
                int xmap = map[x] % s->planewidth[p];                        \
                                                                             \
                dst[x] = src[xmap + ymap * in->linesize[p] / sizeof(type)];  \
            }                                                                \
                                                                             \
            dst += out->linesize[p] / sizeof(type);                          \
            map += s->planewidth[p];                                         \
        }                                                                    \
    }                                                                        \
                                                                             \
    return 0;                                                                \
}

Definition at line 260 of file vf_shufflepixels.c.

OFFSET

#define OFFSET

(

x

)

Value:

offsetof(ShufflePixelsContext, x)

Definition at line 404 of file vf_shufflepixels.c.

FLAGS

#define FLAGS   (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)

Definition at line 405 of file vf_shufflepixels.c.

Function Documentation

make_horizontal_map()

static void make_horizontal_map ( AVFilterContext * ctx )

static

Definition at line 70 of file vf_shufflepixels.c.

Referenced by config_output().

make_vertical_map()

static void make_vertical_map ( AVFilterContext * ctx )

static

Definition at line 108 of file vf_shufflepixels.c.

Referenced by config_output().

make_block_map()

static void make_block_map ( AVFilterContext * ctx )

static

Definition at line 146 of file vf_shufflepixels.c.

Referenced by config_output().

config_output()

static int config_output ( AVFilterLink * outlink )

static

Definition at line 295 of file vf_shufflepixels.c.

filter_frame()

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

static

Definition at line 365 of file vf_shufflepixels.c.

uninit()

static av_cold void uninit ( AVFilterContext * ctx )

static

Definition at line 396 of file vf_shufflepixels.c.

AVFILTER_DEFINE_CLASS()

AVFILTER_DEFINE_CLASS

(

shufflepixels

)

Variable Documentation

pix_fmts

enum AVPixelFormat pix_fmts[]

static

Initial value:

= {
    AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
    AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P,
    AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,
    AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
    AV_PIX_FMT_GBRAP16, AV_PIX_FMT_GBRAP,
    AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUVA444P10,
    AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUVA444P16,
    AV_PIX_FMT_NONE
}

Definition at line 59 of file vf_shufflepixels.c.

shufflepixels_options

const AVOption shufflepixels_options[]

static

Initial value:

= {
    { "direction",  "set shuffle direction",  OFFSET(direction), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, .unit = "dir" },
    { "d",          "set shuffle direction",  OFFSET(direction), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, .unit = "dir" },
    {  "forward",    0,  0,  AV_OPT_TYPE_CONST,     {.i64=0}, 0,  0, FLAGS, .unit = "dir" },
    {  "inverse",    0,  0,  AV_OPT_TYPE_CONST,     {.i64=1}, 0,  0, FLAGS, .unit = "dir" },
    { "mode",       "set shuffle mode",  OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, FLAGS, .unit = "mode" },
    { "m",          "set shuffle mode",  OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, FLAGS, .unit = "mode" },
    {  "horizontal",  0,  0,  AV_OPT_TYPE_CONST,     {.i64=0}, 0,  0, FLAGS, .unit = "mode" },
    {  "vertical",    0,  0,  AV_OPT_TYPE_CONST,     {.i64=1}, 0,  0, FLAGS, .unit = "mode" },
    {  "block",       0,  0,  AV_OPT_TYPE_CONST,     {.i64=2}, 0,  0, FLAGS, .unit = "mode" },
    { "width",      "set block width",  OFFSET(block_w), AV_OPT_TYPE_INT, {.i64=10}, 1, 8000, FLAGS },
    { "w",          "set block width",  OFFSET(block_w), AV_OPT_TYPE_INT, {.i64=10}, 1, 8000, FLAGS },
    { "height",     "set block height", OFFSET(block_h), AV_OPT_TYPE_INT, {.i64=10}, 1, 8000, FLAGS },
    { "h",          "set block height", OFFSET(block_h), AV_OPT_TYPE_INT, {.i64=10}, 1, 8000, FLAGS },
    { "seed",       "set random seed",  OFFSET(seed),   AV_OPT_TYPE_INT64, {.i64=-1}, -1, UINT_MAX, FLAGS },
    { "s",          "set random seed",  OFFSET(seed),   AV_OPT_TYPE_INT64, {.i64=-1}, -1, UINT_MAX, FLAGS },
    { NULL },
}

Definition at line 406 of file vf_shufflepixels.c.

shufflepixels_inputs

const AVFilterPad shufflepixels_inputs[]

static

Initial value:

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

Definition at line 427 of file vf_shufflepixels.c.

shufflepixels_outputs

const AVFilterPad shufflepixels_outputs[]

static

Initial value:

= {
    {
        .name          = "default",
        .type          = AVMEDIA_TYPE_VIDEO,
        .config_props  = config_output,
    },
}

Definition at line 435 of file vf_shufflepixels.c.

ff_vf_shufflepixels

const FFFilter ff_vf_shufflepixels

Initial value:

= {
    .p.name        = "shufflepixels",
    .p.description = NULL_IF_CONFIG_SMALL("Shuffle video pixels."),
    .p.priv_class  = &shufflepixels_class,
    .p.flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
    .priv_size     = sizeof(ShufflePixelsContext),
    .uninit        = uninit,
    FILTER_INPUTS(shufflepixels_inputs),
    FILTER_OUTPUTS(shufflepixels_outputs),
    FILTER_PIXFMTS_ARRAY(pix_fmts),
}

Definition at line 443 of file vf_shufflepixels.c.