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 .priv_class = &color_class,
312 .process_command = color_process_command,
317 #if CONFIG_HALDCLUTSRC_FILTER
319 static const AVOption haldclutsrc_options[] = {
329 int i, j, k, x = 0, y = 0, is16bit = 0,
step;
334 const int w =
frame->width;
335 const int h =
frame->height;
337 const ptrdiff_t linesize =
frame->linesize[0];
339 const int depth =
desc->comp[0].depth;
348 alpha = (1 << depth) - 1;
354 #define LOAD_CLUT(nbits) do { \
355 uint##nbits##_t *dst = ((uint##nbits##_t *)(data + y*linesize)) + x*step; \
356 dst[rgba_map[0]] = av_clip_uint##nbits(i * scale); \
357 dst[rgba_map[1]] = av_clip_uint##nbits(j * scale); \
358 dst[rgba_map[2]] = av_clip_uint##nbits(k * scale); \
360 dst[rgba_map[3]] = alpha; \
363 #define LOAD_CLUT_PLANAR(type, nbits) do { \
364 type *dst = ((type *)(frame->data[2] + y*frame->linesize[2])) + x; \
365 dst[0] = av_clip_uintp2(i * scale, nbits); \
366 dst = ((type *)(frame->data[0] + y*frame->linesize[0])) + x; \
367 dst[0] = av_clip_uintp2(j * scale, nbits); \
368 dst = ((type *)(frame->data[1] + y*frame->linesize[1])) + x; \
369 dst[0] = av_clip_uintp2(k * scale, nbits); \
371 dst = ((type *)(frame->data[3] + y*linesize)) + x; \
377 for (k = 0; k <
level; k++) {
378 for (j = 0; j <
level; j++) {
387 case 8: LOAD_CLUT_PLANAR(uint8_t, 8);
break;
388 case 9: LOAD_CLUT_PLANAR(uint16_t, 9);
break;
389 case 10: LOAD_CLUT_PLANAR(uint16_t,10);
break;
390 case 12: LOAD_CLUT_PLANAR(uint16_t,12);
break;
391 case 14: LOAD_CLUT_PLANAR(uint16_t,14);
break;
392 case 16: LOAD_CLUT_PLANAR(uint16_t,16);
break;
429 static int haldclutsrc_config_props(
AVFilterLink *outlink)
442 .config_props = haldclutsrc_config_props,
447 .
name =
"haldclutsrc",
449 .priv_class = &haldclutsrc_class,
451 .
init = haldclutsrc_init,
462 #if CONFIG_NULLSRC_FILTER
470 test->fill_picture_fn = nullsrc_fill_picture;
477 .priv_class = &nullsrc_yuvtestsrc_class,
478 .init = nullsrc_init,
488 #if CONFIG_TESTSRC_FILTER
490 static const AVOption testsrc_options[] = {
511 static void draw_rectangle(
unsigned val, uint8_t *
dst, ptrdiff_t dst_linesize,
int segment_width,
512 int x,
int y,
int w,
int h)
517 dst += segment_width * (
step * x + y * dst_linesize);
518 w *= segment_width *
step;
520 for (
i = 0;
i <
h;
i++) {
526 static void draw_digit(
int digit, uint8_t *
dst, ptrdiff_t dst_linesize,
532 #define LEFT_TOP_VBAR 8
533 #define LEFT_BOT_VBAR 16
534 #define RIGHT_TOP_VBAR 32
535 #define RIGHT_BOT_VBAR 64
547 static const unsigned char masks[10] = {
548 TOP_HBAR |BOT_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
549 RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
550 TOP_HBAR|MID_HBAR|BOT_HBAR|LEFT_BOT_VBAR |RIGHT_TOP_VBAR,
551 TOP_HBAR|MID_HBAR|BOT_HBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
552 MID_HBAR |LEFT_TOP_VBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
553 TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR |RIGHT_BOT_VBAR,
554 TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR |RIGHT_BOT_VBAR,
555 TOP_HBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
556 TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
557 TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
559 unsigned mask = masks[digit];
566 segments[
i].x, segments[
i].y, segments[
i].
w, segments[
i].
h);
569 #define GRADIENT_SIZE (6 * 256)
576 int color, color_rest;
580 int dquad_x, dquad_y;
581 int grad, dgrad, rgrad, drgrad;
594 for (y = 0; y <
height; y++) {
600 for (x = 0; x <
width; x++) {
606 *(p++) = icolor & 1 ? 255 : 0;
607 *(p++) = icolor & 2 ? 255 : 0;
608 *(p++) = icolor & 4 ? 255 : 0;
610 if (color_rest >=
width) {
617 p0 +=
frame->linesize[0];
625 dgrad = GRADIENT_SIZE /
width;
626 drgrad = GRADIENT_SIZE %
width;
627 for (x = 0; x <
width; x++) {
629 grad < 256 || grad >= 5 * 256 ? 255 :
630 grad >= 2 * 256 &&
grad < 4 * 256 ? 0 :
633 grad >= 4 * 256 ? 0 :
634 grad >= 1 * 256 &&
grad < 3 * 256 ? 255 :
638 grad >= 3 * 256 &&
grad < 5 * 256 ? 255 :
642 if (rgrad >= GRADIENT_SIZE) {
644 rgrad -= GRADIENT_SIZE;
646 if (
grad >= GRADIENT_SIZE)
647 grad -= GRADIENT_SIZE;
650 for (y =
height / 8; y > 0; y--) {
652 p +=
frame->linesize[0];
656 seg_size =
width / 80;
657 if (seg_size >= 1 &&
height >= 13 * seg_size) {
664 for (x = 0; x <
test->nb_decimals; x++)
669 y = (
height - seg_size * 13) / 2;
670 p =
data + (x*3 + y *
frame->linesize[0]);
671 for (
i = 0;
i < 8;
i++) {
672 p -= 3 * 8 * seg_size;
673 draw_digit(second % 10, p,
frame->linesize[0], seg_size);
685 test->fill_picture_fn = test_fill_picture;
693 .priv_class = &testsrc_class,
706 uint8_t rgba[4] = { (argb >> 16) & 0xFF,
709 (argb >> 24) & 0xFF, };
713 #if CONFIG_TESTSRC2_FILTER
715 static const AVOption testsrc2_options[] = {
723 static uint32_t color_gradient(
unsigned index)
725 unsigned si =
index & 0xFF, sd = 0xFF - si;
726 switch (
index >> 8) {
727 case 0:
return 0xFF0000 + (si << 8);
728 case 1:
return 0x00FF00 + (sd << 16);
729 case 2:
return 0x00FF00 + (si << 0);
730 case 3:
return 0x0000FF + (sd << 8);
731 case 4:
return 0x0000FF + (si << 16);
732 case 5:
return 0xFF0000 + (sd << 0);
738 int x0,
int y0,
const uint8_t *text)
742 for (; *text; text++) {
759 unsigned alpha = (uint32_t)
s->alpha << 24;
763 unsigned i, x = 0, x2;
770 ((
i & 2) ? 0x00FF00 : 0) |
771 ((
i & 4) ? 0x0000FF : 0) |
774 x, 0, x2 - x,
frame->height);
782 unsigned x, dx, y0, y, g0,
g;
787 for (x = 0; x <
s->w; x += dx) {
791 y %= 2 * (
s->h - 16);
793 y = 2 * (
s->h - 16) - y;
801 if (
s->w >= 64 &&
s->h >= 64) {
802 int l = (
FFMIN(
s->w,
s->h) - 32) >> 1;
804 int xc = (
s->w >> 2) + (
s->w >> 1);
805 int yc = (
s->h >> 2);
810 for (
c = 0;
c < 3;
c++) {
815 pos < 3 * l ? 3 * l -
pos : 0;
816 yh =
pos < 1 * l ? 0 :
834 if (
s->w >= 64 &&
s->h >= 64) {
835 int l = (
FFMIN(
s->w,
s->h) - 16) >> 2;
837 int xc = (
s->w >> 2);
838 int yc = (
s->h >> 2) + (
s->h >> 1);
858 x1, ym1, x2 - x1, ym2 - ym1);
861 xm1, y1, xm2 - xm1, y2 - y1);
864 x1, y1, x2 - x1, y2 - y1);
877 for (y = ymin; y + 15 < ymax; y += 16) {
878 for (x = xmin; x + 15 < xmax; x += 16) {
881 for (
i = 0;
i < 256;
i++) {
882 r =
r * 1664525 + 1013904223;
888 alpha, 16, 16, 16, 3, 0, x, y);
894 if (
s->w >= 16 &&
s->h >= 16) {
895 unsigned w =
s->w - 8;
896 unsigned h =
s->h - 8;
921 snprintf(buf,
sizeof(buf),
"%02d:%02d:%02d.%03d\n%12"PRIi64,
922 time / 3600000, (time / 60000) % 60, (time / 1000) % 60,
923 time % 1000,
s->pts);
931 s->fill_picture_fn = test2_fill_picture;
948 inlink->color_range, 0) >= 0);
956 static const AVFilterPad avfilter_vsrc_testsrc2_outputs[] = {
960 .config_props = test2_config_props,
968 .priv_class = &testsrc2_class,
979 #if CONFIG_RGBTESTSRC_FILTER
981 static const AVOption rgbtestsrc_options[] = {
995 static void rgbtest_put_pixel(uint8_t *dstp[4],
int dst_linesizep[4],
1000 uint8_t *
dst = dstp[0];
1001 ptrdiff_t dst_linesize = dst_linesizep[0];
1008 case AV_PIX_FMT_BGR444: ((uint16_t*)(
dst + y*dst_linesize))[x] = ((
r >> 4) << 8) | ((
g >> 4) << 4) | (
b >> 4);
break;
1009 case AV_PIX_FMT_RGB444: ((uint16_t*)(
dst + y*dst_linesize))[x] = ((
b >> 4) << 8) | ((
g >> 4) << 4) | (
r >> 4);
break;
1016 v = (
r << (rgba_map[
R]*8)) + (
g << (rgba_map[
G]*8)) + (
b << (rgba_map[
B]*8));
1017 p =
dst + 3*x + y*dst_linesize;
1022 v16 = ((uint64_t)
r << (rgba_map[
R]*16)) + ((uint64_t)
g << (rgba_map[
G]*16)) + ((uint64_t)
b << (rgba_map[
B]*16));
1023 p16 = (uint16_t *)(
dst + 6*x + y*dst_linesize);
1030 v16 = ((uint64_t)
r << (rgba_map[
R]*16)) + ((uint64_t)
g << (rgba_map[
G]*16)) + ((uint64_t)
b << (rgba_map[
B]*16));
1031 p16 = (uint16_t *)(
dst + 8*x + y*dst_linesize);
1041 v = (
r << (rgba_map[
R]*8)) + (
g << (rgba_map[
G]*8)) + (
b << (rgba_map[
B]*8)) + (255
U << (rgba_map[
A]*8));
1042 p =
dst + 4*x + y*dst_linesize;
1047 v = (
r << ((
desc->comp[0].offset*8) +
desc->comp[0].shift)) +
1048 (
g << ((
desc->comp[1].offset*8) +
desc->comp[1].shift)) +
1049 (
b << ((
desc->comp[2].offset*8) +
desc->comp[2].shift)) +
1050 (3
U << ((
desc->comp[3].offset*8) +
desc->comp[3].shift));
1051 p =
dst + 4*x + y*dst_linesize;
1055 p = dstp[0] + x + y * dst_linesize;
1057 p = dstp[1] + x + y * dst_linesizep[1];
1059 p = dstp[2] + x + y * dst_linesizep[2];
1067 p16 = (uint16_t *)(dstp[0] + x*2 + y * dst_linesizep[0]);
1069 p16 = (uint16_t *)(dstp[1] + x*2 + y * dst_linesizep[1]);
1071 p16 = (uint16_t *)(dstp[2] + x*2 + y * dst_linesizep[2]);
1082 for (y = 0; y <
h; y++) {
1083 for (x = 0; x <
w; x++) {
1085 int r = 0,
g = 0,
b = 0;
1087 if (6*y <
h )
r =
c;
1088 else if (6*y < 2*
h)
g =
c,
b =
c;
1089 else if (6*y < 3*
h)
g =
c;
1090 else if (6*y < 4*
h)
r =
c,
b =
c;
1091 else if (6*y < 5*
h)
b =
c;
1094 rgbtest_put_pixel(
frame->data,
frame->linesize, x, y,
r,
g,
b,
1095 ctx->outputs[0]->format,
test->rgba_map);
1105 for (y = 0; y <
h; y++) {
1106 for (x = 0; x <
w; x++) {
1108 int r = 0,
g = 0,
b = 0;
1110 if (3*y <
h )
r =
c;
1111 else if (3*y < 2*
h)
g =
c;
1114 rgbtest_put_pixel(
frame->data,
frame->linesize, x, y,
r,
g,
b,
1115 ctx->outputs[0]->format,
test->rgba_map);
1124 test->draw_once = 1;
1125 test->fill_picture_fn =
test->complement ? rgbtest_fill_picture_complement : rgbtest_fill_picture;
1153 static const AVFilterPad avfilter_vsrc_rgbtestsrc_outputs[] = {
1157 .config_props = rgbtest_config_props,
1162 .
name =
"rgbtestsrc",
1165 .priv_class = &rgbtestsrc_class,
1166 .
init = rgbtest_init,
1181 #if CONFIG_YUVTESTSRC_FILTER
1188 static void yuvtest_put_pixel(uint8_t *dstp[4],
int dst_linesizep[4],
1189 int i,
int j,
unsigned y,
unsigned u,
unsigned v,
enum AVPixelFormat fmt,
1190 uint8_t ayuv_map[4])
1197 n = (y << (ayuv_map[
Y]*8)) + (
u << (ayuv_map[
U]*8)) + (v << (ayuv_map[
V]*8));
1198 AV_WL24(&dstp[0][
i*3 + j*dst_linesizep[0]], n);
1202 n = (y << ((
desc->comp[0].offset*8) +
desc->comp[0].shift)) +
1203 (
u << ((
desc->comp[1].offset*8) +
desc->comp[1].shift)) +
1204 (v << ((
desc->comp[2].offset*8) +
desc->comp[2].shift)) +
1205 (3
U << ((
desc->comp[3].offset*8) +
desc->comp[3].shift));
1206 AV_WL32(&dstp[0][
i*4 + j*dst_linesizep[0]], n);
1211 AV_WN16(&dstp[0][
i*8 + ayuv_map[
Y]*2 + j*dst_linesizep[0]], y <<
desc->comp[0].shift);
1212 AV_WN16(&dstp[0][
i*8 + ayuv_map[
U]*2 + j*dst_linesizep[0]],
u <<
desc->comp[1].shift);
1213 AV_WN16(&dstp[0][
i*8 + ayuv_map[
V]*2 + j*dst_linesizep[0]], v <<
desc->comp[2].shift);
1214 AV_WN16(&dstp[0][
i*8 + ayuv_map[
A]*2 + j*dst_linesizep[0]], UINT16_MAX <<
desc->comp[3].shift);
1220 n = (y << (ayuv_map[
Y]*8)) + (
u << (ayuv_map[
U]*8)) + (v << (ayuv_map[
V]*8)) + (255
U << (ayuv_map[
A]*8));
1221 AV_WL32(&dstp[0][
i*4 + j*dst_linesizep[0]], n);
1225 dstp[0][
i + j*dst_linesizep[0]] = y;
1226 dstp[1][
i + j*dst_linesizep[1]] =
u;
1227 dstp[2][
i + j*dst_linesizep[2]] = v;
1234 AV_WN16(&dstp[0][
i*2 + j*dst_linesizep[0]], y);
1235 AV_WN16(&dstp[1][
i*2 + j*dst_linesizep[1]],
u);
1236 AV_WN16(&dstp[2][
i*2 + j*dst_linesizep[2]], v);
1247 const int mid = 1 << (
desc->comp[0].depth - 1);
1249 for (j = 0; j <
h; j++) {
1250 for (
i = 0;
i <
w;
i++) {
1252 int y = mid,
u = mid, v = mid;
1254 if (3*j <
h ) y =
c;
1255 else if (3*j < 2*
h)
u =
c;
1258 yuvtest_put_pixel(
frame->data,
frame->linesize,
i, j, y,
u, v,
1259 ctx->outputs[0]->format,
test->ayuv_map);
1268 test->draw_once = 1;
1269 test->fill_picture_fn = yuvtest_fill_picture;
1292 static const AVFilterPad avfilter_vsrc_yuvtestsrc_outputs[] = {
1296 .config_props = yuvtest_config_props,
1301 .
name =
"yuvtestsrc",
1304 .priv_class = &nullsrc_yuvtestsrc_class,
1305 .
init = yuvtest_init,
1320 #if CONFIG_PAL75BARS_FILTER || CONFIG_PAL100BARS_FILTER || CONFIG_SMPTEBARS_FILTER || CONFIG_SMPTEHDBARS_FILTER
1322 static const uint8_t rainbow[7][4] = {
1323 { 180, 128, 128, 255 },
1324 { 162, 44, 142, 255 },
1325 { 131, 156, 44, 255 },
1326 { 112, 72, 58, 255 },
1327 { 84, 184, 198, 255 },
1328 { 65, 100, 212, 255 },
1329 { 35, 212, 114, 255 },
1332 static const uint8_t rainbow100[7][4] = {
1333 { 235, 128, 128, 255 },
1334 { 210, 16, 146, 255 },
1335 { 170, 166, 16, 255 },
1336 { 145, 54, 34, 255 },
1337 { 106, 202, 222, 255 },
1338 { 81, 90, 240, 255 },
1339 { 41, 240, 110, 255 },
1342 static const uint8_t rainbowhd[7][4] = {
1343 { 180, 128, 128, 255 },
1344 { 168, 44, 136, 255 },
1345 { 145, 147, 44, 255 },
1346 { 133, 63, 52, 255 },
1347 { 63, 193, 204, 255 },
1348 { 51, 109, 212, 255 },
1349 { 28, 212, 120, 255 },
1352 static const uint8_t wobnair[7][4] = {
1353 { 35, 212, 114, 255 },
1354 { 19, 128, 128, 255 },
1355 { 84, 184, 198, 255 },
1356 { 19, 128, 128, 255 },
1357 { 131, 156, 44, 255 },
1358 { 19, 128, 128, 255 },
1359 { 180, 128, 128, 255 },
1362 static const uint8_t white[4] = { 235, 128, 128, 255 };
1365 static const uint8_t neg4ire[4] = { 7, 128, 128, 255 };
1366 static const uint8_t pos4ire[4] = { 24, 128, 128, 255 };
1369 static const uint8_t i_pixel[4] = { 57, 156, 97, 255 };
1370 static const uint8_t q_pixel[4] = { 44, 171, 147, 255 };
1372 static const uint8_t gray40[4] = { 104, 128, 128, 255 };
1373 static const uint8_t gray15[4] = { 49, 128, 128, 255 };
1374 static const uint8_t cyan[4] = { 188, 154, 16, 255 };
1375 static const uint8_t yellow[4] = { 219, 16, 138, 255 };
1376 static const uint8_t blue[4] = { 32, 240, 118, 255 };
1377 static const uint8_t red[4] = { 63, 102, 240, 255 };
1378 static const uint8_t black0[4] = { 16, 128, 128, 255 };
1379 static const uint8_t black2[4] = { 20, 128, 128, 255 };
1380 static const uint8_t black4[4] = { 25, 128, 128, 255 };
1381 static const uint8_t neg2[4] = { 12, 128, 128, 255 };
1384 int x,
int y,
int w,
int h,
1399 for (plane = 0;
frame->data[plane]; plane++) {
1400 const int c =
color[plane];
1401 const ptrdiff_t linesize =
frame->linesize[plane];
1402 int i, px, py, pw,
ph;
1404 if (plane == 1 || plane == 2) {
1405 px = x >>
desc->log2_chroma_w;
1407 py = y >>
desc->log2_chroma_h;
1416 p0 = p =
frame->data[plane] + py * linesize + px;
1419 for (
i = 1;
i <
ph;
i++, p += linesize)
1438 if (!strcmp(
ctx->name,
"smptehdbars")) {
1455 #if CONFIG_PAL75BARS_FILTER
1467 for (
i = 1;
i < 7;
i++) {
1478 test->fill_picture_fn = pal75bars_fill_picture;
1479 test->draw_once = 1;
1484 .
name =
"pal75bars",
1486 .priv_class = &palbars_class,
1488 .
init = pal75bars_init,
1498 #if CONFIG_PAL100BARS_FILTER
1508 for (
i = 0;
i < 7;
i++) {
1519 test->fill_picture_fn = pal100bars_fill_picture;
1520 test->draw_once = 1;
1525 .
name =
"pal100bars",
1527 .priv_class = &palbars_class,
1529 .
init = pal100bars_init,
1541 #if CONFIG_SMPTEBARS_FILTER
1546 int r_w, r_h, w_h, p_w, p_h,
i,
tmp, x = 0;
1553 p_h =
test->h - w_h - r_h;
1555 for (
i = 0;
i < 7;
i++) {
1561 draw_bar(
test, i_pixel, x, r_h + w_h, p_w, p_h, picref);
1565 draw_bar(
test, q_pixel, x, r_h + w_h, p_w, p_h, picref);
1584 test->fill_picture_fn = smptebars_fill_picture;
1585 test->draw_once = 1;
1590 .
name =
"smptebars",
1593 .priv_class = &smptebars_class,
1594 .
init = smptebars_init,
1604 #if CONFIG_SMPTEHDBARS_FILTER
1609 int d_w, r_w, r_h, l_w,
i,
tmp, x = 0, y = 0;
1618 for (
i = 0;
i < 7;
i++) {
1641 uint8_t yramp[4] = {0};
1643 yramp[0] =
i * 255 /
tmp;
1685 test->fill_picture_fn = smptehdbars_fill_picture;
1686 test->draw_once = 1;
1691 .
name =
"smptehdbars",
1693 .priv_class = &smptebars_class,
1695 .
init = smptehdbars_init,
1709 #if CONFIG_ALLYUV_FILTER
1713 const ptrdiff_t ys =
frame->linesize[0];
1714 const ptrdiff_t
us =
frame->linesize[1];
1715 const ptrdiff_t vs =
frame->linesize[2];
1718 for (y = 0; y < 4096; y++) {
1719 for (x = 0; x < 2048; x++) {
1720 frame->data[0][y * ys + x] = ((x / 8) % 256);
1721 frame->data[0][y * ys + 4095 - x] = ((x / 8) % 256);
1724 for (x = 0; x < 2048; x+=8) {
1725 for (j = 0; j < 8; j++) {
1726 frame->data[1][vs * y + x + j] = (y%16 + (j % 8) * 16);
1727 frame->data[1][vs * y + 4095 - x - j] = (128 + y%16 + (j % 8) * 16);
1731 for (x = 0; x < 4096; x++)
1732 frame->data[2][y *
us + x] = 256 * y / 4096;
1741 test->draw_once = 1;
1742 test->fill_picture_fn = allyuv_fill_picture;
1750 .priv_class = &allyuv_allrgb_class,
1751 .
init = allyuv_init,
1761 #if CONFIG_ALLRGB_FILTER
1766 const ptrdiff_t linesize =
frame->linesize[0];
1769 for (y = 0; y < 4096; y++) {
1772 for (x = 0; x < 4096; x++) {
1775 *
dst++ = (x >> 8) | ((y >> 8) << 4);
1786 test->draw_once = 1;
1787 test->fill_picture_fn = allrgb_fill_picture;
1799 static const AVFilterPad avfilter_vsrc_allrgb_outputs[] = {
1803 .config_props = allrgb_config_props,
1811 .priv_class = &allyuv_allrgb_class,
1812 .
init = allrgb_init,
1822 #if CONFIG_COLORSPECTRUM_FILTER
1824 static const AVOption colorspectrum_options[] = {
1835 static inline float mix(
float a,
float b,
float mix)
1840 static void hsb2rgb(
const float *
c,
float *
rgb)
1853 const float w =
frame->width - 1.f;
1854 const float h =
frame->height - 1.f;
1857 for (
int y = 0; y <
frame->height; y++) {
1858 float *
r = (
float *)(
frame->data[2] + y *
frame->linesize[2]);
1859 float *
g = (
float *)(
frame->data[0] + y *
frame->linesize[0]);
1860 float *
b = (
float *)(
frame->data[1] + y *
frame->linesize[1]);
1861 const float yh = y /
h;
1863 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;
1865 c[3] =
test->type == 1 ? 1.f :
test->type == 2 ? (yh > 0.5f ? 0.f : 1.f): 0.f;
1866 for (
int x = 0; x <
frame->width; x++) {
1883 test->draw_once = 1;
1884 test->fill_picture_fn = colorspectrum_fill_picture;
1889 .
name =
"colorspectrum",
1892 .priv_class = &colorspectrum_class,
1893 .
init = colorspectrum_init,
1903 #if CONFIG_COLORCHART_FILTER
1905 static const AVOption colorchart_options[] = {
1916 static const uint8_t reference_colors[][3] = {
1946 static const uint8_t skintones_colors[][3] = {
1976 typedef struct ColorChartPreset {
1978 const uint8_t (*colors)[3];
1981 static const ColorChartPreset colorchart_presets[] = {
1982 { 6, 4, reference_colors, },
1983 { 6, 4, skintones_colors, },
1992 inlink->color_range, 0) >= 0);
2002 const int w = colorchart_presets[
preset].w;
2003 const int h = colorchart_presets[
preset].h;
2004 const int pw =
test->pw;
2007 for (
int y = 0; y <
h; y++) {
2008 for (
int x = 0; x <
w; x++) {
2009 uint32_t pc =
AV_RB24(colorchart_presets[
preset].colors[y *
w + x]);
2014 x * pw, y *
ph, pw,
ph);
2023 const int w = colorchart_presets[
preset].w;
2024 const int h = colorchart_presets[
preset].h;
2028 test->draw_once = 1;
2029 test->fill_picture_fn = colorchart_fill_picture;
2033 static const AVFilterPad avfilter_vsrc_colorchart_outputs[] = {
2037 .config_props = colorchart_config_props,
2042 .
name =
"colorchart",
2045 .priv_class = &colorchart_class,
2046 .
init = colorchart_init,
2056 #if CONFIG_ZONEPLATE_FILTER
2058 static const AVOption zoneplate_options[] = {
2081 #define ZONEPLATE_SLICE(name, type) \
2082 static int zoneplate_fill_slice_##name(AVFilterContext *ctx, \
2083 void *arg, int job, \
2086 TestSourceContext *test = ctx->priv; \
2087 AVFrame *frame = arg; \
2088 const int w = frame->width; \
2089 const int h = frame->height; \
2090 const int kxt = test->kxt, kyt = test->kyt, kx2 = test->kx2; \
2091 const int t = test->pts + test->to, k0 = test->k0; \
2092 const int kt = test->kt, kt2 = test->kt2, ky2 = test->ky2; \
2093 const int ky = test->ky, kx = test->kx, kxy = test->kxy; \
2094 const int lut_mask = (1 << test->lut_precision) - 1; \
2095 const int nkt2t = kt2 * t * t, nktt = kt * t; \
2096 const int start = (h * job ) / nb_jobs; \
2097 const int end = (h * (job+1)) / nb_jobs; \
2098 const ptrdiff_t ylinesize = frame->linesize[0] / sizeof(type); \
2099 const ptrdiff_t ulinesize = frame->linesize[1] / sizeof(type); \
2100 const ptrdiff_t vlinesize = frame->linesize[2] / sizeof(type); \
2101 const int xreset = -(w / 2) - test->xo; \
2102 const int yreset = -(h / 2) - test->yo + start; \
2103 const int kU = test->kU, kV = test->kV; \
2104 const int skxy = 0xffff / (w / 2); \
2105 const int skx2 = 0xffff / w; \
2106 const int dkxt = kxt * t; \
2107 type *ydst = ((type *)frame->data[0]) + start * ylinesize; \
2108 type *udst = ((type *)frame->data[1]) + start * ulinesize; \
2109 type *vdst = ((type *)frame->data[2]) + start * vlinesize; \
2110 const type *lut = (const type *)test->lut; \
2111 int akx, akxt, aky, akyt; \
2114 akyt = start * kyt * t; \
2116 for (int j = start, y = yreset; j < end; j++, y++) { \
2117 const int dkxy = kxy * y * skxy; \
2118 const int nky2kt2 = (ky2 * y * y) / h + (nkt2t >> 1); \
2119 int akxy = dkxy * xreset; \
2126 for (int i = 0, x = xreset; i < w; i++, x++) { \
2127 int phase = k0, uphase = kU, vphase = kV; \
2130 phase += akx + aky + nktt; \
2134 phase += akxt + akyt; \
2135 phase += akxy >> 16; \
2136 phase += ((kx2 * x * x * skx2) >> 16) + nky2kt2; \
2140 ydst[i] = lut[phase & lut_mask]; \
2141 udst[i] = lut[uphase & lut_mask]; \
2142 vdst[i] = lut[vphase & lut_mask]; \
2145 ydst += ylinesize; \
2146 udst += ulinesize; \
2147 vdst += vlinesize; \
2153 ZONEPLATE_SLICE( 8, uint8_t)
2154 ZONEPLATE_SLICE( 9, uint16_t)
2155 ZONEPLATE_SLICE(10, uint16_t)
2156 ZONEPLATE_SLICE(12, uint16_t)
2157 ZONEPLATE_SLICE(14, uint16_t)
2158 ZONEPLATE_SLICE(16, uint16_t)
2167 static int zoneplate_config_props(
AVFilterLink *outlink)
2172 const int lut_size = 1 <<
test->lut_precision;
2173 const int depth =
desc->comp[0].depth;
2185 lut16 = (uint16_t *)
test->lut;
2188 for (
int i = 0;
i < lut_size;
i++)
2192 for (
int i = 0;
i < lut_size;
i++)
2193 lut16[
i] =
lrintf(((1 << depth) - 1) * (0.5f + 0.5f *
sinf((2.
f *
M_PI *
i) / lut_size)));
2197 test->draw_once = 0;
2198 test->fill_picture_fn = zoneplate_fill_picture;
2201 case 8:
test->fill_slice_fn = zoneplate_fill_slice_8;
break;
2202 case 9:
test->fill_slice_fn = zoneplate_fill_slice_9;
break;
2203 case 10:
test->fill_slice_fn = zoneplate_fill_slice_10;
break;
2204 case 12:
test->fill_slice_fn = zoneplate_fill_slice_12;
break;
2205 case 14:
test->fill_slice_fn = zoneplate_fill_slice_14;
break;
2206 case 16:
test->fill_slice_fn = zoneplate_fill_slice_16;
break;
2229 static const AVFilterPad avfilter_vsrc_zoneplate_outputs[] = {
2233 .config_props = zoneplate_config_props,
2238 .
name =
"zoneplate",
2241 .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)
#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 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
@ AVCOL_RANGE_JPEG
Full range content.
@ AV_ROUND_ZERO
Round toward zero.
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.
Link properties exposed to filter code, but not external callers.
const AVFilter ff_vsrc_haldclutsrc
static const struct @466 planes[]
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
#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.
@ 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
const AVFilter ff_vsrc_pal100bars
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.
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)
const AVFilter ff_vsrc_testsrc2
#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.
const AVFilter ff_vsrc_colorspectrum
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
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
#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)
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 ...
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
@ 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)
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.
const AVFilter ff_vsrc_zoneplate
#define AV_PIX_FMT_GBRP12
AVColorSpace
YUV colorspace type.
#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.
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.
#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.
#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
#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 AVFilter ff_vsrc_rgbtestsrc
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)
@ 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)
@ 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)
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 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)
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...
@ AV_PIX_FMT_VUYX
packed VUYX 4:4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined
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)
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
static const AVOption options[]
#define AV_PIX_FMT_RGB444