FFmpeg: libavfilter/vf_monochrome.c Source File

FFmpeg

[フレーム]

libavfilter

vf_monochrome.c

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public

8 * License as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 * Lesser General Public License for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public

17 * License along with FFmpeg; if not, write to the Free Software

18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

19 */

21 #include <float.h>

23 #include "libavutil/opt.h"

24 #include "libavutil/pixdesc.h"

25 #include "avfilter.h"

26 #include "filters.h"

27 #include "video.h"

29 typedef struct MonochromeContext {

30 const AVClass *class;

32 float b, r;

33 float size;

34 float high;

36 int depth;

37 int subw, subh;

39 int (*do_slice)(AVFilterContext *s, void *arg,

40 int jobnr, int nb_jobs);

41 int (*clear_uv)(AVFilterContext *s, void *arg,

42 int jobnr, int nb_jobs);

43 } MonochromeContext;

45 static float envelope(const float x)

46 {

47 const float beta = 0.6f;

49 if (x < beta) {

50 const float tmp = fabsf(x / beta - 1.f);

52 return 1.f - tmp * tmp;

53 } else {

54 const float tmp = (1.f - x) / (1.f - beta);

56 return tmp * tmp * (3.f - 2.f * tmp);

57 }

58 }

60 static float filter(float b, float r, float u, float v, float size)

61 {

62 return expf(-av_clipf(((b - u) * (b - u) +

63 (r - v) * (r - v)) *

64 size, 0.f, 1.f));

65 }

67 #define PROCESS() \

68 const int cx = x >> subw; \

69 float y = yptr[x] * imax; \

70 float u = uptr[cx] * imax - .5f; \

71 float v = vptr[cx] * imax - .5f; \

72 float tt, t, ny; \

73 \

74 ny = filter(b, r, u, v, size); \

75 tt = envelope(y); \

76 t = tt + (1.f - tt) * ihigh; \

77 ny = (1.f - t) * y + t * ny * y;

79 static int monochrome_slice8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

80 {

81 MonochromeContext *s = ctx->priv;

82 AVFrame *frame = arg;

83 const int depth = s->depth;

84 const int subw = s->subw;

85 const int subh = s->subh;

86 const float max = (1 << depth) - 1;

87 const float imax = 1.f / max;

88 const int width = frame->width;

89 const int height = frame->height;

90 const int slice_start = (height * jobnr) / nb_jobs;

91 const int slice_end = (height * (jobnr + 1)) / nb_jobs;

92 const ptrdiff_t ylinesize = frame->linesize[0];

93 const ptrdiff_t ulinesize = frame->linesize[1];

94 const ptrdiff_t vlinesize = frame->linesize[2];

95 uint8_t *yptr = frame->data[0] + slice_start * ylinesize;

96 const float ihigh = 1.f - s->high;

97 const float size = 1.f / s->size;

98 const float b = s->b * .5f;

99 const float r = s->r * .5f;

100

101 for (int y = slice_start; y < slice_end; y++) {

102 const int cy = y >> subh;

103 uint8_t *uptr = frame->data[1] + cy * ulinesize;

104 uint8_t *vptr = frame->data[2] + cy * vlinesize;

105

106 for (int x = 0; x < width; x++) {

107 PROCESS()

108

109 yptr[x] = av_clip_uint8(lrintf(ny * max));

110 }

111

112 yptr += ylinesize;

113 }

114

115 return 0;

116 }

117

118 static int monochrome_slice16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

119 {

120 MonochromeContext *s = ctx->priv;

121 AVFrame *frame = arg;

122 const int depth = s->depth;

123 const int subw = s->subw;

124 const int subh = s->subh;

125 const float max = (1 << depth) - 1;

126 const float imax = 1.f / max;

127 const int width = frame->width;

128 const int height = frame->height;

129 const int slice_start = (height * jobnr) / nb_jobs;

130 const int slice_end = (height * (jobnr + 1)) / nb_jobs;

131 const ptrdiff_t ylinesize = frame->linesize[0] / 2;

132 const ptrdiff_t ulinesize = frame->linesize[1] / 2;

133 const ptrdiff_t vlinesize = frame->linesize[2] / 2;

134 uint16_t *yptr = (uint16_t *)frame->data[0] + slice_start * ylinesize;

135 const float ihigh = 1.f - s->high;

136 const float size = 1.f / s->size;

137 const float b = s->b * .5f;

138 const float r = s->r * .5f;

139

140 for (int y = slice_start; y < slice_end; y++) {

141 const int cy = y >> subh;

142 uint16_t *uptr = (uint16_t *)frame->data[1] + cy * ulinesize;

143 uint16_t *vptr = (uint16_t *)frame->data[2] + cy * vlinesize;

144

145 for (int x = 0; x < width; x++) {

146 PROCESS()

147

148 yptr[x] = av_clip_uintp2_c(lrintf(ny * max), depth);

149 }

150

151 yptr += ylinesize;

152 }

153

154 return 0;

155 }

156

157 static int clear_slice8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

158 {

159 MonochromeContext *s = ctx->priv;

160 AVFrame *frame = arg;

161 const int depth = s->depth;

162 const int half = 1 << (depth - 1);

163 const int subw = s->subw;

164 const int subh = s->subh;

165 const int width = AV_CEIL_RSHIFT(frame->width, subw);

166 const int height = AV_CEIL_RSHIFT(frame->height, subh);

167 const int slice_start = (height * jobnr) / nb_jobs;

168 const int slice_end = (height * (jobnr + 1)) / nb_jobs;

169 const ptrdiff_t ulinesize = frame->linesize[1];

170 const ptrdiff_t vlinesize = frame->linesize[2];

171

172 for (int y = slice_start; y < slice_end; y++) {

173 uint8_t *uptr = frame->data[1] + y * ulinesize;

174 uint8_t *vptr = frame->data[2] + y * vlinesize;

175

176 memset(uptr, half, width);

177 memset(vptr, half, width);

178 }

179

180 return 0;

181 }

182

183 static int clear_slice16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

184 {

185 MonochromeContext *s = ctx->priv;

186 AVFrame *frame = arg;

187 const int depth = s->depth;

188 const int half = 1 << (depth - 1);

189 const int subw = s->subw;

190 const int subh = s->subh;

191 const int width = AV_CEIL_RSHIFT(frame->width, subw);

192 const int height = AV_CEIL_RSHIFT(frame->height, subh);

193 const int slice_start = (height * jobnr) / nb_jobs;

194 const int slice_end = (height * (jobnr + 1)) / nb_jobs;

195 const ptrdiff_t ulinesize = frame->linesize[1] / 2;

196 const ptrdiff_t vlinesize = frame->linesize[2] / 2;

197

198 for (int y = slice_start; y < slice_end; y++) {

199 uint16_t *uptr = (uint16_t *)frame->data[1] + y * ulinesize;

200 uint16_t *vptr = (uint16_t *)frame->data[2] + y * vlinesize;

201

202 for (int x = 0; x < width; x++) {

203 uptr[x] = half;

204 vptr[x] = half;

205 }

206 }

207

208 return 0;

209 }

210

211 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)

212 {

213 AVFilterContext *ctx = inlink->dst;

214 MonochromeContext *s = ctx->priv;

215

216 ff_filter_execute(ctx, s->do_slice, frame, NULL,

217 FFMIN(frame->height, ff_filter_get_nb_threads(ctx)));

218 ff_filter_execute(ctx, s->clear_uv, frame, NULL,

219 FFMIN(frame->height >> s->subh, ff_filter_get_nb_threads(ctx)));

220

221 return ff_filter_frame(ctx->outputs[0], frame);

222 }

223

224 static const enum AVPixelFormat pixel_fmts[] = {

225 AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,

226 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,

227 AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,

228 AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,

229 AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,

230 AV_PIX_FMT_YUVJ411P,

231 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,

232 AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,

233 AV_PIX_FMT_YUV440P10,

234 AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV420P12,

235 AV_PIX_FMT_YUV440P12,

236 AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV420P14,

237 AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,

238 AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,

239 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA444P12, AV_PIX_FMT_YUVA444P16,

240 AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA422P16,

241 AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA420P16,

242 AV_PIX_FMT_NONE

243 };

244

245 static av_cold int config_input(AVFilterLink *inlink)

246 {

247 AVFilterContext *ctx = inlink->dst;

248 MonochromeContext *s = ctx->priv;

249 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);

250

251 s->depth = desc->comp[0].depth;

252 s->do_slice = s->depth <= 8 ? monochrome_slice8 : monochrome_slice16;

253 s->clear_uv = s->depth <= 8 ? clear_slice8 : clear_slice16;

254 s->subw = desc->log2_chroma_w;

255 s->subh = desc->log2_chroma_h;

256

257 return 0;

258 }

259

260 static const AVFilterPad monochrome_inputs[] = {

261 {

262 .name = "default",

263 .type = AVMEDIA_TYPE_VIDEO,

264 .flags = AVFILTERPAD_FLAG_NEEDS_WRITABLE,

265 .filter_frame = filter_frame,

266 .config_props = config_input,

267 },

268 };

269

270 #define OFFSET(x) offsetof(MonochromeContext, x)

271 #define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM

272

273 static const AVOption monochrome_options[] = {

274 { "cb", "set the chroma blue spot", OFFSET(b), AV_OPT_TYPE_FLOAT, {.dbl=0},-1, 1, VF },

275 { "cr", "set the chroma red spot", OFFSET(r), AV_OPT_TYPE_FLOAT, {.dbl=0},-1, 1, VF },

276 { "size", "set the color filter size", OFFSET(size), AV_OPT_TYPE_FLOAT, {.dbl=1},.1,10, VF },

277 { "high", "set the highlights strength", OFFSET(high), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, 1, VF },

278 { NULL }

279 };

280

281 AVFILTER_DEFINE_CLASS(monochrome);

282

283 const FFFilter ff_vf_monochrome = {

284 .p.name = "monochrome",

285 .p.description = NULL_IF_CONFIG_SMALL("Convert video to gray using custom color filter."),

286 .p.priv_class = &monochrome_class,

287 .p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

288 .priv_size = sizeof(MonochromeContext),

289 FILTER_INPUTS(monochrome_inputs),

290 FILTER_OUTPUTS(ff_video_default_filterpad),

291 FILTER_PIXFMTS_ARRAY(pixel_fmts),

292 .process_command = ff_filter_process_command,

293 };

AV_PIX_FMT_YUVA422P16

#define AV_PIX_FMT_YUVA422P16

Definition: pixfmt.h:596

MonochromeContext::clear_uv

int(* clear_uv)(AVFilterContext *s, void *arg, int jobnr, int nb_jobs)

Definition: vf_monochrome.c:41

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

const char * r

Definition: vf_curves.c:127

opt.h

FILTER_PIXFMTS_ARRAY

#define FILTER_PIXFMTS_ARRAY(array)

Definition: filters.h:243

ff_filter_frame

int ff_filter_frame(AVFilterLink *link, AVFrame *frame)

Send a frame of data to the next filter.

Definition: avfilter.c:1067

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:3447

MonochromeContext::high

float high

Definition: vf_monochrome.c:34

inlink

The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink

Definition: filter_design.txt:212

AV_PIX_FMT_YUVA422P9

#define AV_PIX_FMT_YUVA422P9

Definition: pixfmt.h:588

FILTER_INPUTS

#define FILTER_INPUTS(array)

Definition: filters.h:263

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:427

pixdesc.h

av_clip_uintp2_c

static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)

Clip a signed integer to an unsigned power of two range.

Definition: common.h:280

AV_PIX_FMT_YUVA420P16

#define AV_PIX_FMT_YUVA420P16

Definition: pixfmt.h:595

#define u(width, name, range_min, range_max)

Definition: cbs_apv.c:68

AV_PIX_FMT_YUVA420P10

#define AV_PIX_FMT_YUVA420P10

Definition: pixfmt.h:590

AVOption

AVOption.

Definition: opt.h:429

#define b

Definition: input.c:42

monochrome_slice8

static int monochrome_slice8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

Definition: vf_monochrome.c:79

expf

#define expf(x)

Definition: libm.h:285

AV_PIX_FMT_YUV420P10

#define AV_PIX_FMT_YUV420P10

Definition: pixfmt.h:539

half

static uint8_t half(int a, int b)

Definition: mobiclip.c:540

high

int high

Definition: dovi_rpuenc.c:39

float.h

AV_PIX_FMT_YUV440P

@ AV_PIX_FMT_YUV440P

planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)

Definition: pixfmt.h:106

max

#define max(a, b)

Definition: cuda_runtime.h:33

AVFilter::name

const char * name

Filter name.

Definition: avfilter.h:220

video.h

AVFilterLink

A link between two filters.

Definition: avfilter.h:395

AV_PIX_FMT_YUVA422P10

#define AV_PIX_FMT_YUVA422P10

Definition: pixfmt.h:591

AV_PIX_FMT_YUVA420P9

#define AV_PIX_FMT_YUVA420P9

Definition: pixfmt.h:587

MonochromeContext::b

float b

Definition: vf_monochrome.c:32

slice_end

static int slice_end(AVCodecContext *avctx, AVFrame *pict, int *got_output)

Handle slice ends.

Definition: mpeg12dec.c:1688

#define VF

Definition: vf_monochrome.c:271

MonochromeContext

Definition: vf_monochrome.c:29

AV_PIX_FMT_YUVA444P16

#define AV_PIX_FMT_YUVA444P16

Definition: pixfmt.h:597

pixel_fmts

static enum AVPixelFormat pixel_fmts[]

Definition: vf_monochrome.c:224

AV_PIX_FMT_YUV422P9

#define AV_PIX_FMT_YUV422P9

Definition: pixfmt.h:537

fabsf

static __device__ float fabsf(float a)

Definition: cuda_runtime.h:181

AVFilterPad

A filter pad used for either input or output.

Definition: filters.h:39

AV_PIX_FMT_YUV444P10

#define AV_PIX_FMT_YUV444P10

Definition: pixfmt.h:542

AV_PIX_FMT_YUVJ411P

@ AV_PIX_FMT_YUVJ411P

planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...

Definition: pixfmt.h:283

MonochromeContext::subw

int subw

Definition: vf_monochrome.c:37

MonochromeContext::subh

int subh

Definition: vf_monochrome.c:37

av_cold

#define av_cold

Definition: attributes.h:106

AV_PIX_FMT_YUV422P16

#define AV_PIX_FMT_YUV422P16

Definition: pixfmt.h:551

ff_video_default_filterpad

const AVFilterPad ff_video_default_filterpad[1]

An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_VIDEO.

Definition: video.c:37

FFFilter

Definition: filters.h:266

AV_PIX_FMT_YUVJ422P

@ AV_PIX_FMT_YUVJ422P

planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...

Definition: pixfmt.h:86

#define s(width, name)

Definition: cbs_vp9.c:198

AV_PIX_FMT_YUVA420P

@ AV_PIX_FMT_YUVA420P

planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)

Definition: pixfmt.h:108

AV_PIX_FMT_YUV444P16

#define AV_PIX_FMT_YUV444P16

Definition: pixfmt.h:552

AV_CEIL_RSHIFT

#define AV_CEIL_RSHIFT(a, b)

Definition: common.h:60

filters.h

AV_PIX_FMT_YUVA444P12

#define AV_PIX_FMT_YUVA444P12

Definition: pixfmt.h:594

AV_PIX_FMT_YUV420P9

#define AV_PIX_FMT_YUV420P9

Definition: pixfmt.h:536

AV_PIX_FMT_YUV420P16

#define AV_PIX_FMT_YUV420P16

Definition: pixfmt.h:550

ctx

AVFormatContext * ctx

Definition: movenc.c:49

MonochromeContext::size

float size

Definition: vf_monochrome.c:33

filter_frame

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

Definition: vf_monochrome.c:211

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:73

FILTER_OUTPUTS

#define FILTER_OUTPUTS(array)

Definition: filters.h:264

tmp

static uint8_t tmp[40]

Definition: aes_ctr.c:52

AV_PIX_FMT_YUVJ444P

@ AV_PIX_FMT_YUVJ444P

planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...

Definition: pixfmt.h:87

arg

const char * arg

Definition: jacosubdec.c:67

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:76

NULL

#define NULL

Definition: coverity.c:32

AV_PIX_FMT_YUVJ420P

@ AV_PIX_FMT_YUVJ420P

planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...

Definition: pixfmt.h:85

AV_PIX_FMT_YUV440P10

#define AV_PIX_FMT_YUV440P10

Definition: pixfmt.h:541

AV_PIX_FMT_YUV422P10

#define AV_PIX_FMT_YUV422P10

Definition: pixfmt.h:540

av_clipf

Definition: af_crystalizer.c:122

MonochromeContext::depth

int depth

Definition: vf_monochrome.c:36

AVFILTERPAD_FLAG_NEEDS_WRITABLE

#define AVFILTERPAD_FLAG_NEEDS_WRITABLE

The filter expects writable frames from its input link, duplicating data buffers if needed.

Definition: filters.h:58

Definition: af_crystalizer.c:122

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:94

height

#define height

Definition: dsp.h:89

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:424

AV_PIX_FMT_YUV422P12

#define AV_PIX_FMT_YUV422P12

Definition: pixfmt.h:544

size

int size

Definition: twinvq_data.h:10344

AV_PIX_FMT_YUV444P12

#define AV_PIX_FMT_YUV444P12

Definition: pixfmt.h:546

MonochromeContext::do_slice

int(* do_slice)(AVFilterContext *s, void *arg, int jobnr, int nb_jobs)

Definition: vf_monochrome.c:39

ff_filter_process_command

int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)

Generic processing of user supplied commands that are set in the same way as the filter options.

Definition: avfilter.c:905

PROCESS

#define PROCESS()

Definition: vf_monochrome.c:67

AV_PIX_FMT_YUVA444P

@ AV_PIX_FMT_YUVA444P

planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)

Definition: pixfmt.h:174

AV_PIX_FMT_YUVA444P10

#define AV_PIX_FMT_YUVA444P10

Definition: pixfmt.h:592

monochrome_inputs

static const AVFilterPad monochrome_inputs[]

Definition: vf_monochrome.c:260

config_input

static av_cold int config_input(AVFilterLink *inlink)

Definition: vf_monochrome.c:245

AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC

#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC

Some filters support a generic "enable" expression option that can be used to enable or disable a fil...

Definition: avfilter.h:197

AV_OPT_TYPE_FLOAT

@ AV_OPT_TYPE_FLOAT

Underlying C type is float.

Definition: opt.h:271

lrintf

#define lrintf(x)

Definition: libm_mips.h:72

envelope

static float envelope(const float x)

Definition: vf_monochrome.c:45

ff_vf_monochrome

const FFFilter ff_vf_monochrome

Definition: vf_monochrome.c:283

ff_filter_get_nb_threads

int ff_filter_get_nb_threads(AVFilterContext *ctx)

Get number of threads for current filter instance.

Definition: avfilter.c:845

monochrome_options

static const AVOption monochrome_options[]

Definition: vf_monochrome.c:273

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

AV_PIX_FMT_YUVJ440P

@ AV_PIX_FMT_YUVJ440P

planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range

Definition: pixfmt.h:107

AVFilterPad::name

const char * name

Pad name.

Definition: filters.h:45

AV_PIX_FMT_YUV444P9

#define AV_PIX_FMT_YUV444P9

Definition: pixfmt.h:538

MonochromeContext::r

float r

Definition: vf_monochrome.c:32

slice_start

static int slice_start(SliceContext *sc, VVCContext *s, VVCFrameContext *fc, const CodedBitstreamUnit *unit, const int is_first_slice)

Definition: dec.c:845

filter

static float filter(float b, float r, float u, float v, float size)

Definition: vf_monochrome.c:60

clear_slice8

static int clear_slice8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

Definition: vf_monochrome.c:157

frame

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 the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:265

AV_PIX_FMT_YUVA444P9

#define AV_PIX_FMT_YUVA444P9

Definition: pixfmt.h:589

AV_PIX_FMT_YUV420P12

#define AV_PIX_FMT_YUV420P12

Definition: pixfmt.h:543

AV_PIX_FMT_YUV422P14

#define AV_PIX_FMT_YUV422P14

Definition: pixfmt.h:548

ff_filter_execute

int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)