Go to the documentation of this file.
59 #define OFFSET(x) offsetof(ColorBalanceContext, x)
60 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
95 float s,
float m,
float h)
97 const float a = 4.f,
b = 0.333f,
scale = 0.7f;
110 static float hfun(
float n,
float h,
float s,
float l)
113 float k = fmodf(n +
h / 30.
f, 12.
f);
126 if (*
r == *
g && *
g == *
b) {
128 }
else if (
max == *
r) {
129 h = 60.f * (0.f + (*
g - *
b) / (
max -
min));
130 }
else if (
max == *
g) {
131 h = 60.f * (2.f + (*
b - *
r) / (
max -
min));
132 }
else if (
max == *
b) {
133 h = 60.f * (4.f + (*
r - *
g) / (
max -
min));
157 const int slice_start = (
out->height * jobnr) / nb_jobs;
158 const int slice_end = (
out->height * (jobnr+1)) / nb_jobs;
159 const uint8_t *srcg = in->
data[0] + slice_start * in->
linesize[0];
160 const uint8_t *srcb = in->
data[1] + slice_start * in->
linesize[1];
161 const uint8_t *srcr = in->
data[2] + slice_start * in->
linesize[2];
162 const uint8_t *srca = in->
data[3] + slice_start * in->
linesize[3];
163 uint8_t *dstg =
out->data[0] + slice_start *
out->linesize[0];
164 uint8_t *dstb =
out->data[1] + slice_start *
out->linesize[1];
165 uint8_t *dstr =
out->data[2] + slice_start *
out->linesize[2];
166 uint8_t *dsta =
out->data[3] + slice_start *
out->linesize[3];
167 const float max =
s->max;
171 for (j = 0; j <
out->width; j++) {
172 float r = srcr[j] /
max;
173 float g = srcg[j] /
max;
174 float b = srcb[j] /
max;
177 r =
get_component(
r, l,
s->cyan_red.shadows,
s->cyan_red.midtones,
s->cyan_red.highlights);
178 g =
get_component(
g, l,
s->magenta_green.shadows,
s->magenta_green.midtones,
s->magenta_green.highlights);
179 b =
get_component(
b, l,
s->yellow_blue.shadows,
s->yellow_blue.midtones,
s->yellow_blue.highlights);
181 if (
s->preserve_lightness)
187 if (in !=
out &&
out->linesize[3])
195 dstg +=
out->linesize[0];
196 dstb +=
out->linesize[1];
197 dstr +=
out->linesize[2];
198 dsta +=
out->linesize[3];
210 const int slice_start = (
out->height * jobnr) / nb_jobs;
211 const int slice_end = (
out->height * (jobnr+1)) / nb_jobs;
212 const uint16_t *srcg = (
const uint16_t *)in->
data[0] + slice_start * in->
linesize[0] / 2;
213 const uint16_t *srcb = (
const uint16_t *)in->
data[1] + slice_start * in->
linesize[1] / 2;
214 const uint16_t *srcr = (
const uint16_t *)in->
data[2] + slice_start * in->
linesize[2] / 2;
215 const uint16_t *srca = (
const uint16_t *)in->
data[3] + slice_start * in->
linesize[3] / 2;
216 uint16_t *dstg = (uint16_t *)
out->data[0] + slice_start *
out->linesize[0] / 2;
217 uint16_t *dstb = (uint16_t *)
out->data[1] + slice_start *
out->linesize[1] / 2;
218 uint16_t *dstr = (uint16_t *)
out->data[2] + slice_start *
out->linesize[2] / 2;
219 uint16_t *dsta = (uint16_t *)
out->data[3] + slice_start *
out->linesize[3] / 2;
220 const int depth =
s->depth;
221 const float max =
s->max;
225 for (j = 0; j <
out->width; j++) {
226 float r = srcr[j] /
max;
227 float g = srcg[j] /
max;
228 float b = srcb[j] /
max;
231 r =
get_component(
r, l,
s->cyan_red.shadows,
s->cyan_red.midtones,
s->cyan_red.highlights);
232 g =
get_component(
g, l,
s->magenta_green.shadows,
s->magenta_green.midtones,
s->magenta_green.highlights);
233 b =
get_component(
b, l,
s->yellow_blue.shadows,
s->yellow_blue.midtones,
s->yellow_blue.highlights);
235 if (
s->preserve_lightness)
241 if (in !=
out &&
out->linesize[3])
249 dstg +=
out->linesize[0] / 2;
250 dstb +=
out->linesize[1] / 2;
251 dstr +=
out->linesize[2] / 2;
252 dsta +=
out->linesize[3] / 2;
265 const int slice_start = (
out->height * jobnr) / nb_jobs;
266 const int slice_end = (
out->height * (jobnr+1)) / nb_jobs;
267 const uint8_t *srcrow = in->
data[0] + slice_start * in->
linesize[0];
268 const uint8_t roffset =
s->rgba_map[
R];
269 const uint8_t goffset =
s->rgba_map[
G];
270 const uint8_t boffset =
s->rgba_map[
B];
271 const uint8_t aoffset =
s->rgba_map[
A];
272 const float max =
s->max;
273 const int step =
s->step;
277 dstrow =
out->data[0] + slice_start *
out->linesize[0];
279 const uint8_t *
src = srcrow;
280 uint8_t *dst = dstrow;
282 for (j = 0; j < outlink->
w *
step; j +=
step) {
283 float r =
src[j + roffset] /
max;
284 float g =
src[j + goffset] /
max;
285 float b =
src[j + boffset] /
max;
288 r =
get_component(
r, l,
s->cyan_red.shadows,
s->cyan_red.midtones,
s->cyan_red.highlights);
289 g =
get_component(
g, l,
s->magenta_green.shadows,
s->magenta_green.midtones,
s->magenta_green.highlights);
290 b =
get_component(
b, l,
s->yellow_blue.shadows,
s->yellow_blue.midtones,
s->yellow_blue.highlights);
292 if (
s->preserve_lightness)
299 dst[j + aoffset] =
src[j + aoffset];
303 dstrow +=
out->linesize[0];
316 const int slice_start = (
out->height * jobnr) / nb_jobs;
317 const int slice_end = (
out->height * (jobnr+1)) / nb_jobs;
318 const uint16_t *srcrow = (
const uint16_t *)in->
data[0] + slice_start * in->
linesize[0] / 2;
319 const uint8_t roffset =
s->rgba_map[
R];
320 const uint8_t goffset =
s->rgba_map[
G];
321 const uint8_t boffset =
s->rgba_map[
B];
322 const uint8_t aoffset =
s->rgba_map[
A];
323 const int step =
s->step / 2;
324 const int depth =
s->depth;
325 const float max =
s->max;
329 dstrow = (uint16_t *)
out->data[0] + slice_start *
out->linesize[0] / 2;
331 const uint16_t *
src = srcrow;
332 uint16_t *dst = dstrow;
334 for (j = 0; j < outlink->
w *
step; j +=
step) {
335 float r =
src[j + roffset] /
max;
336 float g =
src[j + goffset] /
max;
337 float b =
src[j + boffset] /
max;
340 r =
get_component(
r, l,
s->cyan_red.shadows,
s->cyan_red.midtones,
s->cyan_red.highlights);
341 g =
get_component(
g, l,
s->magenta_green.shadows,
s->magenta_green.midtones,
s->magenta_green.highlights);
342 b =
get_component(
b, l,
s->yellow_blue.shadows,
s->yellow_blue.midtones,
s->yellow_blue.highlights);
344 if (
s->preserve_lightness)
351 dst[j + aoffset] =
src[j + aoffset];
355 dstrow +=
out->linesize[0] / 2;
366 const int depth =
desc->comp[0].depth;
367 const int max = (1 << depth) - 1;
377 }
else if (
max == 255) {
435 .
name =
"colorbalance",
438 .priv_class = &colorbalance_class,
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
#define AV_PIX_FMT_GBRAP16
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
AVPixelFormat
Pixel format.
static const AVFilterPad colorbalance_outputs[]
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
static float get_component(float v, float l, float s, float m, float h)
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
static const AVFilterPad colorbalance_inputs[]
#define FILTER_PIXFMTS_ARRAY(array)
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
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int(* color_balance)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
This structure describes decoded (raw) audio or video data.
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.
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
const char * name
Filter name.
A link between two filters.
static void preservel(float *r, float *g, float *b, float l)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_GBRP14
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
static int color_balance16_p(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define AV_PIX_FMT_GBRP10
static av_always_inline float scale(float x, float s)
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1<< 16)) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out->ch+ch,(const uint8_t **) in->ch+ch, off *(out-> planar
A filter pad used for either input or output.
#define AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP12
static const AVOption colorbalance_options[]
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
#define FILTER_INPUTS(array)
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
#define AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_RGBA64
Describe the class of an AVClass context structure.
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
static float hfun(float n, float h, float s, float l)
AVFILTER_DEFINE_CLASS(colorbalance)
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
int av_get_padded_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel for the pixel format described by pixdesc, including any padding ...
static int color_balance16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
int format
agreed upon media format
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
static int color_balance8_p(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
AVFilterContext * src
source filter
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.
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
static enum AVPixelFormat pix_fmts[]
const AVFilter ff_vf_colorbalance
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
static int config_output(AVFilterLink *outlink)
#define AV_PIX_FMT_BGRA64
#define i(width, name, range_min, range_max)
int w
agreed upon image width
#define AV_PIX_FMT_GBRP12
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Used for passing data between threads.
static int color_balance8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
const char * name
Pad name.
@ AV_PIX_FMT_0BGR
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
int h
agreed upon image height
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
#define FILTER_OUTPUTS(array)
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
@ AV_PIX_FMT_0RGB
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)