Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
  3.  *
  4.  * This file is part of FFmpeg.
  5.  *
  6.  * FFmpeg is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2.1 of the License, or (at your option) any later version.
  10.  *
  11.  * FFmpeg is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public
  17.  * License along with FFmpeg; if not, write to the Free Software
  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19.  */
  20.  
  21. #include "config.h"
  22.  
  23. #define _SVID_SOURCE // needed for MAP_ANONYMOUS
  24. #define _DARWIN_C_SOURCE // needed for MAP_ANON
  25. #include <inttypes.h>
  26. #include <math.h>
  27. #include <stdio.h>
  28. #include <string.h>
  29. #if HAVE_SYS_MMAN_H
  30. #include <sys/mman.h>
  31. #if defined(MAP_ANON) && !defined(MAP_ANONYMOUS)
  32. #define MAP_ANONYMOUS MAP_ANON
  33. #endif
  34. #endif
  35. #if HAVE_VIRTUALALLOC
  36. #define WIN32_LEAN_AND_MEAN
  37. #include <windows.h>
  38. #endif
  39.  
  40. #include "libavutil/attributes.h"
  41. #include "libavutil/avassert.h"
  42. #include "libavutil/avutil.h"
  43. #include "libavutil/bswap.h"
  44. #include "libavutil/cpu.h"
  45. #include "libavutil/imgutils.h"
  46. #include "libavutil/intreadwrite.h"
  47. #include "libavutil/mathematics.h"
  48. #include "libavutil/opt.h"
  49. #include "libavutil/pixdesc.h"
  50. #include "libavutil/ppc/cpu.h"
  51. #include "libavutil/x86/asm.h"
  52. #include "libavutil/x86/cpu.h"
  53. #include "rgb2rgb.h"
  54. #include "swscale.h"
  55. #include "swscale_internal.h"
  56.  
  57. static void handle_formats(SwsContext *c);
  58.  
  59. unsigned swscale_version(void)
  60. {
  61.     av_assert0(LIBSWSCALE_VERSION_MICRO >= 100);
  62.     return LIBSWSCALE_VERSION_INT;
  63. }
  64.  
  65. const char *swscale_configuration(void)
  66. {
  67.     return FFMPEG_CONFIGURATION;
  68. }
  69.  
  70. const char *swscale_license(void)
  71. {
  72. #define LICENSE_PREFIX "libswscale license: "
  73.     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  74. }
  75.  
  76. typedef struct FormatEntry {
  77.     uint8_t is_supported_in         :1;
  78.     uint8_t is_supported_out        :1;
  79.     uint8_t is_supported_endianness :1;
  80. } FormatEntry;
  81.  
  82. static const FormatEntry format_entries[AV_PIX_FMT_NB] = {
  83.     [AV_PIX_FMT_YUV420P]     = { 1, 1 },
  84.     [AV_PIX_FMT_YUYV422]     = { 1, 1 },
  85.     [AV_PIX_FMT_RGB24]       = { 1, 1 },
  86.     [AV_PIX_FMT_BGR24]       = { 1, 1 },
  87.     [AV_PIX_FMT_YUV422P]     = { 1, 1 },
  88.     [AV_PIX_FMT_YUV444P]     = { 1, 1 },
  89.     [AV_PIX_FMT_YUV410P]     = { 1, 1 },
  90.     [AV_PIX_FMT_YUV411P]     = { 1, 1 },
  91.     [AV_PIX_FMT_GRAY8]       = { 1, 1 },
  92.     [AV_PIX_FMT_MONOWHITE]   = { 1, 1 },
  93.     [AV_PIX_FMT_MONOBLACK]   = { 1, 1 },
  94.     [AV_PIX_FMT_PAL8]        = { 1, 0 },
  95.     [AV_PIX_FMT_YUVJ420P]    = { 1, 1 },
  96.     [AV_PIX_FMT_YUVJ411P]    = { 1, 1 },
  97.     [AV_PIX_FMT_YUVJ422P]    = { 1, 1 },
  98.     [AV_PIX_FMT_YUVJ444P]    = { 1, 1 },
  99.     [AV_PIX_FMT_YVYU422]     = { 1, 1 },
  100.     [AV_PIX_FMT_UYVY422]     = { 1, 1 },
  101.     [AV_PIX_FMT_UYYVYY411]   = { 0, 0 },
  102.     [AV_PIX_FMT_BGR8]        = { 1, 1 },
  103.     [AV_PIX_FMT_BGR4]        = { 0, 1 },
  104.     [AV_PIX_FMT_BGR4_BYTE]   = { 1, 1 },
  105.     [AV_PIX_FMT_RGB8]        = { 1, 1 },
  106.     [AV_PIX_FMT_RGB4]        = { 0, 1 },
  107.     [AV_PIX_FMT_RGB4_BYTE]   = { 1, 1 },
  108.     [AV_PIX_FMT_NV12]        = { 1, 1 },
  109.     [AV_PIX_FMT_NV21]        = { 1, 1 },
  110.     [AV_PIX_FMT_ARGB]        = { 1, 1 },
  111.     [AV_PIX_FMT_RGBA]        = { 1, 1 },
  112.     [AV_PIX_FMT_ABGR]        = { 1, 1 },
  113.     [AV_PIX_FMT_BGRA]        = { 1, 1 },
  114.     [AV_PIX_FMT_0RGB]        = { 1, 1 },
  115.     [AV_PIX_FMT_RGB0]        = { 1, 1 },
  116.     [AV_PIX_FMT_0BGR]        = { 1, 1 },
  117.     [AV_PIX_FMT_BGR0]        = { 1, 1 },
  118.     [AV_PIX_FMT_GRAY16BE]    = { 1, 1 },
  119.     [AV_PIX_FMT_GRAY16LE]    = { 1, 1 },
  120.     [AV_PIX_FMT_YUV440P]     = { 1, 1 },
  121.     [AV_PIX_FMT_YUVJ440P]    = { 1, 1 },
  122.     [AV_PIX_FMT_YUV440P10LE] = { 1, 1 },
  123.     [AV_PIX_FMT_YUV440P10BE] = { 1, 1 },
  124.     [AV_PIX_FMT_YUV440P12LE] = { 1, 1 },
  125.     [AV_PIX_FMT_YUV440P12BE] = { 1, 1 },
  126.     [AV_PIX_FMT_YUVA420P]    = { 1, 1 },
  127.     [AV_PIX_FMT_YUVA422P]    = { 1, 1 },
  128.     [AV_PIX_FMT_YUVA444P]    = { 1, 1 },
  129.     [AV_PIX_FMT_YUVA420P9BE] = { 1, 1 },
  130.     [AV_PIX_FMT_YUVA420P9LE] = { 1, 1 },
  131.     [AV_PIX_FMT_YUVA422P9BE] = { 1, 1 },
  132.     [AV_PIX_FMT_YUVA422P9LE] = { 1, 1 },
  133.     [AV_PIX_FMT_YUVA444P9BE] = { 1, 1 },
  134.     [AV_PIX_FMT_YUVA444P9LE] = { 1, 1 },
  135.     [AV_PIX_FMT_YUVA420P10BE]= { 1, 1 },
  136.     [AV_PIX_FMT_YUVA420P10LE]= { 1, 1 },
  137.     [AV_PIX_FMT_YUVA422P10BE]= { 1, 1 },
  138.     [AV_PIX_FMT_YUVA422P10LE]= { 1, 1 },
  139.     [AV_PIX_FMT_YUVA444P10BE]= { 1, 1 },
  140.     [AV_PIX_FMT_YUVA444P10LE]= { 1, 1 },
  141.     [AV_PIX_FMT_YUVA420P16BE]= { 1, 1 },
  142.     [AV_PIX_FMT_YUVA420P16LE]= { 1, 1 },
  143.     [AV_PIX_FMT_YUVA422P16BE]= { 1, 1 },
  144.     [AV_PIX_FMT_YUVA422P16LE]= { 1, 1 },
  145.     [AV_PIX_FMT_YUVA444P16BE]= { 1, 1 },
  146.     [AV_PIX_FMT_YUVA444P16LE]= { 1, 1 },
  147.     [AV_PIX_FMT_RGB48BE]     = { 1, 1 },
  148.     [AV_PIX_FMT_RGB48LE]     = { 1, 1 },
  149.     [AV_PIX_FMT_RGBA64BE]    = { 1, 1, 1 },
  150.     [AV_PIX_FMT_RGBA64LE]    = { 1, 1, 1 },
  151.     [AV_PIX_FMT_RGB565BE]    = { 1, 1 },
  152.     [AV_PIX_FMT_RGB565LE]    = { 1, 1 },
  153.     [AV_PIX_FMT_RGB555BE]    = { 1, 1 },
  154.     [AV_PIX_FMT_RGB555LE]    = { 1, 1 },
  155.     [AV_PIX_FMT_BGR565BE]    = { 1, 1 },
  156.     [AV_PIX_FMT_BGR565LE]    = { 1, 1 },
  157.     [AV_PIX_FMT_BGR555BE]    = { 1, 1 },
  158.     [AV_PIX_FMT_BGR555LE]    = { 1, 1 },
  159.     [AV_PIX_FMT_YUV420P16LE] = { 1, 1 },
  160.     [AV_PIX_FMT_YUV420P16BE] = { 1, 1 },
  161.     [AV_PIX_FMT_YUV422P16LE] = { 1, 1 },
  162.     [AV_PIX_FMT_YUV422P16BE] = { 1, 1 },
  163.     [AV_PIX_FMT_YUV444P16LE] = { 1, 1 },
  164.     [AV_PIX_FMT_YUV444P16BE] = { 1, 1 },
  165.     [AV_PIX_FMT_RGB444LE]    = { 1, 1 },
  166.     [AV_PIX_FMT_RGB444BE]    = { 1, 1 },
  167.     [AV_PIX_FMT_BGR444LE]    = { 1, 1 },
  168.     [AV_PIX_FMT_BGR444BE]    = { 1, 1 },
  169.     [AV_PIX_FMT_YA8]         = { 1, 1 },
  170.     [AV_PIX_FMT_YA16BE]      = { 1, 0 },
  171.     [AV_PIX_FMT_YA16LE]      = { 1, 0 },
  172.     [AV_PIX_FMT_BGR48BE]     = { 1, 1 },
  173.     [AV_PIX_FMT_BGR48LE]     = { 1, 1 },
  174.     [AV_PIX_FMT_BGRA64BE]    = { 1, 1, 1 },
  175.     [AV_PIX_FMT_BGRA64LE]    = { 1, 1, 1 },
  176.     [AV_PIX_FMT_YUV420P9BE]  = { 1, 1 },
  177.     [AV_PIX_FMT_YUV420P9LE]  = { 1, 1 },
  178.     [AV_PIX_FMT_YUV420P10BE] = { 1, 1 },
  179.     [AV_PIX_FMT_YUV420P10LE] = { 1, 1 },
  180.     [AV_PIX_FMT_YUV420P12BE] = { 1, 1 },
  181.     [AV_PIX_FMT_YUV420P12LE] = { 1, 1 },
  182.     [AV_PIX_FMT_YUV420P14BE] = { 1, 1 },
  183.     [AV_PIX_FMT_YUV420P14LE] = { 1, 1 },
  184.     [AV_PIX_FMT_YUV422P9BE]  = { 1, 1 },
  185.     [AV_PIX_FMT_YUV422P9LE]  = { 1, 1 },
  186.     [AV_PIX_FMT_YUV422P10BE] = { 1, 1 },
  187.     [AV_PIX_FMT_YUV422P10LE] = { 1, 1 },
  188.     [AV_PIX_FMT_YUV422P12BE] = { 1, 1 },
  189.     [AV_PIX_FMT_YUV422P12LE] = { 1, 1 },
  190.     [AV_PIX_FMT_YUV422P14BE] = { 1, 1 },
  191.     [AV_PIX_FMT_YUV422P14LE] = { 1, 1 },
  192.     [AV_PIX_FMT_YUV444P9BE]  = { 1, 1 },
  193.     [AV_PIX_FMT_YUV444P9LE]  = { 1, 1 },
  194.     [AV_PIX_FMT_YUV444P10BE] = { 1, 1 },
  195.     [AV_PIX_FMT_YUV444P10LE] = { 1, 1 },
  196.     [AV_PIX_FMT_YUV444P12BE] = { 1, 1 },
  197.     [AV_PIX_FMT_YUV444P12LE] = { 1, 1 },
  198.     [AV_PIX_FMT_YUV444P14BE] = { 1, 1 },
  199.     [AV_PIX_FMT_YUV444P14LE] = { 1, 1 },
  200.     [AV_PIX_FMT_GBRP]        = { 1, 1 },
  201.     [AV_PIX_FMT_GBRP9LE]     = { 1, 1 },
  202.     [AV_PIX_FMT_GBRP9BE]     = { 1, 1 },
  203.     [AV_PIX_FMT_GBRP10LE]    = { 1, 1 },
  204.     [AV_PIX_FMT_GBRP10BE]    = { 1, 1 },
  205.     [AV_PIX_FMT_GBRP12LE]    = { 1, 1 },
  206.     [AV_PIX_FMT_GBRP12BE]    = { 1, 1 },
  207.     [AV_PIX_FMT_GBRP14LE]    = { 1, 1 },
  208.     [AV_PIX_FMT_GBRP14BE]    = { 1, 1 },
  209.     [AV_PIX_FMT_GBRP16LE]    = { 1, 0 },
  210.     [AV_PIX_FMT_GBRP16BE]    = { 1, 0 },
  211.     [AV_PIX_FMT_GBRAP]       = { 1, 1 },
  212.     [AV_PIX_FMT_GBRAP16LE]   = { 1, 0 },
  213.     [AV_PIX_FMT_GBRAP16BE]   = { 1, 0 },
  214.     [AV_PIX_FMT_BAYER_BGGR8] = { 1, 0 },
  215.     [AV_PIX_FMT_BAYER_RGGB8] = { 1, 0 },
  216.     [AV_PIX_FMT_BAYER_GBRG8] = { 1, 0 },
  217.     [AV_PIX_FMT_BAYER_GRBG8] = { 1, 0 },
  218.     [AV_PIX_FMT_BAYER_BGGR16LE] = { 1, 0 },
  219.     [AV_PIX_FMT_BAYER_BGGR16BE] = { 1, 0 },
  220.     [AV_PIX_FMT_BAYER_RGGB16LE] = { 1, 0 },
  221.     [AV_PIX_FMT_BAYER_RGGB16BE] = { 1, 0 },
  222.     [AV_PIX_FMT_BAYER_GBRG16LE] = { 1, 0 },
  223.     [AV_PIX_FMT_BAYER_GBRG16BE] = { 1, 0 },
  224.     [AV_PIX_FMT_BAYER_GRBG16LE] = { 1, 0 },
  225.     [AV_PIX_FMT_BAYER_GRBG16BE] = { 1, 0 },
  226.     [AV_PIX_FMT_XYZ12BE]     = { 1, 1, 1 },
  227.     [AV_PIX_FMT_XYZ12LE]     = { 1, 1, 1 },
  228.     [AV_PIX_FMT_AYUV64LE]    = { 1, 1},
  229. };
  230.  
  231. int sws_isSupportedInput(enum AVPixelFormat pix_fmt)
  232. {
  233.     return (unsigned)pix_fmt < AV_PIX_FMT_NB ?
  234.            format_entries[pix_fmt].is_supported_in : 0;
  235. }
  236.  
  237. int sws_isSupportedOutput(enum AVPixelFormat pix_fmt)
  238. {
  239.     return (unsigned)pix_fmt < AV_PIX_FMT_NB ?
  240.            format_entries[pix_fmt].is_supported_out : 0;
  241. }
  242.  
  243. int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt)
  244. {
  245.     return (unsigned)pix_fmt < AV_PIX_FMT_NB ?
  246.            format_entries[pix_fmt].is_supported_endianness : 0;
  247. }
  248.  
  249. static double getSplineCoeff(double a, double b, double c, double d,
  250.                              double dist)
  251. {
  252.     if (dist <= 1.0)
  253.         return ((d * dist + c) * dist + b) * dist + a;
  254.     else
  255.         return getSplineCoeff(0.0,
  256.                                b + 2.0 * c + 3.0 * d,
  257.                                c + 3.0 * d,
  258.                               -b - 3.0 * c - 6.0 * d,
  259.                               dist - 1.0);
  260. }
  261.  
  262. static av_cold int get_local_pos(SwsContext *s, int chr_subsample, int pos, int dir)
  263. {
  264.     if (pos == -1 || pos <= -513) {
  265.         pos = (128 << chr_subsample) - 128;
  266.     }
  267.     pos += 128; // relative to ideal left edge
  268.     return pos >> chr_subsample;
  269. }
  270.  
  271. typedef struct {
  272.     int flag;                   ///< flag associated to the algorithm
  273.     const char *description;    ///< human-readable description
  274.     int size_factor;            ///< size factor used when initing the filters
  275. } ScaleAlgorithm;
  276.  
  277. static const ScaleAlgorithm scale_algorithms[] = {
  278.     { SWS_AREA,          "area averaging",                  1 /* downscale only, for upscale it is bilinear */ },
  279.     { SWS_BICUBIC,       "bicubic",                         4 },
  280.     { SWS_BICUBLIN,      "luma bicubic / chroma bilinear", -1 },
  281.     { SWS_BILINEAR,      "bilinear",                        2 },
  282.     { SWS_FAST_BILINEAR, "fast bilinear",                  -1 },
  283.     { SWS_GAUSS,         "Gaussian",                        8 /* infinite ;) */ },
  284.     { SWS_LANCZOS,       "Lanczos",                        -1 /* custom */ },
  285.     { SWS_POINT,         "nearest neighbor / point",       -1 },
  286.     { SWS_SINC,          "sinc",                           20 /* infinite ;) */ },
  287.     { SWS_SPLINE,        "bicubic spline",                 20 /* infinite :)*/ },
  288.     { SWS_X,             "experimental",                    8 },
  289. };
  290.  
  291. static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos,
  292.                               int *outFilterSize, int xInc, int srcW,
  293.                               int dstW, int filterAlign, int one,
  294.                               int flags, int cpu_flags,
  295.                               SwsVector *srcFilter, SwsVector *dstFilter,
  296.                               double param[2], int srcPos, int dstPos)
  297. {
  298.     int i;
  299.     int filterSize;
  300.     int filter2Size;
  301.     int minFilterSize;
  302.     int64_t *filter    = NULL;
  303.     int64_t *filter2   = NULL;
  304.     const int64_t fone = 1LL << (54 - FFMIN(av_log2(srcW/dstW), 8));
  305.     int ret            = -1;
  306.  
  307.     emms_c(); // FIXME should not be required but IS (even for non-MMX versions)
  308.  
  309.     // NOTE: the +3 is for the MMX(+1) / SSE(+3) scaler which reads over the end
  310.     FF_ALLOC_ARRAY_OR_GOTO(NULL, *filterPos, (dstW + 3), sizeof(**filterPos), fail);
  311.  
  312.     if (FFABS(xInc - 0x10000) < 10 && srcPos == dstPos) { // unscaled
  313.         int i;
  314.         filterSize = 1;
  315.         FF_ALLOCZ_ARRAY_OR_GOTO(NULL, filter,
  316.                                 dstW, sizeof(*filter) * filterSize, fail);
  317.  
  318.         for (i = 0; i < dstW; i++) {
  319.             filter[i * filterSize] = fone;
  320.             (*filterPos)[i]        = i;
  321.         }
  322.     } else if (flags & SWS_POINT) { // lame looking point sampling mode
  323.         int i;
  324.         int64_t xDstInSrc;
  325.         filterSize = 1;
  326.         FF_ALLOC_ARRAY_OR_GOTO(NULL, filter,
  327.                                dstW, sizeof(*filter) * filterSize, fail);
  328.  
  329.         xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
  330.         for (i = 0; i < dstW; i++) {
  331.             int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
  332.  
  333.             (*filterPos)[i] = xx;
  334.             filter[i]       = fone;
  335.             xDstInSrc      += xInc;
  336.         }
  337.     } else if ((xInc <= (1 << 16) && (flags & SWS_AREA)) ||
  338.                (flags & SWS_FAST_BILINEAR)) { // bilinear upscale
  339.         int i;
  340.         int64_t xDstInSrc;
  341.         filterSize = 2;
  342.         FF_ALLOC_ARRAY_OR_GOTO(NULL, filter,
  343.                                dstW, sizeof(*filter) * filterSize, fail);
  344.  
  345.         xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
  346.         for (i = 0; i < dstW; i++) {
  347.             int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
  348.             int j;
  349.  
  350.             (*filterPos)[i] = xx;
  351.             // bilinear upscale / linear interpolate / area averaging
  352.             for (j = 0; j < filterSize; j++) {
  353.                 int64_t coeff= fone - FFABS(((int64_t)xx<<16) - xDstInSrc)*(fone>>16);
  354.                 if (coeff < 0)
  355.                     coeff = 0;
  356.                 filter[i * filterSize + j] = coeff;
  357.                 xx++;
  358.             }
  359.             xDstInSrc += xInc;
  360.         }
  361.     } else {
  362.         int64_t xDstInSrc;
  363.         int sizeFactor = -1;
  364.  
  365.         for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) {
  366.             if (flags & scale_algorithms[i].flag && scale_algorithms[i].size_factor > 0) {
  367.                 sizeFactor = scale_algorithms[i].size_factor;
  368.                 break;
  369.             }
  370.         }
  371.         if (flags & SWS_LANCZOS)
  372.             sizeFactor = param[0] != SWS_PARAM_DEFAULT ? ceil(2 * param[0]) : 6;
  373.         av_assert0(sizeFactor > 0);
  374.  
  375.         if (xInc <= 1 << 16)
  376.             filterSize = 1 + sizeFactor;    // upscale
  377.         else
  378.             filterSize = 1 + (sizeFactor * srcW + dstW - 1) / dstW;
  379.  
  380.         filterSize = FFMIN(filterSize, srcW - 2);
  381.         filterSize = FFMAX(filterSize, 1);
  382.  
  383.         FF_ALLOC_ARRAY_OR_GOTO(NULL, filter,
  384.                                dstW, sizeof(*filter) * filterSize, fail);
  385.  
  386.         xDstInSrc = ((dstPos*(int64_t)xInc)>>7) - ((srcPos*0x10000LL)>>7);
  387.         for (i = 0; i < dstW; i++) {
  388.             int xx = (xDstInSrc - (filterSize - 2) * (1LL<<16)) / (1 << 17);
  389.             int j;
  390.             (*filterPos)[i] = xx;
  391.             for (j = 0; j < filterSize; j++) {
  392.                 int64_t d = (FFABS(((int64_t)xx * (1 << 17)) - xDstInSrc)) << 13;
  393.                 double floatd;
  394.                 int64_t coeff;
  395.  
  396.                 if (xInc > 1 << 16)
  397.                     d = d * dstW / srcW;
  398.                 floatd = d * (1.0 / (1 << 30));
  399.  
  400.                 if (flags & SWS_BICUBIC) {
  401.                     int64_t B = (param[0] != SWS_PARAM_DEFAULT ? param[0] :   0) * (1 << 24);
  402.                     int64_t C = (param[1] != SWS_PARAM_DEFAULT ? param[1] : 0.6) * (1 << 24);
  403.  
  404.                     if (d >= 1LL << 31) {
  405.                         coeff = 0.0;
  406.                     } else {
  407.                         int64_t dd  = (d  * d) >> 30;
  408.                         int64_t ddd = (dd * d) >> 30;
  409.  
  410.                         if (d < 1LL << 30)
  411.                             coeff =  (12 * (1 << 24) -  9 * B - 6 * C) * ddd +
  412.                                     (-18 * (1 << 24) + 12 * B + 6 * C) *  dd +
  413.                                       (6 * (1 << 24) -  2 * B)         * (1 << 30);
  414.                         else
  415.                             coeff =      (-B -  6 * C) * ddd +
  416.                                       (6 * B + 30 * C) * dd  +
  417.                                     (-12 * B - 48 * C) * d   +
  418.                                       (8 * B + 24 * C) * (1 << 30);
  419.                     }
  420.                     coeff /= (1LL<<54)/fone;
  421.                 }
  422. #if 0
  423.                 else if (flags & SWS_X) {
  424.                     double p  = param ? param * 0.01 : 0.3;
  425.                     coeff     = d ? sin(d * M_PI) / (d * M_PI) : 1.0;
  426.                     coeff    *= pow(2.0, -p * d * d);
  427.                 }
  428. #endif
  429.                 else if (flags & SWS_X) {
  430.                     double A = param[0] != SWS_PARAM_DEFAULT ? param[0] : 1.0;
  431.                     double c;
  432.  
  433.                     if (floatd < 1.0)
  434.                         c = cos(floatd * M_PI);
  435.                     else
  436.                         c = -1.0;
  437.                     if (c < 0.0)
  438.                         c = -pow(-c, A);
  439.                     else
  440.                         c = pow(c, A);
  441.                     coeff = (c * 0.5 + 0.5) * fone;
  442.                 } else if (flags & SWS_AREA) {
  443.                     int64_t d2 = d - (1 << 29);
  444.                     if (d2 * xInc < -(1LL << (29 + 16)))
  445.                         coeff = 1.0 * (1LL << (30 + 16));
  446.                     else if (d2 * xInc < (1LL << (29 + 16)))
  447.                         coeff = -d2 * xInc + (1LL << (29 + 16));
  448.                     else
  449.                         coeff = 0.0;
  450.                     coeff *= fone >> (30 + 16);
  451.                 } else if (flags & SWS_GAUSS) {
  452.                     double p = param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0;
  453.                     coeff = (pow(2.0, -p * floatd * floatd)) * fone;
  454.                 } else if (flags & SWS_SINC) {
  455.                     coeff = (d ? sin(floatd * M_PI) / (floatd * M_PI) : 1.0) * fone;
  456.                 } else if (flags & SWS_LANCZOS) {
  457.                     double p = param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0;
  458.                     coeff = (d ? sin(floatd * M_PI) * sin(floatd * M_PI / p) /
  459.                              (floatd * floatd * M_PI * M_PI / p) : 1.0) * fone;
  460.                     if (floatd > p)
  461.                         coeff = 0;
  462.                 } else if (flags & SWS_BILINEAR) {
  463.                     coeff = (1 << 30) - d;
  464.                     if (coeff < 0)
  465.                         coeff = 0;
  466.                     coeff *= fone >> 30;
  467.                 } else if (flags & SWS_SPLINE) {
  468.                     double p = -2.196152422706632;
  469.                     coeff = getSplineCoeff(1.0, 0.0, p, -p - 1.0, floatd) * fone;
  470.                 } else {
  471.                     av_assert0(0);
  472.                 }
  473.  
  474.                 filter[i * filterSize + j] = coeff;
  475.                 xx++;
  476.             }
  477.             xDstInSrc += 2 * xInc;
  478.         }
  479.     }
  480.  
  481.     /* apply src & dst Filter to filter -> filter2
  482.      * av_free(filter);
  483.      */
  484.     av_assert0(filterSize > 0);
  485.     filter2Size = filterSize;
  486.     if (srcFilter)
  487.         filter2Size += srcFilter->length - 1;
  488.     if (dstFilter)
  489.         filter2Size += dstFilter->length - 1;
  490.     av_assert0(filter2Size > 0);
  491.     FF_ALLOCZ_ARRAY_OR_GOTO(NULL, filter2, dstW, filter2Size * sizeof(*filter2), fail);
  492.  
  493.     for (i = 0; i < dstW; i++) {
  494.         int j, k;
  495.  
  496.         if (srcFilter) {
  497.             for (k = 0; k < srcFilter->length; k++) {
  498.                 for (j = 0; j < filterSize; j++)
  499.                     filter2[i * filter2Size + k + j] +=
  500.                         srcFilter->coeff[k] * filter[i * filterSize + j];
  501.             }
  502.         } else {
  503.             for (j = 0; j < filterSize; j++)
  504.                 filter2[i * filter2Size + j] = filter[i * filterSize + j];
  505.         }
  506.         // FIXME dstFilter
  507.  
  508.         (*filterPos)[i] += (filterSize - 1) / 2 - (filter2Size - 1) / 2;
  509.     }
  510.     av_freep(&filter);
  511.  
  512.     /* try to reduce the filter-size (step1 find size and shift left) */
  513.     // Assume it is near normalized (*0.5 or *2.0 is OK but * 0.001 is not).
  514.     minFilterSize = 0;
  515.     for (i = dstW - 1; i >= 0; i--) {
  516.         int min = filter2Size;
  517.         int j;
  518.         int64_t cutOff = 0.0;
  519.  
  520.         /* get rid of near zero elements on the left by shifting left */
  521.         for (j = 0; j < filter2Size; j++) {
  522.             int k;
  523.             cutOff += FFABS(filter2[i * filter2Size]);
  524.  
  525.             if (cutOff > SWS_MAX_REDUCE_CUTOFF * fone)
  526.                 break;
  527.  
  528.             /* preserve monotonicity because the core can't handle the
  529.              * filter otherwise */
  530.             if (i < dstW - 1 && (*filterPos)[i] >= (*filterPos)[i + 1])
  531.                 break;
  532.  
  533.             // move filter coefficients left
  534.             for (k = 1; k < filter2Size; k++)
  535.                 filter2[i * filter2Size + k - 1] = filter2[i * filter2Size + k];
  536.             filter2[i * filter2Size + k - 1] = 0;
  537.             (*filterPos)[i]++;
  538.         }
  539.  
  540.         cutOff = 0;
  541.         /* count near zeros on the right */
  542.         for (j = filter2Size - 1; j > 0; j--) {
  543.             cutOff += FFABS(filter2[i * filter2Size + j]);
  544.  
  545.             if (cutOff > SWS_MAX_REDUCE_CUTOFF * fone)
  546.                 break;
  547.             min--;
  548.         }
  549.  
  550.         if (min > minFilterSize)
  551.             minFilterSize = min;
  552.     }
  553.  
  554.     if (PPC_ALTIVEC(cpu_flags)) {
  555.         // we can handle the special case 4, so we don't want to go the full 8
  556.         if (minFilterSize < 5)
  557.             filterAlign = 4;
  558.  
  559.         /* We really don't want to waste our time doing useless computation, so
  560.          * fall back on the scalar C code for very small filters.
  561.          * Vectorizing is worth it only if you have a decent-sized vector. */
  562.         if (minFilterSize < 3)
  563.             filterAlign = 1;
  564.     }
  565.  
  566.     if (HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) {
  567.         // special case for unscaled vertical filtering
  568.         if (minFilterSize == 1 && filterAlign == 2)
  569.             filterAlign = 1;
  570.     }
  571.  
  572.     av_assert0(minFilterSize > 0);
  573.     filterSize = (minFilterSize + (filterAlign - 1)) & (~(filterAlign - 1));
  574.     av_assert0(filterSize > 0);
  575.     filter = av_malloc_array(dstW, filterSize * sizeof(*filter));
  576.     if (!filter)
  577.         goto fail;
  578.     if (filterSize >= MAX_FILTER_SIZE * 16 /
  579.                       ((flags & SWS_ACCURATE_RND) ? APCK_SIZE : 16)) {
  580.         ret = RETCODE_USE_CASCADE;
  581.         goto fail;
  582.     }
  583.     *outFilterSize = filterSize;
  584.  
  585.     if (flags & SWS_PRINT_INFO)
  586.         av_log(NULL, AV_LOG_VERBOSE,
  587.                "SwScaler: reducing / aligning filtersize %d -> %d\n",
  588.                filter2Size, filterSize);
  589.     /* try to reduce the filter-size (step2 reduce it) */
  590.     for (i = 0; i < dstW; i++) {
  591.         int j;
  592.  
  593.         for (j = 0; j < filterSize; j++) {
  594.             if (j >= filter2Size)
  595.                 filter[i * filterSize + j] = 0;
  596.             else
  597.                 filter[i * filterSize + j] = filter2[i * filter2Size + j];
  598.             if ((flags & SWS_BITEXACT) && j >= minFilterSize)
  599.                 filter[i * filterSize + j] = 0;
  600.         }
  601.     }
  602.  
  603.     // FIXME try to align filterPos if possible
  604.  
  605.     // fix borders
  606.     for (i = 0; i < dstW; i++) {
  607.         int j;
  608.         if ((*filterPos)[i] < 0) {
  609.             // move filter coefficients left to compensate for filterPos
  610.             for (j = 1; j < filterSize; j++) {
  611.                 int left = FFMAX(j + (*filterPos)[i], 0);
  612.                 filter[i * filterSize + left] += filter[i * filterSize + j];
  613.                 filter[i * filterSize + j]     = 0;
  614.             }
  615.             (*filterPos)[i]= 0;
  616.         }
  617.  
  618.         if ((*filterPos)[i] + filterSize > srcW) {
  619.             int shift = (*filterPos)[i] + FFMIN(filterSize - srcW, 0);
  620.             int64_t acc = 0;
  621.  
  622.             for (j = filterSize - 1; j >= 0; j--) {
  623.                 if ((*filterPos)[i] + j >= srcW) {
  624.                     acc += filter[i * filterSize + j];
  625.                     filter[i * filterSize + j] = 0;
  626.                 }
  627.             }
  628.             for (j = filterSize - 1; j >= 0; j--) {
  629.                 if (j < shift) {
  630.                     filter[i * filterSize + j] = 0;
  631.                 } else {
  632.                     filter[i * filterSize + j] = filter[i * filterSize + j - shift];
  633.                 }
  634.             }
  635.  
  636.             (*filterPos)[i]-= shift;
  637.             filter[i * filterSize + srcW - 1 - (*filterPos)[i]] += acc;
  638.         }
  639.         av_assert0((*filterPos)[i] >= 0);
  640.         av_assert0((*filterPos)[i] < srcW);
  641.         if ((*filterPos)[i] + filterSize > srcW) {
  642.             for (j = 0; j < filterSize; j++) {
  643.                 av_assert0((*filterPos)[i] + j < srcW || !filter[i * filterSize + j]);
  644.             }
  645.         }
  646.     }
  647.  
  648.     // Note the +1 is for the MMX scaler which reads over the end
  649.     /* align at 16 for AltiVec (needed by hScale_altivec_real) */
  650.     FF_ALLOCZ_ARRAY_OR_GOTO(NULL, *outFilter,
  651.                             (dstW + 3), *outFilterSize * sizeof(int16_t), fail);
  652.  
  653.     /* normalize & store in outFilter */
  654.     for (i = 0; i < dstW; i++) {
  655.         int j;
  656.         int64_t error = 0;
  657.         int64_t sum   = 0;
  658.  
  659.         for (j = 0; j < filterSize; j++) {
  660.             sum += filter[i * filterSize + j];
  661.         }
  662.         sum = (sum + one / 2) / one;
  663.         if (!sum) {
  664.             av_log(NULL, AV_LOG_WARNING, "SwScaler: zero vector in scaling\n");
  665.             sum = 1;
  666.         }
  667.         for (j = 0; j < *outFilterSize; j++) {
  668.             int64_t v = filter[i * filterSize + j] + error;
  669.             int intV  = ROUNDED_DIV(v, sum);
  670.             (*outFilter)[i * (*outFilterSize) + j] = intV;
  671.             error                                  = v - intV * sum;
  672.         }
  673.     }
  674.  
  675.     (*filterPos)[dstW + 0] =
  676.     (*filterPos)[dstW + 1] =
  677.     (*filterPos)[dstW + 2] = (*filterPos)[dstW - 1]; /* the MMX/SSE scaler will
  678.                                                       * read over the end */
  679.     for (i = 0; i < *outFilterSize; i++) {
  680.         int k = (dstW - 1) * (*outFilterSize) + i;
  681.         (*outFilter)[k + 1 * (*outFilterSize)] =
  682.         (*outFilter)[k + 2 * (*outFilterSize)] =
  683.         (*outFilter)[k + 3 * (*outFilterSize)] = (*outFilter)[k];
  684.     }
  685.  
  686.     ret = 0;
  687.  
  688. fail:
  689.     if(ret < 0)
  690.         av_log(NULL, ret == RETCODE_USE_CASCADE ? AV_LOG_DEBUG : AV_LOG_ERROR, "sws: initFilter failed\n");
  691.     av_free(filter);
  692.     av_free(filter2);
  693.     return ret;
  694. }
  695.  
  696. static void fill_rgb2yuv_table(SwsContext *c, const int table[4], int dstRange)
  697. {
  698.     int64_t W, V, Z, Cy, Cu, Cv;
  699.     int64_t vr =  table[0];
  700.     int64_t ub =  table[1];
  701.     int64_t ug = -table[2];
  702.     int64_t vg = -table[3];
  703.     int64_t ONE = 65536;
  704.     int64_t cy = ONE;
  705.     uint8_t *p = (uint8_t*)c->input_rgb2yuv_table;
  706.     int i;
  707.     static const int8_t map[] = {
  708.     BY_IDX, GY_IDX, -1    , BY_IDX, BY_IDX, GY_IDX, -1    , BY_IDX,
  709.     RY_IDX, -1    , GY_IDX, RY_IDX, RY_IDX, -1    , GY_IDX, RY_IDX,
  710.     RY_IDX, GY_IDX, -1    , RY_IDX, RY_IDX, GY_IDX, -1    , RY_IDX,
  711.     BY_IDX, -1    , GY_IDX, BY_IDX, BY_IDX, -1    , GY_IDX, BY_IDX,
  712.     BU_IDX, GU_IDX, -1    , BU_IDX, BU_IDX, GU_IDX, -1    , BU_IDX,
  713.     RU_IDX, -1    , GU_IDX, RU_IDX, RU_IDX, -1    , GU_IDX, RU_IDX,
  714.     RU_IDX, GU_IDX, -1    , RU_IDX, RU_IDX, GU_IDX, -1    , RU_IDX,
  715.     BU_IDX, -1    , GU_IDX, BU_IDX, BU_IDX, -1    , GU_IDX, BU_IDX,
  716.     BV_IDX, GV_IDX, -1    , BV_IDX, BV_IDX, GV_IDX, -1    , BV_IDX,
  717.     RV_IDX, -1    , GV_IDX, RV_IDX, RV_IDX, -1    , GV_IDX, RV_IDX,
  718.     RV_IDX, GV_IDX, -1    , RV_IDX, RV_IDX, GV_IDX, -1    , RV_IDX,
  719.     BV_IDX, -1    , GV_IDX, BV_IDX, BV_IDX, -1    , GV_IDX, BV_IDX,
  720.     RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX,
  721.     BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX,
  722.     GY_IDX, -1    , GY_IDX, -1    , GY_IDX, -1    , GY_IDX, -1    ,
  723.     -1    , GY_IDX, -1    , GY_IDX, -1    , GY_IDX, -1    , GY_IDX,
  724.     RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX,
  725.     BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX,
  726.     GU_IDX, -1    , GU_IDX, -1    , GU_IDX, -1    , GU_IDX, -1    ,
  727.     -1    , GU_IDX, -1    , GU_IDX, -1    , GU_IDX, -1    , GU_IDX,
  728.     RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX,
  729.     BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX,
  730.     GV_IDX, -1    , GV_IDX, -1    , GV_IDX, -1    , GV_IDX, -1    ,
  731.     -1    , GV_IDX, -1    , GV_IDX, -1    , GV_IDX, -1    , GV_IDX, //23
  732.     -1    , -1    , -1    , -1    , -1    , -1    , -1    , -1    , //24
  733.     -1    , -1    , -1    , -1    , -1    , -1    , -1    , -1    , //25
  734.     -1    , -1    , -1    , -1    , -1    , -1    , -1    , -1    , //26
  735.     -1    , -1    , -1    , -1    , -1    , -1    , -1    , -1    , //27
  736.     -1    , -1    , -1    , -1    , -1    , -1    , -1    , -1    , //28
  737.     -1    , -1    , -1    , -1    , -1    , -1    , -1    , -1    , //29
  738.     -1    , -1    , -1    , -1    , -1    , -1    , -1    , -1    , //30
  739.     -1    , -1    , -1    , -1    , -1    , -1    , -1    , -1    , //31
  740.     BY_IDX, GY_IDX, RY_IDX, -1    , -1    , -1    , -1    , -1    , //32
  741.     BU_IDX, GU_IDX, RU_IDX, -1    , -1    , -1    , -1    , -1    , //33
  742.     BV_IDX, GV_IDX, RV_IDX, -1    , -1    , -1    , -1    , -1    , //34
  743.     };
  744.  
  745.     dstRange = 0; //FIXME range = 1 is handled elsewhere
  746.  
  747.     if (!dstRange) {
  748.         cy = cy * 255 / 219;
  749.     } else {
  750.         vr = vr * 224 / 255;
  751.         ub = ub * 224 / 255;
  752.         ug = ug * 224 / 255;
  753.         vg = vg * 224 / 255;
  754.     }
  755.     W = ROUNDED_DIV(ONE*ONE*ug, ub);
  756.     V = ROUNDED_DIV(ONE*ONE*vg, vr);
  757.     Z = ONE*ONE-W-V;
  758.  
  759.     Cy = ROUNDED_DIV(cy*Z, ONE);
  760.     Cu = ROUNDED_DIV(ub*Z, ONE);
  761.     Cv = ROUNDED_DIV(vr*Z, ONE);
  762.  
  763.     c->input_rgb2yuv_table[RY_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*V        , Cy);
  764.     c->input_rgb2yuv_table[GY_IDX] =  ROUNDED_DIV((1 << RGB2YUV_SHIFT)*ONE*ONE  , Cy);
  765.     c->input_rgb2yuv_table[BY_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*W        , Cy);
  766.  
  767.     c->input_rgb2yuv_table[RU_IDX] =  ROUNDED_DIV((1 << RGB2YUV_SHIFT)*V        , Cu);
  768.     c->input_rgb2yuv_table[GU_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*ONE*ONE  , Cu);
  769.     c->input_rgb2yuv_table[BU_IDX] =  ROUNDED_DIV((1 << RGB2YUV_SHIFT)*(Z+W)    , Cu);
  770.  
  771.     c->input_rgb2yuv_table[RV_IDX] =  ROUNDED_DIV((1 << RGB2YUV_SHIFT)*(V+Z)    , Cv);
  772.     c->input_rgb2yuv_table[GV_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*ONE*ONE  , Cv);
  773.     c->input_rgb2yuv_table[BV_IDX] =  ROUNDED_DIV((1 << RGB2YUV_SHIFT)*W        , Cv);
  774.  
  775.     if(/*!dstRange && */!memcmp(table, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], sizeof(ff_yuv2rgb_coeffs[SWS_CS_DEFAULT]))) {
  776.         c->input_rgb2yuv_table[BY_IDX] =  ((int)(0.114 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
  777.         c->input_rgb2yuv_table[BV_IDX] = (-(int)(0.081 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
  778.         c->input_rgb2yuv_table[BU_IDX] =  ((int)(0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
  779.         c->input_rgb2yuv_table[GY_IDX] =  ((int)(0.587 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
  780.         c->input_rgb2yuv_table[GV_IDX] = (-(int)(0.419 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
  781.         c->input_rgb2yuv_table[GU_IDX] = (-(int)(0.331 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
  782.         c->input_rgb2yuv_table[RY_IDX] =  ((int)(0.299 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
  783.         c->input_rgb2yuv_table[RV_IDX] =  ((int)(0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
  784.         c->input_rgb2yuv_table[RU_IDX] = (-(int)(0.169 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
  785.     }
  786.     for(i=0; i<FF_ARRAY_ELEMS(map); i++)
  787.         AV_WL16(p + 16*4 + 2*i, map[i] >= 0 ? c->input_rgb2yuv_table[map[i]] : 0);
  788. }
  789.  
  790. static void fill_xyztables(struct SwsContext *c)
  791. {
  792.     int i;
  793.     double xyzgamma = XYZ_GAMMA;
  794.     double rgbgamma = 1.0 / RGB_GAMMA;
  795.     double xyzgammainv = 1.0 / XYZ_GAMMA;
  796.     double rgbgammainv = RGB_GAMMA;
  797.     static const int16_t xyz2rgb_matrix[3][4] = {
  798.         {13270, -6295, -2041},
  799.         {-3969,  7682,   170},
  800.         {  228,  -835,  4329} };
  801.     static const int16_t rgb2xyz_matrix[3][4] = {
  802.         {1689, 1464,  739},
  803.         { 871, 2929,  296},
  804.         {  79,  488, 3891} };
  805.     static int16_t xyzgamma_tab[4096], rgbgamma_tab[4096], xyzgammainv_tab[4096], rgbgammainv_tab[4096];
  806.  
  807.     memcpy(c->xyz2rgb_matrix, xyz2rgb_matrix, sizeof(c->xyz2rgb_matrix));
  808.     memcpy(c->rgb2xyz_matrix, rgb2xyz_matrix, sizeof(c->rgb2xyz_matrix));
  809.     c->xyzgamma = xyzgamma_tab;
  810.     c->rgbgamma = rgbgamma_tab;
  811.     c->xyzgammainv = xyzgammainv_tab;
  812.     c->rgbgammainv = rgbgammainv_tab;
  813.  
  814.     if (rgbgamma_tab[4095])
  815.         return;
  816.  
  817.     /* set gamma vectors */
  818.     for (i = 0; i < 4096; i++) {
  819.         xyzgamma_tab[i] = lrint(pow(i / 4095.0, xyzgamma) * 4095.0);
  820.         rgbgamma_tab[i] = lrint(pow(i / 4095.0, rgbgamma) * 4095.0);
  821.         xyzgammainv_tab[i] = lrint(pow(i / 4095.0, xyzgammainv) * 4095.0);
  822.         rgbgammainv_tab[i] = lrint(pow(i / 4095.0, rgbgammainv) * 4095.0);
  823.     }
  824. }
  825.  
  826. int sws_setColorspaceDetails(struct SwsContext *c, const int inv_table[4],
  827.                              int srcRange, const int table[4], int dstRange,
  828.                              int brightness, int contrast, int saturation)
  829. {
  830.     const AVPixFmtDescriptor *desc_dst;
  831.     const AVPixFmtDescriptor *desc_src;
  832.     int need_reinit = 0;
  833.  
  834.     handle_formats(c);
  835.     desc_dst = av_pix_fmt_desc_get(c->dstFormat);
  836.     desc_src = av_pix_fmt_desc_get(c->srcFormat);
  837.  
  838.     if(!isYUV(c->dstFormat) && !isGray(c->dstFormat))
  839.         dstRange = 0;
  840.     if(!isYUV(c->srcFormat) && !isGray(c->srcFormat))
  841.         srcRange = 0;
  842.  
  843.     if (c->srcRange != srcRange ||
  844.         c->dstRange != dstRange ||
  845.         c->brightness != brightness ||
  846.         c->contrast   != contrast ||
  847.         c->saturation != saturation ||
  848.         memcmp(c->srcColorspaceTable, inv_table, sizeof(int) * 4) ||
  849.         memcmp(c->dstColorspaceTable,     table, sizeof(int) * 4)
  850.     )
  851.         need_reinit = 1;
  852.  
  853.     memmove(c->srcColorspaceTable, inv_table, sizeof(int) * 4);
  854.     memmove(c->dstColorspaceTable, table, sizeof(int) * 4);
  855.  
  856.  
  857.  
  858.     c->brightness = brightness;
  859.     c->contrast   = contrast;
  860.     c->saturation = saturation;
  861.     c->srcRange   = srcRange;
  862.     c->dstRange   = dstRange;
  863.  
  864.     //The srcBpc check is possibly wrong but we seem to lack a definitive reference to test this
  865.     //and what we have in ticket 2939 looks better with this check
  866.     if (need_reinit && (c->srcBpc == 8 || !isYUV(c->srcFormat)))
  867.         ff_sws_init_range_convert(c);
  868.  
  869.     c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
  870.     c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
  871.  
  872.     if (c->cascaded_context[0])
  873.         return sws_setColorspaceDetails(c->cascaded_context[0],inv_table, srcRange,table, dstRange, brightness,  contrast, saturation);
  874.  
  875.     if (!need_reinit)
  876.         return 0;
  877.  
  878.     if ((isYUV(c->dstFormat) || isGray(c->dstFormat)) && (isYUV(c->srcFormat) || isGray(c->srcFormat))) {
  879.         if (!c->cascaded_context[0] &&
  880.             memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4) &&
  881.             c->srcW && c->srcH && c->dstW && c->dstH) {
  882.             enum AVPixelFormat tmp_format;
  883.             int tmp_width, tmp_height;
  884.             int srcW = c->srcW;
  885.             int srcH = c->srcH;
  886.             int dstW = c->dstW;
  887.             int dstH = c->dstH;
  888.             int ret;
  889.             av_log(c, AV_LOG_VERBOSE, "YUV color matrix differs for YUV->YUV, using intermediate RGB to convert\n");
  890.  
  891.             if (isNBPS(c->dstFormat) || is16BPS(c->dstFormat)) {
  892.                 if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
  893.                     tmp_format = AV_PIX_FMT_BGRA64;
  894.                 } else {
  895.                     tmp_format = AV_PIX_FMT_BGR48;
  896.                 }
  897.             } else {
  898.                 if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
  899.                     tmp_format = AV_PIX_FMT_BGRA;
  900.                 } else {
  901.                     tmp_format = AV_PIX_FMT_BGR24;
  902.                 }
  903.             }
  904.  
  905.             if (srcW*srcH > dstW*dstH) {
  906.                 tmp_width  = dstW;
  907.                 tmp_height = dstH;
  908.             } else {
  909.                 tmp_width  = srcW;
  910.                 tmp_height = srcH;
  911.             }
  912.  
  913.             ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
  914.                                 tmp_width, tmp_height, tmp_format, 64);
  915.             if (ret < 0)
  916.                 return ret;
  917.  
  918.             c->cascaded_context[0] = sws_alloc_set_opts(srcW, srcH, c->srcFormat,
  919.                                                         tmp_width, tmp_height, tmp_format,
  920.                                                         c->flags, c->param);
  921.             if (!c->cascaded_context[0])
  922.                 return -1;
  923.  
  924.             c->cascaded_context[0]->alphablend = c->alphablend;
  925.             ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
  926.             if (ret < 0)
  927.                 return ret;
  928.             //we set both src and dst depending on that the RGB side will be ignored
  929.             sws_setColorspaceDetails(c->cascaded_context[0], inv_table,
  930.                                      srcRange, table, dstRange,
  931.                                      brightness, contrast, saturation);
  932.  
  933.             c->cascaded_context[1] = sws_getContext(tmp_width, tmp_height, tmp_format,
  934.                                                     dstW, dstH, c->dstFormat,
  935.                                                     c->flags, NULL, NULL, c->param);
  936.             if (!c->cascaded_context[1])
  937.                 return -1;
  938.             sws_setColorspaceDetails(c->cascaded_context[1], inv_table,
  939.                                      srcRange, table, dstRange,
  940.                                      0, 1 << 16, 1 << 16);
  941.             return 0;
  942.         }
  943.         return -1;
  944.     }
  945.  
  946.     if (!isYUV(c->dstFormat) && !isGray(c->dstFormat)) {
  947.         ff_yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness,
  948.                                  contrast, saturation);
  949.         // FIXME factorize
  950.  
  951.         if (ARCH_PPC)
  952.             ff_yuv2rgb_init_tables_ppc(c, inv_table, brightness,
  953.                                        contrast, saturation);
  954.     }
  955.  
  956.     fill_rgb2yuv_table(c, table, dstRange);
  957.  
  958.     return 0;
  959. }
  960.  
  961. int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table,
  962.                              int *srcRange, int **table, int *dstRange,
  963.                              int *brightness, int *contrast, int *saturation)
  964. {
  965.     if (!c )
  966.         return -1;
  967.  
  968.     *inv_table  = c->srcColorspaceTable;
  969.     *table      = c->dstColorspaceTable;
  970.     *srcRange   = c->srcRange;
  971.     *dstRange   = c->dstRange;
  972.     *brightness = c->brightness;
  973.     *contrast   = c->contrast;
  974.     *saturation = c->saturation;
  975.  
  976.     return 0;
  977. }
  978.  
  979. static int handle_jpeg(enum AVPixelFormat *format)
  980. {
  981.     switch (*format) {
  982.     case AV_PIX_FMT_YUVJ420P:
  983.         *format = AV_PIX_FMT_YUV420P;
  984.         return 1;
  985.     case AV_PIX_FMT_YUVJ411P:
  986.         *format = AV_PIX_FMT_YUV411P;
  987.         return 1;
  988.     case AV_PIX_FMT_YUVJ422P:
  989.         *format = AV_PIX_FMT_YUV422P;
  990.         return 1;
  991.     case AV_PIX_FMT_YUVJ444P:
  992.         *format = AV_PIX_FMT_YUV444P;
  993.         return 1;
  994.     case AV_PIX_FMT_YUVJ440P:
  995.         *format = AV_PIX_FMT_YUV440P;
  996.         return 1;
  997.     case AV_PIX_FMT_GRAY8:
  998.     case AV_PIX_FMT_GRAY16LE:
  999.     case AV_PIX_FMT_GRAY16BE:
  1000.         return 1;
  1001.     default:
  1002.         return 0;
  1003.     }
  1004. }
  1005.  
  1006. static int handle_0alpha(enum AVPixelFormat *format)
  1007. {
  1008.     switch (*format) {
  1009.     case AV_PIX_FMT_0BGR    : *format = AV_PIX_FMT_ABGR   ; return 1;
  1010.     case AV_PIX_FMT_BGR0    : *format = AV_PIX_FMT_BGRA   ; return 4;
  1011.     case AV_PIX_FMT_0RGB    : *format = AV_PIX_FMT_ARGB   ; return 1;
  1012.     case AV_PIX_FMT_RGB0    : *format = AV_PIX_FMT_RGBA   ; return 4;
  1013.     default:                                          return 0;
  1014.     }
  1015. }
  1016.  
  1017. static int handle_xyz(enum AVPixelFormat *format)
  1018. {
  1019.     switch (*format) {
  1020.     case AV_PIX_FMT_XYZ12BE : *format = AV_PIX_FMT_RGB48BE; return 1;
  1021.     case AV_PIX_FMT_XYZ12LE : *format = AV_PIX_FMT_RGB48LE; return 1;
  1022.     default:                                                return 0;
  1023.     }
  1024. }
  1025.  
  1026. static void handle_formats(SwsContext *c)
  1027. {
  1028.     c->src0Alpha |= handle_0alpha(&c->srcFormat);
  1029.     c->dst0Alpha |= handle_0alpha(&c->dstFormat);
  1030.     c->srcXYZ    |= handle_xyz(&c->srcFormat);
  1031.     c->dstXYZ    |= handle_xyz(&c->dstFormat);
  1032.     if (c->srcXYZ || c->dstXYZ)
  1033.         fill_xyztables(c);
  1034. }
  1035.  
  1036. SwsContext *sws_alloc_context(void)
  1037. {
  1038.     SwsContext *c = av_mallocz(sizeof(SwsContext));
  1039.  
  1040.     av_assert0(offsetof(SwsContext, redDither) + DITHER32_INT == offsetof(SwsContext, dither32));
  1041.  
  1042.     if (c) {
  1043.         c->av_class = &sws_context_class;
  1044.         av_opt_set_defaults(c);
  1045.     }
  1046.  
  1047.     return c;
  1048. }
  1049.  
  1050. static uint16_t * alloc_gamma_tbl(double e)
  1051. {
  1052.     int i = 0;
  1053.     uint16_t * tbl;
  1054.     tbl = (uint16_t*)av_malloc(sizeof(uint16_t) * 1 << 16);
  1055.     if (!tbl)
  1056.         return NULL;
  1057.  
  1058.     for (i = 0; i < 65536; ++i) {
  1059.         tbl[i] = pow(i / 65535.0, e) * 65535.0;
  1060.     }
  1061.     return tbl;
  1062. }
  1063.  
  1064. static enum AVPixelFormat alphaless_fmt(enum AVPixelFormat fmt)
  1065. {
  1066.     switch(fmt) {
  1067.     case AV_PIX_FMT_ARGB:       return AV_PIX_FMT_RGB24;
  1068.     case AV_PIX_FMT_RGBA:       return AV_PIX_FMT_RGB24;
  1069.     case AV_PIX_FMT_ABGR:       return AV_PIX_FMT_BGR24;
  1070.     case AV_PIX_FMT_BGRA:       return AV_PIX_FMT_BGR24;
  1071.     case AV_PIX_FMT_YA8:        return AV_PIX_FMT_GRAY8;
  1072.  
  1073.     case AV_PIX_FMT_YUVA420P:   return AV_PIX_FMT_YUV420P;
  1074.     case AV_PIX_FMT_YUVA422P:   return AV_PIX_FMT_YUV422P;
  1075.     case AV_PIX_FMT_YUVA444P:           return AV_PIX_FMT_YUV444P;
  1076.  
  1077.     case AV_PIX_FMT_GBRAP:              return AV_PIX_FMT_GBRP;
  1078.  
  1079.     case AV_PIX_FMT_GBRAP16LE:          return AV_PIX_FMT_GBRP16;
  1080.     case AV_PIX_FMT_GBRAP16BE:          return AV_PIX_FMT_GBRP16;
  1081.  
  1082.     case AV_PIX_FMT_RGBA64LE:   return AV_PIX_FMT_RGB48;
  1083.     case AV_PIX_FMT_RGBA64BE:   return AV_PIX_FMT_RGB48;
  1084.     case AV_PIX_FMT_BGRA64LE:   return AV_PIX_FMT_BGR48;
  1085.     case AV_PIX_FMT_BGRA64BE:   return AV_PIX_FMT_BGR48;
  1086.  
  1087.     case AV_PIX_FMT_YA16BE:             return AV_PIX_FMT_GRAY16;
  1088.     case AV_PIX_FMT_YA16LE:             return AV_PIX_FMT_GRAY16;
  1089.  
  1090.     case AV_PIX_FMT_YUVA420P9BE:        return AV_PIX_FMT_YUV420P9;
  1091.     case AV_PIX_FMT_YUVA422P9BE:        return AV_PIX_FMT_YUV422P9;
  1092.     case AV_PIX_FMT_YUVA444P9BE:        return AV_PIX_FMT_YUV444P9;
  1093.     case AV_PIX_FMT_YUVA420P9LE:        return AV_PIX_FMT_YUV420P9;
  1094.     case AV_PIX_FMT_YUVA422P9LE:        return AV_PIX_FMT_YUV422P9;
  1095.     case AV_PIX_FMT_YUVA444P9LE:        return AV_PIX_FMT_YUV444P9;
  1096.     case AV_PIX_FMT_YUVA420P10BE:       return AV_PIX_FMT_YUV420P10;
  1097.     case AV_PIX_FMT_YUVA422P10BE:       return AV_PIX_FMT_YUV422P10;
  1098.     case AV_PIX_FMT_YUVA444P10BE:       return AV_PIX_FMT_YUV444P10;
  1099.     case AV_PIX_FMT_YUVA420P10LE:       return AV_PIX_FMT_YUV420P10;
  1100.     case AV_PIX_FMT_YUVA422P10LE:       return AV_PIX_FMT_YUV422P10;
  1101.     case AV_PIX_FMT_YUVA444P10LE:       return AV_PIX_FMT_YUV444P10;
  1102.     case AV_PIX_FMT_YUVA420P16BE:       return AV_PIX_FMT_YUV420P16;
  1103.     case AV_PIX_FMT_YUVA422P16BE:       return AV_PIX_FMT_YUV422P16;
  1104.     case AV_PIX_FMT_YUVA444P16BE:       return AV_PIX_FMT_YUV444P16;
  1105.     case AV_PIX_FMT_YUVA420P16LE:       return AV_PIX_FMT_YUV420P16;
  1106.     case AV_PIX_FMT_YUVA422P16LE:       return AV_PIX_FMT_YUV422P16;
  1107.     case AV_PIX_FMT_YUVA444P16LE:       return AV_PIX_FMT_YUV444P16;
  1108.  
  1109. //     case AV_PIX_FMT_AYUV64LE:
  1110. //     case AV_PIX_FMT_AYUV64BE:
  1111. //     case AV_PIX_FMT_PAL8:
  1112.     default: return AV_PIX_FMT_NONE;
  1113.     }
  1114. }
  1115.  
  1116. av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter,
  1117.                              SwsFilter *dstFilter)
  1118. {
  1119.     int i, j;
  1120.     int usesVFilter, usesHFilter;
  1121.     int unscaled;
  1122.     SwsFilter dummyFilter = { NULL, NULL, NULL, NULL };
  1123.     int srcW              = c->srcW;
  1124.     int srcH              = c->srcH;
  1125.     int dstW              = c->dstW;
  1126.     int dstH              = c->dstH;
  1127.     int dst_stride        = FFALIGN(dstW * sizeof(int16_t) + 66, 16);
  1128.     int flags, cpu_flags;
  1129.     enum AVPixelFormat srcFormat = c->srcFormat;
  1130.     enum AVPixelFormat dstFormat = c->dstFormat;
  1131.     const AVPixFmtDescriptor *desc_src;
  1132.     const AVPixFmtDescriptor *desc_dst;
  1133.     int ret = 0;
  1134.     enum AVPixelFormat tmpFmt;
  1135.  
  1136.     cpu_flags = av_get_cpu_flags();
  1137.     flags     = c->flags;
  1138.     emms_c();
  1139.     if (!rgb15to16)
  1140.         sws_rgb2rgb_init();
  1141.  
  1142.     unscaled = (srcW == dstW && srcH == dstH);
  1143.  
  1144.     c->srcRange |= handle_jpeg(&c->srcFormat);
  1145.     c->dstRange |= handle_jpeg(&c->dstFormat);
  1146.  
  1147.     if(srcFormat!=c->srcFormat || dstFormat!=c->dstFormat)
  1148.         av_log(c, AV_LOG_WARNING, "deprecated pixel format used, make sure you did set range correctly\n");
  1149.  
  1150.     if (!c->contrast && !c->saturation && !c->dstFormatBpp)
  1151.         sws_setColorspaceDetails(c, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], c->srcRange,
  1152.                                  ff_yuv2rgb_coeffs[SWS_CS_DEFAULT],
  1153.                                  c->dstRange, 0, 1 << 16, 1 << 16);
  1154.  
  1155.     handle_formats(c);
  1156.     srcFormat = c->srcFormat;
  1157.     dstFormat = c->dstFormat;
  1158.     desc_src = av_pix_fmt_desc_get(srcFormat);
  1159.     desc_dst = av_pix_fmt_desc_get(dstFormat);
  1160.  
  1161.     if (!(unscaled && sws_isSupportedEndiannessConversion(srcFormat) &&
  1162.           av_pix_fmt_swap_endianness(srcFormat) == dstFormat)) {
  1163.     if (!sws_isSupportedInput(srcFormat)) {
  1164.         av_log(c, AV_LOG_ERROR, "%s is not supported as input pixel format\n",
  1165.                av_get_pix_fmt_name(srcFormat));
  1166.         return AVERROR(EINVAL);
  1167.     }
  1168.     if (!sws_isSupportedOutput(dstFormat)) {
  1169.         av_log(c, AV_LOG_ERROR, "%s is not supported as output pixel format\n",
  1170.                av_get_pix_fmt_name(dstFormat));
  1171.         return AVERROR(EINVAL);
  1172.     }
  1173.     }
  1174.     av_assert2(desc_src && desc_dst);
  1175.  
  1176.     i = flags & (SWS_POINT         |
  1177.                  SWS_AREA          |
  1178.                  SWS_BILINEAR      |
  1179.                  SWS_FAST_BILINEAR |
  1180.                  SWS_BICUBIC       |
  1181.                  SWS_X             |
  1182.                  SWS_GAUSS         |
  1183.                  SWS_LANCZOS       |
  1184.                  SWS_SINC          |
  1185.                  SWS_SPLINE        |
  1186.                  SWS_BICUBLIN);
  1187.  
  1188.     /* provide a default scaler if not set by caller */
  1189.     if (!i) {
  1190.         if (dstW < srcW && dstH < srcH)
  1191.             flags |= SWS_BICUBIC;
  1192.         else if (dstW > srcW && dstH > srcH)
  1193.             flags |= SWS_BICUBIC;
  1194.         else
  1195.             flags |= SWS_BICUBIC;
  1196.         c->flags = flags;
  1197.     } else if (i & (i - 1)) {
  1198.         av_log(c, AV_LOG_ERROR,
  1199.                "Exactly one scaler algorithm must be chosen, got %X\n", i);
  1200.         return AVERROR(EINVAL);
  1201.     }
  1202.     /* sanity check */
  1203.     if (srcW < 1 || srcH < 1 || dstW < 1 || dstH < 1) {
  1204.         /* FIXME check if these are enough and try to lower them after
  1205.          * fixing the relevant parts of the code */
  1206.         av_log(c, AV_LOG_ERROR, "%dx%d -> %dx%d is invalid scaling dimension\n",
  1207.                srcW, srcH, dstW, dstH);
  1208.         return AVERROR(EINVAL);
  1209.     }
  1210.     if (flags & SWS_FAST_BILINEAR) {
  1211.         if (srcW < 8 || dstW < 8) {
  1212.             flags ^= SWS_FAST_BILINEAR | SWS_BILINEAR;
  1213.             c->flags = flags;
  1214.         }
  1215.     }
  1216.  
  1217.     if (!dstFilter)
  1218.         dstFilter = &dummyFilter;
  1219.     if (!srcFilter)
  1220.         srcFilter = &dummyFilter;
  1221.  
  1222.     c->lumXInc      = (((int64_t)srcW << 16) + (dstW >> 1)) / dstW;
  1223.     c->lumYInc      = (((int64_t)srcH << 16) + (dstH >> 1)) / dstH;
  1224.     c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
  1225.     c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
  1226.     c->vRounder     = 4 * 0x0001000100010001ULL;
  1227.  
  1228.     usesVFilter = (srcFilter->lumV && srcFilter->lumV->length > 1) ||
  1229.                   (srcFilter->chrV && srcFilter->chrV->length > 1) ||
  1230.                   (dstFilter->lumV && dstFilter->lumV->length > 1) ||
  1231.                   (dstFilter->chrV && dstFilter->chrV->length > 1);
  1232.     usesHFilter = (srcFilter->lumH && srcFilter->lumH->length > 1) ||
  1233.                   (srcFilter->chrH && srcFilter->chrH->length > 1) ||
  1234.                   (dstFilter->lumH && dstFilter->lumH->length > 1) ||
  1235.                   (dstFilter->chrH && dstFilter->chrH->length > 1);
  1236.  
  1237.     av_pix_fmt_get_chroma_sub_sample(srcFormat, &c->chrSrcHSubSample, &c->chrSrcVSubSample);
  1238.     av_pix_fmt_get_chroma_sub_sample(dstFormat, &c->chrDstHSubSample, &c->chrDstVSubSample);
  1239.  
  1240.     if (isAnyRGB(dstFormat) && !(flags&SWS_FULL_CHR_H_INT)) {
  1241.         if (dstW&1) {
  1242.             av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to odd output size\n");
  1243.             flags |= SWS_FULL_CHR_H_INT;
  1244.             c->flags = flags;
  1245.         }
  1246.  
  1247.         if (   c->chrSrcHSubSample == 0
  1248.             && c->chrSrcVSubSample == 0
  1249.             && c->dither != SWS_DITHER_BAYER //SWS_FULL_CHR_H_INT is currently not supported with SWS_DITHER_BAYER
  1250.             && !(c->flags & SWS_FAST_BILINEAR)
  1251.         ) {
  1252.             av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to input having non subsampled chroma\n");
  1253.             flags |= SWS_FULL_CHR_H_INT;
  1254.             c->flags = flags;
  1255.         }
  1256.     }
  1257.  
  1258.     if (c->dither == SWS_DITHER_AUTO) {
  1259.         if (flags & SWS_ERROR_DIFFUSION)
  1260.             c->dither = SWS_DITHER_ED;
  1261.     }
  1262.  
  1263.     if(dstFormat == AV_PIX_FMT_BGR4_BYTE ||
  1264.        dstFormat == AV_PIX_FMT_RGB4_BYTE ||
  1265.        dstFormat == AV_PIX_FMT_BGR8 ||
  1266.        dstFormat == AV_PIX_FMT_RGB8) {
  1267.         if (c->dither == SWS_DITHER_AUTO)
  1268.             c->dither = (flags & SWS_FULL_CHR_H_INT) ? SWS_DITHER_ED : SWS_DITHER_BAYER;
  1269.         if (!(flags & SWS_FULL_CHR_H_INT)) {
  1270.             if (c->dither == SWS_DITHER_ED || c->dither == SWS_DITHER_A_DITHER || c->dither == SWS_DITHER_X_DITHER) {
  1271.                 av_log(c, AV_LOG_DEBUG,
  1272.                     "Desired dithering only supported in full chroma interpolation for destination format '%s'\n",
  1273.                     av_get_pix_fmt_name(dstFormat));
  1274.                 flags   |= SWS_FULL_CHR_H_INT;
  1275.                 c->flags = flags;
  1276.             }
  1277.         }
  1278.         if (flags & SWS_FULL_CHR_H_INT) {
  1279.             if (c->dither == SWS_DITHER_BAYER) {
  1280.                 av_log(c, AV_LOG_DEBUG,
  1281.                     "Ordered dither is not supported in full chroma interpolation for destination format '%s'\n",
  1282.                     av_get_pix_fmt_name(dstFormat));
  1283.                 c->dither = SWS_DITHER_ED;
  1284.             }
  1285.         }
  1286.     }
  1287.     if (isPlanarRGB(dstFormat)) {
  1288.         if (!(flags & SWS_FULL_CHR_H_INT)) {
  1289.             av_log(c, AV_LOG_DEBUG,
  1290.                    "%s output is not supported with half chroma resolution, switching to full\n",
  1291.                    av_get_pix_fmt_name(dstFormat));
  1292.             flags   |= SWS_FULL_CHR_H_INT;
  1293.             c->flags = flags;
  1294.         }
  1295.     }
  1296.  
  1297.     /* reuse chroma for 2 pixels RGB/BGR unless user wants full
  1298.      * chroma interpolation */
  1299.     if (flags & SWS_FULL_CHR_H_INT &&
  1300.         isAnyRGB(dstFormat)        &&
  1301.         !isPlanarRGB(dstFormat)    &&
  1302.         dstFormat != AV_PIX_FMT_RGBA64LE &&
  1303.         dstFormat != AV_PIX_FMT_RGBA64BE &&
  1304.         dstFormat != AV_PIX_FMT_BGRA64LE &&
  1305.         dstFormat != AV_PIX_FMT_BGRA64BE &&
  1306.         dstFormat != AV_PIX_FMT_RGB48LE &&
  1307.         dstFormat != AV_PIX_FMT_RGB48BE &&
  1308.         dstFormat != AV_PIX_FMT_BGR48LE &&
  1309.         dstFormat != AV_PIX_FMT_BGR48BE &&
  1310.         dstFormat != AV_PIX_FMT_RGBA  &&
  1311.         dstFormat != AV_PIX_FMT_ARGB  &&
  1312.         dstFormat != AV_PIX_FMT_BGRA  &&
  1313.         dstFormat != AV_PIX_FMT_ABGR  &&
  1314.         dstFormat != AV_PIX_FMT_RGB24 &&
  1315.         dstFormat != AV_PIX_FMT_BGR24 &&
  1316.         dstFormat != AV_PIX_FMT_BGR4_BYTE &&
  1317.         dstFormat != AV_PIX_FMT_RGB4_BYTE &&
  1318.         dstFormat != AV_PIX_FMT_BGR8 &&
  1319.         dstFormat != AV_PIX_FMT_RGB8
  1320.     ) {
  1321.         av_log(c, AV_LOG_WARNING,
  1322.                "full chroma interpolation for destination format '%s' not yet implemented\n",
  1323.                av_get_pix_fmt_name(dstFormat));
  1324.         flags   &= ~SWS_FULL_CHR_H_INT;
  1325.         c->flags = flags;
  1326.     }
  1327.     if (isAnyRGB(dstFormat) && !(flags & SWS_FULL_CHR_H_INT))
  1328.         c->chrDstHSubSample = 1;
  1329.  
  1330.     // drop some chroma lines if the user wants it
  1331.     c->vChrDrop          = (flags & SWS_SRC_V_CHR_DROP_MASK) >>
  1332.                            SWS_SRC_V_CHR_DROP_SHIFT;
  1333.     c->chrSrcVSubSample += c->vChrDrop;
  1334.  
  1335.     /* drop every other pixel for chroma calculation unless user
  1336.      * wants full chroma */
  1337.     if (isAnyRGB(srcFormat) && !(flags & SWS_FULL_CHR_H_INP)   &&
  1338.         srcFormat != AV_PIX_FMT_RGB8 && srcFormat != AV_PIX_FMT_BGR8 &&
  1339.         srcFormat != AV_PIX_FMT_RGB4 && srcFormat != AV_PIX_FMT_BGR4 &&
  1340.         srcFormat != AV_PIX_FMT_RGB4_BYTE && srcFormat != AV_PIX_FMT_BGR4_BYTE &&
  1341.         srcFormat != AV_PIX_FMT_GBRP9BE   && srcFormat != AV_PIX_FMT_GBRP9LE  &&
  1342.         srcFormat != AV_PIX_FMT_GBRP10BE  && srcFormat != AV_PIX_FMT_GBRP10LE &&
  1343.         srcFormat != AV_PIX_FMT_GBRP12BE  && srcFormat != AV_PIX_FMT_GBRP12LE &&
  1344.         srcFormat != AV_PIX_FMT_GBRP14BE  && srcFormat != AV_PIX_FMT_GBRP14LE &&
  1345.         srcFormat != AV_PIX_FMT_GBRP16BE  && srcFormat != AV_PIX_FMT_GBRP16LE &&
  1346.         ((dstW >> c->chrDstHSubSample) <= (srcW >> 1) ||
  1347.          (flags & SWS_FAST_BILINEAR)))
  1348.         c->chrSrcHSubSample = 1;
  1349.  
  1350.     // Note the FF_CEIL_RSHIFT is so that we always round toward +inf.
  1351.     c->chrSrcW = FF_CEIL_RSHIFT(srcW, c->chrSrcHSubSample);
  1352.     c->chrSrcH = FF_CEIL_RSHIFT(srcH, c->chrSrcVSubSample);
  1353.     c->chrDstW = FF_CEIL_RSHIFT(dstW, c->chrDstHSubSample);
  1354.     c->chrDstH = FF_CEIL_RSHIFT(dstH, c->chrDstVSubSample);
  1355.  
  1356.     FF_ALLOCZ_OR_GOTO(c, c->formatConvBuffer, FFALIGN(srcW*2+78, 16) * 2, fail);
  1357.  
  1358.     c->srcBpc = 1 + desc_src->comp[0].depth_minus1;
  1359.     if (c->srcBpc < 8)
  1360.         c->srcBpc = 8;
  1361.     c->dstBpc = 1 + desc_dst->comp[0].depth_minus1;
  1362.     if (c->dstBpc < 8)
  1363.         c->dstBpc = 8;
  1364.     if (isAnyRGB(srcFormat) || srcFormat == AV_PIX_FMT_PAL8)
  1365.         c->srcBpc = 16;
  1366.     if (c->dstBpc == 16)
  1367.         dst_stride <<= 1;
  1368.  
  1369.     if (INLINE_MMXEXT(cpu_flags) && c->srcBpc == 8 && c->dstBpc <= 14) {
  1370.         c->canMMXEXTBeUsed = dstW >= srcW && (dstW & 31) == 0 &&
  1371.                              c->chrDstW >= c->chrSrcW &&
  1372.                              (srcW & 15) == 0;
  1373.         if (!c->canMMXEXTBeUsed && dstW >= srcW && c->chrDstW >= c->chrSrcW && (srcW & 15) == 0
  1374.  
  1375.             && (flags & SWS_FAST_BILINEAR)) {
  1376.             if (flags & SWS_PRINT_INFO)
  1377.                 av_log(c, AV_LOG_INFO,
  1378.                        "output width is not a multiple of 32 -> no MMXEXT scaler\n");
  1379.         }
  1380.         if (usesHFilter || isNBPS(c->srcFormat) || is16BPS(c->srcFormat) || isAnyRGB(c->srcFormat))
  1381.             c->canMMXEXTBeUsed = 0;
  1382.     } else
  1383.         c->canMMXEXTBeUsed = 0;
  1384.  
  1385.     c->chrXInc = (((int64_t)c->chrSrcW << 16) + (c->chrDstW >> 1)) / c->chrDstW;
  1386.     c->chrYInc = (((int64_t)c->chrSrcH << 16) + (c->chrDstH >> 1)) / c->chrDstH;
  1387.  
  1388.     /* Match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src
  1389.      * to pixel n-2 of dst, but only for the FAST_BILINEAR mode otherwise do
  1390.      * correct scaling.
  1391.      * n-2 is the last chrominance sample available.
  1392.      * This is not perfect, but no one should notice the difference, the more
  1393.      * correct variant would be like the vertical one, but that would require
  1394.      * some special code for the first and last pixel */
  1395.     if (flags & SWS_FAST_BILINEAR) {
  1396.         if (c->canMMXEXTBeUsed) {
  1397.             c->lumXInc += 20;
  1398.             c->chrXInc += 20;
  1399.         }
  1400.         // we don't use the x86 asm scaler if MMX is available
  1401.         else if (INLINE_MMX(cpu_flags) && c->dstBpc <= 14) {
  1402.             c->lumXInc = ((int64_t)(srcW       - 2) << 16) / (dstW       - 2) - 20;
  1403.             c->chrXInc = ((int64_t)(c->chrSrcW - 2) << 16) / (c->chrDstW - 2) - 20;
  1404.         }
  1405.     }
  1406.  
  1407.     // hardcoded for now
  1408.     c->gamma_value = 2.2;
  1409.     tmpFmt = AV_PIX_FMT_RGBA64LE;
  1410.  
  1411.  
  1412.     if (!unscaled && c->gamma_flag && (srcFormat != tmpFmt || dstFormat != tmpFmt)) {
  1413.         SwsContext *c2;
  1414.         c->cascaded_context[0] = NULL;
  1415.  
  1416.         ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
  1417.                             srcW, srcH, tmpFmt, 64);
  1418.         if (ret < 0)
  1419.             return ret;
  1420.  
  1421.         c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
  1422.                                                 srcW, srcH, tmpFmt,
  1423.                                                 flags, NULL, NULL, c->param);
  1424.         if (!c->cascaded_context[0]) {
  1425.             return -1;
  1426.         }
  1427.  
  1428.         c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFmt,
  1429.                                                 dstW, dstH, tmpFmt,
  1430.                                                 flags, srcFilter, dstFilter, c->param);
  1431.  
  1432.         if (!c->cascaded_context[1])
  1433.             return -1;
  1434.  
  1435.         c2 = c->cascaded_context[1];
  1436.         c2->is_internal_gamma = 1;
  1437.         c2->gamma     = alloc_gamma_tbl(    c->gamma_value);
  1438.         c2->inv_gamma = alloc_gamma_tbl(1.f/c->gamma_value);
  1439.         if (!c2->gamma || !c2->inv_gamma)
  1440.             return AVERROR(ENOMEM);
  1441.  
  1442.         // is_internal_flag is set after creating the context
  1443.         // to properly create the gamma convert FilterDescriptor
  1444.         // we have to re-initialize it
  1445.         ff_free_filters(c2);
  1446.         if (ff_init_filters(c2) < 0) {
  1447.             sws_freeContext(c2);
  1448.             return -1;
  1449.         }
  1450.  
  1451.         c->cascaded_context[2] = NULL;
  1452.         if (dstFormat != tmpFmt) {
  1453.             ret = av_image_alloc(c->cascaded1_tmp, c->cascaded1_tmpStride,
  1454.                                 dstW, dstH, tmpFmt, 64);
  1455.             if (ret < 0)
  1456.                 return ret;
  1457.  
  1458.             c->cascaded_context[2] = sws_getContext(dstW, dstH, tmpFmt,
  1459.                                                 dstW, dstH, dstFormat,
  1460.                                                 flags, NULL, NULL, c->param);
  1461.             if (!c->cascaded_context[2])
  1462.                 return -1;
  1463.         }
  1464.         return 0;
  1465.     }
  1466.  
  1467.     if (isBayer(srcFormat)) {
  1468.         if (!unscaled ||
  1469.             (dstFormat != AV_PIX_FMT_RGB24 && dstFormat != AV_PIX_FMT_YUV420P)) {
  1470.             enum AVPixelFormat tmpFormat = AV_PIX_FMT_RGB24;
  1471.  
  1472.             ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
  1473.                                 srcW, srcH, tmpFormat, 64);
  1474.             if (ret < 0)
  1475.                 return ret;
  1476.  
  1477.             c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
  1478.                                                     srcW, srcH, tmpFormat,
  1479.                                                     flags, srcFilter, NULL, c->param);
  1480.             if (!c->cascaded_context[0])
  1481.                 return -1;
  1482.  
  1483.             c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFormat,
  1484.                                                     dstW, dstH, dstFormat,
  1485.                                                     flags, NULL, dstFilter, c->param);
  1486.             if (!c->cascaded_context[1])
  1487.                 return -1;
  1488.             return 0;
  1489.         }
  1490.     }
  1491.  
  1492.     if (CONFIG_SWSCALE_ALPHA && isALPHA(srcFormat) && !isALPHA(dstFormat)) {
  1493.         enum AVPixelFormat tmpFormat = alphaless_fmt(srcFormat);
  1494.  
  1495.         if (tmpFormat != AV_PIX_FMT_NONE && c->alphablend != SWS_ALPHA_BLEND_NONE)
  1496.         if (!unscaled ||
  1497.             dstFormat != tmpFormat ||
  1498.             usesHFilter || usesVFilter ||
  1499.             c->srcRange != c->dstRange
  1500.         ) {
  1501.             ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
  1502.                                 srcW, srcH, tmpFormat, 64);
  1503.             if (ret < 0)
  1504.                 return ret;
  1505.  
  1506.             c->cascaded_context[0] = sws_alloc_set_opts(srcW, srcH, srcFormat,
  1507.                                                         srcW, srcH, tmpFormat,
  1508.                                                         flags, c->param);
  1509.             if (!c->cascaded_context[0])
  1510.                 return -1;
  1511.             c->cascaded_context[0]->alphablend = c->alphablend;
  1512.             ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
  1513.             if (ret < 0)
  1514.                 return ret;
  1515.  
  1516.             c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFormat,
  1517.                                                     dstW, dstH, dstFormat,
  1518.                                                     flags, srcFilter, dstFilter, c->param);
  1519.             if (!c->cascaded_context[1])
  1520.                 return -1;
  1521.             return 0;
  1522.         }
  1523.     }
  1524.  
  1525. #define USE_MMAP (HAVE_MMAP && HAVE_MPROTECT && defined MAP_ANONYMOUS)
  1526.  
  1527.     /* precalculate horizontal scaler filter coefficients */
  1528.     {
  1529. #if HAVE_MMXEXT_INLINE
  1530. // can't downscale !!!
  1531.         if (c->canMMXEXTBeUsed && (flags & SWS_FAST_BILINEAR)) {
  1532.             c->lumMmxextFilterCodeSize = ff_init_hscaler_mmxext(dstW, c->lumXInc, NULL,
  1533.                                                              NULL, NULL, 8);
  1534.             c->chrMmxextFilterCodeSize = ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc,
  1535.                                                              NULL, NULL, NULL, 4);
  1536.  
  1537. #if USE_MMAP
  1538.             c->lumMmxextFilterCode = mmap(NULL, c->lumMmxextFilterCodeSize,
  1539.                                           PROT_READ | PROT_WRITE,
  1540.                                           MAP_PRIVATE | MAP_ANONYMOUS,
  1541.                                           -1, 0);
  1542.             c->chrMmxextFilterCode = mmap(NULL, c->chrMmxextFilterCodeSize,
  1543.                                           PROT_READ | PROT_WRITE,
  1544.                                           MAP_PRIVATE | MAP_ANONYMOUS,
  1545.                                           -1, 0);
  1546. #elif HAVE_VIRTUALALLOC
  1547.             c->lumMmxextFilterCode = VirtualAlloc(NULL,
  1548.                                                   c->lumMmxextFilterCodeSize,
  1549.                                                   MEM_COMMIT,
  1550.                                                   PAGE_EXECUTE_READWRITE);
  1551.             c->chrMmxextFilterCode = VirtualAlloc(NULL,
  1552.                                                   c->chrMmxextFilterCodeSize,
  1553.                                                   MEM_COMMIT,
  1554.                                                   PAGE_EXECUTE_READWRITE);
  1555. #else
  1556.             c->lumMmxextFilterCode = av_malloc(c->lumMmxextFilterCodeSize);
  1557.             c->chrMmxextFilterCode = av_malloc(c->chrMmxextFilterCodeSize);
  1558. #endif
  1559.  
  1560. #ifdef MAP_ANONYMOUS
  1561.             if (c->lumMmxextFilterCode == MAP_FAILED || c->chrMmxextFilterCode == MAP_FAILED)
  1562. #else
  1563.             if (!c->lumMmxextFilterCode || !c->chrMmxextFilterCode)
  1564. #endif
  1565.             {
  1566.                 av_log(c, AV_LOG_ERROR, "Failed to allocate MMX2FilterCode\n");
  1567.                 return AVERROR(ENOMEM);
  1568.             }
  1569.  
  1570.             FF_ALLOCZ_OR_GOTO(c, c->hLumFilter,    (dstW           / 8 + 8) * sizeof(int16_t), fail);
  1571.             FF_ALLOCZ_OR_GOTO(c, c->hChrFilter,    (c->chrDstW     / 4 + 8) * sizeof(int16_t), fail);
  1572.             FF_ALLOCZ_OR_GOTO(c, c->hLumFilterPos, (dstW       / 2 / 8 + 8) * sizeof(int32_t), fail);
  1573.             FF_ALLOCZ_OR_GOTO(c, c->hChrFilterPos, (c->chrDstW / 2 / 4 + 8) * sizeof(int32_t), fail);
  1574.  
  1575.             ff_init_hscaler_mmxext(      dstW, c->lumXInc, c->lumMmxextFilterCode,
  1576.                                 c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8);
  1577.             ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc, c->chrMmxextFilterCode,
  1578.                                 c->hChrFilter, (uint32_t*)c->hChrFilterPos, 4);
  1579.  
  1580. #if USE_MMAP
  1581.             if (   mprotect(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1
  1582.                 || mprotect(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1) {
  1583.                 av_log(c, AV_LOG_ERROR, "mprotect failed, cannot use fast bilinear scaler\n");
  1584.                 goto fail;
  1585.             }
  1586. #endif
  1587.         } else
  1588. #endif /* HAVE_MMXEXT_INLINE */
  1589.         {
  1590.             const int filterAlign = X86_MMX(cpu_flags)     ? 4 :
  1591.                                     PPC_ALTIVEC(cpu_flags) ? 8 : 1;
  1592.  
  1593.             if ((ret = initFilter(&c->hLumFilter, &c->hLumFilterPos,
  1594.                            &c->hLumFilterSize, c->lumXInc,
  1595.                            srcW, dstW, filterAlign, 1 << 14,
  1596.                            (flags & SWS_BICUBLIN) ? (flags | SWS_BICUBIC) : flags,
  1597.                            cpu_flags, srcFilter->lumH, dstFilter->lumH,
  1598.                            c->param,
  1599.                            get_local_pos(c, 0, 0, 0),
  1600.                            get_local_pos(c, 0, 0, 0))) < 0)
  1601.                 goto fail;
  1602.             if ((ret = initFilter(&c->hChrFilter, &c->hChrFilterPos,
  1603.                            &c->hChrFilterSize, c->chrXInc,
  1604.                            c->chrSrcW, c->chrDstW, filterAlign, 1 << 14,
  1605.                            (flags & SWS_BICUBLIN) ? (flags | SWS_BILINEAR) : flags,
  1606.                            cpu_flags, srcFilter->chrH, dstFilter->chrH,
  1607.                            c->param,
  1608.                            get_local_pos(c, c->chrSrcHSubSample, c->src_h_chr_pos, 0),
  1609.                            get_local_pos(c, c->chrDstHSubSample, c->dst_h_chr_pos, 0))) < 0)
  1610.                 goto fail;
  1611.         }
  1612.     } // initialize horizontal stuff
  1613.  
  1614.     /* precalculate vertical scaler filter coefficients */
  1615.     {
  1616.         const int filterAlign = X86_MMX(cpu_flags)     ? 2 :
  1617.                                 PPC_ALTIVEC(cpu_flags) ? 8 : 1;
  1618.  
  1619.         if ((ret = initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize,
  1620.                        c->lumYInc, srcH, dstH, filterAlign, (1 << 12),
  1621.                        (flags & SWS_BICUBLIN) ? (flags | SWS_BICUBIC) : flags,
  1622.                        cpu_flags, srcFilter->lumV, dstFilter->lumV,
  1623.                        c->param,
  1624.                        get_local_pos(c, 0, 0, 1),
  1625.                        get_local_pos(c, 0, 0, 1))) < 0)
  1626.             goto fail;
  1627.         if ((ret = initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize,
  1628.                        c->chrYInc, c->chrSrcH, c->chrDstH,
  1629.                        filterAlign, (1 << 12),
  1630.                        (flags & SWS_BICUBLIN) ? (flags | SWS_BILINEAR) : flags,
  1631.                        cpu_flags, srcFilter->chrV, dstFilter->chrV,
  1632.                        c->param,
  1633.                        get_local_pos(c, c->chrSrcVSubSample, c->src_v_chr_pos, 1),
  1634.                        get_local_pos(c, c->chrDstVSubSample, c->dst_v_chr_pos, 1))) < 0)
  1635.  
  1636.             goto fail;
  1637.  
  1638. #if HAVE_ALTIVEC
  1639.         FF_ALLOC_OR_GOTO(c, c->vYCoeffsBank, sizeof(vector signed short) * c->vLumFilterSize * c->dstH,    fail);
  1640.         FF_ALLOC_OR_GOTO(c, c->vCCoeffsBank, sizeof(vector signed short) * c->vChrFilterSize * c->chrDstH, fail);
  1641.  
  1642.         for (i = 0; i < c->vLumFilterSize * c->dstH; i++) {
  1643.             int j;
  1644.             short *p = (short *)&c->vYCoeffsBank[i];
  1645.             for (j = 0; j < 8; j++)
  1646.                 p[j] = c->vLumFilter[i];
  1647.         }
  1648.  
  1649.         for (i = 0; i < c->vChrFilterSize * c->chrDstH; i++) {
  1650.             int j;
  1651.             short *p = (short *)&c->vCCoeffsBank[i];
  1652.             for (j = 0; j < 8; j++)
  1653.                 p[j] = c->vChrFilter[i];
  1654.         }
  1655. #endif
  1656.     }
  1657.  
  1658.     // calculate buffer sizes so that they won't run out while handling these damn slices
  1659.     c->vLumBufSize = c->vLumFilterSize;
  1660.     c->vChrBufSize = c->vChrFilterSize;
  1661.     for (i = 0; i < dstH; i++) {
  1662.         int chrI      = (int64_t)i * c->chrDstH / dstH;
  1663.         int nextSlice = FFMAX(c->vLumFilterPos[i] + c->vLumFilterSize - 1,
  1664.                               ((c->vChrFilterPos[chrI] + c->vChrFilterSize - 1)
  1665.                                << c->chrSrcVSubSample));
  1666.  
  1667.         nextSlice >>= c->chrSrcVSubSample;
  1668.         nextSlice <<= c->chrSrcVSubSample;
  1669.         if (c->vLumFilterPos[i] + c->vLumBufSize < nextSlice)
  1670.             c->vLumBufSize = nextSlice - c->vLumFilterPos[i];
  1671.         if (c->vChrFilterPos[chrI] + c->vChrBufSize <
  1672.             (nextSlice >> c->chrSrcVSubSample))
  1673.             c->vChrBufSize = (nextSlice >> c->chrSrcVSubSample) -
  1674.                              c->vChrFilterPos[chrI];
  1675.     }
  1676.  
  1677.     for (i = 0; i < 4; i++)
  1678.         FF_ALLOCZ_OR_GOTO(c, c->dither_error[i], (c->dstW+2) * sizeof(int), fail);
  1679.  
  1680.     /* Allocate pixbufs (we use dynamic allocation because otherwise we would
  1681.      * need to allocate several megabytes to handle all possible cases) */
  1682.     FF_ALLOCZ_OR_GOTO(c, c->lumPixBuf,  c->vLumBufSize * 3 * sizeof(int16_t *), fail);
  1683.     FF_ALLOCZ_OR_GOTO(c, c->chrUPixBuf, c->vChrBufSize * 3 * sizeof(int16_t *), fail);
  1684.     FF_ALLOCZ_OR_GOTO(c, c->chrVPixBuf, c->vChrBufSize * 3 * sizeof(int16_t *), fail);
  1685.     if (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat) && isALPHA(c->dstFormat))
  1686.         FF_ALLOCZ_OR_GOTO(c, c->alpPixBuf, c->vLumBufSize * 3 * sizeof(int16_t *), fail);
  1687.     /* Note we need at least one pixel more at the end because of the MMX code
  1688.      * (just in case someone wants to replace the 4000/8000). */
  1689.     /* align at 16 bytes for AltiVec */
  1690.     for (i = 0; i < c->vLumBufSize; i++) {
  1691.         FF_ALLOCZ_OR_GOTO(c, c->lumPixBuf[i + c->vLumBufSize],
  1692.                           dst_stride + 16, fail);
  1693.         c->lumPixBuf[i] = c->lumPixBuf[i + c->vLumBufSize];
  1694.     }
  1695.     // 64 / c->scalingBpp is the same as 16 / sizeof(scaling_intermediate)
  1696.     c->uv_off   = (dst_stride>>1) + 64 / (c->dstBpc &~ 7);
  1697.     c->uv_offx2 = dst_stride + 16;
  1698.     for (i = 0; i < c->vChrBufSize; i++) {
  1699.         FF_ALLOC_OR_GOTO(c, c->chrUPixBuf[i + c->vChrBufSize],
  1700.                          dst_stride * 2 + 32, fail);
  1701.         c->chrUPixBuf[i] = c->chrUPixBuf[i + c->vChrBufSize];
  1702.         c->chrVPixBuf[i] = c->chrVPixBuf[i + c->vChrBufSize]
  1703.                          = c->chrUPixBuf[i] + (dst_stride >> 1) + 8;
  1704.     }
  1705.     if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf)
  1706.         for (i = 0; i < c->vLumBufSize; i++) {
  1707.             FF_ALLOCZ_OR_GOTO(c, c->alpPixBuf[i + c->vLumBufSize],
  1708.                               dst_stride + 16, fail);
  1709.             c->alpPixBuf[i] = c->alpPixBuf[i + c->vLumBufSize];
  1710.         }
  1711.  
  1712.     // try to avoid drawing green stuff between the right end and the stride end
  1713.     for (i = 0; i < c->vChrBufSize; i++)
  1714.         if(desc_dst->comp[0].depth_minus1 == 15){
  1715.             av_assert0(c->dstBpc > 14);
  1716.             for(j=0; j<dst_stride/2+1; j++)
  1717.                 ((int32_t*)(c->chrUPixBuf[i]))[j] = 1<<18;
  1718.         } else
  1719.             for(j=0; j<dst_stride+1; j++)
  1720.                 ((int16_t*)(c->chrUPixBuf[i]))[j] = 1<<14;
  1721.  
  1722.     av_assert0(c->chrDstH <= dstH);
  1723.  
  1724.     if (flags & SWS_PRINT_INFO) {
  1725.         const char *scaler = NULL, *cpucaps;
  1726.  
  1727.         for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) {
  1728.             if (flags & scale_algorithms[i].flag) {
  1729.                 scaler = scale_algorithms[i].description;
  1730.                 break;
  1731.             }
  1732.         }
  1733.         if (!scaler)
  1734.             scaler =  "ehh flags invalid?!";
  1735.         av_log(c, AV_LOG_INFO, "%s scaler, from %s to %s%s ",
  1736.                scaler,
  1737.                av_get_pix_fmt_name(srcFormat),
  1738. #ifdef DITHER1XBPP
  1739.                dstFormat == AV_PIX_FMT_BGR555   || dstFormat == AV_PIX_FMT_BGR565   ||
  1740.                dstFormat == AV_PIX_FMT_RGB444BE || dstFormat == AV_PIX_FMT_RGB444LE ||
  1741.                dstFormat == AV_PIX_FMT_BGR444BE || dstFormat == AV_PIX_FMT_BGR444LE ?
  1742.                                                              "dithered " : "",
  1743. #else
  1744.                "",
  1745. #endif
  1746.                av_get_pix_fmt_name(dstFormat));
  1747.  
  1748.         if (INLINE_MMXEXT(cpu_flags))
  1749.             cpucaps = "MMXEXT";
  1750.         else if (INLINE_AMD3DNOW(cpu_flags))
  1751.             cpucaps = "3DNOW";
  1752.         else if (INLINE_MMX(cpu_flags))
  1753.             cpucaps = "MMX";
  1754.         else if (PPC_ALTIVEC(cpu_flags))
  1755.             cpucaps = "AltiVec";
  1756.         else
  1757.             cpucaps = "C";
  1758.  
  1759.         av_log(c, AV_LOG_INFO, "using %s\n", cpucaps);
  1760.  
  1761.         av_log(c, AV_LOG_VERBOSE, "%dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
  1762.         av_log(c, AV_LOG_DEBUG,
  1763.                "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
  1764.                c->srcW, c->srcH, c->dstW, c->dstH, c->lumXInc, c->lumYInc);
  1765.         av_log(c, AV_LOG_DEBUG,
  1766.                "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
  1767.                c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH,
  1768.                c->chrXInc, c->chrYInc);
  1769.     }
  1770.  
  1771.     /* alpha blend special case, note this has been split via cascaded contexts if its scaled */
  1772.     if (unscaled && !usesHFilter && !usesVFilter &&
  1773.         c->alphablend != SWS_ALPHA_BLEND_NONE &&
  1774.         isALPHA(srcFormat) &&
  1775.         (c->srcRange == c->dstRange || isAnyRGB(dstFormat)) &&
  1776.         alphaless_fmt(srcFormat) == dstFormat
  1777.     ) {
  1778.         c->swscale = ff_sws_alphablendaway;
  1779.  
  1780.         if (flags & SWS_PRINT_INFO)
  1781.             av_log(c, AV_LOG_INFO,
  1782.                     "using alpha blendaway %s -> %s special converter\n",
  1783.                     av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
  1784.         return 0;
  1785.     }
  1786.  
  1787.     /* unscaled special cases */
  1788.     if (unscaled && !usesHFilter && !usesVFilter &&
  1789.         (c->srcRange == c->dstRange || isAnyRGB(dstFormat))) {
  1790.         ff_get_unscaled_swscale(c);
  1791.  
  1792.         if (c->swscale) {
  1793.             if (flags & SWS_PRINT_INFO)
  1794.                 av_log(c, AV_LOG_INFO,
  1795.                        "using unscaled %s -> %s special converter\n",
  1796.                        av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
  1797.             return 0;
  1798.         }
  1799.     }
  1800.  
  1801.     c->swscale = ff_getSwsFunc(c);
  1802.     return ff_init_filters(c);
  1803. fail: // FIXME replace things by appropriate error codes
  1804.     if (ret == RETCODE_USE_CASCADE)  {
  1805.         int tmpW = sqrt(srcW * (int64_t)dstW);
  1806.         int tmpH = sqrt(srcH * (int64_t)dstH);
  1807.         enum AVPixelFormat tmpFormat = AV_PIX_FMT_YUV420P;
  1808.  
  1809.         if (isALPHA(srcFormat))
  1810.             tmpFormat = AV_PIX_FMT_YUVA420P;
  1811.  
  1812.         if (srcW*(int64_t)srcH <= 4LL*dstW*dstH)
  1813.             return AVERROR(EINVAL);
  1814.  
  1815.         ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
  1816.                              tmpW, tmpH, tmpFormat, 64);
  1817.         if (ret < 0)
  1818.             return ret;
  1819.  
  1820.         c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
  1821.                                                 tmpW, tmpH, tmpFormat,
  1822.                                                 flags, srcFilter, NULL, c->param);
  1823.         if (!c->cascaded_context[0])
  1824.             return -1;
  1825.  
  1826.         c->cascaded_context[1] = sws_getContext(tmpW, tmpH, tmpFormat,
  1827.                                                 dstW, dstH, dstFormat,
  1828.                                                 flags, NULL, dstFilter, c->param);
  1829.         if (!c->cascaded_context[1])
  1830.             return -1;
  1831.         return 0;
  1832.     }
  1833.     return -1;
  1834. }
  1835.  
  1836. SwsContext *sws_alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat,
  1837.                                int dstW, int dstH, enum AVPixelFormat dstFormat,
  1838.                                int flags, const double *param)
  1839. {
  1840.     SwsContext *c;
  1841.  
  1842.     if (!(c = sws_alloc_context()))
  1843.         return NULL;
  1844.  
  1845.     c->flags     = flags;
  1846.     c->srcW      = srcW;
  1847.     c->srcH      = srcH;
  1848.     c->dstW      = dstW;
  1849.     c->dstH      = dstH;
  1850.     c->srcFormat = srcFormat;
  1851.     c->dstFormat = dstFormat;
  1852.  
  1853.     if (param) {
  1854.         c->param[0] = param[0];
  1855.         c->param[1] = param[1];
  1856.     }
  1857.  
  1858.     return c;
  1859. }
  1860.  
  1861. SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
  1862.                            int dstW, int dstH, enum AVPixelFormat dstFormat,
  1863.                            int flags, SwsFilter *srcFilter,
  1864.                            SwsFilter *dstFilter, const double *param)
  1865. {
  1866.     SwsContext *c;
  1867.  
  1868.     c = sws_alloc_set_opts(srcW, srcH, srcFormat,
  1869.                            dstW, dstH, dstFormat,
  1870.                            flags, param);
  1871.     if (!c)
  1872.         return NULL;
  1873.  
  1874.     if (sws_init_context(c, srcFilter, dstFilter) < 0) {
  1875.         sws_freeContext(c);
  1876.         return NULL;
  1877.     }
  1878.  
  1879.     return c;
  1880. }
  1881.  
  1882. static int isnan_vec(SwsVector *a)
  1883. {
  1884.     int i;
  1885.     for (i=0; i<a->length; i++)
  1886.         if (isnan(a->coeff[i]))
  1887.             return 1;
  1888.     return 0;
  1889. }
  1890.  
  1891. static void makenan_vec(SwsVector *a)
  1892. {
  1893.     int i;
  1894.     for (i=0; i<a->length; i++)
  1895.         a->coeff[i] = NAN;
  1896. }
  1897.  
  1898. SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,
  1899.                                 float lumaSharpen, float chromaSharpen,
  1900.                                 float chromaHShift, float chromaVShift,
  1901.                                 int verbose)
  1902. {
  1903.     SwsFilter *filter = av_malloc(sizeof(SwsFilter));
  1904.     if (!filter)
  1905.         return NULL;
  1906.  
  1907.     if (lumaGBlur != 0.0) {
  1908.         filter->lumH = sws_getGaussianVec(lumaGBlur, 3.0);
  1909.         filter->lumV = sws_getGaussianVec(lumaGBlur, 3.0);
  1910.     } else {
  1911.         filter->lumH = sws_getIdentityVec();
  1912.         filter->lumV = sws_getIdentityVec();
  1913.     }
  1914.  
  1915.     if (chromaGBlur != 0.0) {
  1916.         filter->chrH = sws_getGaussianVec(chromaGBlur, 3.0);
  1917.         filter->chrV = sws_getGaussianVec(chromaGBlur, 3.0);
  1918.     } else {
  1919.         filter->chrH = sws_getIdentityVec();
  1920.         filter->chrV = sws_getIdentityVec();
  1921.     }
  1922.  
  1923.     if (!filter->lumH || !filter->lumV || !filter->chrH || !filter->chrV)
  1924.         goto fail;
  1925.  
  1926.     if (chromaSharpen != 0.0) {
  1927.         SwsVector *id = sws_getIdentityVec();
  1928.         if (!id)
  1929.             goto fail;
  1930.         sws_scaleVec(filter->chrH, -chromaSharpen);
  1931.         sws_scaleVec(filter->chrV, -chromaSharpen);
  1932.         sws_addVec(filter->chrH, id);
  1933.         sws_addVec(filter->chrV, id);
  1934.         sws_freeVec(id);
  1935.     }
  1936.  
  1937.     if (lumaSharpen != 0.0) {
  1938.         SwsVector *id = sws_getIdentityVec();
  1939.         if (!id)
  1940.             goto fail;
  1941.         sws_scaleVec(filter->lumH, -lumaSharpen);
  1942.         sws_scaleVec(filter->lumV, -lumaSharpen);
  1943.         sws_addVec(filter->lumH, id);
  1944.         sws_addVec(filter->lumV, id);
  1945.         sws_freeVec(id);
  1946.     }
  1947.  
  1948.     if (chromaHShift != 0.0)
  1949.         sws_shiftVec(filter->chrH, (int)(chromaHShift + 0.5));
  1950.  
  1951.     if (chromaVShift != 0.0)
  1952.         sws_shiftVec(filter->chrV, (int)(chromaVShift + 0.5));
  1953.  
  1954.     sws_normalizeVec(filter->chrH, 1.0);
  1955.     sws_normalizeVec(filter->chrV, 1.0);
  1956.     sws_normalizeVec(filter->lumH, 1.0);
  1957.     sws_normalizeVec(filter->lumV, 1.0);
  1958.  
  1959.     if (isnan_vec(filter->chrH) ||
  1960.         isnan_vec(filter->chrV) ||
  1961.         isnan_vec(filter->lumH) ||
  1962.         isnan_vec(filter->lumV))
  1963.         goto fail;
  1964.  
  1965.     if (verbose)
  1966.         sws_printVec2(filter->chrH, NULL, AV_LOG_DEBUG);
  1967.     if (verbose)
  1968.         sws_printVec2(filter->lumH, NULL, AV_LOG_DEBUG);
  1969.  
  1970.     return filter;
  1971.  
  1972. fail:
  1973.     sws_freeVec(filter->lumH);
  1974.     sws_freeVec(filter->lumV);
  1975.     sws_freeVec(filter->chrH);
  1976.     sws_freeVec(filter->chrV);
  1977.     av_freep(&filter);
  1978.     return NULL;
  1979. }
  1980.  
  1981. SwsVector *sws_allocVec(int length)
  1982. {
  1983.     SwsVector *vec;
  1984.  
  1985.     if(length <= 0 || length > INT_MAX/ sizeof(double))
  1986.         return NULL;
  1987.  
  1988.     vec = av_malloc(sizeof(SwsVector));
  1989.     if (!vec)
  1990.         return NULL;
  1991.     vec->length = length;
  1992.     vec->coeff  = av_malloc(sizeof(double) * length);
  1993.     if (!vec->coeff)
  1994.         av_freep(&vec);
  1995.     return vec;
  1996. }
  1997.  
  1998. SwsVector *sws_getGaussianVec(double variance, double quality)
  1999. {
  2000.     const int length = (int)(variance * quality + 0.5) | 1;
  2001.     int i;
  2002.     double middle  = (length - 1) * 0.5;
  2003.     SwsVector *vec;
  2004.  
  2005.     if(variance < 0 || quality < 0)
  2006.         return NULL;
  2007.  
  2008.     vec = sws_allocVec(length);
  2009.  
  2010.     if (!vec)
  2011.         return NULL;
  2012.  
  2013.     for (i = 0; i < length; i++) {
  2014.         double dist = i - middle;
  2015.         vec->coeff[i] = exp(-dist * dist / (2 * variance * variance)) /
  2016.                         sqrt(2 * variance * M_PI);
  2017.     }
  2018.  
  2019.     sws_normalizeVec(vec, 1.0);
  2020.  
  2021.     return vec;
  2022. }
  2023.  
  2024. SwsVector *sws_getConstVec(double c, int length)
  2025. {
  2026.     int i;
  2027.     SwsVector *vec = sws_allocVec(length);
  2028.  
  2029.     if (!vec)
  2030.         return NULL;
  2031.  
  2032.     for (i = 0; i < length; i++)
  2033.         vec->coeff[i] = c;
  2034.  
  2035.     return vec;
  2036. }
  2037.  
  2038. SwsVector *sws_getIdentityVec(void)
  2039. {
  2040.     return sws_getConstVec(1.0, 1);
  2041. }
  2042.  
  2043. static double sws_dcVec(SwsVector *a)
  2044. {
  2045.     int i;
  2046.     double sum = 0;
  2047.  
  2048.     for (i = 0; i < a->length; i++)
  2049.         sum += a->coeff[i];
  2050.  
  2051.     return sum;
  2052. }
  2053.  
  2054. void sws_scaleVec(SwsVector *a, double scalar)
  2055. {
  2056.     int i;
  2057.  
  2058.     for (i = 0; i < a->length; i++)
  2059.         a->coeff[i] *= scalar;
  2060. }
  2061.  
  2062. void sws_normalizeVec(SwsVector *a, double height)
  2063. {
  2064.     sws_scaleVec(a, height / sws_dcVec(a));
  2065. }
  2066.  
  2067. static SwsVector *sws_getConvVec(SwsVector *a, SwsVector *b)
  2068. {
  2069.     int length = a->length + b->length - 1;
  2070.     int i, j;
  2071.     SwsVector *vec = sws_getConstVec(0.0, length);
  2072.  
  2073.     if (!vec)
  2074.         return NULL;
  2075.  
  2076.     for (i = 0; i < a->length; i++) {
  2077.         for (j = 0; j < b->length; j++) {
  2078.             vec->coeff[i + j] += a->coeff[i] * b->coeff[j];
  2079.         }
  2080.     }
  2081.  
  2082.     return vec;
  2083. }
  2084.  
  2085. static SwsVector *sws_sumVec(SwsVector *a, SwsVector *b)
  2086. {
  2087.     int length = FFMAX(a->length, b->length);
  2088.     int i;
  2089.     SwsVector *vec = sws_getConstVec(0.0, length);
  2090.  
  2091.     if (!vec)
  2092.         return NULL;
  2093.  
  2094.     for (i = 0; i < a->length; i++)
  2095.         vec->coeff[i + (length - 1) / 2 - (a->length - 1) / 2] += a->coeff[i];
  2096.     for (i = 0; i < b->length; i++)
  2097.         vec->coeff[i + (length - 1) / 2 - (b->length - 1) / 2] += b->coeff[i];
  2098.  
  2099.     return vec;
  2100. }
  2101.  
  2102. static SwsVector *sws_diffVec(SwsVector *a, SwsVector *b)
  2103. {
  2104.     int length = FFMAX(a->length, b->length);
  2105.     int i;
  2106.     SwsVector *vec = sws_getConstVec(0.0, length);
  2107.  
  2108.     if (!vec)
  2109.         return NULL;
  2110.  
  2111.     for (i = 0; i < a->length; i++)
  2112.         vec->coeff[i + (length - 1) / 2 - (a->length - 1) / 2] += a->coeff[i];
  2113.     for (i = 0; i < b->length; i++)
  2114.         vec->coeff[i + (length - 1) / 2 - (b->length - 1) / 2] -= b->coeff[i];
  2115.  
  2116.     return vec;
  2117. }
  2118.  
  2119. /* shift left / or right if "shift" is negative */
  2120. static SwsVector *sws_getShiftedVec(SwsVector *a, int shift)
  2121. {
  2122.     int length = a->length + FFABS(shift) * 2;
  2123.     int i;
  2124.     SwsVector *vec = sws_getConstVec(0.0, length);
  2125.  
  2126.     if (!vec)
  2127.         return NULL;
  2128.  
  2129.     for (i = 0; i < a->length; i++) {
  2130.         vec->coeff[i + (length    - 1) / 2 -
  2131.                        (a->length - 1) / 2 - shift] = a->coeff[i];
  2132.     }
  2133.  
  2134.     return vec;
  2135. }
  2136.  
  2137. void sws_shiftVec(SwsVector *a, int shift)
  2138. {
  2139.     SwsVector *shifted = sws_getShiftedVec(a, shift);
  2140.     if (!shifted) {
  2141.         makenan_vec(a);
  2142.         return;
  2143.     }
  2144.     av_free(a->coeff);
  2145.     a->coeff  = shifted->coeff;
  2146.     a->length = shifted->length;
  2147.     av_free(shifted);
  2148. }
  2149.  
  2150. void sws_addVec(SwsVector *a, SwsVector *b)
  2151. {
  2152.     SwsVector *sum = sws_sumVec(a, b);
  2153.     if (!sum) {
  2154.         makenan_vec(a);
  2155.         return;
  2156.     }
  2157.     av_free(a->coeff);
  2158.     a->coeff  = sum->coeff;
  2159.     a->length = sum->length;
  2160.     av_free(sum);
  2161. }
  2162.  
  2163. void sws_subVec(SwsVector *a, SwsVector *b)
  2164. {
  2165.     SwsVector *diff = sws_diffVec(a, b);
  2166.     if (!diff) {
  2167.         makenan_vec(a);
  2168.         return;
  2169.     }
  2170.     av_free(a->coeff);
  2171.     a->coeff  = diff->coeff;
  2172.     a->length = diff->length;
  2173.     av_free(diff);
  2174. }
  2175.  
  2176. void sws_convVec(SwsVector *a, SwsVector *b)
  2177. {
  2178.     SwsVector *conv = sws_getConvVec(a, b);
  2179.     if (!conv) {
  2180.         makenan_vec(a);
  2181.         return;
  2182.     }
  2183.     av_free(a->coeff);
  2184.     a->coeff  = conv->coeff;
  2185.     a->length = conv->length;
  2186.     av_free(conv);
  2187. }
  2188.  
  2189. SwsVector *sws_cloneVec(SwsVector *a)
  2190. {
  2191.     SwsVector *vec = sws_allocVec(a->length);
  2192.  
  2193.     if (!vec)
  2194.         return NULL;
  2195.  
  2196.     memcpy(vec->coeff, a->coeff, a->length * sizeof(*a->coeff));
  2197.  
  2198.     return vec;
  2199. }
  2200.  
  2201. void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level)
  2202. {
  2203.     int i;
  2204.     double max = 0;
  2205.     double min = 0;
  2206.     double range;
  2207.  
  2208.     for (i = 0; i < a->length; i++)
  2209.         if (a->coeff[i] > max)
  2210.             max = a->coeff[i];
  2211.  
  2212.     for (i = 0; i < a->length; i++)
  2213.         if (a->coeff[i] < min)
  2214.             min = a->coeff[i];
  2215.  
  2216.     range = max - min;
  2217.  
  2218.     for (i = 0; i < a->length; i++) {
  2219.         int x = (int)((a->coeff[i] - min) * 60.0 / range + 0.5);
  2220.         av_log(log_ctx, log_level, "%1.3f ", a->coeff[i]);
  2221.         for (; x > 0; x--)
  2222.             av_log(log_ctx, log_level, " ");
  2223.         av_log(log_ctx, log_level, "|\n");
  2224.     }
  2225. }
  2226.  
  2227. void sws_freeVec(SwsVector *a)
  2228. {
  2229.     if (!a)
  2230.         return;
  2231.     av_freep(&a->coeff);
  2232.     a->length = 0;
  2233.     av_free(a);
  2234. }
  2235.  
  2236. void sws_freeFilter(SwsFilter *filter)
  2237. {
  2238.     if (!filter)
  2239.         return;
  2240.  
  2241.     sws_freeVec(filter->lumH);
  2242.     sws_freeVec(filter->lumV);
  2243.     sws_freeVec(filter->chrH);
  2244.     sws_freeVec(filter->chrV);
  2245.     av_free(filter);
  2246. }
  2247.  
  2248. void sws_freeContext(SwsContext *c)
  2249. {
  2250.     int i;
  2251.     if (!c)
  2252.         return;
  2253.  
  2254.     if (c->lumPixBuf) {
  2255.         for (i = 0; i < c->vLumBufSize; i++)
  2256.             av_freep(&c->lumPixBuf[i]);
  2257.         av_freep(&c->lumPixBuf);
  2258.     }
  2259.  
  2260.     if (c->chrUPixBuf) {
  2261.         for (i = 0; i < c->vChrBufSize; i++)
  2262.             av_freep(&c->chrUPixBuf[i]);
  2263.         av_freep(&c->chrUPixBuf);
  2264.         av_freep(&c->chrVPixBuf);
  2265.     }
  2266.  
  2267.     if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {
  2268.         for (i = 0; i < c->vLumBufSize; i++)
  2269.             av_freep(&c->alpPixBuf[i]);
  2270.         av_freep(&c->alpPixBuf);
  2271.     }
  2272.  
  2273.     for (i = 0; i < 4; i++)
  2274.         av_freep(&c->dither_error[i]);
  2275.  
  2276.     av_freep(&c->vLumFilter);
  2277.     av_freep(&c->vChrFilter);
  2278.     av_freep(&c->hLumFilter);
  2279.     av_freep(&c->hChrFilter);
  2280. #if HAVE_ALTIVEC
  2281.     av_freep(&c->vYCoeffsBank);
  2282.     av_freep(&c->vCCoeffsBank);
  2283. #endif
  2284.  
  2285.     av_freep(&c->vLumFilterPos);
  2286.     av_freep(&c->vChrFilterPos);
  2287.     av_freep(&c->hLumFilterPos);
  2288.     av_freep(&c->hChrFilterPos);
  2289.  
  2290. #if HAVE_MMX_INLINE
  2291. #if USE_MMAP
  2292.     if (c->lumMmxextFilterCode)
  2293.         munmap(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize);
  2294.     if (c->chrMmxextFilterCode)
  2295.         munmap(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize);
  2296. #elif HAVE_VIRTUALALLOC
  2297.     if (c->lumMmxextFilterCode)
  2298.         VirtualFree(c->lumMmxextFilterCode, 0, MEM_RELEASE);
  2299.     if (c->chrMmxextFilterCode)
  2300.         VirtualFree(c->chrMmxextFilterCode, 0, MEM_RELEASE);
  2301. #else
  2302.     av_free(c->lumMmxextFilterCode);
  2303.     av_free(c->chrMmxextFilterCode);
  2304. #endif
  2305.     c->lumMmxextFilterCode = NULL;
  2306.     c->chrMmxextFilterCode = NULL;
  2307. #endif /* HAVE_MMX_INLINE */
  2308.  
  2309.     av_freep(&c->yuvTable);
  2310.     av_freep(&c->formatConvBuffer);
  2311.  
  2312.     sws_freeContext(c->cascaded_context[0]);
  2313.     sws_freeContext(c->cascaded_context[1]);
  2314.     sws_freeContext(c->cascaded_context[2]);
  2315.     memset(c->cascaded_context, 0, sizeof(c->cascaded_context));
  2316.     av_freep(&c->cascaded_tmp[0]);
  2317.     av_freep(&c->cascaded1_tmp[0]);
  2318.  
  2319.     av_freep(&c->gamma);
  2320.     av_freep(&c->inv_gamma);
  2321.  
  2322.     ff_free_filters(c);
  2323.  
  2324.     av_free(c);
  2325. }
  2326.  
  2327. struct SwsContext *sws_getCachedContext(struct SwsContext *context, int srcW,
  2328.                                         int srcH, enum AVPixelFormat srcFormat,
  2329.                                         int dstW, int dstH,
  2330.                                         enum AVPixelFormat dstFormat, int flags,
  2331.                                         SwsFilter *srcFilter,
  2332.                                         SwsFilter *dstFilter,
  2333.                                         const double *param)
  2334. {
  2335.     static const double default_param[2] = { SWS_PARAM_DEFAULT,
  2336.                                              SWS_PARAM_DEFAULT };
  2337.     int64_t src_h_chr_pos = -513, dst_h_chr_pos = -513,
  2338.             src_v_chr_pos = -513, dst_v_chr_pos = -513;
  2339.  
  2340.     if (!param)
  2341.         param = default_param;
  2342.  
  2343.     if (context &&
  2344.         (context->srcW      != srcW      ||
  2345.          context->srcH      != srcH      ||
  2346.          context->srcFormat != srcFormat ||
  2347.          context->dstW      != dstW      ||
  2348.          context->dstH      != dstH      ||
  2349.          context->dstFormat != dstFormat ||
  2350.          context->flags     != flags     ||
  2351.          context->param[0]  != param[0]  ||
  2352.          context->param[1]  != param[1])) {
  2353.  
  2354.         av_opt_get_int(context, "src_h_chr_pos", 0, &src_h_chr_pos);
  2355.         av_opt_get_int(context, "src_v_chr_pos", 0, &src_v_chr_pos);
  2356.         av_opt_get_int(context, "dst_h_chr_pos", 0, &dst_h_chr_pos);
  2357.         av_opt_get_int(context, "dst_v_chr_pos", 0, &dst_v_chr_pos);
  2358.         sws_freeContext(context);
  2359.         context = NULL;
  2360.     }
  2361.  
  2362.     if (!context) {
  2363.         if (!(context = sws_alloc_context()))
  2364.             return NULL;
  2365.         context->srcW      = srcW;
  2366.         context->srcH      = srcH;
  2367.         context->srcFormat = srcFormat;
  2368.         context->dstW      = dstW;
  2369.         context->dstH      = dstH;
  2370.         context->dstFormat = dstFormat;
  2371.         context->flags     = flags;
  2372.         context->param[0]  = param[0];
  2373.         context->param[1]  = param[1];
  2374.  
  2375.         av_opt_set_int(context, "src_h_chr_pos", src_h_chr_pos, 0);
  2376.         av_opt_set_int(context, "src_v_chr_pos", src_v_chr_pos, 0);
  2377.         av_opt_set_int(context, "dst_h_chr_pos", dst_h_chr_pos, 0);
  2378.         av_opt_set_int(context, "dst_v_chr_pos", dst_v_chr_pos, 0);
  2379.  
  2380.         if (sws_init_context(context, srcFilter, dstFilter) < 0) {
  2381.             sws_freeContext(context);
  2382.             return NULL;
  2383.         }
  2384.     }
  2385.     return context;
  2386. }
  2387.