Go to the documentation of this file.
36 #include "config_components.h"
93 #define OFFSET(x) offsetof(TestSourceContext, x)
94 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
95 #define FLAGSR AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
97 #define SIZE_OPTIONS \
98 { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },\
99 { "s", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },\
101 #define COMMON_OPTIONS_NOSIZE \
102 { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },\
103 { "r", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },\
104 { "duration", "set video duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },\
105 { "d", "set video duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },\
106 { "sar", "set video sample aspect ratio", OFFSET(sar), AV_OPT_TYPE_RATIONAL, {.dbl= 1}, 0, INT_MAX, FLAGS },
108 #define COMMON_OPTIONS SIZE_OPTIONS COMMON_OPTIONS_NOSIZE
110 #define NOSIZE_OPTIONS_OFFSET 2
128 test->duration < 0 ? -1 : (
double)
test->duration/1000000,
144 outlink->
w =
test->w;
145 outlink->
h =
test->h;
161 if (
test->duration >= 0 &&
167 if (
test->draw_once) {
168 if (
test->draw_once_reset) {
170 test->draw_once_reset = 0;
186 frame->key_frame = 1;
187 frame->interlaced_frame = 0;
190 if (!
test->draw_once)
199 #if CONFIG_COLOR_FILTER
201 static const AVOption color_options[] = {
221 test->fill_picture_fn = color_fill_picture;
251 static int color_process_command(
AVFilterContext *
ctx,
const char *cmd,
const char *args,
252 char *res,
int res_len,
int flags)
262 test->draw_once_reset = 1;
270 .config_props = color_config_props,
277 .priv_class = &color_class,
285 .process_command = color_process_command,
290 #if CONFIG_HALDCLUTSRC_FILTER
292 static const AVOption haldclutsrc_options[] = {
302 int i, j, k, x = 0, y = 0, is16bit = 0,
step;
307 const int w =
frame->width;
308 const int h =
frame->height;
310 const int linesize =
frame->linesize[0];
312 const int depth =
desc->comp[0].depth;
321 alpha = (1 << depth) - 1;
327 #define LOAD_CLUT(nbits) do { \
328 uint##nbits##_t *dst = ((uint##nbits##_t *)(data + y*linesize)) + x*step; \
329 dst[rgba_map[0]] = av_clip_uint##nbits(i * scale); \
330 dst[rgba_map[1]] = av_clip_uint##nbits(j * scale); \
331 dst[rgba_map[2]] = av_clip_uint##nbits(k * scale); \
333 dst[rgba_map[3]] = alpha; \
336 #define LOAD_CLUT_PLANAR(type, nbits) do { \
337 type *dst = ((type *)(frame->data[2] + y*frame->linesize[2])) + x; \
338 dst[0] = av_clip_uintp2(i * scale, nbits); \
339 dst = ((type *)(frame->data[0] + y*frame->linesize[0])) + x; \
340 dst[0] = av_clip_uintp2(j * scale, nbits); \
341 dst = ((type *)(frame->data[1] + y*frame->linesize[1])) + x; \
342 dst[0] = av_clip_uintp2(k * scale, nbits); \
344 dst = ((type *)(frame->data[3] + y*linesize)) + x; \
350 for (k = 0; k <
level; k++) {
351 for (j = 0; j <
level; j++) {
360 case 8: LOAD_CLUT_PLANAR(uint8_t, 8);
break;
361 case 9: LOAD_CLUT_PLANAR(uint16_t, 9);
break;
362 case 10: LOAD_CLUT_PLANAR(uint16_t,10);
break;
363 case 12: LOAD_CLUT_PLANAR(uint16_t,12);
break;
364 case 14: LOAD_CLUT_PLANAR(uint16_t,14);
break;
365 case 16: LOAD_CLUT_PLANAR(uint16_t,16);
break;
402 static int haldclutsrc_config_props(
AVFilterLink *outlink)
415 .config_props = haldclutsrc_config_props,
420 .
name =
"haldclutsrc",
422 .priv_class = &haldclutsrc_class,
424 .
init = haldclutsrc_init,
435 #if CONFIG_NULLSRC_FILTER
443 test->fill_picture_fn = nullsrc_fill_picture;
458 .priv_class = &nullsrc_yuvtestsrc_class,
459 .init = nullsrc_init,
469 #if CONFIG_TESTSRC_FILTER
471 static const AVOption testsrc_options[] = {
492 static void draw_rectangle(
unsigned val, uint8_t *dst,
int dst_linesize,
int segment_width,
493 int x,
int y,
int w,
int h)
498 dst += segment_width * (
step * x + y * dst_linesize);
499 w *= segment_width *
step;
501 for (
i = 0;
i <
h;
i++) {
507 static void draw_digit(
int digit, uint8_t *dst,
int dst_linesize,
513 #define LEFT_TOP_VBAR 8
514 #define LEFT_BOT_VBAR 16
515 #define RIGHT_TOP_VBAR 32
516 #define RIGHT_BOT_VBAR 64
528 static const unsigned char masks[10] = {
529 TOP_HBAR |BOT_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
530 RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
531 TOP_HBAR|MID_HBAR|BOT_HBAR|LEFT_BOT_VBAR |RIGHT_TOP_VBAR,
532 TOP_HBAR|MID_HBAR|BOT_HBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
533 MID_HBAR |LEFT_TOP_VBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
534 TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR |RIGHT_BOT_VBAR,
535 TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR |RIGHT_BOT_VBAR,
536 TOP_HBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
537 TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
538 TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
540 unsigned mask = masks[digit];
547 segments[
i].x, segments[
i].y, segments[
i].
w, segments[
i].
h);
550 #define GRADIENT_SIZE (6 * 256)
557 int color, color_rest;
561 int dquad_x, dquad_y;
562 int grad, dgrad, rgrad, drgrad;
575 for (y = 0; y <
height; y++) {
581 for (x = 0; x <
width; x++) {
587 *(p++) = icolor & 1 ? 255 : 0;
588 *(p++) = icolor & 2 ? 255 : 0;
589 *(p++) = icolor & 4 ? 255 : 0;
591 if (color_rest >=
width) {
598 p0 +=
frame->linesize[0];
603 grad = (256 *
test->nb_frame *
test->time_base.num /
test->time_base.den) %
606 dgrad = GRADIENT_SIZE /
width;
607 drgrad = GRADIENT_SIZE %
width;
608 for (x = 0; x <
width; x++) {
610 grad < 256 || grad >= 5 * 256 ? 255 :
611 grad >= 2 * 256 && grad < 4 * 256 ? 0 :
612 grad < 2 * 256 ? 2 * 256 - 1 - grad : grad - 4 * 256;
614 grad >= 4 * 256 ? 0 :
615 grad >= 1 * 256 && grad < 3 * 256 ? 255 :
616 grad < 1 * 256 ? grad : 4 * 256 - 1 - grad;
619 grad >= 3 * 256 && grad < 5 * 256 ? 255 :
620 grad < 3 * 256 ? grad - 2 * 256 : 6 * 256 - 1 - grad;
623 if (rgrad >= GRADIENT_SIZE) {
625 rgrad -= GRADIENT_SIZE;
627 if (grad >= GRADIENT_SIZE)
628 grad -= GRADIENT_SIZE;
631 for (y =
height / 8; y > 0; y--) {
633 p +=
frame->linesize[0];
637 seg_size =
width / 80;
638 if (seg_size >= 1 &&
height >= 13 * seg_size) {
639 int64_t p10decimals = 1;
645 for (x = 0; x <
test->nb_decimals; x++)
650 y = (
height - seg_size * 13) / 2;
651 p =
data + (x*3 + y *
frame->linesize[0]);
652 for (
i = 0;
i < 8;
i++) {
653 p -= 3 * 8 * seg_size;
654 draw_digit(second % 10, p,
frame->linesize[0], seg_size);
666 test->fill_picture_fn = test_fill_picture;
670 static const AVFilterPad avfilter_vsrc_testsrc_outputs[] = {
682 .priv_class = &testsrc_class,
693 #if CONFIG_TESTSRC2_FILTER
695 static const AVOption testsrc2_options[] = {
705 uint8_t rgba[4] = { (argb >> 16) & 0xFF,
708 (argb >> 24) & 0xFF, };
712 static uint32_t color_gradient(
unsigned index)
714 unsigned si =
index & 0xFF, sd = 0xFF - si;
715 switch (
index >> 8) {
716 case 0:
return 0xFF0000 + (si << 8);
717 case 1:
return 0x00FF00 + (sd << 16);
718 case 2:
return 0x00FF00 + (si << 0);
719 case 3:
return 0x0000FF + (sd << 8);
720 case 4:
return 0x0000FF + (si << 16);
721 case 5:
return 0xFF0000 + (sd << 0);
727 int x0,
int y0,
const uint8_t *text)
731 for (; *text; text++) {
748 unsigned alpha = (uint32_t)
s->alpha << 24;
752 unsigned i, x = 0, x2;
758 set_color(
s, &
color, ((
i & 1) ? 0xFF0000 : 0) |
759 ((
i & 2) ? 0x00FF00 : 0) |
760 ((
i & 4) ? 0x0000FF : 0) |
763 x, 0, x2 - x,
frame->height);
771 unsigned x, dx, y0, y, g0,
g;
776 for (x = 0; x <
s->w; x += dx) {
780 y %= 2 * (
s->h - 16);
782 y = 2 * (
s->h - 16) - y;
790 if (
s->w >= 64 &&
s->h >= 64) {
791 int l = (
FFMIN(
s->w,
s->h) - 32) >> 1;
792 int steps =
FFMAX(4, l >> 5);
793 int xc = (
s->w >> 2) + (
s->w >> 1);
794 int yc = (
s->h >> 2);
799 for (
c = 0;
c < 3;
c++) {
800 set_color(
s, &
color, (0xBBBBBB ^ (0xFF << (
c << 3))) |
alpha);
804 pos < 3 * l ? 3 * l -
pos : 0;
805 yh =
pos < 1 * l ? 0 :
811 for (
i = 1;
i <= steps;
i++) {
823 if (
s->w >= 64 &&
s->h >= 64) {
824 int l = (
FFMIN(
s->w,
s->h) - 16) >> 2;
826 int xc = (
s->w >> 2);
827 int yc = (
s->h >> 2) + (
s->h >> 1);
840 set_color(
s, &
color, 0xFF808080);
847 x1, ym1, x2 - x1, ym2 - ym1);
850 xm1, y1, xm2 - xm1, y2 - y1);
853 x1, y1, x2 - x1, y2 - y1);
866 for (y = ymin; y + 15 < ymax; y += 16) {
867 for (x = xmin; x + 15 < xmax; x += 16) {
870 for (
i = 0;
i < 256;
i++) {
871 r =
r * 1664525 + 1013904223;
874 set_color(
s, &
color, 0xFF00FF80);
877 alpha, 16, 16, 16, 3, 0, x, y);
883 if (
s->w >= 16 &&
s->h >= 16) {
884 unsigned w =
s->w - 8;
885 unsigned h =
s->h - 8;
894 set_color(
s, &
color, 0xFF8000FF);
905 set_color(
s, &
color, 0xC0000000);
909 set_color(
s, &
color, 0xFFFF8000);
910 snprintf(buf,
sizeof(buf),
"%02d:%02d:%02d.%03d\n%12"PRIi64,
911 time / 3600000, (time / 60000) % 60, (time / 1000) % 60,
912 time % 1000,
s->pts);
920 s->fill_picture_fn = test2_fill_picture;
942 static const AVFilterPad avfilter_vsrc_testsrc2_outputs[] = {
946 .config_props = test2_config_props,
954 .priv_class = &testsrc2_class,
965 #if CONFIG_RGBTESTSRC_FILTER
967 static const AVOption rgbtestsrc_options[] = {
981 static void rgbtest_put_pixel(uint8_t *dstp[4],
int dst_linesizep[4],
985 uint8_t *dst = dstp[0];
986 int dst_linesize = dst_linesizep[0];
992 case AV_PIX_FMT_BGR444: ((uint16_t*)(dst + y*dst_linesize))[x] = ((
r >> 4) << 8) | ((
g >> 4) << 4) | (
b >> 4);
break;
993 case AV_PIX_FMT_RGB444: ((uint16_t*)(dst + y*dst_linesize))[x] = ((
b >> 4) << 8) | ((
g >> 4) << 4) | (
r >> 4);
break;
994 case AV_PIX_FMT_BGR555: ((uint16_t*)(dst + y*dst_linesize))[x] = ((
r>>3)<<10) | ((
g>>3)<<5) | (
b>>3);
break;
995 case AV_PIX_FMT_RGB555: ((uint16_t*)(dst + y*dst_linesize))[x] = ((
b>>3)<<10) | ((
g>>3)<<5) | (
r>>3);
break;
996 case AV_PIX_FMT_BGR565: ((uint16_t*)(dst + y*dst_linesize))[x] = ((
r>>3)<<11) | ((
g>>2)<<5) | (
b>>3);
break;
997 case AV_PIX_FMT_RGB565: ((uint16_t*)(dst + y*dst_linesize))[x] = ((
b>>3)<<11) | ((
g>>2)<<5) | (
r>>3);
break;
1000 v = (
r << (rgba_map[
R]*8)) + (
g << (rgba_map[
G]*8)) + (
b << (rgba_map[
B]*8));
1001 p = dst + 3*x + y*dst_linesize;
1008 v = (
r << (rgba_map[
R]*8)) + (
g << (rgba_map[
G]*8)) + (
b << (rgba_map[
B]*8)) + (255
U << (rgba_map[
A]*8));
1009 p = dst + 4*x + y*dst_linesize;
1013 p = dstp[0] + x + y * dst_linesizep[0];
1015 p = dstp[1] + x + y * dst_linesizep[1];
1017 p = dstp[2] + x + y * dst_linesizep[2];
1025 p16 = (uint16_t *)(dstp[0] + x*2 + y * dst_linesizep[0]);
1027 p16 = (uint16_t *)(dstp[1] + x*2 + y * dst_linesizep[1]);
1029 p16 = (uint16_t *)(dstp[2] + x*2 + y * dst_linesizep[2]);
1040 for (y = 0; y <
h; y++) {
1041 for (x = 0; x <
w; x++) {
1043 int r = 0,
g = 0,
b = 0;
1045 if (6*y <
h )
r =
c;
1046 else if (6*y < 2*
h)
g =
c,
b =
c;
1047 else if (6*y < 3*
h)
g =
c;
1048 else if (6*y < 4*
h)
r =
c,
b =
c;
1049 else if (6*y < 5*
h)
b =
c;
1052 rgbtest_put_pixel(
frame->data,
frame->linesize, x, y,
r,
g,
b,
1053 ctx->outputs[0]->format,
test->rgba_map);
1063 for (y = 0; y <
h; y++) {
1064 for (x = 0; x <
w; x++) {
1066 int r = 0,
g = 0,
b = 0;
1068 if (3*y <
h )
r =
c;
1069 else if (3*y < 2*
h)
g =
c;
1072 rgbtest_put_pixel(
frame->data,
frame->linesize, x, y,
r,
g,
b,
1073 ctx->outputs[0]->format,
test->rgba_map);
1082 test->draw_once = 1;
1083 test->fill_picture_fn =
test->complement ? rgbtest_fill_picture_complement : rgbtest_fill_picture;
1108 static const AVFilterPad avfilter_vsrc_rgbtestsrc_outputs[] = {
1112 .config_props = rgbtest_config_props,
1117 .
name =
"rgbtestsrc",
1120 .priv_class = &rgbtestsrc_class,
1121 .
init = rgbtest_init,
1131 #if CONFIG_YUVTESTSRC_FILTER
1138 const int mid = 1 << (
desc->comp[0].depth - 1);
1139 uint8_t *ydst =
frame->data[0];
1140 uint8_t *udst =
frame->data[1];
1141 uint8_t *vdst =
frame->data[2];
1142 int ylinesize =
frame->linesize[0];
1143 int ulinesize =
frame->linesize[1];
1144 int vlinesize =
frame->linesize[2];
1146 for (y = 0; y <
h; y++) {
1147 for (x = 0; x <
w; x++) {
1161 for (; y <
h; y++) {
1162 for (x = 0; x <
w; x++) {
1175 for (; y <
frame->height; y++) {
1176 for (x = 0; x <
w; x++) {
1195 const int mid = 1 << (
desc->comp[0].depth - 1);
1196 uint16_t *ydst = (uint16_t *)
frame->data[0];
1197 uint16_t *udst = (uint16_t *)
frame->data[1];
1198 uint16_t *vdst = (uint16_t *)
frame->data[2];
1199 int ylinesize =
frame->linesize[0] / 2;
1200 int ulinesize =
frame->linesize[1] / 2;
1201 int vlinesize =
frame->linesize[2] / 2;
1203 for (y = 0; y <
h; y++) {
1204 for (x = 0; x <
w; x++) {
1218 for (; y <
h; y++) {
1219 for (x = 0; x <
w; x++) {
1232 for (; y <
frame->height; y++) {
1233 for (x = 0; x <
w; x++) {
1251 test->draw_once = 1;
1268 test->fill_picture_fn =
desc->comp[0].depth > 8 ? yuvtest_fill_picture16 : yuvtest_fill_picture8;
1272 static const AVFilterPad avfilter_vsrc_yuvtestsrc_outputs[] = {
1276 .config_props = yuvtest_config_props,
1281 .
name =
"yuvtestsrc",
1284 .priv_class = &nullsrc_yuvtestsrc_class,
1285 .
init = yuvtest_init,
1295 #if CONFIG_PAL75BARS_FILTER || CONFIG_PAL100BARS_FILTER || CONFIG_SMPTEBARS_FILTER || CONFIG_SMPTEHDBARS_FILTER
1297 static const uint8_t rainbow[7][4] = {
1298 { 180, 128, 128, 255 },
1299 { 162, 44, 142, 255 },
1300 { 131, 156, 44, 255 },
1301 { 112, 72, 58, 255 },
1302 { 84, 184, 198, 255 },
1303 { 65, 100, 212, 255 },
1304 { 35, 212, 114, 255 },
1307 static const uint8_t rainbow100[7][4] = {
1308 { 235, 128, 128, 255 },
1309 { 210, 16, 146, 255 },
1310 { 170, 166, 16, 255 },
1311 { 145, 54, 34, 255 },
1312 { 106, 202, 222, 255 },
1313 { 81, 90, 240, 255 },
1314 { 41, 240, 110, 255 },
1317 static const uint8_t rainbowhd[7][4] = {
1318 { 180, 128, 128, 255 },
1319 { 168, 44, 136, 255 },
1320 { 145, 147, 44, 255 },
1321 { 133, 63, 52, 255 },
1322 { 63, 193, 204, 255 },
1323 { 51, 109, 212, 255 },
1324 { 28, 212, 120, 255 },
1327 static const uint8_t wobnair[7][4] = {
1328 { 35, 212, 114, 255 },
1329 { 19, 128, 128, 255 },
1330 { 84, 184, 198, 255 },
1331 { 19, 128, 128, 255 },
1332 { 131, 156, 44, 255 },
1333 { 19, 128, 128, 255 },
1334 { 180, 128, 128, 255 },
1337 static const uint8_t white[4] = { 235, 128, 128, 255 };
1340 static const uint8_t neg4ire[4] = { 7, 128, 128, 255 };
1341 static const uint8_t pos4ire[4] = { 24, 128, 128, 255 };
1344 static const uint8_t i_pixel[4] = { 57, 156, 97, 255 };
1345 static const uint8_t q_pixel[4] = { 44, 171, 147, 255 };
1347 static const uint8_t gray40[4] = { 104, 128, 128, 255 };
1348 static const uint8_t gray15[4] = { 49, 128, 128, 255 };
1349 static const uint8_t cyan[4] = { 188, 154, 16, 255 };
1350 static const uint8_t yellow[4] = { 219, 16, 138, 255 };
1351 static const uint8_t blue[4] = { 32, 240, 118, 255 };
1352 static const uint8_t red[4] = { 63, 102, 240, 255 };
1353 static const uint8_t black0[4] = { 16, 128, 128, 255 };
1354 static const uint8_t black2[4] = { 20, 128, 128, 255 };
1355 static const uint8_t black4[4] = { 25, 128, 128, 255 };
1356 static const uint8_t neg2[4] = { 12, 128, 128, 255 };
1359 int x,
int y,
int w,
int h,
1374 for (plane = 0;
frame->data[plane]; plane++) {
1375 const int c =
color[plane];
1376 const int linesize =
frame->linesize[plane];
1377 int i, px, py, pw, ph;
1379 if (plane == 1 || plane == 2) {
1380 px = x >>
desc->log2_chroma_w;
1382 py = y >>
desc->log2_chroma_h;
1391 p0 = p =
frame->data[plane] + py * linesize + px;
1394 for (
i = 1;
i < ph;
i++, p += linesize)
1416 #if CONFIG_PAL75BARS_FILTER
1429 draw_bar(
test, white, x, 0, r_w,
test->h, picref);
1431 for (
i = 1;
i < 7;
i++) {
1432 draw_bar(
test, rainbow[
i], x, 0, r_w,
test->h, picref);
1435 draw_bar(
test, black0, x, 0, r_w,
test->h, picref);
1442 test->fill_picture_fn = pal75bars_fill_picture;
1443 test->draw_once = 1;
1448 .
name =
"pal75bars",
1450 .priv_class = &palbars_class,
1452 .
init = pal75bars_init,
1462 #if CONFIG_PAL100BARS_FILTER
1475 for (
i = 0;
i < 7;
i++) {
1476 draw_bar(
test, rainbow100[
i], x, 0, r_w,
test->h, picref);
1479 draw_bar(
test, black0, x, 0, r_w,
test->h, picref);
1486 test->fill_picture_fn = pal100bars_fill_picture;
1487 test->draw_once = 1;
1492 .
name =
"pal100bars",
1494 .priv_class = &palbars_class,
1496 .
init = pal100bars_init,
1508 #if CONFIG_SMPTEBARS_FILTER
1513 int r_w, r_h, w_h, p_w, p_h,
i,
tmp, x = 0;
1522 p_h =
test->h - w_h - r_h;
1524 for (
i = 0;
i < 7;
i++) {
1525 draw_bar(
test, rainbow[
i], x, 0, r_w, r_h, picref);
1526 draw_bar(
test, wobnair[
i], x, r_h, r_w, w_h, picref);
1530 draw_bar(
test, i_pixel, x, r_h + w_h, p_w, p_h, picref);
1532 draw_bar(
test, white, x, r_h + w_h, p_w, p_h, picref);
1534 draw_bar(
test, q_pixel, x, r_h + w_h, p_w, p_h, picref);
1537 draw_bar(
test, black0, x, r_h + w_h,
tmp, p_h, picref);
1540 draw_bar(
test, neg4ire, x, r_h + w_h,
tmp, p_h, picref);
1542 draw_bar(
test, black0, x, r_h + w_h,
tmp, p_h, picref);
1544 draw_bar(
test, pos4ire, x, r_h + w_h,
tmp, p_h, picref);
1546 draw_bar(
test, black0, x, r_h + w_h,
test->w - x, p_h, picref);
1553 test->fill_picture_fn = smptebars_fill_picture;
1554 test->draw_once = 1;
1559 .
name =
"smptebars",
1562 .priv_class = &smptebars_class,
1563 .
init = smptebars_init,
1573 #if CONFIG_SMPTEHDBARS_FILTER
1578 int d_w, r_w, r_h, l_w,
i,
tmp, x = 0, y = 0;
1585 draw_bar(
test, gray40, x, 0, d_w, r_h, picref);
1589 for (
i = 0;
i < 7;
i++) {
1590 draw_bar(
test, rainbowhd[
i], x, 0, r_w, r_h, picref);
1593 draw_bar(
test, gray40, x, 0,
test->w - x, r_h, picref);
1596 draw_bar(
test, cyan, 0, y, d_w, r_h, picref);
1598 draw_bar(
test, i_pixel, x, y, r_w, r_h, picref);
1601 draw_bar(
test, rainbowhd[0], x, y,
tmp, r_h, picref);
1604 draw_bar(
test, blue, x, y,
test->w - x, r_h, picref);
1606 draw_bar(
test, yellow, 0, y, d_w, r_h, picref);
1608 draw_bar(
test, q_pixel, x, y, r_w, r_h, picref);
1612 uint8_t yramp[4] = {0};
1614 yramp[0] =
i * 255 /
tmp;
1622 draw_bar(
test, red, x, y,
test->w - x, r_h, picref);
1624 draw_bar(
test, gray15, 0, y, d_w,
test->h - y, picref);
1627 draw_bar(
test, black0, x, y,
tmp,
test->h - y, picref);
1630 draw_bar(
test, white, x, y,
tmp,
test->h - y, picref);
1633 draw_bar(
test, black0, x, y,
tmp,
test->h - y, picref);
1636 draw_bar(
test, neg2, x, y,
tmp,
test->h - y, picref);
1638 draw_bar(
test, black0, x, y,
tmp,
test->h - y, picref);
1640 draw_bar(
test, black2, x, y,
tmp,
test->h - y, picref);
1642 draw_bar(
test, black0, x, y,
tmp,
test->h - y, picref);
1644 draw_bar(
test, black4, x, y,
tmp,
test->h - y, picref);
1647 draw_bar(
test, black0, x, y, r_w,
test->h - y, picref);
1649 draw_bar(
test, gray15, x, y,
test->w - x,
test->h - y, picref);
1656 test->fill_picture_fn = smptehdbars_fill_picture;
1657 test->draw_once = 1;
1662 .
name =
"smptehdbars",
1664 .priv_class = &smptebars_class,
1666 .
init = smptehdbars_init,
1680 #if CONFIG_ALLYUV_FILTER
1684 const int ys =
frame->linesize[0];
1685 const int us =
frame->linesize[1];
1686 const int vs =
frame->linesize[2];
1689 for (y = 0; y < 4096; y++) {
1690 for (x = 0; x < 2048; x++) {
1691 frame->data[0][y * ys + x] = ((x / 8) % 256);
1692 frame->data[0][y * ys + 4095 - x] = ((x / 8) % 256);
1695 for (x = 0; x < 2048; x+=8) {
1696 for (j = 0; j < 8; j++) {
1697 frame->data[1][vs * y + x + j] = (y%16 + (j % 8) * 16);
1698 frame->data[1][vs * y + 4095 - x - j] = (128 + y%16 + (j % 8) * 16);
1702 for (x = 0; x < 4096; x++)
1703 frame->data[2][y *
us + x] = 256 * y / 4096;
1712 test->draw_once = 1;
1713 test->fill_picture_fn = allyuv_fill_picture;
1717 static const AVFilterPad avfilter_vsrc_allyuv_outputs[] = {
1729 .priv_class = &allyuv_allrgb_class,
1730 .
init = allyuv_init,
1740 #if CONFIG_ALLRGB_FILTER
1745 const int linesize =
frame->linesize[0];
1748 for (y = 0; y < 4096; y++) {
1749 uint8_t *dst =
line;
1751 for (x = 0; x < 4096; x++) {
1754 *dst++ = (x >> 8) | ((y >> 8) << 4);
1765 test->draw_once = 1;
1766 test->fill_picture_fn = allrgb_fill_picture;
1778 static const AVFilterPad avfilter_vsrc_allrgb_outputs[] = {
1782 .config_props = allrgb_config_props,
1790 .priv_class = &allyuv_allrgb_class,
1791 .
init = allrgb_init,
1801 #if CONFIG_COLORSPECTRUM_FILTER
1803 static const AVOption colorspectrum_options[] = {
1814 static inline float mix(
float a,
float b,
float mix)
1819 static void hsb2rgb(
const float *
c,
float *
rgb)
1832 const float w =
frame->width - 1.f;
1833 const float h =
frame->height - 1.f;
1836 for (
int y = 0; y <
frame->height; y++) {
1837 float *
r = (
float *)(
frame->data[2] + y *
frame->linesize[2]);
1838 float *
g = (
float *)(
frame->data[0] + y *
frame->linesize[0]);
1839 float *
b = (
float *)(
frame->data[1] + y *
frame->linesize[1]);
1840 const float yh = y /
h;
1842 c[1] =
test->type == 2 ? yh > 0.5f ? 2.f * (yh - 0.5f) : 1.
f - 2.
f * yh :
test->type == 1 ? 1.f - yh : yh;
1844 c[3] =
test->type == 1 ? 1.f :
test->type == 2 ? (yh > 0.5f ? 0.f : 1.f): 0.f;
1845 for (
int x = 0; x <
frame->width; x++) {
1862 test->draw_once = 1;
1863 test->fill_picture_fn = colorspectrum_fill_picture;
1867 static const AVFilterPad avfilter_vsrc_colorspectrum_outputs[] = {
1876 .
name =
"colorspectrum",
1879 .priv_class = &colorspectrum_class,
1880 .
init = colorspectrum_init,
1890 #if CONFIG_COLORCHART_FILTER
1892 static const AVOption colorchart_options[] = {
1903 static const uint8_t reference_colors[][3] = {
1933 static const uint8_t skintones_colors[][3] = {
1963 typedef struct ColorChartPreset {
1965 const uint8_t (*colors)[3];
1968 static const ColorChartPreset colorchart_presets[] = {
1969 { 6, 4, reference_colors, },
1970 { 6, 4, skintones_colors, },
1988 const int w = colorchart_presets[
preset].w;
1989 const int h = colorchart_presets[
preset].h;
1990 const int pw =
test->pw;
1991 const int ph =
test->pw;
1993 for (
int y = 0; y <
h; y++) {
1994 for (
int x = 0; x <
w; x++) {
1995 uint32_t pc =
AV_RB24(colorchart_presets[
preset].colors[y *
w + x]);
2000 x * pw, y * ph, pw, ph);
2009 const int w = colorchart_presets[
preset].w;
2010 const int h = colorchart_presets[
preset].h;
2014 test->draw_once = 1;
2015 test->fill_picture_fn = colorchart_fill_picture;
2019 static const AVFilterPad avfilter_vsrc_colorchart_outputs[] = {
2023 .config_props = colorchart_config_props,
2028 .
name =
"colorchart",
2031 .priv_class = &colorchart_class,
2032 .
init = colorchart_init,
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
enum AVColorRange color_range
MPEG vs JPEG YUV range.
AVPixelFormat
Pixel format.
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
static int mix(int c0, int c1)
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
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)
#define AVERROR_EOF
End of file.
static av_cold void uninit(AVFilterContext *ctx)
#define FILTER_PIXFMTS_ARRAY(array)
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
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.
enum AVColorSpace colorspace
YUV colorspace type.
This structure describes decoded (raw) audio or video data.
const AVFilter ff_vsrc_color
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
#define FILTER_QUERY_FUNC(func)
const AVFilter ff_vsrc_pal75bars
#define AV_LOG_VERBOSE
Detailed information.
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
static av_cold int init(AVFilterContext *ctx)
const char * name
Filter name.
A link between two filters.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
const AVFilter ff_vsrc_haldclutsrc
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
@ AVCOL_SPC_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
const AVFilter ff_vsrc_yuvtestsrc
#define AV_PIX_FMT_GBRP14
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
void * priv
private data for use by the filter
#define AV_PIX_FMT_GBRP10
static void draw_rectangle(AVFormatContext *s)
static double val(void *priv, double ch)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
static av_always_inline float scale(float x, float s)
#define us(width, name, range_min, range_max, subs,...)
const AVFilter ff_vsrc_allrgb
void ff_blend_mask(FFDrawContext *draw, FFDrawColor *color, uint8_t *dst[], int dst_linesize[], int dst_w, int dst_h, const uint8_t *mask, int mask_linesize, int mask_w, int mask_h, int l2depth, unsigned endianness, int x0, int y0)
Blend an alpha mask with an uniform color.
static __device__ float fabsf(float a)
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_YUV444P10
const AVFilter ff_vsrc_pal100bars
int64_t duration
duration expressed in microseconds
#define FF_ARRAY_ELEMS(a)
static const uint16_t mask[17]
#define AV_PIX_FMT_GBRAP10
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
#define AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_YUV444P16
#define AV_CEIL_RSHIFT(a, b)
static double av_q2d(AVRational a)
Convert an AVRational to a double.
AVRational sample_aspect_ratio
agreed upon sample aspect ratio
#define av_assert0(cond)
assert() equivalent, that is always enabled.
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable; if left to 0/0,...
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
int ff_draw_init(FFDrawContext *draw, enum AVPixelFormat format, unsigned flags)
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
const AVFilter ff_vsrc_testsrc2
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
#define AV_PIX_FMT_GBRP16
AVRational sar
sample aspect ratio
#define AV_PIX_FMT_RGBA64
Describe the class of an AVClass context structure.
const AVFilter ff_vsrc_colorspectrum
Rational number (pair of numerator and denominator).
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
@ AV_PICTURE_TYPE_I
Intra.
#define NOSIZE_OPTIONS_OFFSET
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
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
const AVFilter ff_vsrc_colorchart
const AVFilter ff_vsrc_allyuv
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
AVFrame * picref
cached reference containing the painted picture
static const struct @328 planes[]
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
@ 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.
static int config_props(AVFilterLink *outlink)
const AVFilter ff_vsrc_smptehdbars
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 ...
#define FILTER_PIXFMTS(...)
void ff_blend_rectangle(FFDrawContext *draw, FFDrawColor *color, uint8_t *dst[], int dst_linesize[], int dst_w, int dst_h, int x0, int y0, int w, int h)
Blend a rectangle with an uniform color.
@ AV_ROUND_ZERO
Round toward zero.
#define AV_PIX_FMT_GBRPF32
int format
agreed upon media format
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
static AVRational av_make_q(int num, int den)
Create an AVRational.
#define AV_PIX_FMT_BGR555
void ff_fill_rectangle(FFDrawContext *draw, FFDrawColor *color, uint8_t *dst[], int dst_linesize[], int dst_x, int dst_y, int w, int h)
Fill a rectangle with an uniform color.
#define AV_PIX_FMT_YUV444P12
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
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
#define AVFILTER_DEFINE_CLASS(fname)
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
#define FILTER_SINGLE_PIXFMT(pix_fmt_)
int draw_once
draw only the first frame, always put out the same picture
#define AV_PIX_FMT_BGRA64
const uint8_t avpriv_vga16_font[4096]
#define i(width, name, range_min, range_max)
const AVFilter ff_vsrc_nullsrc
int w
agreed upon image width
AVFilterFormats * ff_draw_supported_pixel_formats(unsigned flags)
Return the list of pixel formats supported by the draw functions.
#define AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_BGR444
#define AV_PIX_FMT_RGB555
int ff_draw_round_to_sub(FFDrawContext *draw, int sub_dir, int round_dir, int value)
Round a dimension according to subsampling.
const AVFilter ff_vsrc_smptebars
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
#define AV_PIX_FMT_BGR565
const char * name
Pad name.
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
#define AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_RGB565
void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4])
Prepare a color.
@ AV_PIX_FMT_0BGR
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
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
static void draw_text(FFDrawContext *draw, AVFrame *out, FFDrawColor *color, int x0, int y0, const uint8_t *text)
const AVFilter ff_vsrc_rgbtestsrc
int h
agreed upon image height
static int activate(AVFilterContext *ctx)
AVFILTER_DEFINE_CLASS_EXT(nullsrc_yuvtestsrc, "nullsrc/yuvtestsrc", options)
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link.
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
static const int factor[16]
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
const AVFilter ff_vsrc_testsrc
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
static const int16_t alpha[]
#define FILTER_OUTPUTS(array)
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
int draw_once_reset
draw only the first frame or in case of reset
#define flags(name, subs,...)
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
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function. If this function returns true
#define AV_PIX_FMT_YUV444P14
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
void(* fill_picture_fn)(AVFilterContext *ctx, AVFrame *frame)
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted line
#define COMMON_OPTIONS_NOSIZE
static const AVOption options[]
#define AV_PIX_FMT_RGB444