23 #define _SVID_SOURCE // needed for MAP_ANONYMOUS
24 #define _DARWIN_C_SOURCE // needed for MAP_ANON
31 #if defined(MAP_ANON) && !defined(MAP_ANONYMOUS)
32 #define MAP_ANONYMOUS MAP_ANON
36 #define WIN32_LEAN_AND_MEAN
67 return FFMPEG_CONFIGURATION;
72 #define LICENSE_PREFIX "libswscale license: "
252 return ((d * dist + c) * dist + b) * dist +
a;
255 b + 2.0 * c + 3.0 * d,
257 -b - 3.0 * c - 6.0 * d,
263 if (pos == -1 || pos <= -513) {
264 pos = (128 << chr_subsample) - 128;
267 return pos >> chr_subsample;
284 {
SWS_POINT,
"nearest neighbor / point", -1 },
287 {
SWS_X,
"experimental", 8 },
291 int *outFilterSize,
int xInc,
int srcW,
292 int dstW,
int filterAlign,
int one,
293 int flags,
int cpu_flags,
295 double param[2],
int srcPos,
int dstPos)
302 int64_t *filter2 =
NULL;
303 const int64_t fone = 1LL << (54 -
FFMIN(
av_log2(srcW/dstW), 8));
311 if (
FFABS(xInc - 0x10000) < 10 && srcPos == dstPos) {
315 dstW,
sizeof(*filter) * filterSize, fail);
317 for (i = 0; i < dstW; i++) {
318 filter[i * filterSize] = fone;
326 dstW,
sizeof(*filter) * filterSize, fail);
328 xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
329 for (i = 0; i < dstW; i++) {
330 int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
332 (*filterPos)[i] = xx;
336 }
else if ((xInc <= (1 << 16) && (flags &
SWS_AREA)) ||
342 dstW,
sizeof(*filter) * filterSize, fail);
344 xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
345 for (i = 0; i < dstW; i++) {
346 int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
349 (*filterPos)[i] = xx;
351 for (j = 0; j < filterSize; j++) {
352 int64_t
coeff= fone -
FFABS(((int64_t)xx<<16) - xDstInSrc)*(fone>>16);
355 filter[i * filterSize + j] =
coeff;
365 if (flags & scale_algorithms[i].flag && scale_algorithms[i].size_factor > 0) {
375 filterSize = 1 + sizeFactor;
377 filterSize = 1 + (sizeFactor * srcW + dstW - 1) / dstW;
379 filterSize =
FFMIN(filterSize, srcW - 2);
380 filterSize =
FFMAX(filterSize, 1);
383 dstW,
sizeof(*filter) * filterSize, fail);
385 xDstInSrc = ((dstPos*(int64_t)xInc)>>7) - ((srcPos*0x10000LL)>>7);
386 for (i = 0; i < dstW; i++) {
387 int xx = (xDstInSrc - ((int64_t)(filterSize - 2) << 16)) / (1 << 17);
389 (*filterPos)[i] = xx;
390 for (j = 0; j < filterSize; j++) {
391 int64_t d = (
FFABS(((int64_t)xx * (1 << 17)) - xDstInSrc)) << 13;
397 floatd = d * (1.0 / (1 << 30));
403 if (d >= 1LL << 31) {
406 int64_t dd = (d * d) >> 30;
407 int64_t ddd = (dd * d) >> 30;
410 coeff = (12 * (1 << 24) - 9 * B - 6 * C) * ddd +
411 (-18 * (1 << 24) + 12 * B + 6 * C) * dd +
412 (6 * (1 << 24) - 2 * B) * (1 << 30);
414 coeff = (-B - 6 *
C) * ddd +
415 (6 * B + 30 * C) * dd +
416 (-12 * B - 48 *
C) * d +
417 (8 * B + 24 * C) * (1 << 30);
419 coeff /= (1LL<<54)/fone;
422 else if (flags &
SWS_X) {
423 double p = param ? param * 0.01 : 0.3;
424 coeff = d ? sin(d *
M_PI) / (d *
M_PI) : 1.0;
425 coeff *= pow(2.0, -p * d * d);
428 else if (flags & SWS_X) {
433 c = cos(floatd *
M_PI);
440 coeff = (c * 0.5 + 0.5) * fone;
442 int64_t d2 = d - (1 << 29);
443 if (d2 * xInc < -(1LL << (29 + 16)))
444 coeff = 1.0 * (1LL << (30 + 16));
445 else if (d2 * xInc < (1LL << (29 + 16)))
446 coeff = -d2 * xInc + (1LL << (29 + 16));
449 coeff *= fone >> (30 + 16);
452 coeff = (pow(2.0, -p * floatd * floatd)) * fone;
454 coeff = (d ? sin(floatd *
M_PI) / (floatd *
M_PI) : 1.0) * fone;
455 }
else if (flags & SWS_LANCZOS) {
457 coeff = (d ? sin(floatd *
M_PI) * sin(floatd * M_PI / p) /
458 (floatd * floatd * M_PI * M_PI / p) : 1.0) * fone;
462 coeff = (1 << 30) - d;
467 double p = -2.196152422706632;
473 filter[i * filterSize + j] =
coeff;
476 xDstInSrc += 2 * xInc;
484 filter2Size = filterSize;
486 filter2Size += srcFilter->
length - 1;
488 filter2Size += dstFilter->
length - 1;
492 for (i = 0; i < dstW; i++) {
496 for (k = 0; k < srcFilter->
length; k++) {
497 for (j = 0; j < filterSize; j++)
498 filter2[i * filter2Size + k + j] +=
499 srcFilter->
coeff[k] * filter[i * filterSize + j];
502 for (j = 0; j < filterSize; j++)
503 filter2[i * filter2Size + j] = filter[i * filterSize + j];
507 (*filterPos)[i] += (filterSize - 1) / 2 - (filter2Size - 1) / 2;
514 for (i = dstW - 1; i >= 0; i--) {
515 int min = filter2Size;
517 int64_t cutOff = 0.0;
520 for (j = 0; j < filter2Size; j++) {
522 cutOff +=
FFABS(filter2[i * filter2Size]);
529 if (i < dstW - 1 && (*filterPos)[i] >= (*filterPos)[i + 1])
533 for (k = 1; k < filter2Size; k++)
534 filter2[i * filter2Size + k - 1] = filter2[i * filter2Size + k];
535 filter2[i * filter2Size + k - 1] = 0;
541 for (j = filter2Size - 1; j > 0; j--) {
542 cutOff +=
FFABS(filter2[i * filter2Size + j]);
549 if (min > minFilterSize)
555 if (minFilterSize < 5)
561 if (minFilterSize < 3)
567 if (minFilterSize == 1 && filterAlign == 2)
572 filterSize = (minFilterSize + (filterAlign - 1)) & (~(filterAlign - 1));
582 *outFilterSize = filterSize;
586 "SwScaler: reducing / aligning filtersize %d -> %d\n",
587 filter2Size, filterSize);
589 for (i = 0; i < dstW; i++) {
592 for (j = 0; j < filterSize; j++) {
593 if (j >= filter2Size)
594 filter[i * filterSize + j] = 0;
596 filter[i * filterSize + j] = filter2[i * filter2Size + j];
598 filter[i * filterSize + j] = 0;
605 for (i = 0; i < dstW; i++) {
607 if ((*filterPos)[i] < 0) {
609 for (j = 1; j < filterSize; j++) {
610 int left =
FFMAX(j + (*filterPos)[i], 0);
611 filter[i * filterSize + left] += filter[i * filterSize + j];
612 filter[i * filterSize + j] = 0;
617 if ((*filterPos)[i] + filterSize > srcW) {
618 int shift = (*filterPos)[i] +
FFMIN(filterSize - srcW, 0);
621 for (j = filterSize - 1; j >= 0; j--) {
622 if ((*filterPos)[i] + j >= srcW) {
623 acc += filter[i * filterSize + j];
624 filter[i * filterSize + j] = 0;
627 for (j = filterSize - 1; j >= 0; j--) {
629 filter[i * filterSize + j] = 0;
631 filter[i * filterSize + j] = filter[i * filterSize + j -
shift];
635 (*filterPos)[i]-=
shift;
636 filter[i * filterSize + srcW - 1 - (*filterPos)[i]] +=
acc;
640 if ((*filterPos)[i] + filterSize > srcW) {
641 for (j = 0; j < filterSize; j++) {
642 av_assert0((*filterPos)[i] + j < srcW || !filter[i * filterSize + j]);
650 (dstW + 3), *outFilterSize *
sizeof(int16_t), fail);
653 for (i = 0; i < dstW; i++) {
658 for (j = 0; j < filterSize; j++) {
659 sum += filter[i * filterSize + j];
661 sum = (sum + one / 2) / one;
666 for (j = 0; j < *outFilterSize; j++) {
667 int64_t
v = filter[i * filterSize + j] + error;
669 (*outFilter)[i * (*outFilterSize) + j] = intV;
670 error = v - intV * sum;
674 (*filterPos)[dstW + 0] =
675 (*filterPos)[dstW + 1] =
676 (*filterPos)[dstW + 2] = (*filterPos)[dstW - 1];
678 for (i = 0; i < *outFilterSize; i++) {
679 int k = (dstW - 1) * (*outFilterSize) + i;
680 (*outFilter)[k + 1 * (*outFilterSize)] =
681 (*outFilter)[k + 2 * (*outFilterSize)] =
682 (*outFilter)[k + 3 * (*outFilterSize)] = (*outFilter)[k];
697 int64_t
W,
V, Z, Cy, Cu, Cv;
698 int64_t vr = table[0];
699 int64_t ub = table[1];
700 int64_t ug = -table[2];
701 int64_t vg = -table[3];
706 static const int8_t map[] = {
731 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
732 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
733 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
734 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
735 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
736 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
737 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
738 -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 ,
786 AV_WL16(p + 16*4 + 2*i, map[i] >= 0 ?
c->input_rgb2yuv_table[map[i]] : 0);
796 static const int16_t xyz2rgb_matrix[3][4] = {
797 {13270, -6295, -2041},
799 { 228, -835, 4329} };
800 static const int16_t rgb2xyz_matrix[3][4] = {
804 static int16_t xyzgamma_tab[4096], rgbgamma_tab[4096], xyzgammainv_tab[4096], rgbgammainv_tab[4096];
813 if (rgbgamma_tab[4095])
817 for (i = 0; i < 4096; i++) {
818 xyzgamma_tab[i] =
lrint(pow(i / 4095.0, xyzgamma) * 4095.0);
819 rgbgamma_tab[i] =
lrint(pow(i / 4095.0, rgbgamma) * 4095.0);
820 xyzgammainv_tab[i] =
lrint(pow(i / 4095.0, xyzgammainv) * 4095.0);
821 rgbgammainv_tab[i] =
lrint(pow(i / 4095.0, rgbgammainv) * 4095.0);
826 int srcRange,
const int table[4],
int dstRange,
827 int brightness,
int contrast,
int saturation)
865 contrast, saturation);
870 contrast, saturation);
879 int *srcRange,
int **
table,
int *dstRange,
880 int *brightness,
int *contrast,
int *saturation)
971 tbl = (uint16_t*)
av_malloc(
sizeof(uint16_t) * 1 << 16);
975 for (i = 0; i < 65536; ++i) {
976 tbl[i] = pow(i / 65535.0, e) * 65535.0;
985 int usesVFilter, usesHFilter;
992 int dst_stride =
FFALIGN(dstW *
sizeof(int16_t) + 66, 16);
993 int flags, cpu_flags;
1007 unscaled = (srcW == dstW && srcH == dstH);
1013 av_log(c,
AV_LOG_WARNING,
"deprecated pixel format used, make sure you did set range correctly\n");
1054 if (dstW < srcW && dstH < srcH)
1056 else if (dstW > srcW && dstH > srcH)
1061 }
else if (i & (i - 1)) {
1063 "Exactly one scaler algorithm must be chosen, got %X\n", i);
1067 if (srcW < 1 || srcH < 1 || dstW < 1 || dstH < 1) {
1071 srcW, srcH, dstW, dstH);
1076 dstFilter = &dummyFilter;
1078 srcFilter = &dummyFilter;
1080 c->
lumXInc = (((int64_t)srcW << 16) + (dstW >> 1)) / dstW;
1081 c->
lumYInc = (((int64_t)srcH << 16) + (dstH >> 1)) / dstH;
1084 c->
vRounder = 4 * 0x0001000100010001ULL;
1086 usesVFilter = (srcFilter->
lumV && srcFilter->
lumV->
length > 1) ||
1090 usesHFilter = (srcFilter->
lumH && srcFilter->
lumH->
length > 1) ||
1110 av_log(c,
AV_LOG_DEBUG,
"Forcing full internal H chroma due to input having non subsampled chroma\n");
1127 if (!(flags & SWS_FULL_CHR_H_INT)) {
1130 "Desired dithering only supported in full chroma interpolation for destination format '%s'\n",
1136 if (flags & SWS_FULL_CHR_H_INT) {
1139 "Ordered dither is not supported in full chroma interpolation for destination format '%s'\n",
1146 if (!(flags & SWS_FULL_CHR_H_INT)) {
1148 "%s output is not supported with half chroma resolution, switching to full\n",
1157 if (flags & SWS_FULL_CHR_H_INT &&
1172 "full chroma interpolation for destination format '%s' not yet implemented\n",
1174 flags &= ~SWS_FULL_CHR_H_INT;
1177 if (
isAnyRGB(dstFormat) && !(flags & SWS_FULL_CHR_H_INT))
1228 "output width is not a multiple of 32 -> no MMXEXT scaler\n");
1245 if (flags & SWS_FAST_BILINEAR) {
1252 c->
lumXInc = ((int64_t)(srcW - 2) << 16) / (dstW - 2) - 20;
1262 if (!unscaled && c->
gamma_flag && (srcFormat != tmpFmt || dstFormat != tmpFmt)) {
1267 srcW, srcH, tmpFmt, 64);
1280 flags, srcFilter, dstFilter, c->
param);
1293 if (dstFormat != tmpFmt) {
1295 dstW, dstH, tmpFmt, 64);
1300 dstW, dstH, dstFormat,
1314 srcW, srcH, tmpFormat, 64);
1319 srcW, srcH, tmpFormat,
1325 dstW, dstH, dstFormat,
1333 #define USE_MMAP (HAVE_MMAP && HAVE_MPROTECT && defined MAP_ANONYMOUS)
1337 #if HAVE_MMXEXT_INLINE
1347 PROT_READ | PROT_WRITE,
1348 MAP_PRIVATE | MAP_ANONYMOUS,
1351 PROT_READ | PROT_WRITE,
1352 MAP_PRIVATE | MAP_ANONYMOUS,
1354 #elif HAVE_VIRTUALALLOC
1358 PAGE_EXECUTE_READWRITE);
1362 PAGE_EXECUTE_READWRITE);
1368 #ifdef MAP_ANONYMOUS
1398 const int filterAlign =
X86_MMX(cpu_flags) ? 4 :
1403 srcW, dstW, filterAlign, 1 << 14,
1405 cpu_flags, srcFilter->
lumH, dstFilter->
lumH,
1413 (flags & SWS_BICUBLIN) ? (flags |
SWS_BILINEAR) : flags,
1414 cpu_flags, srcFilter->
chrH, dstFilter->
chrH,
1424 const int filterAlign =
X86_MMX(cpu_flags) ? 2 :
1428 c->
lumYInc, srcH, dstH, filterAlign, (1 << 12),
1430 cpu_flags, srcFilter->
lumV, dstFilter->
lumV,
1437 filterAlign, (1 << 12),
1438 (flags & SWS_BICUBLIN) ? (flags |
SWS_BILINEAR) : flags,
1439 cpu_flags, srcFilter->
chrV, dstFilter->
chrV,
1452 short *p = (
short *)&c->vYCoeffsBank[i];
1453 for (j = 0; j < 8; j++)
1459 short *p = (
short *)&c->vCCoeffsBank[i];
1460 for (j = 0; j < 8; j++)
1469 for (i = 0; i < dstH; i++) {
1470 int chrI = (int64_t)i * c->
chrDstH / dstH;
1485 for (i = 0; i < 4; i++)
1500 dst_stride + 16, fail);
1508 dst_stride * 2 + 32, fail);
1513 if (CONFIG_SWSCALE_ALPHA && c->
alpPixBuf)
1516 dst_stride + 16, fail);
1524 for(j=0; j<dst_stride/2+1; j++)
1527 for(j=0; j<dst_stride+1; j++)
1533 const char *scaler =
NULL, *cpucaps;
1536 if (flags & scale_algorithms[i].flag) {
1542 scaler =
"ehh flags invalid?!";
1563 cpucaps =
"AltiVec";
1571 "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1574 "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1580 if (unscaled && !usesHFilter && !usesVFilter &&
1585 if (flags & SWS_PRINT_INFO)
1587 "using unscaled %s -> %s special converter\n",
1597 int tmpW = sqrt(srcW * (int64_t)dstW);
1598 int tmpH = sqrt(srcH * (int64_t)dstH);
1601 if (srcW*(int64_t)srcH <= 4LL*dstW*dstH)
1605 tmpW, tmpH, tmpFormat, 64);
1610 tmpW, tmpH, tmpFormat,
1616 dstW, dstH, dstFormat,
1628 SwsFilter *dstFilter,
const double *param)
1644 c->
param[0] = param[0];
1645 c->
param[1] = param[1];
1657 float lumaSharpen,
float chromaSharpen,
1658 float chromaHShift,
float chromaVShift,
1665 if (lumaGBlur != 0.0) {
1673 if (chromaGBlur != 0.0) {
1684 if (chromaSharpen != 0.0) {
1695 if (lumaSharpen != 0.0) {
1706 if (chromaHShift != 0.0)
1709 if (chromaVShift != 0.0)
1752 const int length = (int)(variance * quality + 0.5) | 1;
1754 double middle = (length - 1) * 0.5;
1757 if(variance < 0 || quality < 0)
1765 for (i = 0; i <
length; i++) {
1766 double dist = i - middle;
1767 vec->
coeff[i] = exp(-dist * dist / (2 * variance * variance)) /
1768 sqrt(2 * variance *
M_PI);
1784 for (i = 0; i <
length; i++)
1800 for (i = 0; i < a->
length; i++)
1810 for (i = 0; i < a->
length; i++)
1811 a->
coeff[i] *= scalar;
1828 for (i = 0; i < a->
length; i++) {
1829 for (j = 0; j < b->
length; j++) {
1846 for (i = 0; i < a->
length; i++)
1863 for (i = 0; i < a->
length; i++)
1881 for (i = 0; i < a->
length; i++) {
1882 vec->
coeff[i + (length - 1) / 2 -
1944 for (i = 0; i < a->
length; i++)
1945 if (a->
coeff[i] > max)
1948 for (i = 0; i < a->
length; i++)
1949 if (a->
coeff[i] < min)
1954 for (i = 0; i < a->
length; i++) {
1955 int x = (int)((a->
coeff[i] - min) * 60.0 / range + 0.5);
1956 av_log(log_ctx, log_level,
"%1.3f ", a->
coeff[i]);
1958 av_log(log_ctx, log_level,
" ");
1959 av_log(log_ctx, log_level,
"|\n");
2003 if (CONFIG_SWSCALE_ALPHA && c->
alpPixBuf) {
2009 for (i = 0; i < 4; i++)
2032 #elif HAVE_VIRTUALALLOC
2068 const double *
param)
2076 param = default_param;
2079 (context->
srcW != srcW ||
2080 context->
srcH != srcH ||
2082 context->
dstW != dstW ||
2083 context->
dstH != dstH ||
2085 context->
flags != flags ||
2086 context->
param[0] != param[0] ||
2087 context->
param[1] != param[1])) {
2107 context->
param[0] = param[0];
2108 context->
param[1] = param[1];
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
int16_t ** alpPixBuf
Ring buffer for scaled horizontal alpha plane lines to be fed to the vertical scaler.
int sws_isSupportedOutput(enum AVPixelFormat pix_fmt)
Return a positive value if pix_fmt is a supported output format, 0 otherwise.
static const FormatEntry format_entries[AV_PIX_FMT_NB]
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
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 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.
#define FF_ALLOCZ_ARRAY_OR_GOTO(ctx, p, nelem, elsize, label)
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)
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.
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)
bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian */
int dstFormatBpp
Number of bits per pixel of the destination pixel format.
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)
static int handle_jpeg(enum AVPixelFormat *format)
int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt)
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
void sws_subVec(SwsVector *a, SwsVector *b)
#define FF_ARRAY_ELEMS(a)
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 */
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 ...
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 uint16_t * alloc_gamma_tbl(double e)
const int32_t ff_yuv2rgb_coeffs[8][4]
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...
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
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
8 bit 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...
int vChrFilterSize
Vertical filter size for chroma pixels.
bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian */
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...
int16_t ** lumPixBuf
Ring buffer for scaled horizontal luma plane lines to be fed to the vertical scaler.
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined ...
void sws_addVec(SwsVector *a, SwsVector *b)
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
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
planar GBR 4:4:4 48bpp, big-endian
FF_ENABLE_DEPRECATION_WARNINGS enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt)
Utility function to swap the endianness of a pixel format.
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)
av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, SwsFilter *dstFilter)
Initialize the swscaler context sws_context.
#define AV_LOG_VERBOSE
Detailed information.
int16_t rgb2xyz_matrix[3][4]
enum AVPixelFormat dstFormat
Destination pixel format.
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)
static SwsVector * sws_getShiftedVec(SwsVector *a, int shift)
#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)
uint16_t depth_minus1
Number of bits in the component minus 1.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
16bit gray, 16bit alpha (big-endian)
int16_t ** chrVPixBuf
Ring buffer for scaled horizontal chroma plane lines to be fed to the vertical scaler.
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.
static const struct endianess table[]
#define PPC_ALTIVEC(flags)
#define SWS_MAX_REDUCE_CUTOFF
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
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
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
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.
int vChrBufSize
Number of vertical chroma lines allocated in the ring buffer.
av_cold void sws_rgb2rgb_init(void)
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
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.
as above, but U and V bytes are swapped
int dstRange
0 = MPG YUV range, 1 = JPG YUV range (destination image).
ptrdiff_t uv_offx2
offset (in bytes) between u and v planes
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)
int vLumBufSize
Number of vertical luma/alpha lines allocated in the ring buffer.
int16_t ** chrUPixBuf
Ring buffer for scaled horizontal chroma plane lines to be fed to the vertical scaler.
#define FF_CEIL_RSHIFT(a, b)
SwsVector * sws_getIdentityVec(void)
Allocate and return a vector with just one coefficient, with value 1.0.
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
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)
unsigned swscale_version(void)
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.
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]
static const ScaleAlgorithm scale_algorithms[]
int cascaded1_tmpStride[4]
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]
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)
void(* rgb15to16)(const uint8_t *src, uint8_t *dst, int src_size)
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
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
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)
void sws_shiftVec(SwsVector *a, int shift)
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)
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
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
static av_always_inline av_const long int lrint(double x)
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
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.
SwsVector * sws_cloneVec(SwsVector *a)
Allocate and return a clone of the vector a, that is a vector with the same coefficients as a...
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
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
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)
#define FF_ALLOC_ARRAY_OR_GOTO(ctx, p, nelem, elsize, label)
void sws_convVec(SwsVector *a, SwsVector *b)
const AVClass sws_context_class
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb...
#define INLINE_MMXEXT(flags)
static double sws_dcVec(SwsVector *a)
static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
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
#define FF_ALLOC_OR_GOTO(ctx, p, size, label)
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
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.
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 ...
16bit gray, 16bit alpha (little-endian)
int sws_isSupportedInput(enum AVPixelFormat pix_fmt)
Return a positive value if pix_fmt is a supported input format, 0 otherwise.
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
number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of...
int16_t * vLumFilter
Array of vertical filter coefficients for luma/alpha planes.
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 (1 Cr & Cb sample per 1x2 Y samples)
planar GBR 4:4:4 48bpp, little-endian
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 ...
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
int chrDstHSubSample
Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in destination...
int chrSrcW
Width of source chroma planes.
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.
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
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
#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)
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
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.