Go to the documentation of this file.
36 #include "config_components.h"
103 #define OFFSET(x) offsetof(TestSourceContext, x)
104 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
105 #define FLAGSR AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
107 #define SIZE_OPTIONS \
108 { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },\
109 { "s", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },\
111 #define COMMON_OPTIONS_NOSIZE \
112 { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },\
113 { "r", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },\
114 { "duration", "set video duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },\
115 { "d", "set video duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },\
116 { "sar", "set video sample aspect ratio", OFFSET(sar), AV_OPT_TYPE_RATIONAL, {.dbl= 1}, 0, INT_MAX, FLAGS },
118 #define COMMON_OPTIONS SIZE_OPTIONS COMMON_OPTIONS_NOSIZE
120 #define NOSIZE_OPTIONS_OFFSET 2
138 test->duration < 0 ? -1 : (
double)
test->duration/1000000,
156 outlink->
w =
test->w;
157 outlink->
h =
test->h;
181 if (
test->duration >= 0 &&
187 if (
test->draw_once) {
188 if (
test->draw_once_reset) {
190 test->draw_once_reset = 0;
208 #if FF_API_INTERLACED_FRAME
210 frame->interlaced_frame = 0;
216 if (!
test->draw_once)
225 #if CONFIG_COLOR_FILTER
227 static const AVOption color_options[] = {
247 test->fill_picture_fn = color_fill_picture;
278 static int color_process_command(
AVFilterContext *
ctx,
const char *cmd,
const char *args,
279 char *res,
int res_len,
int flags)
289 test->draw_once_reset = 1;
297 .config_props = color_config_props,
304 .p.priv_class = &color_class,
311 .process_command = color_process_command,
316 #if CONFIG_HALDCLUTSRC_FILTER
318 static const AVOption haldclutsrc_options[] = {
328 int i, j, k, x = 0, y = 0, is16bit = 0,
step;
333 const int w =
frame->width;
334 const int h =
frame->height;
336 const ptrdiff_t linesize =
frame->linesize[0];
338 const int depth =
desc->comp[0].depth;
347 alpha = (1 << depth) - 1;
353 #define LOAD_CLUT(nbits) do { \
354 uint##nbits##_t *dst = ((uint##nbits##_t *)(data + y*linesize)) + x*step; \
355 dst[rgba_map[0]] = av_clip_uint##nbits(i * scale); \
356 dst[rgba_map[1]] = av_clip_uint##nbits(j * scale); \
357 dst[rgba_map[2]] = av_clip_uint##nbits(k * scale); \
359 dst[rgba_map[3]] = alpha; \
362 #define LOAD_CLUT_PLANAR(type, nbits) do { \
363 type *dst = ((type *)(frame->data[2] + y*frame->linesize[2])) + x; \
364 dst[0] = av_clip_uintp2(i * scale, nbits); \
365 dst = ((type *)(frame->data[0] + y*frame->linesize[0])) + x; \
366 dst[0] = av_clip_uintp2(j * scale, nbits); \
367 dst = ((type *)(frame->data[1] + y*frame->linesize[1])) + x; \
368 dst[0] = av_clip_uintp2(k * scale, nbits); \
370 dst = ((type *)(frame->data[3] + y*linesize)) + x; \
376 for (k = 0; k <
level; k++) {
377 for (j = 0; j <
level; j++) {
386 case 8: LOAD_CLUT_PLANAR(uint8_t, 8);
break;
387 case 9: LOAD_CLUT_PLANAR(uint16_t, 9);
break;
388 case 10: LOAD_CLUT_PLANAR(uint16_t,10);
break;
389 case 12: LOAD_CLUT_PLANAR(uint16_t,12);
break;
390 case 14: LOAD_CLUT_PLANAR(uint16_t,14);
break;
391 case 16: LOAD_CLUT_PLANAR(uint16_t,16);
break;
428 static int haldclutsrc_config_props(
AVFilterLink *outlink)
441 .config_props = haldclutsrc_config_props,
446 .
p.
name =
"haldclutsrc",
448 .p.priv_class = &haldclutsrc_class,
450 .
init = haldclutsrc_init,
460 #if CONFIG_NULLSRC_FILTER
468 test->fill_picture_fn = nullsrc_fill_picture;
475 .p.priv_class= &nullsrc_yuvtestsrc_class,
476 .init = nullsrc_init,
485 #if CONFIG_TESTSRC_FILTER
487 static const AVOption testsrc_options[] = {
508 static void draw_rectangle(
unsigned val, uint8_t *
dst, ptrdiff_t dst_linesize,
int segment_width,
509 int x,
int y,
int w,
int h)
514 dst += segment_width * (
step * x + y * dst_linesize);
515 w *= segment_width *
step;
517 for (
i = 0;
i <
h;
i++) {
523 static void draw_digit(
int digit, uint8_t *
dst, ptrdiff_t dst_linesize,
529 #define LEFT_TOP_VBAR 8
530 #define LEFT_BOT_VBAR 16
531 #define RIGHT_TOP_VBAR 32
532 #define RIGHT_BOT_VBAR 64
544 static const unsigned char masks[10] = {
545 TOP_HBAR |BOT_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
546 RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
547 TOP_HBAR|MID_HBAR|BOT_HBAR|LEFT_BOT_VBAR |RIGHT_TOP_VBAR,
548 TOP_HBAR|MID_HBAR|BOT_HBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
549 MID_HBAR |LEFT_TOP_VBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
550 TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR |RIGHT_BOT_VBAR,
551 TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR |RIGHT_BOT_VBAR,
552 TOP_HBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
553 TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
554 TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
556 unsigned mask = masks[digit];
563 segments[
i].x, segments[
i].y, segments[
i].
w, segments[
i].
h);
566 #define GRADIENT_SIZE (6 * 256)
573 int color, color_rest;
577 int dquad_x, dquad_y;
578 int grad, dgrad, rgrad, drgrad;
591 for (y = 0; y <
height; y++) {
597 for (x = 0; x <
width; x++) {
603 *(p++) = icolor & 1 ? 255 : 0;
604 *(p++) = icolor & 2 ? 255 : 0;
605 *(p++) = icolor & 4 ? 255 : 0;
607 if (color_rest >=
width) {
614 p0 +=
frame->linesize[0];
622 dgrad = GRADIENT_SIZE /
width;
623 drgrad = GRADIENT_SIZE %
width;
624 for (x = 0; x <
width; x++) {
626 grad < 256 || grad >= 5 * 256 ? 255 :
627 grad >= 2 * 256 &&
grad < 4 * 256 ? 0 :
630 grad >= 4 * 256 ? 0 :
631 grad >= 1 * 256 &&
grad < 3 * 256 ? 255 :
635 grad >= 3 * 256 &&
grad < 5 * 256 ? 255 :
639 if (rgrad >= GRADIENT_SIZE) {
641 rgrad -= GRADIENT_SIZE;
643 if (
grad >= GRADIENT_SIZE)
644 grad -= GRADIENT_SIZE;
647 for (y =
height / 8; y > 0; y--) {
649 p +=
frame->linesize[0];
653 seg_size =
width / 80;
654 if (seg_size >= 1 &&
height >= 13 * seg_size) {
661 for (x = 0; x <
test->nb_decimals; x++)
666 y = (
height - seg_size * 13) / 2;
667 p =
data + (x*3 + y *
frame->linesize[0]);
668 for (
i = 0;
i < 8;
i++) {
669 p -= 3 * 8 * seg_size;
670 draw_digit(second % 10, p,
frame->linesize[0], seg_size);
682 test->fill_picture_fn = test_fill_picture;
689 .p.priv_class = &testsrc_class,
702 uint8_t rgba[4] = { (argb >> 16) & 0xFF,
705 (argb >> 24) & 0xFF, };
709 #if CONFIG_TESTSRC2_FILTER
711 static const AVOption testsrc2_options[] = {
719 static uint32_t color_gradient(
unsigned index)
721 unsigned si =
index & 0xFF, sd = 0xFF - si;
722 switch (
index >> 8) {
723 case 0:
return 0xFF0000 + (si << 8);
724 case 1:
return 0x00FF00 + (sd << 16);
725 case 2:
return 0x00FF00 + (si << 0);
726 case 3:
return 0x0000FF + (sd << 8);
727 case 4:
return 0x0000FF + (si << 16);
728 case 5:
return 0xFF0000 + (sd << 0);
734 int x0,
int y0,
const uint8_t *text)
738 for (; *text; text++) {
755 unsigned alpha = (uint32_t)
s->alpha << 24;
759 unsigned i, x = 0, x2;
766 ((
i & 2) ? 0x00FF00 : 0) |
767 ((
i & 4) ? 0x0000FF : 0) |
770 x, 0, x2 - x,
frame->height);
778 unsigned x, dx, y0, y, g0,
g;
783 for (x = 0; x <
s->w; x += dx) {
787 y %= 2 * (
s->h - 16);
789 y = 2 * (
s->h - 16) - y;
797 if (
s->w >= 64 &&
s->h >= 64) {
798 int l = (
FFMIN(
s->w,
s->h) - 32) >> 1;
800 int xc = (
s->w >> 2) + (
s->w >> 1);
801 int yc = (
s->h >> 2);
806 for (
c = 0;
c < 3;
c++) {
811 pos < 3 * l ? 3 * l -
pos : 0;
812 yh =
pos < 1 * l ? 0 :
830 if (
s->w >= 64 &&
s->h >= 64) {
831 int l = (
FFMIN(
s->w,
s->h) - 16) >> 2;
833 int xc = (
s->w >> 2);
834 int yc = (
s->h >> 2) + (
s->h >> 1);
854 x1, ym1, x2 - x1, ym2 - ym1);
857 xm1, y1, xm2 - xm1, y2 - y1);
860 x1, y1, x2 - x1, y2 - y1);
873 for (y = ymin; y + 15 < ymax; y += 16) {
874 for (x = xmin; x + 15 < xmax; x += 16) {
877 for (
i = 0;
i < 256;
i++) {
878 r =
r * 1664525 + 1013904223;
884 alpha, 16, 16, 16, 3, 0, x, y);
890 if (
s->w >= 16 &&
s->h >= 16) {
891 unsigned w =
s->w - 8;
892 unsigned h =
s->h - 8;
917 snprintf(buf,
sizeof(buf),
"%02d:%02d:%02d.%03d\n%12"PRIi64,
918 time / 3600000, (time / 60000) % 60, (time / 1000) % 60,
919 time % 1000,
s->pts);
927 s->fill_picture_fn = test2_fill_picture;
944 inlink->color_range, 0) >= 0);
952 static const AVFilterPad avfilter_vsrc_testsrc2_outputs[] = {
956 .config_props = test2_config_props,
961 .
p.
name =
"testsrc2",
963 .p.priv_class = &testsrc2_class,
974 #if CONFIG_RGBTESTSRC_FILTER
976 static const AVOption rgbtestsrc_options[] = {
990 static void rgbtest_put_pixel(uint8_t *dstp[4],
int dst_linesizep[4],
995 uint8_t *
dst = dstp[0];
996 ptrdiff_t dst_linesize = dst_linesizep[0];
1003 case AV_PIX_FMT_BGR444: ((uint16_t*)(
dst + y*dst_linesize))[x] = ((
r >> 4) << 8) | ((
g >> 4) << 4) | (
b >> 4);
break;
1004 case AV_PIX_FMT_RGB444: ((uint16_t*)(
dst + y*dst_linesize))[x] = ((
b >> 4) << 8) | ((
g >> 4) << 4) | (
r >> 4);
break;
1011 v = (
r << (rgba_map[
R]*8)) + (
g << (rgba_map[
G]*8)) + (
b << (rgba_map[
B]*8));
1012 p =
dst + 3*x + y*dst_linesize;
1017 v16 = ((uint64_t)
r << (rgba_map[
R]*16)) + ((uint64_t)
g << (rgba_map[
G]*16)) + ((uint64_t)
b << (rgba_map[
B]*16));
1018 p16 = (uint16_t *)(
dst + 6*x + y*dst_linesize);
1025 v16 = ((uint64_t)
r << (rgba_map[
R]*16)) + ((uint64_t)
g << (rgba_map[
G]*16)) + ((uint64_t)
b << (rgba_map[
B]*16));
1026 p16 = (uint16_t *)(
dst + 8*x + y*dst_linesize);
1036 v = (
r << (rgba_map[
R]*8)) + (
g << (rgba_map[
G]*8)) + (
b << (rgba_map[
B]*8)) + (255
U << (rgba_map[
A]*8));
1037 p =
dst + 4*x + y*dst_linesize;
1042 v = (
r << ((
desc->comp[0].offset*8) +
desc->comp[0].shift)) +
1043 (
g << ((
desc->comp[1].offset*8) +
desc->comp[1].shift)) +
1044 (
b << ((
desc->comp[2].offset*8) +
desc->comp[2].shift)) +
1045 (3
U << ((
desc->comp[3].offset*8) +
desc->comp[3].shift));
1046 p =
dst + 4*x + y*dst_linesize;
1050 p = dstp[0] + x + y * dst_linesize;
1052 p = dstp[1] + x + y * dst_linesizep[1];
1054 p = dstp[2] + x + y * dst_linesizep[2];
1062 p16 = (uint16_t *)(dstp[0] + x*2 + y * dst_linesizep[0]);
1064 p16 = (uint16_t *)(dstp[1] + x*2 + y * dst_linesizep[1]);
1066 p16 = (uint16_t *)(dstp[2] + x*2 + y * dst_linesizep[2]);
1077 for (y = 0; y <
h; y++) {
1078 for (x = 0; x <
w; x++) {
1080 int r = 0,
g = 0,
b = 0;
1082 if (6*y <
h )
r =
c;
1083 else if (6*y < 2*
h)
g =
c,
b =
c;
1084 else if (6*y < 3*
h)
g =
c;
1085 else if (6*y < 4*
h)
r =
c,
b =
c;
1086 else if (6*y < 5*
h)
b =
c;
1089 rgbtest_put_pixel(
frame->data,
frame->linesize, x, y,
r,
g,
b,
1090 ctx->outputs[0]->format,
test->rgba_map);
1100 for (y = 0; y <
h; y++) {
1101 for (x = 0; x <
w; x++) {
1103 int r = 0,
g = 0,
b = 0;
1105 if (3*y <
h )
r =
c;
1106 else if (3*y < 2*
h)
g =
c;
1109 rgbtest_put_pixel(
frame->data,
frame->linesize, x, y,
r,
g,
b,
1110 ctx->outputs[0]->format,
test->rgba_map);
1119 test->draw_once = 1;
1120 test->fill_picture_fn =
test->complement ? rgbtest_fill_picture_complement : rgbtest_fill_picture;
1148 static const AVFilterPad avfilter_vsrc_rgbtestsrc_outputs[] = {
1152 .config_props = rgbtest_config_props,
1157 .
p.
name =
"rgbtestsrc",
1159 .p.priv_class = &rgbtestsrc_class,
1161 .
init = rgbtest_init,
1175 #if CONFIG_YUVTESTSRC_FILTER
1182 static void yuvtest_put_pixel(uint8_t *dstp[4],
int dst_linesizep[4],
1183 int i,
int j,
unsigned y,
unsigned u,
unsigned v,
enum AVPixelFormat fmt,
1184 uint8_t ayuv_map[4])
1191 n = (y << (ayuv_map[
Y]*8)) + (
u << (ayuv_map[
U]*8)) + (v << (ayuv_map[
V]*8));
1192 AV_WL24(&dstp[0][
i*3 + j*dst_linesizep[0]], n);
1196 n = (y << ((
desc->comp[0].offset*8) +
desc->comp[0].shift)) +
1197 (
u << ((
desc->comp[1].offset*8) +
desc->comp[1].shift)) +
1198 (v << ((
desc->comp[2].offset*8) +
desc->comp[2].shift)) +
1199 (3
U << ((
desc->comp[3].offset*8) +
desc->comp[3].shift));
1200 AV_WL32(&dstp[0][
i*4 + j*dst_linesizep[0]], n);
1205 AV_WN16(&dstp[0][
i*8 + ayuv_map[
Y]*2 + j*dst_linesizep[0]], y <<
desc->comp[0].shift);
1206 AV_WN16(&dstp[0][
i*8 + ayuv_map[
U]*2 + j*dst_linesizep[0]],
u <<
desc->comp[1].shift);
1207 AV_WN16(&dstp[0][
i*8 + ayuv_map[
V]*2 + j*dst_linesizep[0]], v <<
desc->comp[2].shift);
1208 AV_WN16(&dstp[0][
i*8 + ayuv_map[
A]*2 + j*dst_linesizep[0]], UINT16_MAX <<
desc->comp[3].shift);
1214 n = (y << (ayuv_map[
Y]*8)) + (
u << (ayuv_map[
U]*8)) + (v << (ayuv_map[
V]*8)) + (255
U << (ayuv_map[
A]*8));
1215 AV_WL32(&dstp[0][
i*4 + j*dst_linesizep[0]], n);
1219 dstp[0][
i + j*dst_linesizep[0]] = y;
1220 dstp[1][
i + j*dst_linesizep[1]] =
u;
1221 dstp[2][
i + j*dst_linesizep[2]] = v;
1228 AV_WN16(&dstp[0][
i*2 + j*dst_linesizep[0]], y);
1229 AV_WN16(&dstp[1][
i*2 + j*dst_linesizep[1]],
u);
1230 AV_WN16(&dstp[2][
i*2 + j*dst_linesizep[2]], v);
1233 dstp[0][
i + j*dst_linesizep[0] + 0] = y;
1234 dstp[1][
i*2 + j*dst_linesizep[1] + 0] =
u;
1235 dstp[1][
i*2 + j*dst_linesizep[1] + 1] = v;
1238 dstp[0][
i + j*dst_linesizep[0] + 0] = y;
1239 dstp[1][
i*2 + j*dst_linesizep[1] + 1] =
u;
1240 dstp[1][
i*2 + j*dst_linesizep[1] + 0] = v;
1245 AV_WN16(&dstp[0][
i*2 + j*dst_linesizep[0] + 0], y << (16 -
desc->comp[0].depth));
1246 AV_WN16(&dstp[1][
i*4 + j*dst_linesizep[1] + 0],
u << (16 -
desc->comp[1].depth));
1247 AV_WN16(&dstp[1][
i*4 + j*dst_linesizep[1] + 2], v << (16 -
desc->comp[1].depth));
1258 const int mid = 1 << (
desc->comp[0].depth - 1);
1260 for (j = 0; j <
h; j++) {
1261 for (
i = 0;
i <
w;
i++) {
1263 int y = mid,
u = mid, v = mid;
1265 if (3*j <
h ) y =
c;
1266 else if (3*j < 2*
h)
u =
c;
1269 yuvtest_put_pixel(
frame->data,
frame->linesize,
i, j, y,
u, v,
1270 ctx->outputs[0]->format,
test->ayuv_map);
1279 test->draw_once = 1;
1280 test->fill_picture_fn = yuvtest_fill_picture;
1305 static const AVFilterPad avfilter_vsrc_yuvtestsrc_outputs[] = {
1309 .config_props = yuvtest_config_props,
1314 .
p.
name =
"yuvtestsrc",
1316 .p.priv_class = &nullsrc_yuvtestsrc_class,
1318 .
init = yuvtest_init,
1332 #if CONFIG_PAL75BARS_FILTER || CONFIG_PAL100BARS_FILTER || CONFIG_SMPTEBARS_FILTER || CONFIG_SMPTEHDBARS_FILTER
1334 static const uint8_t rainbow[7][4] = {
1335 { 180, 128, 128, 255 },
1336 { 162, 44, 142, 255 },
1337 { 131, 156, 44, 255 },
1338 { 112, 72, 58, 255 },
1339 { 84, 184, 198, 255 },
1340 { 65, 100, 212, 255 },
1341 { 35, 212, 114, 255 },
1344 static const uint8_t rainbow100[7][4] = {
1345 { 235, 128, 128, 255 },
1346 { 210, 16, 146, 255 },
1347 { 170, 166, 16, 255 },
1348 { 145, 54, 34, 255 },
1349 { 106, 202, 222, 255 },
1350 { 81, 90, 240, 255 },
1351 { 41, 240, 110, 255 },
1354 static const uint8_t rainbowhd[7][4] = {
1355 { 180, 128, 128, 255 },
1356 { 168, 44, 136, 255 },
1357 { 145, 147, 44, 255 },
1358 { 133, 63, 52, 255 },
1359 { 63, 193, 204, 255 },
1360 { 51, 109, 212, 255 },
1361 { 28, 212, 120, 255 },
1364 static const uint8_t wobnair[7][4] = {
1365 { 35, 212, 114, 255 },
1366 { 19, 128, 128, 255 },
1367 { 84, 184, 198, 255 },
1368 { 19, 128, 128, 255 },
1369 { 131, 156, 44, 255 },
1370 { 19, 128, 128, 255 },
1371 { 180, 128, 128, 255 },
1374 static const uint8_t white[4] = { 235, 128, 128, 255 };
1377 static const uint8_t neg4ire[4] = { 7, 128, 128, 255 };
1378 static const uint8_t pos4ire[4] = { 24, 128, 128, 255 };
1381 static const uint8_t i_pixel[4] = { 57, 156, 97, 255 };
1382 static const uint8_t q_pixel[4] = { 44, 171, 147, 255 };
1384 static const uint8_t gray40[4] = { 104, 128, 128, 255 };
1385 static const uint8_t gray15[4] = { 49, 128, 128, 255 };
1386 static const uint8_t cyan[4] = { 188, 154, 16, 255 };
1387 static const uint8_t yellow[4] = { 219, 16, 138, 255 };
1388 static const uint8_t blue[4] = { 32, 240, 118, 255 };
1389 static const uint8_t red[4] = { 63, 102, 240, 255 };
1390 static const uint8_t black0[4] = { 16, 128, 128, 255 };
1391 static const uint8_t black2[4] = { 20, 128, 128, 255 };
1392 static const uint8_t black4[4] = { 25, 128, 128, 255 };
1393 static const uint8_t neg2[4] = { 12, 128, 128, 255 };
1396 int x,
int y,
int w,
int h,
1411 for (plane = 0;
frame->data[plane]; plane++) {
1412 const int c =
color[plane];
1413 const ptrdiff_t linesize =
frame->linesize[plane];
1414 int i, px, py, pw,
ph;
1416 if (plane == 1 || plane == 2) {
1417 px = x >>
desc->log2_chroma_w;
1419 py = y >>
desc->log2_chroma_h;
1428 p0 = p =
frame->data[plane] + py * linesize + px;
1431 for (
i = 1;
i <
ph;
i++, p += linesize)
1450 if (!strcmp(
ctx->name,
"smptehdbars")) {
1467 #if CONFIG_PAL75BARS_FILTER
1479 for (
i = 1;
i < 7;
i++) {
1490 test->fill_picture_fn = pal75bars_fill_picture;
1491 test->draw_once = 1;
1496 .
p.
name =
"pal75bars",
1498 .p.priv_class = &palbars_class,
1500 .
init = pal75bars_init,
1509 #if CONFIG_PAL100BARS_FILTER
1519 for (
i = 0;
i < 7;
i++) {
1530 test->fill_picture_fn = pal100bars_fill_picture;
1531 test->draw_once = 1;
1536 .
p.
name =
"pal100bars",
1538 .p.priv_class = &palbars_class,
1540 .
init = pal100bars_init,
1551 #if CONFIG_SMPTEBARS_FILTER
1556 int r_w, r_h, w_h, p_w, p_h,
i,
tmp, x = 0;
1563 p_h =
test->h - w_h - r_h;
1565 for (
i = 0;
i < 7;
i++) {
1571 draw_bar(
test, i_pixel, x, r_h + w_h, p_w, p_h, picref);
1575 draw_bar(
test, q_pixel, x, r_h + w_h, p_w, p_h, picref);
1594 test->fill_picture_fn = smptebars_fill_picture;
1595 test->draw_once = 1;
1600 .
p.
name =
"smptebars",
1602 .p.priv_class = &smptebars_class,
1604 .
init = smptebars_init,
1613 #if CONFIG_SMPTEHDBARS_FILTER
1618 int d_w, r_w, r_h, l_w,
i,
tmp, x = 0, y = 0;
1627 for (
i = 0;
i < 7;
i++) {
1650 uint8_t yramp[4] = {0};
1652 yramp[0] =
i * 255 /
tmp;
1694 test->fill_picture_fn = smptehdbars_fill_picture;
1695 test->draw_once = 1;
1700 .
p.
name =
"smptehdbars",
1702 .p.priv_class = &smptebars_class,
1704 .
init = smptehdbars_init,
1717 #if CONFIG_ALLYUV_FILTER
1721 const ptrdiff_t ys =
frame->linesize[0];
1722 const ptrdiff_t
us =
frame->linesize[1];
1723 const ptrdiff_t vs =
frame->linesize[2];
1726 for (y = 0; y < 4096; y++) {
1727 for (x = 0; x < 2048; x++) {
1728 frame->data[0][y * ys + x] = ((x / 8) % 256);
1729 frame->data[0][y * ys + 4095 - x] = ((x / 8) % 256);
1732 for (x = 0; x < 2048; x+=8) {
1733 for (j = 0; j < 8; j++) {
1734 frame->data[1][vs * y + x + j] = (y%16 + (j % 8) * 16);
1735 frame->data[1][vs * y + 4095 - x - j] = (128 + y%16 + (j % 8) * 16);
1739 for (x = 0; x < 4096; x++)
1740 frame->data[2][y *
us + x] = 256 * y / 4096;
1749 test->draw_once = 1;
1750 test->fill_picture_fn = allyuv_fill_picture;
1757 .p.priv_class = &allyuv_allrgb_class,
1759 .
init = allyuv_init,
1768 #if CONFIG_ALLRGB_FILTER
1773 const ptrdiff_t linesize =
frame->linesize[0];
1776 for (y = 0; y < 4096; y++) {
1779 for (x = 0; x < 4096; x++) {
1782 *
dst++ = (x >> 8) | ((y >> 8) << 4);
1793 test->draw_once = 1;
1794 test->fill_picture_fn = allrgb_fill_picture;
1806 static const AVFilterPad avfilter_vsrc_allrgb_outputs[] = {
1810 .config_props = allrgb_config_props,
1817 .p.priv_class = &allyuv_allrgb_class,
1819 .
init = allrgb_init,
1828 #if CONFIG_COLORSPECTRUM_FILTER
1830 static const AVOption colorspectrum_options[] = {
1841 static inline float mix(
float a,
float b,
float mix)
1846 static void hsb2rgb(
const float *
c,
float *
rgb)
1859 const float w =
frame->width - 1.f;
1860 const float h =
frame->height - 1.f;
1863 for (
int y = 0; y <
frame->height; y++) {
1864 float *
r = (
float *)(
frame->data[2] + y *
frame->linesize[2]);
1865 float *
g = (
float *)(
frame->data[0] + y *
frame->linesize[0]);
1866 float *
b = (
float *)(
frame->data[1] + y *
frame->linesize[1]);
1867 const float yh = y /
h;
1869 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;
1871 c[3] =
test->type == 1 ? 1.f :
test->type == 2 ? (yh > 0.5f ? 0.f : 1.f): 0.f;
1872 for (
int x = 0; x <
frame->width; x++) {
1889 test->draw_once = 1;
1890 test->fill_picture_fn = colorspectrum_fill_picture;
1895 .
p.
name =
"colorspectrum",
1897 .p.priv_class = &colorspectrum_class,
1899 .
init = colorspectrum_init,
1908 #if CONFIG_COLORCHART_FILTER
1910 static const AVOption colorchart_options[] = {
1921 static const uint8_t reference_colors[][3] = {
1951 static const uint8_t skintones_colors[][3] = {
1981 typedef struct ColorChartPreset {
1983 const uint8_t (*colors)[3];
1986 static const ColorChartPreset colorchart_presets[] = {
1987 { 6, 4, reference_colors, },
1988 { 6, 4, skintones_colors, },
1997 inlink->color_range, 0) >= 0);
2007 const int w = colorchart_presets[
preset].w;
2008 const int h = colorchart_presets[
preset].h;
2009 const int pw =
test->pw;
2012 for (
int y = 0; y <
h; y++) {
2013 for (
int x = 0; x <
w; x++) {
2014 uint32_t pc =
AV_RB24(colorchart_presets[
preset].colors[y *
w + x]);
2019 x * pw, y *
ph, pw,
ph);
2028 const int w = colorchart_presets[
preset].w;
2029 const int h = colorchart_presets[
preset].h;
2033 test->draw_once = 1;
2034 test->fill_picture_fn = colorchart_fill_picture;
2038 static const AVFilterPad avfilter_vsrc_colorchart_outputs[] = {
2042 .config_props = colorchart_config_props,
2047 .
p.
name =
"colorchart",
2049 .p.priv_class = &colorchart_class,
2051 .
init = colorchart_init,
2060 #if CONFIG_ZONEPLATE_FILTER
2062 static const AVOption zoneplate_options[] = {
2085 #define ZONEPLATE_SLICE(name, type) \
2086 static int zoneplate_fill_slice_##name(AVFilterContext *ctx, \
2087 void *arg, int job, \
2090 TestSourceContext *test = ctx->priv; \
2091 AVFrame *frame = arg; \
2092 const int w = frame->width; \
2093 const int h = frame->height; \
2094 const int kxt = test->kxt, kyt = test->kyt, kx2 = test->kx2; \
2095 const int t = test->pts + test->to, k0 = test->k0; \
2096 const int kt = test->kt, kt2 = test->kt2, ky2 = test->ky2; \
2097 const int ky = test->ky, kx = test->kx, kxy = test->kxy; \
2098 const int lut_mask = (1 << test->lut_precision) - 1; \
2099 const int nkt2t = kt2 * t * t, nktt = kt * t; \
2100 const int start = (h * job ) / nb_jobs; \
2101 const int end = (h * (job+1)) / nb_jobs; \
2102 const ptrdiff_t ylinesize = frame->linesize[0] / sizeof(type); \
2103 const ptrdiff_t ulinesize = frame->linesize[1] / sizeof(type); \
2104 const ptrdiff_t vlinesize = frame->linesize[2] / sizeof(type); \
2105 const int xreset = -(w / 2) - test->xo; \
2106 const int yreset = -(h / 2) - test->yo + start; \
2107 const int kU = test->kU, kV = test->kV; \
2108 const int skxy = 0xffff / (w / 2); \
2109 const int skx2 = 0xffff / w; \
2110 const int dkxt = kxt * t; \
2111 type *ydst = ((type *)frame->data[0]) + start * ylinesize; \
2112 type *udst = ((type *)frame->data[1]) + start * ulinesize; \
2113 type *vdst = ((type *)frame->data[2]) + start * vlinesize; \
2114 const type *lut = (const type *)test->lut; \
2115 int akx, akxt, aky, akyt; \
2118 akyt = start * kyt * t; \
2120 for (int j = start, y = yreset; j < end; j++, y++) { \
2121 const int dkxy = kxy * y * skxy; \
2122 const int nky2kt2 = (ky2 * y * y) / h + (nkt2t >> 1); \
2123 int akxy = dkxy * xreset; \
2130 for (int i = 0, x = xreset; i < w; i++, x++) { \
2131 int phase = k0, uphase = kU, vphase = kV; \
2134 phase += akx + aky + nktt; \
2138 phase += akxt + akyt; \
2139 phase += akxy >> 16; \
2140 phase += ((kx2 * x * x * skx2) >> 16) + nky2kt2; \
2144 ydst[i] = lut[phase & lut_mask]; \
2145 udst[i] = lut[uphase & lut_mask]; \
2146 vdst[i] = lut[vphase & lut_mask]; \
2149 ydst += ylinesize; \
2150 udst += ulinesize; \
2151 vdst += vlinesize; \
2157 ZONEPLATE_SLICE( 8, uint8_t)
2158 ZONEPLATE_SLICE( 9, uint16_t)
2159 ZONEPLATE_SLICE(10, uint16_t)
2160 ZONEPLATE_SLICE(12, uint16_t)
2161 ZONEPLATE_SLICE(14, uint16_t)
2162 ZONEPLATE_SLICE(16, uint16_t)
2171 static int zoneplate_config_props(
AVFilterLink *outlink)
2176 const int lut_size = 1 <<
test->lut_precision;
2177 const int depth =
desc->comp[0].depth;
2189 lut16 = (uint16_t *)
test->lut;
2192 for (
int i = 0;
i < lut_size;
i++)
2196 for (
int i = 0;
i < lut_size;
i++)
2197 lut16[
i] =
lrintf(((1 << depth) - 1) * (0.5f + 0.5f *
sinf((2.
f *
M_PI *
i) / lut_size)));
2201 test->draw_once = 0;
2202 test->fill_picture_fn = zoneplate_fill_picture;
2205 case 8:
test->fill_slice_fn = zoneplate_fill_slice_8;
break;
2206 case 9:
test->fill_slice_fn = zoneplate_fill_slice_9;
break;
2207 case 10:
test->fill_slice_fn = zoneplate_fill_slice_10;
break;
2208 case 12:
test->fill_slice_fn = zoneplate_fill_slice_12;
break;
2209 case 14:
test->fill_slice_fn = zoneplate_fill_slice_14;
break;
2210 case 16:
test->fill_slice_fn = zoneplate_fill_slice_16;
break;
2233 static const AVFilterPad avfilter_vsrc_zoneplate_outputs[] = {
2237 .config_props = zoneplate_config_props,
2242 .
p.
name =
"zoneplate",
2244 .p.priv_class = &zoneplate_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
#define FF_ENABLE_DEPRECATION_WARNINGS
@ AV_PIX_FMT_XV30LE
packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), little-endian, variant of Y410 where alpha channe...
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
#define FILTER_PIXFMTS_ARRAY(array)
#define u(width, name, range_min, range_max)
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)
static const struct @475 planes[]
const FFFilter ff_vsrc_yuvtestsrc
#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.
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
This structure describes decoded (raw) audio or video data.
const FFFilter ff_vsrc_testsrc2
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
@ AVCOL_RANGE_JPEG
Full range content.
@ AV_ROUND_ZERO
Round toward zero.
#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.
Link properties exposed to filter code, but not external callers.
const FFFilter ff_vsrc_nullsrc
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
#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)
const FFFilter ff_vsrc_allrgb
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
#define us(width, name, range_min, range_max, subs,...)
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.
@ AV_PIX_FMT_VUYA
packed VUYA 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), VUYAVUYA...
#define AV_PIX_FMT_YUV444P10
int64_t duration
duration expressed in microseconds
#define FF_ARRAY_ELEMS(a)
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
#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.
const FFFilter ff_vsrc_pal100bars
const FFFilter ff_vsrc_zoneplate
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.
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)
#define FILTER_OUTPUTS(array)
@ 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.
static double grad(int hash, double x, double y, double z)
Rational number (pair of numerator and denominator).
@ AV_OPT_TYPE_COLOR
Underlying C type is uint8_t[4].
@ AV_OPT_TYPE_IMAGE_SIZE
Underlying C type is two consecutive integers.
@ AV_PICTURE_TYPE_I
Intra.
#define NOSIZE_OPTIONS_OFFSET
int ff_fill_ayuv_map(uint8_t *ayuv_map, enum AVPixelFormat pix_fmt)
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
const FFFilter ff_vsrc_colorspectrum
#define AVFILTER_DEFINE_CLASS(fname)
@ 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 FilterLink * ff_filter_link(AVFilterLink *link)
@ AV_PIX_FMT_X2RGB10LE
packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined
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)
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 ...
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
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.
int ff_draw_init2(FFDrawContext *draw, enum AVPixelFormat format, enum AVColorSpace csp, enum AVColorRange range, unsigned flags)
Init a draw context.
#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
#define AV_PIX_FMT_AYUV64
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
static void draw_bar(ShowCWTContext *s, int y, float Y, float U, float V)
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
const FFFilter ff_vsrc_allyuv
@ AV_PIX_FMT_AYUV
packed AYUV 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), AYUVAYUV...
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
@ AV_PIX_FMT_UYVA
packed UYVA 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), UYVAUYVA...
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)
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.
const FFFilter ff_vsrc_smptebars
#define AV_PIX_FMT_GBRP12
AVColorSpace
YUV colorspace type.
@ AV_PIX_FMT_NV24
planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
#define AV_PIX_FMT_BGR444
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
#define AV_PIX_FMT_RGB555
#define FILTER_QUERY_FUNC2(func)
int ff_draw_round_to_sub(FFDrawContext *draw, int sub_dir, int round_dir, int value)
Round a dimension according to subsampling.
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
#define AV_PIX_FMT_BGR565
const char * name
Pad name.
#define FILTER_PIXFMTS(...)
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
@ AV_PIX_FMT_NV42
as above, but U and V bytes are swapped
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
void * av_calloc(size_t nmemb, size_t size)
#define AV_PIX_FMT_YUV444P9
const FFFilter ff_vsrc_haldclutsrc
#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 const AVFilterPad outputs[]
static void draw_text(FFDrawContext *draw, AVFrame *out, FFDrawColor *color, int x0, int y0, const uint8_t *text)
static const int16_t steps[16]
const FFFilter ff_vsrc_testsrc
int h
agreed upon image height
int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
static int activate(AVFilterContext *ctx)
const FFFilter ff_vsrc_colorchart
@ AV_OPT_TYPE_INT
Underlying C type is int.
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]
#define FF_DISABLE_DEPRECATION_WARNINGS
@ 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...
int(* fill_slice_fn)(AVFilterContext *ctx, void *arg, int job, int nb_jobs)
AVFilter p
The public AVFilter.
@ AV_PIX_FMT_X2BGR10LE
packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined
@ AV_PIX_FMT_V30XLE
packed VYUX 4:4:4 like XV30, 32bpp, (msb)10V 10Y 10U 2X(lsb), little-endian
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
static void scale(int *out, const int *in, const int w, const int h, const int shift)
static const int16_t alpha[]
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
@ 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)
const FFFilter ff_vsrc_color
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
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable.
#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...
const FFFilter ff_vsrc_rgbtestsrc
@ AV_PIX_FMT_VUYX
packed VUYX 4:4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined
const FFFilter ff_vsrc_pal75bars
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
@ AV_PIX_FMT_VYU444
packed VYU 4:4:4, 24bpp (1 Cr & Cb sample per 1x1 Y), VYUVYU...
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
#define FILTER_SINGLE_PIXFMT(pix_fmt_)
void(* fill_picture_fn)(AVFilterContext *ctx, AVFrame *frame)
const FFFilter ff_vsrc_smptehdbars
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
static void av_unused set_color(TestSourceContext *s, FFDrawColor *color, uint32_t argb)
#define COMMON_OPTIONS_NOSIZE
#define AV_PIX_FMT_RGB444