66 #define OFFSET(x) offsetof(WaveformContext, x)
67 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
155 const int dst_linesize = out->
linesize[component] / 2;
156 const int bg = s->
bg_color[component] * (s->
max / 256);
157 const int limit = s->
max - 1;
158 const int is_chroma = (component == 1 || component == 2);
169 for (x = 0; x < dst_w; x++) {
170 for (y = start; y <
end; y++) {
171 dst = (uint16_t *)out->
data[component] + y * dst_linesize + x;
177 for (y = end - 1; y >=
start; y--) {
178 dst = (uint16_t *)out->
data[component] + y * dst_linesize + x;
186 for (y = 0; y < dst_h; y++) {
187 dst = (uint16_t *)out->
data[component] + y * dst_linesize;
188 for (x = start; x <
end; x++) {
194 for (x = end - 1; x >=
start; x--) {
206 const int dst_linesize = out->
linesize[component];
208 const int is_chroma = (component == 1 || component == 2);
219 for (x = 0; x < dst_w; x++) {
220 for (y = start; y <
end; y++) {
221 dst = out->
data[component] + y * dst_linesize + x;
227 for (y = end - 1; y >=
start; y--) {
228 dst = out->
data[component] + y * dst_linesize + x;
236 for (y = 0; y < dst_h; y++) {
237 dst = out->
data[component] + y * dst_linesize;
238 for (x = start; x <
end; x++) {
244 for (x = end - 1; x >=
start; x--) {
256 const int dst_linesize = out->
linesize[component] / 2;
257 const int bg = s->
bg_color[component] * (s->
max / 256);
258 const int limit = s->
max - 1;
259 const int is_chroma = (component == 1 || component == 2);
272 for (x = 0; x < dst_w; x++) {
273 for (y = start; y < end && y < emin[x]; y++) {
274 dst = (uint16_t *)out->
data[component] + y * dst_linesize + x;
280 for (y = end - 1; y >= start && y >= emax[x]; y--) {
281 dst = (uint16_t *)out->
data[component] + y * dst_linesize + x;
292 for (x = 0; x < dst_w; x++) {
293 dst = (uint16_t *)out->
data[component] + emin[x] * dst_linesize + x;
295 dst = (uint16_t *)out->
data[component] + emax[x] * dst_linesize + x;
299 for (y = 0; y < dst_h; y++) {
300 dst = (uint16_t *)out->
data[component] + y * dst_linesize;
301 for (x = start; x < end && x < emin[y]; x++) {
307 for (x = end - 1; x >= start && x >= emax[y]; x--) {
318 for (y = 0; y < dst_h; y++) {
319 dst = (uint16_t *)out->
data[component] + y * dst_linesize + emin[y];
321 dst = (uint16_t *)out->
data[component] + y * dst_linesize + emax[y];
329 const int dst_linesize = out->
linesize[component];
330 const int bg = s->
bg_color[component];
331 const int is_chroma = (component == 1 || component == 2);
344 for (x = 0; x < dst_w; x++) {
345 for (y = start; y < end && y < emin[x]; y++) {
346 dst = out->
data[component] + y * dst_linesize + x;
352 for (y = end - 1; y >= start && y >= emax[x]; y--) {
353 dst = out->
data[component] + y * dst_linesize + x;
364 for (x = 0; x < dst_w; x++) {
365 dst = out->
data[component] + emin[x] * dst_linesize + x;
367 dst = out->
data[component] + emax[x] * dst_linesize + x;
371 for (y = 0; y < dst_h; y++) {
372 dst = out->
data[component] + y * dst_linesize;
373 for (x = start; x < end && x < emin[y]; x++) {
379 for (x = end - 1; x >= start && x >= emax[y]; x--) {
390 for (y = 0; y < dst_h; y++) {
391 dst = out->
data[component] + y * dst_linesize + emin[y];
393 dst = out->
data[component] + y * dst_linesize + emax[y];
442 const int is_chroma = (component == 1 || component == 2);
447 const int dst_signed_linesize = dst_linesize * (mirror == 1 ? -1 : 1);
448 const int limit = s->
max - 1;
452 const uint16_t *src_data = (
const uint16_t *)in->
data[plane];
453 uint16_t *dst_data = (uint16_t *)out->
data[
plane] + (column ? (offset >> shift_h) * dst_linesize : offset >> shift_w);
454 uint16_t *
const dst_bottom_line = dst_data + dst_linesize * ((s->
size >> shift_h) - 1);
455 uint16_t *
const dst_line = (mirror ? dst_bottom_line : dst_data);
459 if (!column && mirror)
460 dst_data += s->
size >> shift_w;
462 for (y = 0; y < src_h; y++) {
463 const uint16_t *src_data_end = src_data + src_w;
464 uint16_t *dst = dst_line;
466 for (p = src_data; p < src_data_end; p++) {
468 int v =
FFMIN(*p, limit);
471 target = dst++ + dst_signed_linesize * (v >> shift_h);
474 target = dst_data - (v >> shift_w) - 1;
476 target = dst_data + (v >> shift_w);
478 update16(target, max, intensity, limit);
480 src_data += src_linesize;
481 dst_data += dst_linesize;
492 const int is_chroma = (component == 1 || component == 2);
497 const int dst_signed_linesize = dst_linesize * (mirror == 1 ? -1 : 1);
502 uint8_t *dst_data = out->
data[
plane] + (column ? (offset >> shift_h) * dst_linesize : offset >> shift_w);
503 uint8_t *
const dst_bottom_line = dst_data + dst_linesize * ((s->
size >> shift_h) - 1);
504 uint8_t *
const dst_line = (mirror ? dst_bottom_line : dst_data);
508 if (!column && mirror)
509 dst_data += s->
size >> shift_w;
511 for (y = 0; y < src_h; y++) {
512 const uint8_t *src_data_end = src_data + src_w;
515 for (p = src_data; p < src_data_end; p++) {
518 target = dst++ + dst_signed_linesize * (*p >> shift_h);
521 target = dst_data - (*p >> shift_w) - 1;
523 target = dst_data + (*p >> shift_w);
525 update(target, max, intensity);
527 src_data += src_linesize;
528 dst_data += dst_linesize;
539 const int c0_linesize = in->
linesize[ plane + 0 ];
540 const int c1_linesize = in->
linesize[(plane + 1) % s->
ncomp];
541 const int c2_linesize = in->
linesize[(plane + 2) % s->
ncomp];
542 const int d0_linesize = out->
linesize[ plane + 0 ];
543 const int d1_linesize = out->
linesize[(plane + 1) % s->
ncomp];
544 const int max = 255 - intensity;
545 const int src_h = in->
height;
546 const int src_w = in->
width;
550 const int d0_signed_linesize = d0_linesize * (mirror == 1 ? -1 : 1);
551 const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1);
553 for (x = 0; x < src_w; x++) {
558 uint8_t *d1_data = out->
data[(plane + 1) % s->
ncomp] + offset * d1_linesize;
559 uint8_t *
const d0_bottom_line = d0_data + d0_linesize * (s->
size - 1);
560 uint8_t *
const d0 = (mirror ? d0_bottom_line : d0_data);
561 uint8_t *
const d1_bottom_line = d1_data + d1_linesize * (s->
size - 1);
562 uint8_t *
const d1 = (mirror ? d1_bottom_line : d1_data);
564 for (y = 0; y < src_h; y++) {
565 const int c0 = c0_data[x] + 256;
566 const int c1 =
FFABS(c1_data[x] - 128) +
FFABS(c2_data[x] - 128);
569 target = d0 + x + d0_signed_linesize * c0;
571 target = d1 + x + d1_signed_linesize * (c0 -
c1);
573 target = d1 + x + d1_signed_linesize * (c0 +
c1);
576 c0_data += c0_linesize;
577 c1_data += c1_linesize;
578 c2_data += c2_linesize;
579 d0_data += d0_linesize;
580 d1_data += d1_linesize;
591 d0_data += s->
size - 1;
592 d1_data += s->
size - 1;
595 for (y = 0; y < src_h; y++) {
596 for (x = 0; x < src_w; x++) {
597 int c0 = c0_data[x] + 256;
598 const int c1 =
FFABS(c1_data[x] - 128) +
FFABS(c2_data[x] - 128);
602 target = d0_data - c0;
604 target = d1_data - (c0 -
c1);
606 target = d1_data - (c0 +
c1);
609 target = d0_data + c0;
611 target = d1_data + (c0 -
c1);
613 target = d1_data + (c0 +
c1);
618 c0_data += c0_linesize;
619 c1_data += c1_linesize;
620 c2_data += c2_linesize;
621 d0_data += d0_linesize;
622 d1_data += d1_linesize;
635 const int c0_linesize = in->
linesize[ plane + 0 ];
636 const int c1_linesize = in->
linesize[(plane + 1) % s->
ncomp];
637 const int c2_linesize = in->
linesize[(plane + 2) % s->
ncomp];
638 const int d0_linesize = out->
linesize[ plane + 0 ];
639 const int d1_linesize = out->
linesize[(plane + 1) % s->
ncomp];
640 const int d2_linesize = out->
linesize[(plane + 2) % s->
ncomp];
642 const int src_h = in->
height;
643 const int src_w = in->
width;
647 const int d0_signed_linesize = d0_linesize * (mirror == 1 ? -1 : 1);
648 const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1);
649 const int d2_signed_linesize = d2_linesize * (mirror == 1 ? -1 : 1);
651 for (x = 0; x < src_w; x++) {
656 uint8_t *d1_data = out->
data[(plane + 1) % s->
ncomp] + offset * d1_linesize;
657 uint8_t *d2_data = out->
data[(plane + 2) % s->
ncomp] + offset * d2_linesize;
658 uint8_t *
const d0_bottom_line = d0_data + d0_linesize * (s->
size - 1);
659 uint8_t *
const d0 = (mirror ? d0_bottom_line : d0_data);
660 uint8_t *
const d1_bottom_line = d1_data + d1_linesize * (s->
size - 1);
661 uint8_t *
const d1 = (mirror ? d1_bottom_line : d1_data);
662 uint8_t *
const d2_bottom_line = d2_data + d2_linesize * (s->
size - 1);
663 uint8_t *
const d2 = (mirror ? d2_bottom_line : d2_data);
665 for (y = 0; y < src_h; y++) {
666 const int c0 = c0_data[x] + 128;
667 const int c1 = c1_data[x] - 128;
668 const int c2 = c2_data[x] - 128;
671 target = d0 + x + d0_signed_linesize * c0;
672 update(target, max, intensity);
674 target = d1 + x + d1_signed_linesize * (c0 +
c1);
677 target = d2 + x + d2_signed_linesize * (c0 +
c2);
680 c0_data += c0_linesize;
681 c1_data += c1_linesize;
682 c2_data += c2_linesize;
683 d0_data += d0_linesize;
684 d1_data += d1_linesize;
685 d2_data += d2_linesize;
697 d0_data += s->
size - 1;
698 d1_data += s->
size - 1;
699 d2_data += s->
size - 1;
702 for (y = 0; y < src_h; y++) {
703 for (x = 0; x < src_w; x++) {
704 const int c0 = c0_data[x] + 128;
705 const int c1 = c1_data[x] - 128;
706 const int c2 = c2_data[x] - 128;
710 target = d0_data - c0;
711 update(target, max, intensity);
712 target = d1_data - (c0 +
c1);
714 target = d2_data - (c0 +
c2);
717 target = d0_data + c0;
718 update(target, max, intensity);
719 target = d1_data + (c0 +
c1);
721 target = d2_data + (c0 +
c2);
726 c0_data += c0_linesize;
727 c1_data += c1_linesize;
728 c2_data += c2_linesize;
729 d0_data += d0_linesize;
730 d1_data += d1_linesize;
731 d2_data += d2_linesize;
745 const int c0_linesize = in->
linesize[(plane + 1) % s->
ncomp];
746 const int c1_linesize = in->
linesize[(plane + 2) % s->
ncomp];
749 const int src_h = in->
height;
750 const int src_w = in->
width;
754 const int dst_signed_linesize = dst_linesize * (mirror == 1 ? -1 : 1);
756 for (x = 0; x < src_w; x++) {
760 uint8_t *
const dst_bottom_line = dst_data + dst_linesize * (s->
size - 1);
761 uint8_t *
const dst_line = (mirror ? dst_bottom_line : dst_data);
764 for (y = 0; y < src_h; y++) {
765 const int sum =
FFABS(c0_data[x] - 128) +
FFABS(c1_data[x] - 128);
768 target = dst + x + dst_signed_linesize * (256 - sum);
769 update(target, max, intensity);
770 target = dst + x + dst_signed_linesize * (255 + sum);
771 update(target, max, intensity);
773 c0_data += c0_linesize;
774 c1_data += c1_linesize;
775 dst_data += dst_linesize;
784 dst_data += s->
size - 1;
785 for (y = 0; y < src_h; y++) {
786 for (x = 0; x < src_w; x++) {
787 const int sum =
FFABS(c0_data[x] - 128) +
FFABS(c1_data[x] - 128);
791 target = dst_data - (256 - sum);
792 update(target, max, intensity);
793 target = dst_data - (255 + sum);
794 update(target, max, intensity);
796 target = dst_data + (256 - sum);
797 update(target, max, intensity);
798 target = dst_data + (255 + sum);
799 update(target, max, intensity);
803 c0_data += c0_linesize;
804 c1_data += c1_linesize;
805 dst_data += dst_linesize;
817 const int c1_linesize = in->
linesize[(plane + 1) % s->
ncomp];
818 const int c2_linesize = in->
linesize[(plane + 2) % s->
ncomp];
819 const int d1_linesize = out->
linesize[(plane + 1) % s->
ncomp];
820 const int d2_linesize = out->
linesize[(plane + 2) % s->
ncomp];
822 const int src_h = in->
height;
823 const int src_w = in->
width;
827 const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1);
828 const int d2_signed_linesize = d2_linesize * (mirror == 1 ? -1 : 1);
830 for (x = 0; x < src_w; x++) {
833 uint8_t *d1_data = out->
data[(plane + 1) % s->
ncomp] + offset * d1_linesize;
834 uint8_t *d2_data = out->
data[(plane + 2) % s->
ncomp] + offset * d2_linesize;
835 uint8_t *
const d1_bottom_line = d1_data + d1_linesize * (s->
size - 1);
836 uint8_t *
const d1 = (mirror ? d1_bottom_line : d1_data);
837 uint8_t *
const d2_bottom_line = d2_data + d2_linesize * (s->
size - 1);
838 uint8_t *
const d2 = (mirror ? d2_bottom_line : d2_data);
840 for (y = 0; y < src_h; y++) {
841 const int c1 = c1_data[x] - 128;
842 const int c2 = c2_data[x] - 128;
845 target = d1 + x + d1_signed_linesize * (128 +
c1);
846 update(target, max, intensity);
848 target = d2 + x + d2_signed_linesize * (128 +
c2);
849 update(target, max, intensity);
851 c1_data += c1_linesize;
852 c2_data += c2_linesize;
853 d1_data += d1_linesize;
854 d2_data += d2_linesize;
865 d0_data += s->
size - 1;
866 d1_data += s->
size - 1;
867 d2_data += s->
size - 1;
870 for (y = 0; y < src_h; y++) {
871 for (x = 0; x < src_w; x++) {
872 const int c1 = c1_data[x] - 128;
873 const int c2 = c2_data[x] - 128;
877 target = d1_data - (128 +
c1);
878 update(target, max, intensity);
879 target = d2_data - (128 +
c2);
880 update(target, max, intensity);
882 target = d1_data + (128 +
c1);
883 update(target, max, intensity);
884 target = d2_data + (128 +
c2);
885 update(target, max, intensity);
889 c1_data += c1_linesize;
890 c2_data += c2_linesize;
891 d1_data += d1_linesize;
892 d2_data += d2_linesize;
905 const int limit = s->
max - 1;
906 const uint16_t *c0_data = (
const uint16_t *)in->
data[plane + 0];
907 const uint16_t *c1_data = (
const uint16_t *)in->
data[(plane + 1) % s->
ncomp];
908 const uint16_t *c2_data = (
const uint16_t *)in->
data[(plane + 2) % s->
ncomp];
909 const int c0_linesize = in->
linesize[ plane + 0 ] / 2;
910 const int c1_linesize = in->
linesize[(plane + 1) % s->
ncomp] / 2;
911 const int c2_linesize = in->
linesize[(plane + 2) % s->
ncomp] / 2;
912 const int d0_linesize = out->
linesize[ plane + 0 ] / 2;
913 const int d1_linesize = out->
linesize[(plane + 1) % s->
ncomp] / 2;
914 const int d2_linesize = out->
linesize[(plane + 2) % s->
ncomp] / 2;
915 const int src_h = in->
height;
916 const int src_w = in->
width;
920 const int d0_signed_linesize = d0_linesize * (mirror == 1 ? -1 : 1);
921 const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1);
922 const int d2_signed_linesize = d2_linesize * (mirror == 1 ? -1 : 1);
923 uint16_t *d0_data = (uint16_t *)out->
data[plane] + offset * d0_linesize;
924 uint16_t *d1_data = (uint16_t *)out->
data[(plane + 1) % s->
ncomp] + offset * d1_linesize;
925 uint16_t *d2_data = (uint16_t *)out->
data[(plane + 2) % s->
ncomp] + offset * d2_linesize;
926 uint16_t *
const d0_bottom_line = d0_data + d0_linesize * (s->
size - 1);
927 uint16_t *
const d0 = (mirror ? d0_bottom_line : d0_data);
928 uint16_t *
const d1_bottom_line = d1_data + d1_linesize * (s->
size - 1);
929 uint16_t *
const d1 = (mirror ? d1_bottom_line : d1_data);
930 uint16_t *
const d2_bottom_line = d2_data + d2_linesize * (s->
size - 1);
931 uint16_t *
const d2 = (mirror ? d2_bottom_line : d2_data);
933 for (y = 0; y < src_h; y++) {
934 for (x = 0; x < src_w; x++) {
935 const int c0 =
FFMIN(c0_data[x], limit);
936 const int c1 = c1_data[x];
937 const int c2 = c2_data[x];
939 *(d0 + d0_signed_linesize * c0 + x) = c0;
940 *(d1 + d1_signed_linesize * c0 + x) = c1;
941 *(d2 + d2_signed_linesize * c0 + x) = c2;
944 c0_data += c0_linesize;
945 c1_data += c1_linesize;
946 c2_data += c2_linesize;
947 d0_data += d0_linesize;
948 d1_data += d1_linesize;
949 d2_data += d2_linesize;
952 uint16_t *d0_data = (uint16_t *)out->
data[plane] + offset;
953 uint16_t *d1_data = (uint16_t *)out->
data[(plane + 1) % s->
ncomp] + offset;
954 uint16_t *d2_data = (uint16_t *)out->
data[(plane + 2) % s->
ncomp] + offset;
957 d0_data += s->
size - 1;
958 d1_data += s->
size - 1;
959 d2_data += s->
size - 1;
962 for (y = 0; y < src_h; y++) {
963 for (x = 0; x < src_w; x++) {
964 const int c0 =
FFMIN(c0_data[x], limit);
965 const int c1 = c1_data[x];
966 const int c2 = c2_data[x];
969 *(d0_data - c0) = c0;
970 *(d1_data - c0) = c1;
971 *(d2_data - c0) = c2;
973 *(d0_data + c0) = c0;
974 *(d1_data + c0) = c1;
975 *(d2_data + c0) = c2;
979 c0_data += c0_linesize;
980 c1_data += c1_linesize;
981 c2_data += c2_linesize;
982 d0_data += d0_linesize;
983 d1_data += d1_linesize;
984 d2_data += d2_linesize;
999 const int c0_linesize = in->
linesize[ plane + 0 ];
1000 const int c1_linesize = in->
linesize[(plane + 1) % s->
ncomp];
1001 const int c2_linesize = in->
linesize[(plane + 2) % s->
ncomp];
1002 const int d0_linesize = out->
linesize[ plane + 0 ];
1003 const int d1_linesize = out->
linesize[(plane + 1) % s->
ncomp];
1004 const int d2_linesize = out->
linesize[(plane + 2) % s->
ncomp];
1005 const int src_h = in->
height;
1006 const int src_w = in->
width;
1010 const int d0_signed_linesize = d0_linesize * (mirror == 1 ? -1 : 1);
1011 const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1);
1012 const int d2_signed_linesize = d2_linesize * (mirror == 1 ? -1 : 1);
1014 uint8_t *d1_data = out->
data[(plane + 1) % s->
ncomp] + offset * d1_linesize;
1015 uint8_t *d2_data = out->
data[(plane + 2) % s->
ncomp] + offset * d2_linesize;
1016 uint8_t *
const d0_bottom_line = d0_data + d0_linesize * (s->
size - 1);
1017 uint8_t *
const d0 = (mirror ? d0_bottom_line : d0_data);
1018 uint8_t *
const d1_bottom_line = d1_data + d1_linesize * (s->
size - 1);
1019 uint8_t *
const d1 = (mirror ? d1_bottom_line : d1_data);
1020 uint8_t *
const d2_bottom_line = d2_data + d2_linesize * (s->
size - 1);
1021 uint8_t *
const d2 = (mirror ? d2_bottom_line : d2_data);
1023 for (y = 0; y < src_h; y++) {
1024 for (x = 0; x < src_w; x++) {
1025 const int c0 = c0_data[x];
1026 const int c1 = c1_data[x];
1027 const int c2 = c2_data[x];
1029 *(d0 + d0_signed_linesize * c0 + x) = c0;
1030 *(d1 + d1_signed_linesize * c0 + x) = c1;
1031 *(d2 + d2_signed_linesize * c0 + x) = c2;
1034 c0_data += c0_linesize;
1035 c1_data += c1_linesize;
1036 c2_data += c2_linesize;
1037 d0_data += d0_linesize;
1038 d1_data += d1_linesize;
1039 d2_data += d2_linesize;
1047 d0_data += s->
size - 1;
1048 d1_data += s->
size - 1;
1049 d2_data += s->
size - 1;
1052 for (y = 0; y < src_h; y++) {
1053 for (x = 0; x < src_w; x++) {
1054 const int c0 = c0_data[x];
1055 const int c1 = c1_data[x];
1056 const int c2 = c2_data[x];
1059 *(d0_data - c0) = c0;
1060 *(d1_data - c0) = c1;
1061 *(d2_data - c0) = c2;
1063 *(d0_data + c0) = c0;
1064 *(d1_data + c0) = c1;
1065 *(d2_data + c0) = c2;
1069 c0_data += c0_linesize;
1070 c1_data += c1_linesize;
1071 c2_data += c2_linesize;
1072 d0_data += d0_linesize;
1073 d1_data += d1_linesize;
1074 d2_data += d2_linesize;
1118 switch (inlink->
format) {
1139 for (i = 0; i < s->
ncomp; i++) {
1140 if ((1 << i) & s->
pcomp)
1158 for (p = 0; p < 4; p++) {
1159 const int is_chroma = (p == 1 || p == 2);
1165 if (!((1 << p) & s->
pcomp))
1168 shift = s->
mode ? shift_h : shift_w;
1170 for (k = 0; k < 4; k++) {
1178 for (i = 0; i <
size; i++) {
1179 for (k = 0; k < 4; k++) {
1206 for (k = 0; k < s->
ncomp; k++) {
1207 const int is_chroma = (k == 1 || k == 2);
1211 for (i = 0; i < dst_h ; i++)
1219 for (i = 0; i < dst_h ; i++) {
1220 for (j = 0; j < dst_w; j++)
1227 for (k = 0, i = 0; k < s->
ncomp; k++) {
1228 if ((1 << k) & s->
pcomp) {
1268 .priv_class = &waveform_class,
int plane
Which of the 4 planes contains the component.
static int shift(int a, int b)
#define AV_PIX_FMT_YUVA422P9
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
#define AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA422P10
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Main libavfilter public API header.
int h
agreed upon image height
#define AV_PIX_FMT_GBRP10
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
const char * name
Pad name.
AVFilterLink ** inputs
array of pointers to input links
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
static av_cold int end(AVCodecContext *avctx)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, uint8_t clip)
#define AV_PIX_FMT_YUVA420P9
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
A filter pad used for either input or output.
A link between two filters.
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
int width
width and height of the video frame
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
void * priv
private data for use by the filter
simple assert() macros that are a bit more flexible than ISO C assert().
#define AV_PIX_FMT_YUV444P10
static const uint8_t offset[127][2]
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
int w
agreed upon image width
#define AV_PIX_FMT_YUV422P9
uint8_t nb_components
The number of components each pixel has, (1-4)
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
AVFilterContext * src
source filter
#define AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUV444P9
int format
agreed upon media format
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
static int16_t mult(Float11 *f1, Float11 *f2)
#define AV_PIX_FMT_YUV420P10
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Describe the class of an AVClass context structure.
rational number numerator/denominator
const char * name
Filter name.
#define AV_PIX_FMT_YUV420P9
AVRational sample_aspect_ratio
agreed upon sample aspect ratio
AVFilterLink ** outputs
array of pointers to output links
static enum AVPixelFormat pix_fmts[]
#define AV_PIX_FMT_YUV422P10
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
void(* waveform)(struct WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, int offset, int column)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
planar GBRA 4:4:4:4 32bpp
#define AV_PIX_FMT_YUVA444P9
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
AVFilterContext * dst
dest filter
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
static void comp(unsigned char *dst, int dst_stride, unsigned char *src, int src_stride, int add)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
#define av_malloc_array(a, b)
int depth
Number of bits in the component.
const AVPixFmtDescriptor * desc
AVPixelFormat
Pixel format.
#define AV_CEIL_RSHIFT(a, b)