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 37 #define WIN32_LEAN_AND_MEAN 59 #undef attribute_deprecated 60 #define attribute_deprecated 66 #if !FF_API_SWS_VECTOR 83 return FFMPEG_CONFIGURATION;
88 #define LICENSE_PREFIX "libswscale license: " 299 return ((d * dist + c) * dist + b) * dist +
a;
302 b + 2.0 * c + 3.0 * d,
304 -b - 3.0 * c - 6.0 * d,
310 if (pos == -1 || pos <= -513) {
311 pos = (128 << chr_subsample) - 128;
314 return pos >> chr_subsample;
331 {
SWS_POINT,
"nearest neighbor / point", -1 },
334 {
SWS_X,
"experimental", 8 },
338 int *outFilterSize,
int xInc,
int srcW,
339 int dstW,
int filterAlign,
int one,
342 double param[2],
int srcPos,
int dstPos)
349 int64_t *filter2 =
NULL;
350 const int64_t fone = 1LL << (54 -
FFMIN(
av_log2(srcW/dstW), 8));
359 if (
FFABS(xInc - 0x10000) < 10 && srcPos == dstPos) {
365 for (i = 0; i < dstW; i++) {
366 filter[i * filterSize] = fone;
376 xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
377 for (i = 0; i < dstW; i++) {
378 int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
380 (*filterPos)[
i] = xx;
384 }
else if ((xInc <= (1 << 16) && (flags &
SWS_AREA)) ||
392 xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
393 for (i = 0; i < dstW; i++) {
394 int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
397 (*filterPos)[
i] = xx;
399 for (j = 0; j < filterSize; j++) {
400 int64_t
coeff = fone -
FFABS((int64_t)xx * (1 << 16) - xDstInSrc) * (fone >> 16);
403 filter[i * filterSize + j] =
coeff;
413 if (flags & scale_algorithms[i].
flag && scale_algorithms[i].size_factor > 0) {
423 filterSize = 1 + sizeFactor;
425 filterSize = 1 + (sizeFactor * srcW + dstW - 1) / dstW;
427 filterSize =
FFMIN(filterSize, srcW - 2);
428 filterSize =
FFMAX(filterSize, 1);
432 xDstInSrc = ((dstPos*(int64_t)xInc)>>7) - ((srcPos*0x10000LL)>>7);
433 for (i = 0; i < dstW; i++) {
434 int xx = (xDstInSrc - (filterSize - 2) * (1LL<<16)) / (1 << 17);
436 (*filterPos)[
i] = xx;
437 for (j = 0; j < filterSize; j++) {
438 int64_t
d = (
FFABS(((int64_t)xx * (1 << 17)) - xDstInSrc)) << 13;
444 floatd = d * (1.0 / (1 << 30));
450 if (d >= 1LL << 31) {
453 int64_t dd = (d *
d) >> 30;
454 int64_t ddd = (dd *
d) >> 30;
457 coeff = (12 * (1 << 24) - 9 * B - 6 * C) * ddd +
458 (-18 * (1 << 24) + 12 * B + 6 * C) * dd +
459 (6 * (1 << 24) - 2 * B) * (1 << 30);
461 coeff = (-B - 6 *
C) * ddd +
462 (6 * B + 30 * C) * dd +
463 (-12 * B - 48 *
C) * d +
464 (8 * B + 24 * C) * (1 << 30);
466 coeff /= (1LL<<54)/fone;
467 }
else if (flags &
SWS_X) {
472 c = cos(floatd *
M_PI);
479 coeff = (c * 0.5 + 0.5) * fone;
481 int64_t d2 = d - (1 << 29);
482 if (d2 * xInc < -(1LL << (29 + 16)))
483 coeff = 1.0 * (1LL << (30 + 16));
484 else if (d2 * xInc < (1LL << (29 + 16)))
485 coeff = -d2 * xInc + (1LL << (29 + 16));
488 coeff *= fone >> (30 + 16);
491 coeff =
exp2(-p * floatd * floatd) * fone;
493 coeff = (d ? sin(floatd *
M_PI) / (floatd *
M_PI) : 1.0) * fone;
494 }
else if (flags & SWS_LANCZOS) {
496 coeff = (d ? sin(floatd *
M_PI) * sin(floatd * M_PI / p) /
497 (floatd * floatd * M_PI * M_PI / p) : 1.0) * fone;
501 coeff = (1 << 30) - d;
506 double p = -2.196152422706632;
512 filter[i * filterSize + j] =
coeff;
515 xDstInSrc += 2 * xInc;
523 filter2Size = filterSize;
525 filter2Size += srcFilter->
length - 1;
527 filter2Size += dstFilter->
length - 1;
531 for (i = 0; i < dstW; i++) {
535 for (k = 0; k < srcFilter->
length; k++) {
536 for (j = 0; j < filterSize; j++)
537 filter2[i * filter2Size + k + j] +=
538 srcFilter->
coeff[k] * filter[i * filterSize + j];
541 for (j = 0; j < filterSize; j++)
542 filter2[i * filter2Size + j] = filter[i * filterSize + j];
546 (*filterPos)[
i] += (filterSize - 1) / 2 - (filter2Size - 1) / 2;
553 for (i = dstW - 1; i >= 0; i--) {
554 int min = filter2Size;
556 int64_t cutOff = 0.0;
559 for (j = 0; j < filter2Size; j++) {
561 cutOff +=
FFABS(filter2[i * filter2Size]);
568 if (i < dstW - 1 && (*filterPos)[i] >= (*filterPos)[i + 1])
572 for (k = 1; k < filter2Size; k++)
573 filter2[i * filter2Size + k - 1] = filter2[i * filter2Size + k];
574 filter2[i * filter2Size + k - 1] = 0;
580 for (j = filter2Size - 1; j > 0; j--) {
581 cutOff +=
FFABS(filter2[i * filter2Size + j]);
588 if (min > minFilterSize)
594 if (minFilterSize < 5)
600 if (minFilterSize < 3)
606 if (minFilterSize == 1 && filterAlign == 2)
611 filterSize = (minFilterSize + (filterAlign - 1)) & (~(filterAlign - 1));
621 *outFilterSize = filterSize;
625 "SwScaler: reducing / aligning filtersize %d -> %d\n",
626 filter2Size, filterSize);
628 for (i = 0; i < dstW; i++) {
631 for (j = 0; j < filterSize; j++) {
632 if (j >= filter2Size)
633 filter[i * filterSize + j] = 0;
635 filter[i * filterSize + j] = filter2[i * filter2Size + j];
637 filter[i * filterSize + j] = 0;
644 for (i = 0; i < dstW; i++) {
646 if ((*filterPos)[i] < 0) {
648 for (j = 1; j < filterSize; j++) {
649 int left =
FFMAX(j + (*filterPos)[i], 0);
650 filter[i * filterSize +
left] += filter[i * filterSize + j];
651 filter[i * filterSize + j] = 0;
656 if ((*filterPos)[i] + filterSize > srcW) {
657 int shift = (*filterPos)[
i] +
FFMIN(filterSize - srcW, 0);
660 for (j = filterSize - 1; j >= 0; j--) {
661 if ((*filterPos)[i] + j >= srcW) {
662 acc += filter[i * filterSize + j];
663 filter[i * filterSize + j] = 0;
666 for (j = filterSize - 1; j >= 0; j--) {
668 filter[i * filterSize + j] = 0;
670 filter[i * filterSize + j] = filter[i * filterSize + j -
shift];
675 filter[i * filterSize + srcW - 1 - (*filterPos)[
i]] +=
acc;
679 if ((*filterPos)[i] + filterSize > srcW) {
680 for (j = 0; j < filterSize; j++) {
681 av_assert0((*filterPos)[i] + j < srcW || !filter[i * filterSize + j]);
692 for (i = 0; i < dstW; i++) {
697 for (j = 0; j < filterSize; j++) {
698 sum += filter[i * filterSize + j];
700 sum = (sum + one / 2) / one;
705 for (j = 0; j < *outFilterSize; j++) {
706 int64_t v = filter[i * filterSize + j] +
error;
708 (*outFilter)[i * (*outFilterSize) + j] = intV;
709 error = v - intV * sum;
713 (*filterPos)[dstW + 0] =
714 (*filterPos)[dstW + 1] =
715 (*filterPos)[dstW + 2] = (*filterPos)[dstW - 1];
717 for (i = 0; i < *outFilterSize; i++) {
718 int k = (dstW - 1) * (*outFilterSize) +
i;
719 (*outFilter)[k + 1 * (*outFilterSize)] =
720 (*outFilter)[k + 2 * (*outFilterSize)] =
721 (*outFilter)[k + 3 * (*outFilterSize)] = (*outFilter)[k];
739 int64_t
W,
V, Z, Cy, Cu, Cv;
740 int64_t vr = table[0];
741 int64_t
ub = table[1];
742 int64_t ug = -table[2];
743 int64_t vg = -table[3];
748 static const int8_t
map[] = {
773 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
774 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
775 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
776 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
777 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
778 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
779 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
780 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
838 static const int16_t xyz2rgb_matrix[3][4] = {
839 {13270, -6295, -2041},
841 { 228, -835, 4329} };
842 static const int16_t rgb2xyz_matrix[3][4] = {
846 static int16_t xyzgamma_tab[4096], rgbgamma_tab[4096], xyzgammainv_tab[4096], rgbgammainv_tab[4096];
855 if (rgbgamma_tab[4095])
859 for (i = 0; i < 4096; i++) {
860 xyzgamma_tab[
i] =
lrint(pow(i / 4095.0, xyzgamma) * 4095.0);
861 rgbgamma_tab[
i] =
lrint(pow(i / 4095.0, rgbgamma) * 4095.0);
862 xyzgammainv_tab[
i] =
lrint(pow(i / 4095.0, xyzgammainv) * 4095.0);
863 rgbgammainv_tab[
i] =
lrint(pow(i / 4095.0, rgbgammainv) * 4095.0);
873 int srcRange,
const int table[4],
int dstRange,
874 int brightness,
int contrast,
int saturation)
929 int tmp_width, tmp_height;
935 av_log(c,
AV_LOG_VERBOSE,
"YUV color matrix differs for YUV->YUV, using intermediate RGB to convert\n");
951 if (srcW*srcH > dstW*dstH) {
960 tmp_width, tmp_height, tmp_format, 64);
965 tmp_width, tmp_height, tmp_format,
976 srcRange, table, dstRange,
977 brightness, contrast, saturation);
985 srcRange, table, dstRange,
986 0, 1 << 16, 1 << 16);
994 contrast, saturation);
999 contrast, saturation);
1008 int *srcRange,
int **
table,
int *dstRange,
1009 int *brightness,
int *contrast,
int *saturation)
1111 tbl = (uint16_t*)
av_malloc(
sizeof(uint16_t) * 1 << 16);
1115 for (i = 0; i < 65536; ++
i) {
1116 tbl[
i] = pow(i / 65535.0, e) * 65535.0;
1183 int usesVFilter, usesHFilter;
1190 int dst_stride =
FFALIGN(dstW *
sizeof(int16_t) + 66, 16);
1198 static const float float_mult = 1.0f / 255.0f;
1206 unscaled = (srcW == dstW && srcH == dstH);
1212 av_log(c,
AV_LOG_WARNING,
"deprecated pixel format used, make sure you did set range correctly\n");
1258 if (dstW < srcW && dstH < srcH)
1260 else if (dstW > srcW && dstH > srcH)
1265 }
else if (i & (i - 1)) {
1267 "Exactly one scaler algorithm must be chosen, got %X\n", i);
1271 if (srcW < 1 || srcH < 1 || dstW < 1 || dstH < 1) {
1275 srcW, srcH, dstW, dstH);
1279 if (srcW < 8 || dstW < 8) {
1286 dstFilter = &dummyFilter;
1288 srcFilter = &dummyFilter;
1290 c->
lumXInc = (((int64_t)srcW << 16) + (dstW >> 1)) / dstW;
1291 c->
lumYInc = (((int64_t)srcH << 16) + (dstH >> 1)) / dstH;
1294 c->
vRounder = 4 * 0x0001000100010001ULL;
1296 usesVFilter = (srcFilter->
lumV && srcFilter->
lumV->
length > 1) ||
1300 usesHFilter = (srcFilter->
lumH && srcFilter->
lumH->
length > 1) ||
1318 && !(c->
flags & SWS_FAST_BILINEAR)
1320 av_log(c,
AV_LOG_DEBUG,
"Forcing full internal H chroma due to input having non subsampled chroma\n");
1337 if (!(flags & SWS_FULL_CHR_H_INT)) {
1340 "Desired dithering only supported in full chroma interpolation for destination format '%s'\n",
1346 if (flags & SWS_FULL_CHR_H_INT) {
1349 "Ordered dither is not supported in full chroma interpolation for destination format '%s'\n",
1356 if (!(flags & SWS_FULL_CHR_H_INT)) {
1358 "%s output is not supported with half chroma resolution, switching to full\n",
1367 if (flags & SWS_FULL_CHR_H_INT &&
1390 "full chroma interpolation for destination format '%s' not yet implemented\n",
1392 flags &= ~SWS_FULL_CHR_H_INT;
1395 if (
isAnyRGB(dstFormat) && !(flags & SWS_FULL_CHR_H_INT))
1420 (flags & SWS_FAST_BILINEAR)))
1452 "output width is not a multiple of 32 -> no MMXEXT scaler\n");
1469 if (flags & SWS_FAST_BILINEAR) {
1476 c->
lumXInc = ((int64_t)(srcW - 2) << 16) / (dstW - 2) - 20;
1486 if (!unscaled && c->
gamma_flag && (srcFormat != tmpFmt || dstFormat != tmpFmt)) {
1491 srcW, srcH, tmpFmt, 64);
1497 flags, NULL, NULL, c->
param);
1504 flags, srcFilter, dstFilter, c->
param);
1527 if (dstFormat != tmpFmt) {
1529 dstW, dstH, tmpFmt, 64);
1534 dstW, dstH, dstFormat,
1535 flags, NULL, NULL, c->
param);
1549 srcW, srcH, tmpFormat, 64);
1554 srcW, srcH, tmpFormat,
1555 flags, srcFilter, NULL, c->
param);
1560 dstW, dstH, dstFormat,
1561 flags, NULL, dstFilter, c->
param);
1569 for (i = 0; i < 256; ++
i){
1576 (!unscaled || unscaled && dstFormat != srcFormat && (srcFormat !=
AV_PIX_FMT_GRAYF32 ||
1581 if (CONFIG_SWSCALE_ALPHA &&
isALPHA(srcFormat) && !
isALPHA(dstFormat)) {
1586 dstFormat != tmpFormat ||
1587 usesHFilter || usesVFilter ||
1592 srcW, srcH, tmpFormat, 64);
1597 srcW, srcH, tmpFormat,
1607 dstW, dstH, dstFormat,
1623 #if HAVE_MMAP && HAVE_MPROTECT && defined(MAP_ANONYMOUS) 1631 #if HAVE_MMXEXT_INLINE 1637 NULL, NULL, NULL, 4);
1641 PROT_READ | PROT_WRITE,
1642 MAP_PRIVATE | MAP_ANONYMOUS,
1645 PROT_READ | PROT_WRITE,
1646 MAP_PRIVATE | MAP_ANONYMOUS,
1648 #elif HAVE_VIRTUALALLOC 1652 PAGE_EXECUTE_READWRITE);
1656 PAGE_EXECUTE_READWRITE);
1662 #ifdef MAP_ANONYMOUS 1694 const int filterAlign =
X86_MMX(cpu_flags) ? 4 :
1700 srcW, dstW, filterAlign, 1 << 14,
1702 cpu_flags, srcFilter->
lumH, dstFilter->
lumH,
1710 (flags & SWS_BICUBLIN) ? (flags |
SWS_BILINEAR) : flags,
1711 cpu_flags, srcFilter->
chrH, dstFilter->
chrH,
1721 const int filterAlign =
X86_MMX(cpu_flags) ? 2 :
1726 c->
lumYInc, srcH, dstH, filterAlign, (1 << 12),
1728 cpu_flags, srcFilter->
lumV, dstFilter->
lumV,
1735 filterAlign, (1 << 12),
1736 (flags & SWS_BICUBLIN) ? (flags |
SWS_BILINEAR) : flags,
1737 cpu_flags, srcFilter->
chrV, dstFilter->
chrV,
1751 short *p = (
short *)&c->vYCoeffsBank[i];
1752 for (j = 0; j < 8; j++)
1758 short *p = (
short *)&c->vCCoeffsBank[i];
1759 for (j = 0; j < 8; j++)
1765 for (i = 0; i < 4; i++)
1778 const char *scaler =
NULL, *cpucaps;
1781 if (flags & scale_algorithms[i].
flag) {
1787 scaler =
"ehh flags invalid?!";
1808 cpucaps =
"AltiVec";
1816 "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1819 "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1825 if (unscaled && !usesHFilter && !usesVFilter &&
1833 if (flags & SWS_PRINT_INFO)
1835 "using alpha blendaway %s -> %s special converter\n",
1841 if (unscaled && !usesHFilter && !usesVFilter &&
1847 if (flags & SWS_PRINT_INFO)
1849 "using unscaled %s -> %s special converter\n",
1861 int tmpW = sqrt(srcW * (int64_t)dstW);
1862 int tmpH = sqrt(srcH * (int64_t)dstH);
1868 if (srcW*(int64_t)srcH <= 4LL*dstW*dstH)
1872 tmpW, tmpH, tmpFormat, 64);
1877 tmpW, tmpH, tmpFormat,
1878 flags, srcFilter, NULL, c->
param);
1883 dstW, dstH, dstFormat,
1884 flags, NULL, dstFilter, c->
param);
1894 int flags,
const double *param)
1910 c->
param[0] = param[0];
1911 c->
param[1] = param[1];
1920 SwsFilter *dstFilter,
const double *param)
1925 dstW, dstH, dstFormat,
1941 for (i=0; i<a->
length; i++)
1950 for (i=0; i<a->
length; i++)
1955 float lumaSharpen,
float chromaSharpen,
1956 float chromaHShift,
float chromaVShift,
1963 if (lumaGBlur != 0.0) {
1971 if (chromaGBlur != 0.0) {
1982 if (chromaSharpen != 0.0) {
1993 if (lumaSharpen != 0.0) {
2004 if (chromaHShift != 0.0)
2007 if (chromaVShift != 0.0)
2056 const int length = (
int)(variance * quality + 0.5) | 1;
2058 double middle = (length - 1) * 0.5;
2061 if(variance < 0 || quality < 0)
2069 for (i = 0; i <
length; i++) {
2070 double dist = i - middle;
2071 vec->
coeff[
i] =
exp(-dist * dist / (2 * variance * variance)) /
2072 sqrt(2 * variance *
M_PI);
2084 #if !FF_API_SWS_VECTOR 2095 for (i = 0; i <
length; i++)
2105 #if !FF_API_SWS_VECTOR 2118 for (i = 0; i < a->
length; i++)
2128 for (i = 0; i < a->
length; i++)
2129 a->
coeff[i] *= scalar;
2137 #if FF_API_SWS_VECTOR 2147 for (i = 0; i < a->
length; i++) {
2148 for (j = 0; j < b->
length; j++) {
2166 for (i = 0; i < a->
length; i++)
2174 #if FF_API_SWS_VECTOR 2184 for (i = 0; i < a->
length; i++)
2203 for (i = 0; i < a->
length; i++) {
2204 vec->
coeff[i + (length - 1) / 2 -
2211 #if !FF_API_SWS_VECTOR 2227 #if !FF_API_SWS_VECTOR 2243 #if FF_API_SWS_VECTOR 2287 #if !FF_API_SWS_VECTOR 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++) {
2308 int x = (
int)((a->
coeff[i] - min) * 60.0 / range + 0.5);
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");
2343 for (i = 0; i < 4; i++)
2366 #elif HAVE_VIRTUALALLOC 2403 const double *
param)
2411 param = default_param;
2414 (context->
srcW != srcW ||
2415 context->
srcH != srcH ||
2417 context->
dstW != dstW ||
2418 context->
dstH != dstH ||
2420 context->
flags != flags ||
2421 context->
param[0] != param[0] ||
2422 context->
param[1] != param[1])) {
2442 context->
param[0] = param[0];
2443 context->
param[1] = param[1];
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
IEEE-754 single precision Y, 32bpp, big-endian.
packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian
planar GBR 4:4:4:4 40bpp, little-endian
int sws_isSupportedOutput(enum AVPixelFormat pix_fmt)
Return a positive value if pix_fmt is a supported output format, 0 otherwise.
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
static enum AVPixelFormat pix_fmt
static SwsVector * sws_sumVec(SwsVector *a, SwsVector *b)
av_cold void ff_yuv2rgb_init_tables_ppc(SwsContext *c, const int inv_table[4], int brightness, int contrast, int saturation)
static const FormatEntry format_entries[]
static int shift(int a, int b)
static int handle_0alpha(enum AVPixelFormat *format)
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
#define SWS_SRC_V_CHR_DROP_MASK
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
int chrSrcH
Height of source chroma planes.
int ff_free_filters(SwsContext *c)
static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
#define LIBSWSCALE_VERSION_MICRO
uint8_t * chrMmxextFilterCode
Runtime-generated MMXEXT horizontal fast bilinear scaler code for chroma planes.
static void fill_rgb2yuv_table(SwsContext *c, const int table[4], int dstRange)
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
static int conv(int samples, float **pcm, char *buf, int channels)
8 bits gray, 8 bits alpha
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
uint8_t * lumMmxextFilterCode
Runtime-generated MMXEXT horizontal fast bilinear scaler code for luma/alpha planes.
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
#define AV_LOG_WARNING
Something somehow does not look correct.
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian ...
packed RGB 8:8:8, 24bpp, RGBRGB...
packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in ...
static av_cold int get_local_pos(SwsContext *s, int chr_subsample, int pos, int dir)
int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table, int *srcRange, int **table, int *dstRange, int *brightness, int *contrast, int *saturation)
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...
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
SwsVector * sws_getGaussianVec(double variance, double quality)
Return a normalized Gaussian curve used to filter stuff quality = 3 is high quality, lower is lower quality.
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
int vChrDrop
Binary logarithm of extra vertical subsampling factor in source image chroma planes specified by user...
bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples
int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
static double getSplineCoeff(double a, double b, double c, double d, double dist)
#define AV_PIX_FMT_GBRP10
bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian
int dstFormatBpp
Number of bits per pixel of the destination pixel format.
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
#define AV_PIX_FMT_BGRA64
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
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
Convenience header that includes libavutil's core.
static int handle_jpeg(enum AVPixelFormat *format)
int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt)
static int isnan_vec(SwsVector *a)
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
#define SWS_SRC_V_CHR_DROP_SHIFT
const char * swscale_configuration(void)
Return the libswscale build-time configuration.
planar GBR 4:4:4 36bpp, little-endian
The following 12 formats have the disadvantage of needing 1 format for each bit depth.
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
static atomic_int cpu_flags
#define FF_ARRAY_ELEMS(a)
const int32_t ff_yuv2rgb_coeffs[11][4]
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
int srcRange
0 = MPG YUV range, 1 = JPG YUV range (source image).
bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples
static __device__ float ceil(float a)
static void error(const char *err)
Y , 12bpp, little-endian.
enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt)
Utility function to swap the endianness of a pixel format.
planar GBR 4:4:4 36bpp, big-endian
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in ...
Macro definitions for various function/variable attributes.
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
int srcH
Height of source luma/alpha planes.
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian ...
void sws_convVec(SwsVector *a, SwsVector *b)
planar GBRA 4:4:4:4 64bpp, big-endian
#define av_assert0(cond)
assert() equivalent, that is always enabled.
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
static av_always_inline int isBayer16BPS(enum AVPixelFormat pix_fmt)
static uint16_t * alloc_gamma_tbl(double e)
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
int chrDstVSubSample
Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in destination i...
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian ...
ptrdiff_t uv_off
offset (in pixels) between u and v planes
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
int length
number of coefficients in the vector
av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, SwsFilter *dstFilter)
Initialize the swscaler context sws_context.
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
8 bits with AV_PIX_FMT_RGB32 palette
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
SwsVector * sws_cloneVec(SwsVector *a)
int vChrFilterSize
Vertical filter size for chroma pixels.
bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian
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
bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined ...
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
#define SWS_FULL_CHR_H_INT
int cascaded_tmpStride[4]
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
#define SWS_FAST_BILINEAR
SwsVector * sws_getConstVec(double c, int length)
Allocate and return a vector with length coefficients, all with the same value c. ...
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
planar GBR 4:4:4 48bpp, big-endian
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
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.
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
#define AV_LOG_VERBOSE
Detailed information.
int16_t rgb2xyz_matrix[3][4]
#define AV_PIX_FMT_YUV444P16
Y , 10bpp, little-endian.
enum AVPixelFormat dstFormat
Destination pixel format.
int ff_sws_alphablendaway(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian
int chrSrcHSubSample
Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in source imag...
static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
float uint2float_lut[256]
static SwsVector * sws_getShiftedVec(SwsVector *a, int shift)
static const uint16_t table[]
#define ROUNDED_DIV(a, b)
int32_t * vChrFilterPos
Array of vertical filter starting positions for each dst[i] for chroma planes.
int dstH
Height of destination luma/alpha planes.
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
SwsFilter * sws_getDefaultFilter(float lumaGBlur, float chromaGBlur, float lumaSharpen, float chromaSharpen, float chromaHShift, float chromaVShift, int verbose)
planar GBR 4:4:4 27bpp, big-endian
#define INLINE_MMX(flags)
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
16 bits gray, 16 bits alpha (big-endian)
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
like NV12, with 16bpp per component, big-endian
int32_t * hChrFilterPos
Array of horizontal filter starting positions for each dst[i] for chroma planes.
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
int hLumFilterSize
Horizontal filter size for luma/alpha pixels.
SwsFunc ff_getSwsFunc(SwsContext *c)
Return function pointer to fastest main scaler path function depending on architecture and available ...
const char * description
human-readable description
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.
#define PPC_ALTIVEC(flags)
#define SWS_MAX_REDUCE_CUTOFF
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
void sws_subVec(SwsVector *a, SwsVector *b)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
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.
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
simple assert() macros that are a bit more flexible than ISO C assert().
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
like NV12, with 16bpp per component, little-endian
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
#define AV_PIX_FMT_YUV444P10
like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, big-endian
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
void sws_scaleVec(SwsVector *a, double scalar)
Scale all the coefficients of a by the scalar value.
int chrDstW
Width of destination chroma planes.
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as lit...
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
uint8_t * cascaded1_tmp[4]
void sws_normalizeVec(SwsVector *a, double height)
Scale all the coefficients of a so that their sum equals height.
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
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.
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
#define RETCODE_USE_CASCADE
static enum AVPixelFormat alphaless_fmt(enum AVPixelFormat fmt)
int32_t * hLumFilterPos
Array of horizontal filter starting positions for each dst[i] for luma/alpha planes.
void sws_freeFilter(SwsFilter *filter)
int hChrFilterSize
Horizontal filter size for chroma pixels.
SwsVector * sws_allocVec(int length)
Allocate and return an uninitialized vector with length coefficients.
planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
#define AV_PIX_FMT_YUV422P9
as above, but U and V bytes are swapped
int dstRange
0 = MPG YUV range, 1 = JPG YUV range (destination image).
planar GBR 4:4:4:4 48bpp, big-endian
ptrdiff_t uv_offx2
offset (in bytes) between u and v planes
planar GBR 4:4:4:4 40bpp, big-endian
#define AV_PIX_FMT_GBRP16
IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.
#define AV_PIX_FMT_GRAY16
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
uint8_t * formatConvBuffer
#define INLINE_AMD3DNOW(flags)
static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
av_cold void ff_sws_rgb2rgb_init(void)
void sws_shiftVec(SwsVector *a, int shift)
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
void sws_freeContext(SwsContext *c)
Free the swscaler context swsContext.
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
packed RGB 8:8:8, 24bpp, BGRBGR...
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
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...
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
av_cold void ff_sws_init_range_convert(SwsContext *c)
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.
unsigned swscale_version(void)
like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, little-endian
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)
int srcColorspaceTable[4]
int dstW
Width of destination luma/alpha planes.
#define AV_PIX_FMT_YUV444P9
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big...
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
uint8_t * cascaded_tmp[4]
packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined ...
static const ScaleAlgorithm scale_algorithms[]
static int range_override_needed(enum AVPixelFormat format)
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
int cascaded1_tmpStride[4]
planar GBR 4:4:4:4 48bpp, little-endian
#define AV_PIX_FMT_YUV420P16
int32_t * vLumFilterPos
Array of vertical filter starting positions for each dst[i] for luma/alpha planes.
#define AV_PIX_FMT_BGR555
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
double * coeff
pointer to the list of coefficients
int flag
flag associated to the algorithm
#define AV_LOG_INFO
Standard information.
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
int dstColorspaceTable[4]
#define AV_PIX_FMT_GRAYF32
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)
const AVClass * av_class
info on struct for av_log
int16_t xyz2rgb_matrix[3][4]
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...
bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian
void sws_freeVec(SwsVector *a)
planar GBR 4:4:4 30bpp, big-endian
#define AV_CPU_FLAG_MMX
standard MMX
bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
int chrDstH
Height of destination chroma planes.
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
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
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
planar GBR 4:4:4 42bpp, little-endian
#define SWS_ERROR_DIFFUSION
Replacements for frequently missing libm functions.
#define AV_PIX_FMT_YUV420P10
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
static SwsVector * sws_diffVec(SwsVector *a, SwsVector *b)
int lumMmxextFilterCodeSize
Runtime-generated MMXEXT horizontal fast bilinear scaler code size for luma/alpha planes...
Describe the class of an AVClass context structure.
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode, int16_t *filter, int32_t *filterPos, int numSplits)
as above, but U and V bytes are swapped
IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
int vLumFilterSize
Vertical filter size for luma/alpha pixels.
static void handle_formats(SwsContext *c)
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian ...
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
int chrMmxextFilterCodeSize
Runtime-generated MMXEXT horizontal fast bilinear scaler code size for chroma planes.
planar GBR 4:4:4 42bpp, big-endian
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
#define AV_PIX_FMT_YUV420P9
const VDPAUPixFmtMap * map
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined ...
int16_t * vChrFilter
Array of vertical filter coefficients for chroma planes.
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
int ff_init_filters(SwsContext *c)
Y , 14bpp, little-endian.
bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian
int16_t * hLumFilter
Array of horizontal filter coefficients for luma/alpha planes.
SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext.
#define AV_PIX_FMT_BGR565
#define AV_PIX_FMT_GBRP12
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
#define flags(name, subs,...)
#define AV_PIX_FMT_YUV422P10
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
static int handle_xyz(enum AVPixelFormat *format)
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb...
void sws_addVec(SwsVector *a, SwsVector *b)
#define INLINE_MMXEXT(flags)
static double sws_dcVec(SwsVector *a)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
double param[2]
Input parameters for scaling algorithms that need them.
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb...
planar GBRA 4:4:4:4 32bpp
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
planar GBR 4:4:4 27bpp, little-endian
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
enum AVPixelFormat srcFormat
Source pixel format.
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
struct SwsContext * cascaded_context[3]
#define SWS_PARAM_DEFAULT
#define SWS_FULL_CHR_H_INP
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.
SwsFunc swscale
Note that src, dst, srcStride, dstStride will be copied in the sws_scale() wrapper so they can be fre...
static av_always_inline int diff(const uint32_t a, const uint32_t b)
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...
int size_factor
size factor used when initing the filters
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
int srcFormatBpp
Number of bits per pixel of the source pixel format.
const AVClass ff_sws_context_class
Y , 16bpp, little-endian.
uint8_t is_supported_endianness
static const double coeff[2][5]
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
16 bits gray, 16 bits alpha (little-endian)
int sws_isSupportedInput(enum AVPixelFormat pix_fmt)
Return a positive value if pix_fmt is a supported input format, 0 otherwise.
SwsVector * sws_getIdentityVec(void)
Allocate and return a vector with just one coefficient, with value 1.0.
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
int32_t input_rgb2yuv_table[16+40 *4]
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
int16_t * vLumFilter
Array of vertical filter coefficients for luma/alpha planes.
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
planar GBR 4:4:4 48bpp, little-endian
static void makenan_vec(SwsVector *a)
int16_t * hChrFilter
Array of horizontal filter coefficients for chroma planes.
#define av_malloc_array(a, b)
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined ...
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
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.
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), 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 they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
int chrDstHSubSample
Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in destination...
int chrSrcW
Width of source chroma planes.
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 local context
static av_always_inline int isFloat(enum AVPixelFormat pix_fmt)
int depth
Number of bits in the component.
IEEE-754 single precision Y, 32bpp, little-endian.
void ff_get_unscaled_swscale(SwsContext *c)
Set c->swscale to an unscaled converter if one exists for the specific source and destination formats...
planar GBRA 4:4:4:4 64bpp, little-endian
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
int srcW
Width of source luma/alpha planes.
packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
static void fill_xyztables(struct SwsContext *c)
int chrSrcVSubSample
Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in source image...
int flags
Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc...
AVPixelFormat
Pixel format.
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
void(* rgb15to16)(const uint8_t *src, uint8_t *dst, int src_size)
#define AV_PIX_FMT_YUV422P16
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
planar GBR 4:4:4 30bpp, little-endian
static SwsVector * sws_getConvVec(SwsVector *a, SwsVector *b)
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
#define LIBSWSCALE_VERSION_INT
packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
#define AV_CEIL_RSHIFT(a, b)
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian ...
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
const char * swscale_license(void)
Return the libswscale license.