Go to the documentation of this file.
23 #define _DEFAULT_SOURCE
24 #define _SVID_SOURCE // needed for MAP_ANONYMOUS
25 #define _DARWIN_C_SOURCE // needed for MAP_ANON
32 #if defined(MAP_ANON) && !defined(MAP_ANONYMOUS)
33 #define MAP_ANONYMOUS MAP_ANON
271 int filterSize, int16_t *
filter,
280 if ((
c->srcBpc == 8) && (
c->dstBpc <= 14)) {
281 int16_t *filterCopy =
NULL;
282 if (filterSize > 4) {
285 memcpy(filterCopy,
filter, dstW * filterSize *
sizeof(int16_t));
289 for (
i = 0;
i + 16 <= dstW;
i += 16) {
290 FFSWAP(
int, filterPos[
i + 2], filterPos[
i + 4]);
291 FFSWAP(
int, filterPos[
i + 3], filterPos[
i + 5]);
292 FFSWAP(
int, filterPos[
i + 10], filterPos[
i + 12]);
293 FFSWAP(
int, filterPos[
i + 11], filterPos[
i + 13]);
295 if (filterSize > 4) {
297 for (
i = 0;
i + 16 <= dstW;
i += 16) {
299 for (k = 0; k + 4 <= filterSize; k += 4) {
300 for (j = 0; j < 16; ++j) {
301 int from = (
i + j) * filterSize + k;
302 int to =
i * filterSize + j * 4 + k * 16;
303 memcpy(&
filter[
to], &filterCopy[
from], 4 *
sizeof(int16_t));
308 for (;
i < dstW;
i += 4) {
310 int rem = dstW -
i >= 4 ? 4 : dstW -
i;
311 for (k = 0; k + 4 <= filterSize; k += 4) {
312 for (j = 0; j < rem; ++j) {
313 int from = (
i + j) * filterSize + k;
314 int to =
i * filterSize + j * 4 + k * 4;
315 memcpy(&
filter[
to], &filterCopy[
from], 4 *
sizeof(int16_t));
349 return ((
d * dist +
c) * dist +
b) * dist +
a;
352 b + 2.0 *
c + 3.0 *
d,
354 -
b - 3.0 *
c - 6.0 *
d,
360 if (
pos == -1 ||
pos <= -513) {
361 pos = (128 << chr_subsample) - 128;
364 return pos >> chr_subsample;
381 {
SWS_POINT,
"nearest neighbor / point", -1 },
384 {
SWS_X,
"experimental", 8 },
388 int *outFilterSize,
int xInc,
int srcW,
389 int dstW,
int filterAlign,
int one,
392 double param[2],
int srcPos,
int dstPos)
399 int64_t *filter2 =
NULL;
400 const int64_t fone = 1LL << (54 -
FFMIN(
av_log2(srcW/dstW), 8));
409 if (
FFABS(xInc - 0x10000) < 10 && srcPos == dstPos) {
415 for (
i = 0;
i < dstW;
i++) {
426 xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
427 for (
i = 0;
i < dstW;
i++) {
428 int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
430 (*filterPos)[
i] = xx;
442 xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
443 for (
i = 0;
i < dstW;
i++) {
444 int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
447 (*filterPos)[
i] = xx;
449 for (j = 0; j < filterSize; j++) {
450 int64_t
coeff = fone -
FFABS((int64_t)xx * (1 << 16) - xDstInSrc) * (fone >> 16);
473 filterSize = 1 + sizeFactor;
475 filterSize = 1 + (sizeFactor * srcW + dstW - 1) / dstW;
477 filterSize =
FFMIN(filterSize, srcW - 2);
478 filterSize =
FFMAX(filterSize, 1);
482 xDstInSrc = ((dstPos*(int64_t)xInc)>>7) - ((srcPos*0x10000LL)>>7);
483 for (
i = 0;
i < dstW;
i++) {
484 int xx = (xDstInSrc - (filterSize - 2) * (1LL<<16)) / (1 << 17);
486 (*filterPos)[
i] = xx;
487 for (j = 0; j < filterSize; j++) {
488 int64_t
d = (
FFABS(((int64_t)xx * (1 << 17)) - xDstInSrc)) << 13;
494 floatd =
d * (1.0 / (1 << 30));
500 if (
d >= 1LL << 31) {
503 int64_t dd = (
d *
d) >> 30;
504 int64_t ddd = (dd *
d) >> 30;
507 coeff = (12 * (1 << 24) - 9 *
B - 6 *
C) * ddd +
508 (-18 * (1 << 24) + 12 *
B + 6 *
C) * dd +
509 (6 * (1 << 24) - 2 *
B) * (1 << 30);
512 (6 *
B + 30 *
C) * dd +
513 (-12 *
B - 48 *
C) *
d +
514 (8 *
B + 24 *
C) * (1 << 30);
516 coeff /= (1LL<<54)/fone;
522 c = cos(floatd *
M_PI);
529 coeff = (
c * 0.5 + 0.5) * fone;
531 int64_t d2 =
d - (1 << 29);
532 if (d2 * xInc < -(1LL << (29 + 16)))
533 coeff = 1.0 * (1LL << (30 + 16));
534 else if (d2 * xInc < (1LL << (29 + 16)))
535 coeff = -d2 * xInc + (1LL << (29 + 16));
538 coeff *= fone >> (30 + 16);
541 coeff =
exp2(-p * floatd * floatd) * fone;
547 (floatd * floatd *
M_PI *
M_PI / p) : 1.0) * fone;
556 double p = -2.196152422706632;
565 xDstInSrc += 2 * xInc;
573 filter2Size = filterSize;
575 filter2Size += srcFilter->
length - 1;
577 filter2Size += dstFilter->
length - 1;
581 for (
i = 0;
i < dstW;
i++) {
585 for (k = 0; k < srcFilter->
length; k++) {
586 for (j = 0; j < filterSize; j++)
587 filter2[
i * filter2Size + k + j] +=
591 for (j = 0; j < filterSize; j++)
592 filter2[
i * filter2Size + j] =
filter[
i * filterSize + j];
596 (*filterPos)[
i] += (filterSize - 1) / 2 - (filter2Size - 1) / 2;
603 for (
i = dstW - 1;
i >= 0;
i--) {
604 int min = filter2Size;
606 int64_t cutOff = 0.0;
609 for (j = 0; j < filter2Size; j++) {
611 cutOff +=
FFABS(filter2[
i * filter2Size]);
618 if (
i < dstW - 1 && (*filterPos)[
i] >= (*filterPos)[
i + 1])
622 for (k = 1; k < filter2Size; k++)
623 filter2[
i * filter2Size + k - 1] = filter2[
i * filter2Size + k];
624 filter2[
i * filter2Size + k - 1] = 0;
630 for (j = filter2Size - 1; j > 0; j--) {
631 cutOff +=
FFABS(filter2[
i * filter2Size + j]);
638 if (
min > minFilterSize)
644 if (minFilterSize < 5)
650 if (minFilterSize < 3)
656 if (minFilterSize == 1 && filterAlign == 2)
661 int reNum = minFilterSize & (0x07);
663 if (minFilterSize < 5)
670 filterSize = (minFilterSize + (filterAlign - 1)) & (~(filterAlign - 1));
680 *outFilterSize = filterSize;
684 "SwScaler: reducing / aligning filtersize %d -> %d\n",
685 filter2Size, filterSize);
687 for (
i = 0;
i < dstW;
i++) {
690 for (j = 0; j < filterSize; j++) {
691 if (j >= filter2Size)
692 filter[
i * filterSize + j] = 0;
694 filter[
i * filterSize + j] = filter2[
i * filter2Size + j];
696 filter[
i * filterSize + j] = 0;
703 for (
i = 0;
i < dstW;
i++) {
705 if ((*filterPos)[
i] < 0) {
707 for (j = 1; j < filterSize; j++) {
710 filter[
i * filterSize + j] = 0;
715 if ((*filterPos)[
i] + filterSize > srcW) {
716 int shift = (*filterPos)[
i] +
FFMIN(filterSize - srcW, 0);
719 for (j = filterSize - 1; j >= 0; j--) {
720 if ((*filterPos)[
i] + j >= srcW) {
722 filter[
i * filterSize + j] = 0;
725 for (j = filterSize - 1; j >= 0; j--) {
727 filter[
i * filterSize + j] = 0;
734 filter[
i * filterSize + srcW - 1 - (*filterPos)[
i]] +=
acc;
738 if ((*filterPos)[
i] + filterSize > srcW) {
739 for (j = 0; j < filterSize; j++) {
751 for (
i = 0;
i < dstW;
i++) {
756 for (j = 0; j < filterSize; j++) {
757 sum +=
filter[
i * filterSize + j];
759 sum = (sum + one / 2) / one;
764 for (j = 0; j < *outFilterSize; j++) {
767 (*outFilter)[
i * (*outFilterSize) + j] = intV;
768 error = v - intV * sum;
772 (*filterPos)[dstW + 0] =
773 (*filterPos)[dstW + 1] =
774 (*filterPos)[dstW + 2] = (*filterPos)[dstW - 1];
776 for (
i = 0;
i < *outFilterSize;
i++) {
777 int k = (dstW - 1) * (*outFilterSize) +
i;
778 (*outFilter)[k + 1 * (*outFilterSize)] =
779 (*outFilter)[k + 2 * (*outFilterSize)] =
780 (*outFilter)[k + 3 * (*outFilterSize)] = (*outFilter)[k];
798 int64_t
W,
V, Z, Cy, Cu, Cv;
799 int64_t vr =
table[0];
801 int64_t ug = -
table[2];
802 int64_t vg = -
table[3];
805 uint8_t *p = (uint8_t*)
c->input_rgb2yuv_table;
807 static const int8_t
map[] = {
832 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
833 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
834 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
835 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
836 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
837 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
838 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
839 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
897 static const int16_t xyz2rgb_matrix[3][4] = {
898 {13270, -6295, -2041},
900 { 228, -835, 4329} };
901 static const int16_t rgb2xyz_matrix[3][4] = {
905 static int16_t xyzgamma_tab[4096], rgbgamma_tab[4096], xyzgammainv_tab[4096], rgbgammainv_tab[4096];
907 memcpy(
c->xyz2rgb_matrix, xyz2rgb_matrix,
sizeof(
c->xyz2rgb_matrix));
908 memcpy(
c->rgb2xyz_matrix, rgb2xyz_matrix,
sizeof(
c->rgb2xyz_matrix));
909 c->xyzgamma = xyzgamma_tab;
910 c->rgbgamma = rgbgamma_tab;
911 c->xyzgammainv = xyzgammainv_tab;
912 c->rgbgammainv = rgbgammainv_tab;
914 if (rgbgamma_tab[4095])
918 for (
i = 0;
i < 4096;
i++) {
919 xyzgamma_tab[
i] =
lrint(pow(
i / 4095.0, xyzgamma) * 4095.0);
920 rgbgamma_tab[
i] =
lrint(pow(
i / 4095.0, rgbgamma) * 4095.0);
921 xyzgammainv_tab[
i] =
lrint(pow(
i / 4095.0, xyzgammainv) * 4095.0);
922 rgbgammainv_tab[
i] =
lrint(pow(
i / 4095.0, rgbgammainv) * 4095.0);
990 if (
c->srcXYZ ||
c->dstXYZ)
1000 int srcRange,
const int table[4],
int dstRange,
1001 int brightness,
int contrast,
int saturation)
1005 int need_reinit = 0;
1007 if (
c->nb_slice_ctx) {
1009 for (
int i = 0;
i <
c->nb_slice_ctx;
i++) {
1011 srcRange,
table, dstRange,
1012 brightness, contrast, saturation);
1029 if (
c->srcRange != srcRange ||
1030 c->dstRange != dstRange ||
1031 c->brightness != brightness ||
1032 c->contrast != contrast ||
1033 c->saturation != saturation ||
1034 memcmp(
c->srcColorspaceTable, inv_table,
sizeof(
int) * 4) ||
1035 memcmp(
c->dstColorspaceTable,
table,
sizeof(
int) * 4)
1039 memmove(
c->srcColorspaceTable, inv_table,
sizeof(
int) * 4);
1040 memmove(
c->dstColorspaceTable,
table,
sizeof(
int) * 4);
1044 c->brightness = brightness;
1045 c->contrast = contrast;
1046 c->saturation = saturation;
1047 c->srcRange = srcRange;
1048 c->dstRange = dstRange;
1052 if (need_reinit && (
c->srcBpc == 8 || !
isYUV(
c->srcFormat)))
1058 if (
c->cascaded_context[
c->cascaded_mainindex])
1065 if (!
c->cascaded_context[0] &&
1066 memcmp(
c->dstColorspaceTable,
c->srcColorspaceTable,
sizeof(
int) * 4) &&
1067 c->srcW &&
c->srcH &&
c->dstW &&
c->dstH) {
1069 int tmp_width, tmp_height;
1075 av_log(
c,
AV_LOG_VERBOSE,
"YUV color matrix differs for YUV->YUV, using intermediate RGB to convert\n");
1091 if (srcW*srcH > dstW*dstH) {
1100 tmp_width, tmp_height, tmp_format, 64);
1105 tmp_width, tmp_height, tmp_format,
1106 c->flags,
c->param);
1107 if (!
c->cascaded_context[0])
1110 c->cascaded_context[0]->alphablend =
c->alphablend;
1116 srcRange,
table, dstRange,
1117 brightness, contrast, saturation);
1120 dstW, dstH,
c->dstFormat,
1121 c->flags,
c->param);
1122 if (!
c->cascaded_context[1])
1124 c->cascaded_context[1]->srcRange = srcRange;
1125 c->cascaded_context[1]->dstRange = dstRange;
1130 srcRange,
table, dstRange,
1131 0, 1 << 16, 1 << 16);
1135 if (
c->cascaded_context[0] && memcmp(
c->dstColorspaceTable,
c->srcColorspaceTable,
sizeof(
int) * 4))
1142 contrast, saturation);
1147 contrast, saturation);
1157 int *srcRange,
int **
table,
int *dstRange,
1158 int *brightness,
int *contrast,
int *saturation)
1163 if (
c->nb_slice_ctx) {
1165 table, dstRange, brightness, contrast,
1169 *inv_table =
c->srcColorspaceTable;
1170 *
table =
c->dstColorspaceTable;
1173 *brightness =
c->brightness;
1174 *contrast =
c->contrast;
1175 *saturation =
c->saturation;
1200 tbl = (uint16_t*)
av_malloc(
sizeof(uint16_t) * 1 << 16);
1204 for (
i = 0;
i < 65536; ++
i) {
1205 tbl[
i] = pow(
i / 65535.0, e) * 65535.0;
1275 int usesVFilter, usesHFilter;
1282 int dst_stride =
FFALIGN(dstW *
sizeof(int16_t) + 66, 16);
1289 static const float float_mult = 1.0f / 255.0f;
1295 unscaled = (srcW == dstW && srcH == dstH);
1297 if (!
c->contrast && !
c->saturation && !
c->dstFormatBpp)
1300 c->dstRange, 0, 1 << 16, 1 << 16);
1303 srcFormat =
c->srcFormat;
1304 dstFormat =
c->dstFormat;
1341 if (dstW < srcW && dstH < srcH)
1343 else if (dstW > srcW && dstH > srcH)
1348 }
else if (
i & (
i - 1)) {
1350 "Exactly one scaler algorithm must be chosen, got %X\n",
i);
1354 if (srcW < 1 || srcH < 1 || dstW < 1 || dstH < 1) {
1358 srcW, srcH, dstW, dstH);
1362 if (srcW < 8 || dstW < 8) {
1369 dstFilter = &dummyFilter;
1371 srcFilter = &dummyFilter;
1373 c->lumXInc = (((int64_t)srcW << 16) + (dstW >> 1)) / dstW;
1374 c->lumYInc = (((int64_t)srcH << 16) + (dstH >> 1)) / dstH;
1377 c->vRounder = 4 * 0x0001000100010001ULL;
1379 usesVFilter = (srcFilter->
lumV && srcFilter->
lumV->
length > 1) ||
1383 usesHFilter = (srcFilter->
lumH && srcFilter->
lumH->
length > 1) ||
1391 c->dst_slice_align = 1 <<
c->chrDstVSubSample;
1400 if (
c->chrSrcHSubSample == 0
1401 &&
c->chrSrcVSubSample == 0
1405 av_log(
c,
AV_LOG_DEBUG,
"Forcing full internal H chroma due to input having non subsampled chroma\n");
1425 "Desired dithering only supported in full chroma interpolation for destination format '%s'\n",
1434 "Ordered dither is not supported in full chroma interpolation for destination format '%s'\n",
1443 "%s output is not supported with half chroma resolution, switching to full\n",
1475 "full chroma interpolation for destination format '%s' not yet implemented\n",
1481 c->chrDstHSubSample = 1;
1486 c->chrSrcVSubSample +=
c->vChrDrop;
1504 ((dstW >>
c->chrDstHSubSample) <= (srcW >> 1) ||
1506 c->chrSrcHSubSample = 1;
1525 if (
c->dstBpc == 16)
1529 c->canMMXEXTBeUsed = dstW >= srcW && (dstW & 31) == 0 &&
1530 c->chrDstW >=
c->chrSrcW &&
1532 if (!
c->canMMXEXTBeUsed && dstW >= srcW &&
c->chrDstW >=
c->chrSrcW && (srcW & 15) == 0
1537 "output width is not a multiple of 32 -> no MMXEXT scaler\n");
1540 c->canMMXEXTBeUsed = 0;
1542 c->canMMXEXTBeUsed = 0;
1544 c->chrXInc = (((int64_t)
c->chrSrcW << 16) + (
c->chrDstW >> 1)) /
c->chrDstW;
1545 c->chrYInc = (((int64_t)
c->chrSrcH << 16) + (
c->chrDstH >> 1)) /
c->chrDstH;
1555 if (
c->canMMXEXTBeUsed) {
1561 c->lumXInc = ((int64_t)(srcW - 2) << 16) / (dstW - 2) - 20;
1562 c->chrXInc = ((int64_t)(
c->chrSrcW - 2) << 16) / (
c->chrDstW - 2) - 20;
1567 c->gamma_value = 2.2;
1571 if (!unscaled &&
c->gamma_flag && (srcFormat != tmpFmt || dstFormat != tmpFmt)) {
1573 c->cascaded_context[0] =
NULL;
1576 srcW, srcH, tmpFmt, 64);
1583 if (!
c->cascaded_context[0]) {
1589 flags, srcFilter, dstFilter,
c->param);
1591 if (!
c->cascaded_context[1])
1594 c2 =
c->cascaded_context[1];
1595 c2->is_internal_gamma = 1;
1598 if (!
c2->gamma || !
c2->inv_gamma)
1607 c->cascaded_context[1] =
NULL;
1611 c->cascaded_context[2] =
NULL;
1612 if (dstFormat != tmpFmt) {
1614 dstW, dstH, tmpFmt, 64);
1619 dstW, dstH, dstFormat,
1621 if (!
c->cascaded_context[2])
1634 srcW, srcH, tmpFormat, 64);
1639 srcW, srcH, tmpFormat,
1641 if (!
c->cascaded_context[0])
1645 dstW, dstH, dstFormat,
1647 if (!
c->cascaded_context[1])
1654 for (
i = 0;
i < 256; ++
i){
1655 c->uint2float_lut[
i] = (
float)
i * float_mult;
1661 (!unscaled || unscaled && dstFormat != srcFormat && (srcFormat !=
AV_PIX_FMT_GRAYF32 ||
1666 if (CONFIG_SWSCALE_ALPHA &&
isALPHA(srcFormat) && !
isALPHA(dstFormat)) {
1671 dstFormat != tmpFormat ||
1672 usesHFilter || usesVFilter ||
1673 c->srcRange !=
c->dstRange
1675 c->cascaded_mainindex = 1;
1677 srcW, srcH, tmpFormat, 64);
1682 srcW, srcH, tmpFormat,
1684 if (!
c->cascaded_context[0])
1686 c->cascaded_context[0]->alphablend =
c->alphablend;
1692 dstW, dstH, dstFormat,
1694 if (!
c->cascaded_context[1])
1697 c->cascaded_context[1]->srcRange =
c->srcRange;
1698 c->cascaded_context[1]->dstRange =
c->dstRange;
1709 if (unscaled && !usesHFilter && !usesVFilter &&
1712 (
c->srcRange ==
c->dstRange ||
isAnyRGB(dstFormat)) &&
1719 "using alpha blendaway %s -> %s special converter\n",
1725 if (unscaled && !usesHFilter && !usesVFilter &&
1726 (
c->srcRange ==
c->dstRange ||
isAnyRGB(dstFormat) ||
1730 if (
c->convert_unscaled) {
1733 "using unscaled %s -> %s special converter\n",
1739 #if HAVE_MMAP && HAVE_MPROTECT && defined(MAP_ANONYMOUS)
1747 #if HAVE_MMXEXT_INLINE
1756 c->lumMmxextFilterCode = mmap(
NULL,
c->lumMmxextFilterCodeSize,
1757 PROT_READ | PROT_WRITE,
1758 MAP_PRIVATE | MAP_ANONYMOUS,
1760 c->chrMmxextFilterCode = mmap(
NULL,
c->chrMmxextFilterCodeSize,
1761 PROT_READ | PROT_WRITE,
1762 MAP_PRIVATE | MAP_ANONYMOUS,
1764 #elif HAVE_VIRTUALALLOC
1765 c->lumMmxextFilterCode = VirtualAlloc(
NULL,
1766 c->lumMmxextFilterCodeSize,
1768 PAGE_EXECUTE_READWRITE);
1769 c->chrMmxextFilterCode = VirtualAlloc(
NULL,
1770 c->chrMmxextFilterCodeSize,
1772 PAGE_EXECUTE_READWRITE);
1774 c->lumMmxextFilterCode =
av_malloc(
c->lumMmxextFilterCodeSize);
1775 c->chrMmxextFilterCode =
av_malloc(
c->chrMmxextFilterCodeSize);
1778 #ifdef MAP_ANONYMOUS
1779 if (
c->lumMmxextFilterCode == MAP_FAILED ||
c->chrMmxextFilterCode == MAP_FAILED)
1781 if (!
c->lumMmxextFilterCode || !
c->chrMmxextFilterCode)
1795 c->hLumFilter, (uint32_t*)
c->hLumFilterPos, 8);
1797 c->hChrFilter, (uint32_t*)
c->hChrFilterPos, 4);
1800 if ( mprotect(
c->lumMmxextFilterCode,
c->lumMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1
1801 || mprotect(
c->chrMmxextFilterCode,
c->chrMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1) {
1817 &
c->hLumFilterSize,
c->lumXInc,
1818 srcW, dstW, filterAlign, 1 << 14,
1828 &
c->hChrFilterSize,
c->chrXInc,
1829 c->chrSrcW,
c->chrDstW, filterAlign, 1 << 14,
1847 if ((
ret =
initFilter(&
c->vLumFilter, &
c->vLumFilterPos, &
c->vLumFilterSize,
1848 c->lumYInc, srcH, dstH, filterAlign, (1 << 12),
1855 if ((
ret =
initFilter(&
c->vChrFilter, &
c->vChrFilterPos, &
c->vChrFilterSize,
1856 c->chrYInc,
c->chrSrcH,
c->chrDstH,
1857 filterAlign, (1 << 12),
1871 for (
i = 0;
i <
c->vLumFilterSize *
c->dstH;
i++) {
1873 short *p = (
short *)&
c->vYCoeffsBank[
i];
1874 for (j = 0; j < 8; j++)
1875 p[j] =
c->vLumFilter[
i];
1878 for (
i = 0;
i <
c->vChrFilterSize *
c->chrDstH;
i++) {
1880 short *p = (
short *)&
c->vCCoeffsBank[
i];
1881 for (j = 0; j < 8; j++)
1882 p[j] =
c->vChrFilter[
i];
1887 for (
i = 0;
i < 4;
i++)
1891 c->needAlpha = (CONFIG_SWSCALE_ALPHA &&
isALPHA(
c->srcFormat) &&
isALPHA(
c->dstFormat)) ? 1 : 0;
1894 c->uv_off = (dst_stride>>1) + 64 / (
c->dstBpc &~ 7);
1895 c->uv_offx2 = dst_stride + 16;
1900 const char *scaler =
NULL, *cpucaps;
1909 scaler =
"ehh flags invalid?!";
1928 cpucaps =
"AltiVec";
1936 "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1937 c->srcW,
c->srcH,
c->dstW,
c->dstH,
c->lumXInc,
c->lumYInc);
1939 "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1940 c->chrSrcW,
c->chrSrcH,
c->chrDstW,
c->chrDstH,
1941 c->chrXInc,
c->chrYInc);
1951 int tmpW = sqrt(srcW * (int64_t)dstW);
1952 int tmpH = sqrt(srcH * (int64_t)dstH);
1958 if (srcW*(int64_t)srcH <= 4LL*dstW*dstH)
1962 tmpW, tmpH, tmpFormat, 64);
1967 tmpW, tmpH, tmpFormat,
1969 if (!
c->cascaded_context[0])
1973 dstW, dstH, dstFormat,
1975 if (!
c->cascaded_context[1])
1995 c->nb_threads =
ret;
1997 c->slice_ctx =
av_calloc(
c->nb_threads,
sizeof(*
c->slice_ctx));
1998 c->slice_err =
av_calloc(
c->nb_threads,
sizeof(*
c->slice_err));
1999 if (!
c->slice_ctx || !
c->slice_err)
2002 for (
int i = 0;
i <
c->nb_threads;
i++) {
2004 if (!
c->slice_ctx[
i])
2007 c->slice_ctx[
i]->parent =
c;
2013 c->slice_ctx[
i]->nb_threads = 1;
2023 "Error-diffusion dither is in use, scaling will be single-threaded.");
2040 if (!
c->frame_src || !
c->frame_dst)
2046 src_format =
c->srcFormat;
2047 dst_format =
c->dstFormat;
2051 if (src_format !=
c->srcFormat || dst_format !=
c->dstFormat)
2054 if (
c->nb_threads != 1) {
2056 if (ret < 0 || c->nb_threads > 1)
2066 int flags,
const double *param)
2078 c->srcFormat = srcFormat;
2079 c->dstFormat = dstFormat;
2082 c->param[0] = param[0];
2083 c->param[1] = param[1];
2092 SwsFilter *dstFilter,
const double *param)
2097 dstW, dstH, dstFormat,
2113 for (
i=0;
i<
a->length;
i++)
2122 for (
i=0;
i<
a->length;
i++)
2130 if(length <= 0 || length > INT_MAX/
sizeof(
double))
2145 const int length = (
int)(variance *
quality + 0.5) | 1;
2147 double middle = (length - 1) * 0.5;
2150 if(variance < 0 ||
quality < 0)
2158 for (
i = 0;
i < length;
i++) {
2159 double dist =
i - middle;
2160 vec->
coeff[
i] =
exp(-dist * dist / (2 * variance * variance)) /
2161 sqrt(2 * variance *
M_PI);
2182 for (
i = 0;
i < length;
i++)
2203 for (
i = 0;
i <
a->length;
i++)
2213 for (
i = 0;
i <
a->length;
i++)
2214 a->coeff[
i] *= scalar;
2224 int length =
FFMAX(
a->length,
b->length);
2231 for (
i = 0;
i <
a->length;
i++)
2232 vec->
coeff[
i + (length - 1) / 2 - (
a->length - 1) / 2] +=
a->coeff[
i];
2233 for (
i = 0;
i <
b->length;
i++)
2234 vec->
coeff[
i + (length - 1) / 2 - (
b->length - 1) / 2] +=
b->coeff[
i];
2249 for (
i = 0;
i <
a->length;
i++) {
2250 vec->
coeff[
i + (length - 1) / 2 -
2251 (
a->length - 1) / 2 -
shift] =
a->coeff[
i];
2266 a->coeff = shifted->
coeff;
2297 for (
i = 0;
i <
a->length;
i++)
2298 if (
a->coeff[
i] >
max)
2301 for (
i = 0;
i <
a->length;
i++)
2302 if (
a->coeff[
i] <
min)
2307 for (
i = 0;
i <
a->length;
i++) {
2309 av_log(log_ctx, log_level,
"%1.3f ",
a->coeff[
i]);
2311 av_log(log_ctx, log_level,
" ");
2312 av_log(log_ctx, log_level,
"|\n");
2338 float lumaSharpen,
float chromaSharpen,
2339 float chromaHShift,
float chromaVShift,
2346 if (lumaGBlur != 0.0) {
2354 if (chromaGBlur != 0.0) {
2365 if (chromaSharpen != 0.0) {
2376 if (lumaSharpen != 0.0) {
2387 if (chromaHShift != 0.0)
2390 if (chromaVShift != 0.0)
2426 for (
i = 0;
i <
c->nb_slice_ctx;
i++)
2433 for (
i = 0;
i < 4;
i++)
2457 if (
c->lumMmxextFilterCode)
2458 munmap(
c->lumMmxextFilterCode,
c->lumMmxextFilterCodeSize);
2459 if (
c->chrMmxextFilterCode)
2460 munmap(
c->chrMmxextFilterCode,
c->chrMmxextFilterCodeSize);
2461 #elif HAVE_VIRTUALALLOC
2462 if (
c->lumMmxextFilterCode)
2463 VirtualFree(
c->lumMmxextFilterCode, 0, MEM_RELEASE);
2464 if (
c->chrMmxextFilterCode)
2465 VirtualFree(
c->chrMmxextFilterCode, 0, MEM_RELEASE);
2470 c->lumMmxextFilterCode =
NULL;
2471 c->chrMmxextFilterCode =
NULL;
2480 memset(
c->cascaded_context, 0,
sizeof(
c->cascaded_context));
2501 const double *
param)
2509 param = default_param;
2562 for (idx = 0; idx < rl->
nb_ranges; idx++)
2569 if (prev->
start + prev->
len > start)
2572 if (idx < rl->nb_ranges) {
2602 if (idx < rl->nb_ranges - 1) {
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
static void error(const char *err)
static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
struct SwsContext * sws_getCachedContext(struct SwsContext *context, int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, SwsFilter *srcFilter, SwsFilter *dstFilter, const double *param)
Check if context can be reused, otherwise reallocate a new one.
#define INLINE_MMX(flags)
@ AV_PIX_FMT_XYZ12LE
packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as lit...
enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt)
Utility function to swap the endianness of a pixel format.
@ AV_PIX_FMT_YUV420P9LE
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
@ AV_PIX_FMT_XV30LE
packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), little-endian, variant of Y410 where alpha channe...
#define AV_LOG_WARNING
Something somehow does not look correct.
@ AV_PIX_FMT_GRAY10BE
Y , 10bpp, big-endian.
int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_BAYER_GBRG16LE
bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian
@ AV_PIX_FMT_BGR48LE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as lit...
static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
@ AV_PIX_FMT_P416BE
interleaved chroma YUV 4:4:4, 48bpp, big-endian
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
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
@ AV_PIX_FMT_BGRA64BE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
static SwsVector * sws_getIdentityVec(void)
Allocate and return a vector with just one coefficient, with value 1.0.
int dstW
Width of destination luma/alpha planes.
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
static void fill_xyztables(struct SwsContext *c)
@ AV_PIX_FMT_RGB444LE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
@ AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
@ AV_PIX_FMT_YUV422P14LE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define EXTERNAL_AVX2_FAST(flags)
@ AV_PIX_FMT_YUVA444P10BE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
static enum AVPixelFormat alphaless_fmt(enum AVPixelFormat fmt)
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
static int handle_0alpha(enum AVPixelFormat *format)
@ AV_PIX_FMT_YUV440P12BE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
@ AV_PIX_FMT_GBRAPF32LE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
@ AV_PIX_FMT_GBRPF32BE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
int depth
Number of bits in the component.
@ AV_PIX_FMT_P412BE
interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, big-endian
static const uint16_t table[]
@ AV_PIX_FMT_P010BE
like NV12, with 10bpp per component, data in the high bits, zeros in the low bits,...
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
@ AV_PIX_FMT_YUV420P14BE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
#define AV_PIX_FMT_YUV420P10
@ AV_PIX_FMT_YUV420P16LE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
#define AV_LOG_VERBOSE
Detailed information.
@ AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
@ AV_PIX_FMT_YUV422P9BE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
@ AV_PIX_FMT_YUVA444P9BE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
static SwsVector * sws_getShiftedVec(SwsVector *a, int shift)
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
@ AV_PIX_FMT_BAYER_GRBG16BE
bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian
static atomic_int cpu_flags
@ AV_PIX_FMT_GRAY10LE
Y , 10bpp, little-endian.
@ AV_PIX_FMT_GRAYF32LE
IEEE-754 single precision Y, 32bpp, little-endian.
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
@ AV_PIX_FMT_RGBAF16LE
IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., little-endian.
void sws_freeVec(SwsVector *a)
@ AV_PIX_FMT_AYUV64LE
packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
@ AV_PIX_FMT_YUV444P16LE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
@ AV_PIX_FMT_BAYER_GBRG16BE
bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian
static int sws_init_single_context(SwsContext *c, SwsFilter *srcFilter, SwsFilter *dstFilter)
static int isnan_vec(SwsVector *a)
@ AV_PIX_FMT_GBRAP12LE
planar GBR 4:4:4:4 48bpp, little-endian
#define SWS_FAST_BILINEAR
static int handle_jpeg(enum AVPixelFormat *format)
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
@ AV_PIX_FMT_YUV420P12LE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
int avpriv_slicethread_create(AVSliceThread **pctx, void *priv, void(*worker_func)(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads), void(*main_func)(void *priv), int nb_threads)
Create slice threading context.
#define AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_YUV422P9
@ AV_PIX_FMT_GRAY9LE
Y , 9bpp, little-endian.
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
#define AV_PIX_FMT_GRAY16
@ AV_PIX_FMT_YUVA444P16BE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
@ AV_PIX_FMT_YUV444P10BE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
@ AV_PIX_FMT_YUV420P10LE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
#define AV_CPU_FLAG_SLOW_GATHER
CPU has slow gathers.
@ AV_PIX_FMT_VUYA
packed VUYA 4:4:4, 32bpp, VUYAVUYA...
@ AV_PIX_FMT_YUV444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define AV_PIX_FMT_YUV444P10
int ff_init_filters(SwsContext *c)
@ AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
uint8_t is_supported_endianness
@ AV_PIX_FMT_YUV422P12BE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
@ AV_PIX_FMT_YUV444P14LE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
static __device__ float ceil(float a)
static int ff_thread_once(char *control, void(*routine)(void))
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
@ AV_PIX_FMT_BAYER_RGGB16BE
bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian
static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, int *outFilterSize, int xInc, int srcW, int dstW, int filterAlign, int one, int flags, int cpu_flags, SwsVector *srcFilter, SwsVector *dstFilter, double param[2], int srcPos, int dstPos)
#define FF_ARRAY_ELEMS(a)
enum AVPixelFormat srcFormat
Source pixel format.
#define AV_PIX_FMT_YUV422P16
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
#define SWS_MAX_REDUCE_CUTOFF
int ff_range_add(RangeList *rl, unsigned int start, unsigned int len)
@ AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
static void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level)
Print with av_log() a textual representation of the vector a if log_level <= av_log_level.
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
int ff_sws_alphablendaway(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
@ AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
@ AV_PIX_FMT_P416LE
interleaved chroma YUV 4:4:4, 48bpp, little-endian
@ AV_PIX_FMT_BAYER_RGGB16LE
bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian
#define AV_PIX_FMT_YUV444P16
#define AV_CEIL_RSHIFT(a, b)
@ AV_PIX_FMT_P210LE
interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, little-endian
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 format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
@ AV_PIX_FMT_BAYER_BGGR8
bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples
#define SWS_FULL_CHR_H_INP
static enum AVPixelFormat pix_fmt
int length
number of coefficients in the vector
SwsVector * sws_allocVec(int length)
Allocate and return an uninitialized vector with length coefficients.
@ AV_PIX_FMT_P016BE
like NV12, with 16bpp per component, big-endian
@ AV_PIX_FMT_GBRP12LE
planar GBR 4:4:4 36bpp, little-endian
static av_cold int get_local_pos(SwsContext *s, int chr_subsample, int pos, int dir)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define AV_PIX_FMT_YUV420P9
@ AV_PIX_FMT_YUVA420P16BE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_PIX_FMT_YUV420P16
static const ScaleAlgorithm scale_algorithms[]
int flag
flag associated to the algorithm
@ AV_PIX_FMT_RGB4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in ...
static const FormatEntry format_entries[]
@ AV_PIX_FMT_GBRP10LE
planar GBR 4:4:4 30bpp, little-endian
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
SwsVector * sws_getGaussianVec(double variance, double quality)
Return a normalized Gaussian curve used to filter stuff quality = 3 is high quality,...
#define AV_PIX_FMT_GRAYF32
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
enum AVPixelFormat dstFormat
Destination pixel format.
@ AV_PIX_FMT_YUV444P10LE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
@ AV_PIX_FMT_BAYER_RGGB8
bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples
int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode, int16_t *filter, int32_t *filterPos, int numSplits)
@ AV_PIX_FMT_YUVA422P10LE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
av_cold void ff_sws_init_range_convert(SwsContext *c)
@ AV_PIX_FMT_BAYER_GRBG16LE
bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian
@ AV_PIX_FMT_YUV444P9BE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
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 default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
@ AV_PIX_FMT_YUV422P10BE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
static uint16_t * alloc_gamma_tbl(double e)
#define AV_PIX_FMT_GBRP16
@ AV_PIX_FMT_YUV422P16LE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
void ff_get_unscaled_swscale(SwsContext *c)
Set c->convert_unscaled to an unscaled converter if one exists for the specific source and destinatio...
#define SWS_SRC_V_CHR_DROP_SHIFT
Describe the class of an AVClass context structure.
@ AV_PIX_FMT_GBRAPF32BE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.
@ AV_PIX_FMT_GBRAP12BE
planar GBR 4:4:4:4 48bpp, big-endian
@ AV_PIX_FMT_P012LE
like NV12, with 12bpp per component, data in the high bits, zeros in the low bits,...
#define RETCODE_USE_CASCADE
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
@ AV_PIX_FMT_P210BE
interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, big-endian
@ AV_PIX_FMT_RGB48LE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
@ AV_PIX_FMT_YA16LE
16 bits gray, 16 bits alpha (little-endian)
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
SwsFilter * sws_getDefaultFilter(float lumaGBlur, float chromaGBlur, float lumaSharpen, float chromaSharpen, float chromaHShift, float chromaVShift, int verbose)
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
@ AV_PIX_FMT_YUVA422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian
#define ROUNDED_DIV(a, b)
@ AV_PIX_FMT_BGR565LE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
@ AV_PIX_FMT_YUVA444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian
SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext.
static void makenan_vec(SwsVector *a)
@ AV_PIX_FMT_YUVA444P9LE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
@ AV_PIX_FMT_Y210LE
packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian
static void fill_rgb2yuv_table(SwsContext *c, const int table[4], int dstRange)
@ AV_PIX_FMT_YUVA420P16LE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
av_cold void ff_sws_rgb2rgb_init(void)
@ AV_PIX_FMT_BGR4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in ...
#define AV_PIX_FMT_YUV422P10
@ AV_PIX_FMT_YUV440P10LE
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
static void sws_addVec(SwsVector *a, SwsVector *b)
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
double * coeff
pointer to the list of coefficients
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
static void handle_formats(SwsContext *c)
static int range_override_needed(enum AVPixelFormat format)
int sws_setColorspaceDetails(struct SwsContext *c, const int inv_table[4], int srcRange, const int table[4], int dstRange, int brightness, int contrast, int saturation)
@ AV_PIX_FMT_BGR555BE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
@ AV_PIX_FMT_YUVA420P9LE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian
const AVClass ff_sws_context_class
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
void sws_scaleVec(SwsVector *a, double scalar)
Scale all the coefficients of a by the scalar value.
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
static SwsVector * sws_getConstVec(double c, int length)
Allocate and return a vector with length coefficients, all with the same value c.
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
@ AV_PIX_FMT_YUV420P14LE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
@ AV_PIX_FMT_YUV444P14BE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
@ AV_PIX_FMT_BGR4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
@ AV_PIX_FMT_X2RGB10LE
packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined
#define SWS_PARAM_DEFAULT
@ AV_PIX_FMT_P212LE
interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, little-endian
@ AV_PIX_FMT_YUV420P9BE
The following 12 formats have the disadvantage of needing 1 format for each bit depth.
int av_image_alloc(uint8_t *pointers[4], int linesizes[4], int w, int h, enum AVPixelFormat pix_fmt, int align)
Allocate an image with size w and h and pixel format pix_fmt, and fill pointers and linesizes accordi...
void ff_sws_slice_worker(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads)
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
@ AV_PIX_FMT_YUV440P12LE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
void ff_sws_init_scale(SwsContext *c)
#define PPC_ALTIVEC(flags)
SwsContext * sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, SwsFilter *srcFilter, SwsFilter *dstFilter, const double *param)
Allocate and return an SwsContext.
static int shift(int a, int b)
@ AV_PIX_FMT_BAYER_BGGR16LE
bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian
@ AV_PIX_FMT_YUV420P12BE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
@ AV_PIX_FMT_YUV422P10LE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
@ AV_PIX_FMT_RGB444BE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
#define SWS_FULL_CHR_H_INT
@ AV_PIX_FMT_YUV422P14BE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
@ AV_PIX_FMT_YA16BE
16 bits gray, 16 bits alpha (big-endian)
@ AV_PIX_FMT_GRAY12LE
Y , 12bpp, little-endian.
#define AV_PIX_FMT_BGR555
int srcH
Height of source luma/alpha planes.
static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
@ AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
@ AV_PIX_FMT_YUV420P10BE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
@ AV_PIX_FMT_RGBAF16BE
IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., big-endian.
@ AV_PIX_FMT_NV16
interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
@ AV_PIX_FMT_BGR444BE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
@ AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
@ AV_PIX_FMT_GBRAP10LE
planar GBR 4:4:4:4 40bpp, little-endian
@ AV_PIX_FMT_BGR565BE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
int sws_isSupportedInput(enum AVPixelFormat pix_fmt)
Return a positive value if pix_fmt is a supported input format, 0 otherwise.
@ AV_PIX_FMT_P012BE
like NV12, with 12bpp per component, data in the high bits, zeros in the low bits,...
@ AV_PIX_FMT_P410LE
interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, little-endian
@ AV_PIX_FMT_YUVA420P10LE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
#define AV_LOG_INFO
Standard information.
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
@ AV_PIX_FMT_BGRA64LE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
@ AV_PIX_FMT_YUVA422P10BE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
static int handle_xyz(enum AVPixelFormat *format)
@ AV_PIX_FMT_YUVA444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian
@ AV_PIX_FMT_YUVA422P9BE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
#define AV_PIX_FMT_BGRA64
int srcW
Width of source luma/alpha planes.
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt)
@ AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
const int32_t ff_yuv2rgb_coeffs[11][4]
static int context_init_threaded(SwsContext *c, SwsFilter *src_filter, SwsFilter *dst_filter)
static void sws_shiftVec(SwsVector *a, int shift)
#define i(width, name, range_min, range_max)
#define AV_PIX_FMT_GBRP12
#define av_malloc_array(a, b)
@ AV_PIX_FMT_GRAY9BE
Y , 9bpp, big-endian.
@ 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...
int ff_free_filters(SwsContext *c)
@ AV_PIX_FMT_BAYER_GBRG8
bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples
static double getSplineCoeff(double a, double b, double c, double d, double dist)
int sws_isSupportedOutput(enum AVPixelFormat pix_fmt)
Return a positive value if pix_fmt is a supported output format, 0 otherwise.
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
@ AV_PIX_FMT_XYZ12BE
packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as big...
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
@ AV_PIX_FMT_NV21
as above, but U and V bytes are swapped
#define AV_PIX_FMT_BGR565
@ AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
@ AV_PIX_FMT_YUV444P16BE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
@ AV_PIX_FMT_GBRPF32LE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.
@ AV_PIX_FMT_NV42
as above, but U and V bytes are swapped
void * av_calloc(size_t nmemb, size_t size)
#define AV_PIX_FMT_YUV444P9
void sws_freeFilter(SwsFilter *filter)
static av_always_inline int isFloat(enum AVPixelFormat pix_fmt)
@ AV_PIX_FMT_GBRAP16LE
planar GBRA 4:4:4:4 64bpp, little-endian
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
@ AV_PIX_FMT_GRAY12BE
Y , 12bpp, big-endian.
@ AV_PIX_FMT_YVYU422
packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
@ AV_PIX_FMT_0BGR
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
#define FFSWAP(type, a, b)
@ AV_PIX_FMT_Y212LE
packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits,...
@ AV_PIX_FMT_BAYER_BGGR16BE
bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian
@ AV_PIX_FMT_P410BE
interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, big-endian
@ AV_PIX_FMT_P016LE
like NV12, with 16bpp per component, little-endian
@ AV_PIX_FMT_GRAYF32BE
IEEE-754 single precision Y, 32bpp, big-endian.
int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table, int *srcRange, int **table, int *dstRange, int *brightness, int *contrast, int *saturation)
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, SwsFilter *dstFilter)
Initialize the swscaler context sws_context.
@ AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
@ AV_PIX_FMT_YUV444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
#define AV_CPU_FLAG_MMX
standard MMX
void sws_freeContext(SwsContext *c)
Free the swscaler context swsContext.
@ AV_PIX_FMT_YUV444P9LE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
int ff_shuffle_filter_coefficients(SwsContext *c, int *filterPos, int filterSize, int16_t *filter, int dstW)
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
@ AV_PIX_FMT_P216LE
interleaved chroma YUV 4:2:2, 32bpp, little-endian
const char * description
human-readable description
#define INLINE_MMXEXT(flags)
@ AV_PIX_FMT_YUVA420P10BE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
@ AV_PIX_FMT_RGB565BE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
@ AV_PIX_FMT_YUV420P16BE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
@ AV_PIX_FMT_YUV422P16BE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
@ AV_PIX_FMT_P212BE
interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, big-endian
@ AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
@ AV_PIX_FMT_X2BGR10LE
packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined
static av_always_inline int isBayer16BPS(enum AVPixelFormat pix_fmt)
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
@ AV_PIX_FMT_P010LE
like NV12, with 10bpp per component, data in the high bits, zeros in the low bits,...
@ AV_PIX_FMT_YUVA444P10LE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
@ AV_PIX_FMT_BGR555LE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
const VDPAUPixFmtMap * map
int size_factor
size factor used when initing the filters
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
@ AV_PIX_FMT_P216BE
interleaved chroma YUV 4:2:2, 32bpp, big-endian
SwsContext * sws_alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, const double *param)
Allocate and return an SwsContext.
@ AV_PIX_FMT_P412LE
interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, little-endian
@ AV_PIX_FMT_GRAY14LE
Y , 14bpp, little-endian.
@ AV_PIX_FMT_XV36LE
packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, little-endian,...
static SwsVector * sws_sumVec(SwsVector *a, SwsVector *b)
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
@ AV_PIX_FMT_GRAY14BE
Y , 14bpp, big-endian.
@ AV_PIX_FMT_YUVA422P16BE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
@ AV_PIX_FMT_YUV440P10BE
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
@ AV_PIX_FMT_YUV422P9LE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
@ AV_PIX_FMT_YUVA422P16LE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
@ AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
av_cold void ff_yuv2rgb_init_tables_ppc(SwsContext *c, const int inv_table[4], int brightness, int contrast, int saturation)
#define flags(name, subs,...)
@ AV_PIX_FMT_0RGB
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
void avpriv_slicethread_free(AVSliceThread **pctx)
Destroy slice threading context.
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
static const double coeff[2][5]
@ AV_PIX_FMT_GBRAP10BE
planar GBR 4:4:4:4 40bpp, big-endian
#define atomic_init(obj, value)
@ AV_PIX_FMT_YUVA444P16LE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
@ AV_PIX_FMT_VUYX
packed VUYX 4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined
@ AV_PIX_FMT_YUVA422P12BE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian
@ AV_PIX_FMT_BGR444LE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
#define SWS_SRC_V_CHR_DROP_MASK
static double sws_dcVec(SwsVector *a)
int dstH
Height of destination luma/alpha planes.
@ AV_PIX_FMT_YUV422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
void sws_normalizeVec(SwsVector *a, double height)
Scale all the coefficients of a so that their sum equals height.
@ AV_PIX_FMT_YUVA420P9BE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
@ AV_PIX_FMT_BAYER_GRBG8
bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
@ AV_PIX_FMT_UYYVYY411
packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
@ AV_PIX_FMT_BGR48BE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big...
#define SWS_ERROR_DIFFUSION
@ AV_PIX_FMT_YUVA422P9LE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
double param[2]
Input parameters for scaling algorithms that need them.