Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 13 Apr 2012 19:21:15 +0000 (21:21 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 13 Apr 2012 19:50:37 +0000 (21:50 +0200)
* qatar/master:
  swscale: K&R formatting cosmetics (part II)
  tiffdec: Add a malloc check and refactor another.
  faxcompr: Check malloc results and unify return path
  configure: escape colons in values written to config.fate
  ac3dsp: call femms/emms at the end of float_to_fixed24() for 3DNow and SSE
  matroska: Fix leaking memory allocated for laces.
  pthread: Fix crash due to fctx->delaying not being cleared.
  vp3: Assert on invalid filter_limit values.
  h264: fix 10bit biweight functions after recent x86inc.asm fixes.
  ffv1: Fix size mismatch in encode_line.
  movenc: Remove a dead initialization
  git-howto: Explain how to avoid Windows line endings in git checkouts.
  build: Move all arch OBJS declarations into arch subdirectory Makefiles.

Conflicts:
configure
libavcodec/vp3.c
libavformat/matroskadec.c
libavutil/Makefile
libswscale/Makefile
libswscale/swscale.c
libswscale/swscale_internal.h
libswscale/utils.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
14 files changed:
1  2 
configure
doc/git-howto.texi
libavcodec/faxcompr.c
libavcodec/ffv1.c
libavcodec/tiff.c
libavcodec/x86/ac3dsp.asm
libavformat/matroskadec.c
libavformat/movenc.c
libavutil/Makefile
libswscale/Makefile
libswscale/swscale.c
libswscale/swscale_internal.h
libswscale/utils.c
libswscale/x86/Makefile

diff --cc configure
+++ b/configure
@@@ -2803,7 -2594,11 +2803,11 @@@ case $target_os i
          ;;
  esac
  
- echo "config:$arch:$subarch:$cpu:$target_os:$cc_ident:$FFMPEG_CONFIGURATION" >config.fate
+ esc(){
+     echo "$*" | sed 's/%/%25/g;s/:/%3a/g'
+ }
 -echo "config:$arch:$subarch:$cpu:$target_os:$(esc $cc_ident):$(esc $LIBAV_CONFIGURATION)" >config.fate
++echo "config:$arch:$subarch:$cpu:$target_os:$(esc $cc_ident):$(esc $FFMPEG_CONFIGURATION)" >config.fate
  
  check_cpp_condition stdlib.h "defined(__PIC__) || defined(__pic__) || defined(PIC)" && enable pic
  
@@@ -53,18 -53,26 +53,26 @@@ Most distribution and operating system 
  @section Cloning the source tree
  
  @example
 -git clone git://git.libav.org/libav.git <target>
 +git clone git://source.ffmpeg.org/ffmpeg <target>
  @end example
  
 -This will put the Libav sources into the directory @var{<target>}.
 +This will put the FFmpeg sources into the directory @var{<target>}.
  
  @example
 -git clone git@@git.libav.org:libav.git <target>
 +git clone git@@source.ffmpeg.org:ffmpeg <target>
  @end example
  
 -This will put the Libav sources into the directory @var{<target>} and let
 +This will put the FFmpeg sources into the directory @var{<target>} and let
  you push back your changes to the remote repository.
  
+ Make sure that you do not have Windows line endings in your checkouts,
+ otherwise you may experience spurious compilation failures. One way to
+ achieve this is to run
+ @example
+ git config --global core.autocrlf false
+ @end example
  
  @section Updating the source tree to the latest revision
  
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -79,15 -72,7 +79,12 @@@ OBJS = adler32.
         tree.o                                                           \
         utils.o                                                          \
  
- OBJS-$(ARCH_PPC) += ppc/cpu.o
- OBJS-$(ARCH_X86) += x86/cpu.o
 -TESTPROGS = adler32 aes avstring base64 cpu crc des eval fifo lfg lls \
 -            md5 opt parseutils sha tree
 +TESTPROGS = adler32 aes avstring base64 bprint cpu crc des eval file fifo \
 +            lfg lls md5 opt pca parseutils random_seed rational sha tree
 +TESTPROGS-$(HAVE_LZO1X_999_COMPRESS) += lzo
 +
 +TOOLS = ffeval
  
  ARCH_HEADERS = bswap.h intmath.h intreadwrite.h timer.h
 +
 +$(SUBDIR)lzo-test$(EXESUF): ELIBS = -llzo2
Simple merge
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
+ #include <assert.h>
  #include <inttypes.h>
- #include <string.h>
  #include <math.h>
  #include <stdio.h>
- #include "config.h"
- #include <assert.h>
- #include "swscale.h"
- #include "swscale_internal.h"
- #include "rgb2rgb.h"
+ #include <string.h>
 +#include "libavutil/avassert.h"
- #include "libavutil/intreadwrite.h"
- #include "libavutil/cpu.h"
  #include "libavutil/avutil.h"
- #include "libavutil/mathematics.h"
  #include "libavutil/bswap.h"
+ #include "libavutil/cpu.h"
+ #include "libavutil/intreadwrite.h"
+ #include "libavutil/mathematics.h"
  #include "libavutil/pixdesc.h"
+ #include "config.h"
+ #include "rgb2rgb.h"
+ #include "swscale_internal.h"
+ #include "swscale.h"
  
  DECLARE_ALIGNED(8, const uint8_t, dither_8x8_128)[8][8] = {
{  36, 68, 60, 92, 34, 66, 58, 90,},
{ 100,  4,124, 28, 98,  2,122, 26,},
{  52, 84, 44, 76, 50, 82, 42, 74,},
{ 116, 20,108, 12,114, 18,106, 10,},
{  32, 64, 56, 88, 38, 70, 62, 94,},
{  96,  0,120, 24,102,  6,126, 30,},
{  48, 80, 40, 72, 54, 86, 46, 78,},
{ 112, 16,104,  8,118, 22,110, 14,},
    {  36, 68,  60, 92,  34, 66,  58, 90, },
    { 100,  4, 124, 28,  98,  2, 122, 26, },
    {  52, 84,  44, 76,  50, 82,  42, 74, },
    { 116, 20, 108, 12, 114, 18, 106, 10, },
    {  32, 64,  56, 88,  38, 70,  62, 94, },
    {  96,  0, 120, 24, 102,  6, 126, 30, },
    {  48, 80,  40, 72,  54, 86,  46, 78, },
    { 112, 16, 104,  8, 118, 22, 110, 14, },
  };
- DECLARE_ALIGNED(8, const uint8_t, ff_sws_pb_64)[8] =
- {  64, 64, 64, 64, 64, 64, 64, 64 };
  
+ DECLARE_ALIGNED(8, const uint8_t, ff_sws_pb_64)[8] = {
+     64, 64, 64, 64, 64, 64, 64, 64
+ };
  
- static av_always_inline void fillPlane(uint8_t* plane, int stride,
-                                        int width, int height,
-                                        int y, uint8_t val)
+ static av_always_inline void fillPlane(uint8_t *plane, int stride, int width,
+                                        int height, int y, uint8_t val)
  {
      int i;
-     uint8_t *ptr = plane + stride*y;
-     for (i=0; i<height; i++) {
+     uint8_t *ptr = plane + stride * y;
+     for (i = 0; i < height; i++) {
          memset(ptr, val, width);
          ptr += stride;
      }
@@@ -66,14 -66,11 +67,14 @@@ static void hScale16To19_c(SwsContext *
                             const int32_t *filterPos, int filterSize)
  {
      int i;
-     int32_t *dst = (int32_t *) _dst;
+     int32_t *dst        = (int32_t *) _dst;
      const uint16_t *src = (const uint16_t *) _src;
-     int bits = av_pix_fmt_descriptors[c->srcFormat].comp[0].depth_minus1;
-     int sh = bits - 4;
+     int bits            = av_pix_fmt_descriptors[c->srcFormat].comp[0].depth_minus1;
+     int sh              = bits - 4;
  
 +    if((isAnyRGB(c->srcFormat) || c->srcFormat==PIX_FMT_PAL8) && av_pix_fmt_descriptors[c->srcFormat].comp[0].depth_minus1<15)
 +        sh= 9;
 +
      for (i = 0; i < dstW; i++) {
          int j;
          int srcPos = filterPos[i];
@@@ -93,11 -90,8 +94,11 @@@ static void hScale16To15_c(SwsContext *
  {
      int i;
      const uint16_t *src = (const uint16_t *) _src;
-     int sh = av_pix_fmt_descriptors[c->srcFormat].comp[0].depth_minus1;
+     int sh              = av_pix_fmt_descriptors[c->srcFormat].comp[0].depth_minus1;
  
 +    if(sh<15)
 +        sh= isAnyRGB(c->srcFormat) || c->srcFormat==PIX_FMT_PAL8 ? 13 : av_pix_fmt_descriptors[c->srcFormat].comp[0].depth_minus1;
 +
      for (i = 0; i < dstW; i++) {
          int j;
          int srcPos = filterPos[i];
@@@ -219,15 -215,13 +222,15 @@@ static void hyscale_fast_c(SwsContext *
                             const uint8_t *src, int srcW, int xInc)
  {
      int i;
-     unsigned int xpos=0;
-     for (i=0;i<dstWidth;i++) {
-         register unsigned int xx=xpos>>16;
-         register unsigned int xalpha=(xpos&0xFFFF)>>9;
-         dst[i]= (src[xx]<<7) + (src[xx+1] - src[xx])*xalpha;
-         xpos+=xInc;
+     unsigned int xpos = 0;
+     for (i = 0; i < dstWidth; i++) {
+         register unsigned int xx     = xpos >> 16;
+         register unsigned int xalpha = (xpos & 0xFFFF) >> 9;
+         dst[i] = (src[xx] << 7) + (src[xx + 1] - src[xx]) * xalpha;
+         xpos  += xInc;
      }
 +    for (i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--)
 +        dst[i] = src[srcW-1]*128;
  }
  
  // *** horizontal scale Y line to temp buffer
@@@ -238,13 -234,14 +243,14 @@@ static av_always_inline void hyscale(Sw
                                       uint8_t *formatConvBuffer,
                                       uint32_t *pal, int isAlpha)
  {
-     void (*toYV12)(uint8_t *, const uint8_t *, const uint8_t *, const uint8_t *, int, uint32_t *) = isAlpha ? c->alpToYV12 : c->lumToYV12;
 -    void (*toYV12)(uint8_t *, const uint8_t *, int, uint32_t *) =
++    void (*toYV12)(uint8_t *, const uint8_t *, const uint8_t *, const uint8_t *, int, uint32_t *) =
+         isAlpha ? c->alpToYV12 : c->lumToYV12;
      void (*convertRange)(int16_t *, int) = isAlpha ? NULL : c->lumConvertRange;
      const uint8_t *src = src_in[isAlpha ? 3 : 0];
  
      if (toYV12) {
 -        toYV12(formatConvBuffer, src, srcW, pal);
 +        toYV12(formatConvBuffer, src, src_in[1], src_in[2], srcW, pal);
-         src= formatConvBuffer;
+         src = formatConvBuffer;
      } else if (c->readLumPlanar && !isAlpha) {
          c->readLumPlanar(formatConvBuffer, src_in, srcW);
          src = formatConvBuffer;
@@@ -265,37 -263,38 +272,42 @@@ static void hcscale_fast_c(SwsContext *
                             const uint8_t *src2, int srcW, int xInc)
  {
      int i;
-     unsigned int xpos=0;
-     for (i=0;i<dstWidth;i++) {
-         register unsigned int xx=xpos>>16;
-         register unsigned int xalpha=(xpos&0xFFFF)>>9;
-         dst1[i]=(src1[xx]*(xalpha^127)+src1[xx+1]*xalpha);
-         dst2[i]=(src2[xx]*(xalpha^127)+src2[xx+1]*xalpha);
-         xpos+=xInc;
+     unsigned int xpos = 0;
+     for (i = 0; i < dstWidth; i++) {
+         register unsigned int xx     = xpos >> 16;
+         register unsigned int xalpha = (xpos & 0xFFFF) >> 9;
+         dst1[i] = (src1[xx] * (xalpha ^ 127) + src1[xx + 1] * xalpha);
+         dst2[i] = (src2[xx] * (xalpha ^ 127) + src2[xx + 1] * xalpha);
+         xpos   += xInc;
      }
 +    for (i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--) {
 +        dst1[i] = src1[srcW-1]*128;
 +        dst2[i] = src2[srcW-1]*128;
 +    }
  }
  
- static av_always_inline void hcscale(SwsContext *c, int16_t *dst1, int16_t *dst2, int dstWidth,
+ static av_always_inline void hcscale(SwsContext *c, int16_t *dst1,
+                                      int16_t *dst2, int dstWidth,
                                       const uint8_t *src_in[4],
-                                      int srcW, int xInc, const int16_t *hChrFilter,
-                                      const int32_t *hChrFilterPos, int hChrFilterSize,
+                                      int srcW, int xInc,
+                                      const int16_t *hChrFilter,
+                                      const int32_t *hChrFilterPos,
+                                      int hChrFilterSize,
                                       uint8_t *formatConvBuffer, uint32_t *pal)
  {
      const uint8_t *src1 = src_in[1], *src2 = src_in[2];
      if (c->chrToYV12) {
-         uint8_t *buf2 = formatConvBuffer + FFALIGN(srcW*2+78, 16);
+         uint8_t *buf2 = formatConvBuffer +
 -                        FFALIGN(srcW * FFALIGN(c->srcBpc, 8) >> 3, 16);
 -        c->chrToYV12(formatConvBuffer, buf2, src1, src2, srcW, pal);
 -        src1 = formatConvBuffer;
 -        src2 = buf2;
++                        FFALIGN(srcW*2+78, 16);
 +        c->chrToYV12(formatConvBuffer, buf2, src_in[0], src1, src2, srcW, pal);
 +        src1= formatConvBuffer;
 +        src2= buf2;
      } else if (c->readChrPlanar) {
-         uint8_t *buf2 = formatConvBuffer + FFALIGN(srcW*2+78, 16);
+         uint8_t *buf2 = formatConvBuffer +
 -                        FFALIGN(srcW * FFALIGN(c->srcBpc, 8) >> 3, 16);
++                        FFALIGN(srcW*2+78, 16);
          c->readChrPlanar(formatConvBuffer, buf2, src_in, srcW);
-         src1= formatConvBuffer;
-         src2= buf2;
+         src1 = formatConvBuffer;
+         src2 = buf2;
      }
  
      if (!c->hcscale_fast) {
  }
  
  #define DEBUG_SWSCALE_BUFFERS 0
- #define DEBUG_BUFFERS(...) if (DEBUG_SWSCALE_BUFFERS) av_log(c, AV_LOG_DEBUG, __VA_ARGS__)
+ #define DEBUG_BUFFERS(...)                      \
+     if (DEBUG_SWSCALE_BUFFERS)                  \
+         av_log(c, AV_LOG_DEBUG, __VA_ARGS__)
  
- static int swScale(SwsContext *c, const uint8_tsrc[],
+ static int swScale(SwsContext *c, const uint8_t *src[],
                     int srcStride[], int srcSliceY,
-                    int srcSliceH, uint8_tdst[], int dstStride[])
+                    int srcSliceH, uint8_t *dst[], int dstStride[])
  {
-     /* load a few things into local vars to make the code more readable? and faster */
-     const int srcW= c->srcW;
-     const int dstW= c->dstW;
-     const int dstH= c->dstH;
-     const int chrDstW= c->chrDstW;
-     const int chrSrcW= c->chrSrcW;
-     const int lumXInc= c->lumXInc;
-     const int chrXInc= c->chrXInc;
-     const enum PixelFormat dstFormat= c->dstFormat;
-     const int flags= c->flags;
-     int32_t *vLumFilterPos= c->vLumFilterPos;
-     int32_t *vChrFilterPos= c->vChrFilterPos;
-     int32_t *hLumFilterPos= c->hLumFilterPos;
-     int32_t *hChrFilterPos= c->hChrFilterPos;
-     int16_t *hLumFilter= c->hLumFilter;
-     int16_t *hChrFilter= c->hChrFilter;
-     int32_t *lumMmxFilter= c->lumMmxFilter;
-     int32_t *chrMmxFilter= c->chrMmxFilter;
-     const int vLumFilterSize= c->vLumFilterSize;
-     const int vChrFilterSize= c->vChrFilterSize;
-     const int hLumFilterSize= c->hLumFilterSize;
-     const int hChrFilterSize= c->hChrFilterSize;
-     int16_t **lumPixBuf= c->lumPixBuf;
-     int16_t **chrUPixBuf= c->chrUPixBuf;
-     int16_t **chrVPixBuf= c->chrVPixBuf;
-     int16_t **alpPixBuf= c->alpPixBuf;
-     const int vLumBufSize= c->vLumBufSize;
-     const int vChrBufSize= c->vChrBufSize;
-     uint8_t *formatConvBuffer= c->formatConvBuffer;
-     const int chrSrcSliceY= srcSliceY >> c->chrSrcVSubSample;
-     const int chrSrcSliceH= -((-srcSliceH) >> c->chrSrcVSubSample);
+     /* load a few things into local vars to make the code more readable?
+      * and faster */
+     const int srcW                   = c->srcW;
+     const int dstW                   = c->dstW;
+     const int dstH                   = c->dstH;
+     const int chrDstW                = c->chrDstW;
+     const int chrSrcW                = c->chrSrcW;
+     const int lumXInc                = c->lumXInc;
+     const int chrXInc                = c->chrXInc;
+     const enum PixelFormat dstFormat = c->dstFormat;
+     const int flags                  = c->flags;
+     int32_t *vLumFilterPos           = c->vLumFilterPos;
+     int32_t *vChrFilterPos           = c->vChrFilterPos;
+     int32_t *hLumFilterPos           = c->hLumFilterPos;
+     int32_t *hChrFilterPos           = c->hChrFilterPos;
+     int16_t *vLumFilter              = c->vLumFilter;
+     int16_t *vChrFilter              = c->vChrFilter;
+     int16_t *hLumFilter              = c->hLumFilter;
+     int16_t *hChrFilter              = c->hChrFilter;
+     int32_t *lumMmxFilter            = c->lumMmxFilter;
+     int32_t *chrMmxFilter            = c->chrMmxFilter;
+     const int vLumFilterSize         = c->vLumFilterSize;
+     const int vChrFilterSize         = c->vChrFilterSize;
+     const int hLumFilterSize         = c->hLumFilterSize;
+     const int hChrFilterSize         = c->hChrFilterSize;
+     int16_t **lumPixBuf              = c->lumPixBuf;
+     int16_t **chrUPixBuf             = c->chrUPixBuf;
+     int16_t **chrVPixBuf             = c->chrVPixBuf;
+     int16_t **alpPixBuf              = c->alpPixBuf;
+     const int vLumBufSize            = c->vLumBufSize;
+     const int vChrBufSize            = c->vChrBufSize;
+     uint8_t *formatConvBuffer        = c->formatConvBuffer;
+     uint32_t *pal                    = c->pal_yuv;
+     yuv2planar1_fn yuv2plane1        = c->yuv2plane1;
+     yuv2planarX_fn yuv2planeX        = c->yuv2planeX;
+     yuv2interleavedX_fn yuv2nv12cX   = c->yuv2nv12cX;
+     yuv2packed1_fn yuv2packed1       = c->yuv2packed1;
+     yuv2packed2_fn yuv2packed2       = c->yuv2packed2;
+     yuv2packedX_fn yuv2packedX       = c->yuv2packedX;
+     const int chrSrcSliceY           =     srcSliceY  >> c->chrSrcVSubSample;
+     const int chrSrcSliceH           = -((-srcSliceH) >> c->chrSrcVSubSample);
+     int should_dither                = is9_OR_10BPS(c->srcFormat) ||
+                                        is16BPS(c->srcFormat);
      int lastDstY;
-     uint32_t *pal=c->pal_yuv;
-     int should_dither= isNBPS(c->srcFormat) || is16BPS(c->srcFormat);
-     yuv2planar1_fn yuv2plane1 = c->yuv2plane1;
-     yuv2planarX_fn yuv2planeX = c->yuv2planeX;
-     yuv2interleavedX_fn yuv2nv12cX = c->yuv2nv12cX;
-     yuv2packed1_fn yuv2packed1 = c->yuv2packed1;
-     yuv2packed2_fn yuv2packed2 = c->yuv2packed2;
-     yuv2packedX_fn yuv2packedX = c->yuv2packedX;
  
      /* vars which will change and which we need to store back in the context */
-     int dstY= c->dstY;
-     int lumBufIndex= c->lumBufIndex;
-     int chrBufIndex= c->chrBufIndex;
-     int lastInLumBuf= c->lastInLumBuf;
-     int lastInChrBuf= c->lastInChrBuf;
+     int dstY         = c->dstY;
+     int lumBufIndex  = c->lumBufIndex;
+     int chrBufIndex  = c->chrBufIndex;
+     int lastInLumBuf = c->lastInLumBuf;
+     int lastInChrBuf = c->lastInChrBuf;
  
      if (isPacked(c->srcFormat)) {
-         src[0]=
-         src[1]=
-         src[2]=
-         src[3]= src[0];
-         srcStride[0]=
-         srcStride[1]=
-         srcStride[2]=
-         srcStride[3]= srcStride[0];
+         src[0] =
+         src[1] =
+         src[2] =
+         src[3] = src[0];
+         srcStride[0] =
+         srcStride[1] =
+         srcStride[2] =
+         srcStride[3] = srcStride[0];
      }
-     srcStride[1]<<= c->vChrDrop;
-     srcStride[2]<<= c->vChrDrop;
+     srcStride[1] <<= c->vChrDrop;
+     srcStride[2] <<= c->vChrDrop;
  
      DEBUG_BUFFERS("swScale() %p[%d] %p[%d] %p[%d] %p[%d] -> %p[%d] %p[%d] %p[%d] %p[%d]\n",
-                   src[0], srcStride[0], src[1], srcStride[1], src[2], srcStride[2], src[3], srcStride[3],
-                   dst[0], dstStride[0], dst[1], dstStride[1], dst[2], dstStride[2], dst[3], dstStride[3]);
+                   src[0], srcStride[0], src[1], srcStride[1],
+                   src[2], srcStride[2], src[3], srcStride[3],
+                   dst[0], dstStride[0], dst[1], dstStride[1],
+                   dst[2], dstStride[2], dst[3], dstStride[3]);
      DEBUG_BUFFERS("srcSliceY: %d srcSliceH: %d dstY: %d dstH: %d\n",
-                    srcSliceY,    srcSliceH,    dstY,    dstH);
+                   srcSliceY, srcSliceH, dstY, dstH);
      DEBUG_BUFFERS("vLumFilterSize: %d vLumBufSize: %d vChrFilterSize: %d vChrBufSize: %d\n",
-                    vLumFilterSize,    vLumBufSize,    vChrFilterSize,    vChrBufSize);
+                   vLumFilterSize, vLumBufSize, vChrFilterSize, vChrBufSize);
  
-     if (dstStride[0]%16 !=0 || dstStride[1]%16 !=0 || dstStride[2]%16 !=0 || dstStride[3]%16 != 0) {
-         static int warnedAlready=0; //FIXME move this into the context perhaps
 -    if (dstStride[0] % 8 != 0 || dstStride[1] % 8 != 0 ||
 -        dstStride[2] % 8 != 0 || dstStride[3] % 8 != 0) {
++    if (dstStride[0]%16 !=0 || dstStride[1]%16 !=0 ||
++        dstStride[2]%16 !=0 || dstStride[3]%16 != 0) {
+         static int warnedAlready = 0; // FIXME maybe move this into the context
          if (flags & SWS_PRINT_INFO && !warnedAlready) {
-             av_log(c, AV_LOG_WARNING, "Warning: dstStride is not aligned!\n"
+             av_log(c, AV_LOG_WARNING,
+                    "Warning: dstStride is not aligned!\n"
                     "         ->cannot do aligned memory accesses anymore\n");
-             warnedAlready=1;
+             warnedAlready = 1;
          }
      }
  
 +    if ((int)dst[0]%16 || (int)dst[1]%16 || (int)dst[2]%16 || (int)src[0]%16 || (int)src[1]%16 || (int)src[2]%16
 +        || dstStride[0]%16 || dstStride[1]%16 || dstStride[2]%16 || dstStride[3]%16
 +        || srcStride[0]%16 || srcStride[1]%16 || srcStride[2]%16 || srcStride[3]%16
 +    ) {
 +        static int warnedAlready=0;
 +        int cpu_flags = av_get_cpu_flags();
 +        if (HAVE_MMX2 && (cpu_flags & AV_CPU_FLAG_SSE2) && !warnedAlready){
 +            av_log(c, AV_LOG_WARNING, "Warning: data is not aligned! This can lead to a speedloss\n");
 +            warnedAlready=1;
 +        }
 +    }
 +
      /* Note the user might start scaling the picture in the middle so this
-        will not get executed. This is not really intended but works
-        currently, so people might do it. */
-     if (srcSliceY ==0) {
-         lumBufIndex=-1;
-         chrBufIndex=-1;
-         dstY=0;
-         lastInLumBuf= -1;
-         lastInChrBuf= -1;
+      * will not get executed. This is not really intended but works
+      * currently, so people might do it. */
+     if (srcSliceY == 0) {
+         lumBufIndex  = -1;
+         chrBufIndex  = -1;
+         dstY         = 0;
+         lastInLumBuf = -1;
+         lastInChrBuf = -1;
      }
  
      if (!should_dither) {
              dst[2] + dstStride[2] * chrDstY,
              (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? dst[3] + dstStride[3] * dstY : NULL,
          };
 +        int use_mmx_vfilter= c->use_mmx_vfilter;
  
-         const int firstLumSrcY= FFMAX(1 - vLumFilterSize, vLumFilterPos[dstY]); //First line needed as input
-         const int firstLumSrcY2= FFMAX(1 - vLumFilterSize, vLumFilterPos[FFMIN(dstY | ((1<<c->chrDstVSubSample) - 1), dstH-1)]);
-         const int firstChrSrcY= FFMAX(1 - vChrFilterSize, vChrFilterPos[chrDstY]); //First line needed as input
+         // First line needed as input
+         const int firstLumSrcY  = FFMAX(1 - vLumFilterSize, vLumFilterPos[dstY]);
+         const int firstLumSrcY2 = FFMAX(1 - vLumFilterSize, vLumFilterPos[FFMIN(dstY | ((1 << c->chrDstVSubSample) - 1), dstH - 1)]);
+         // First line needed as input
+         const int firstChrSrcY  = FFMAX(1 - vChrFilterSize, vChrFilterPos[chrDstY]);
  
          // Last line needed as input
          int lastLumSrcY  = FFMIN(c->srcH,    firstLumSrcY  + vLumFilterSize) - 1;
  #endif
          if (should_dither) {
              c->chrDither8 = dither_8x8_128[chrDstY & 7];
-             c->lumDither8 = dither_8x8_128[dstY & 7];
+             c->lumDither8 = dither_8x8_128[dstY    & 7];
          }
-         if (dstY >= dstH-2) {
-             // hmm looks like we can't use MMX here without overwriting this array's tail
-             ff_sws_init_output_funcs(c, &yuv2plane1, &yuv2planeX,  &yuv2nv12cX,
+         if (dstY >= dstH - 2) {
+             /* hmm looks like we can't use MMX here without overwriting
+              * this array's tail */
+             ff_sws_init_output_funcs(c, &yuv2plane1, &yuv2planeX, &yuv2nv12cX,
                                       &yuv2packed1, &yuv2packed2, &yuv2packedX);
 +            use_mmx_vfilter= 0;
          }
  
          {
-             const int16_t **lumSrcPtr= (const int16_t **)(void*) lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;
-             const int16_t **chrUSrcPtr= (const int16_t **)(void*) chrUPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;
-             const int16_t **chrVSrcPtr= (const int16_t **)(void*) chrVPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;
-             const int16_t **alpSrcPtr= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t **)(void*) alpPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize : NULL;
-             int16_t *vLumFilter= c->vLumFilter;
-             int16_t *vChrFilter= c->vChrFilter;
-             if (isPlanarYUV(dstFormat) || (isGray(dstFormat) && !isALPHA(dstFormat))) { //YV12 like
-                 const int chrSkipMask= (1<<c->chrDstVSubSample)-1;
 -            const int16_t **lumSrcPtr  = (const int16_t **)lumPixBuf  + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;
 -            const int16_t **chrUSrcPtr = (const int16_t **)chrUPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;
 -            const int16_t **chrVSrcPtr = (const int16_t **)chrVPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;
++            const int16_t **lumSrcPtr  = (const int16_t **)(void*) lumPixBuf  + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;
++            const int16_t **chrUSrcPtr = (const int16_t **)(void*) chrUPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;
++            const int16_t **chrVSrcPtr = (const int16_t **)(void*) chrVPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;
+             const int16_t **alpSrcPtr  = (CONFIG_SWSCALE_ALPHA && alpPixBuf) ?
 -                                         (const int16_t **)alpPixBuf  + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize : NULL;
 -
 -            if (firstLumSrcY < 0 || firstLumSrcY + vLumFilterSize > c->srcH) {
 -                const int16_t **tmpY = (const int16_t **)lumPixBuf +
 -                                       2 * vLumBufSize;
 -                int neg = -firstLumSrcY, i;
 -                int end = FFMIN(c->srcH - firstLumSrcY, vLumFilterSize);
 -                for (i = 0; i < neg; i++)
 -                    tmpY[i] = lumSrcPtr[neg];
 -                for (; i < end; i++)
 -                    tmpY[i] = lumSrcPtr[i];
 -                for (; i < vLumFilterSize; i++)
 -                    tmpY[i] = tmpY[i - 1];
 -                lumSrcPtr = tmpY;
 -
 -                if (alpSrcPtr) {
 -                    const int16_t **tmpA = (const int16_t **)alpPixBuf +
 -                                           2 * vLumBufSize;
 -                    for (i = 0; i < neg; i++)
 -                        tmpA[i] = alpSrcPtr[neg];
 -                    for (; i < end; i++)
 -                        tmpA[i] = alpSrcPtr[i];
 -                    for (; i < vLumFilterSize; i++)
 -                        tmpA[i] = tmpA[i - 1];
 -                    alpSrcPtr = tmpA;
 -                }
 -            }
 -            if (firstChrSrcY < 0 ||
 -                firstChrSrcY + vChrFilterSize > c->chrSrcH) {
 -                const int16_t **tmpU = (const int16_t **)chrUPixBuf + 2 * vChrBufSize,
 -                **tmpV               = (const int16_t **)chrVPixBuf + 2 * vChrBufSize;
 -                int neg = -firstChrSrcY, i;
 -                int end = FFMIN(c->chrSrcH - firstChrSrcY, vChrFilterSize);
 -                for (i = 0; i < neg; i++) {
 -                    tmpU[i] = chrUSrcPtr[neg];
 -                    tmpV[i] = chrVSrcPtr[neg];
 -                }
 -                for (; i < end; i++) {
 -                    tmpU[i] = chrUSrcPtr[i];
 -                    tmpV[i] = chrVSrcPtr[i];
 -                }
 -                for (; i < vChrFilterSize; i++) {
 -                    tmpU[i] = tmpU[i - 1];
 -                    tmpV[i] = tmpV[i - 1];
 -                }
 -                chrUSrcPtr = tmpU;
 -                chrVSrcPtr = tmpV;
 -            }
++                                         (const int16_t **)(void*) alpPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize : NULL;
++            int16_t *vLumFilter = c->vLumFilter;
++            int16_t *vChrFilter = c->vChrFilter;
+             if (isPlanarYUV(dstFormat) ||
+                 (isGray(dstFormat) && !isALPHA(dstFormat))) { // YV12 like
+                 const int chrSkipMask = (1 << c->chrDstVSubSample) - 1;
  
 +                vLumFilter +=    dstY * vLumFilterSize;
 +                vChrFilter += chrDstY * vChrFilterSize;
 +
 +//                 av_assert0(use_mmx_vfilter != (
 +//                                yuv2planeX == yuv2planeX_10BE_c
 +//                             || yuv2planeX == yuv2planeX_10LE_c
 +//                             || yuv2planeX == yuv2planeX_9BE_c
 +//                             || yuv2planeX == yuv2planeX_9LE_c
 +//                             || yuv2planeX == yuv2planeX_16BE_c
 +//                             || yuv2planeX == yuv2planeX_16LE_c
 +//                             || yuv2planeX == yuv2planeX_8_c) || !ARCH_X86);
 +
 +                if(use_mmx_vfilter){
 +                    vLumFilter= c->lumMmxFilter;
 +                    vChrFilter= c->chrMmxFilter;
 +                }
 +
                  if (vLumFilterSize == 1) {
                      yuv2plane1(lumSrcPtr[0], dest[0], dstW, c->lumDither8, 0);
                  } else {
 -                    yuv2planeX(vLumFilter + dstY * vLumFilterSize,
 -                               vLumFilterSize, lumSrcPtr, dest[0],
 +                    yuv2planeX(vLumFilter, vLumFilterSize,
-                                lumSrcPtr, dest[0], dstW, c->lumDither8, 0);
++                               lumSrcPtr, dest[0],
+                                dstW, c->lumDither8, 0);
                  }
  
-                 if (!((dstY&chrSkipMask) || isGray(dstFormat))) {
+                 if (!((dstY & chrSkipMask) || isGray(dstFormat))) {
                      if (yuv2nv12cX) {
-                         yuv2nv12cX(c, vChrFilter, vChrFilterSize, chrUSrcPtr, chrVSrcPtr, dest[1], chrDstW);
 -                        yuv2nv12cX(c, vChrFilter + chrDstY * vChrFilterSize,
++                        yuv2nv12cX(c, vChrFilter,
+                                    vChrFilterSize, chrUSrcPtr, chrVSrcPtr,
+                                    dest[1], chrDstW);
                      } else if (vChrFilterSize == 1) {
                          yuv2plane1(chrUSrcPtr[0], dest[1], chrDstW, c->chrDither8, 0);
                          yuv2plane1(chrVSrcPtr[0], dest[2], chrDstW, c->chrDither8, 3);
                      } else {
-                         yuv2planeX(vChrFilter, vChrFilterSize,
-                                    chrUSrcPtr, dest[1], chrDstW, c->chrDither8, 0);
-                         yuv2planeX(vChrFilter, vChrFilterSize,
-                                    chrVSrcPtr, dest[2], chrDstW, c->chrDither8, use_mmx_vfilter ? (c->uv_offx2 >> 1) : 3);
 -                        yuv2planeX(vChrFilter + chrDstY * vChrFilterSize,
++                        yuv2planeX(vChrFilter,
+                                    vChrFilterSize, chrUSrcPtr, dest[1],
+                                    chrDstW, c->chrDither8, 0);
 -                        yuv2planeX(vChrFilter + chrDstY * vChrFilterSize,
++                        yuv2planeX(vChrFilter,
+                                    vChrFilterSize, chrVSrcPtr, dest[2],
 -                                   chrDstW, c->chrDither8, 3);
++                                   chrDstW, c->chrDither8, use_mmx_vfilter ? (c->uv_offx2 >> 1) : 3);
                      }
                  }
  
-                 if (CONFIG_SWSCALE_ALPHA && alpPixBuf){
+                 if (CONFIG_SWSCALE_ALPHA && alpPixBuf) {
 +                    if(use_mmx_vfilter){
 +                        vLumFilter= c->alpMmxFilter;
 +                    }
                      if (vLumFilterSize == 1) {
-                         yuv2plane1(alpSrcPtr[0], dest[3], dstW, c->lumDither8, 0);
+                         yuv2plane1(alpSrcPtr[0], dest[3], dstW,
+                                    c->lumDither8, 0);
                      } else {
-                         yuv2planeX(vLumFilter, vLumFilterSize,
-                                    alpSrcPtr, dest[3], dstW, c->lumDither8, 0);
 -                        yuv2planeX(vLumFilter + dstY * vLumFilterSize,
++                        yuv2planeX(vLumFilter,
+                                    vLumFilterSize, alpSrcPtr, dest[3],
+                                    dstW, c->lumDither8, 0);
                      }
                  }
              } else {
@@@ -588,96 -574,56 +588,96 @@@ const char *sws_format_name(enum PixelF
       (x) == PIX_FMT_GRAY16LE)
  #endif
  
 -#define isRGBinInt(x)                  \
 -    ((x) == PIX_FMT_RGB48BE     ||     \
 -     (x) == PIX_FMT_RGB48LE     ||     \
 -     (x) == PIX_FMT_RGB32       ||     \
 -     (x) == PIX_FMT_RGB32_1     ||     \
 -     (x) == PIX_FMT_RGB24       ||     \
 -     (x) == PIX_FMT_RGB565BE    ||     \
 -     (x) == PIX_FMT_RGB565LE    ||     \
 -     (x) == PIX_FMT_RGB555BE    ||     \
 -     (x) == PIX_FMT_RGB555LE    ||     \
 -     (x) == PIX_FMT_RGB444BE    ||     \
 -     (x) == PIX_FMT_RGB444LE    ||     \
 -     (x) == PIX_FMT_RGB8        ||     \
 -     (x) == PIX_FMT_RGB4        ||     \
 -     (x) == PIX_FMT_RGB4_BYTE   ||     \
 -     (x) == PIX_FMT_MONOBLACK   ||     \
 -     (x) == PIX_FMT_MONOWHITE)
 -
 -#define isBGRinInt(x)                  \
 -    ((x) == PIX_FMT_BGR48BE     ||     \
 -     (x) == PIX_FMT_BGR48LE     ||     \
 -     (x) == PIX_FMT_BGR32       ||     \
 -     (x) == PIX_FMT_BGR32_1     ||     \
 -     (x) == PIX_FMT_BGR24       ||     \
 -     (x) == PIX_FMT_BGR565BE    ||     \
 -     (x) == PIX_FMT_BGR565LE    ||     \
 -     (x) == PIX_FMT_BGR555BE    ||     \
 -     (x) == PIX_FMT_BGR555LE    ||     \
 -     (x) == PIX_FMT_BGR444BE    ||     \
 -     (x) == PIX_FMT_BGR444LE    ||     \
 -     (x) == PIX_FMT_BGR8        ||     \
 -     (x) == PIX_FMT_BGR4        ||     \
 -     (x) == PIX_FMT_BGR4_BYTE   ||     \
 -     (x) == PIX_FMT_MONOBLACK   ||     \
 -     (x) == PIX_FMT_MONOWHITE)
 -
 -#define isAnyRGB(x)                    \
 -    (isRGBinInt(x)              ||     \
 -     isBGRinInt(x))
 +#define isRGBinInt(x) \
 +    (           \
 +        (x)==PIX_FMT_RGB48BE   ||   \
 +        (x)==PIX_FMT_RGB48LE   ||   \
 +        (x)==PIX_FMT_RGBA64BE  ||   \
 +        (x)==PIX_FMT_RGBA64LE  ||   \
 +        (x)==PIX_FMT_RGB32     ||   \
 +        (x)==PIX_FMT_RGB32_1   ||   \
 +        (x)==PIX_FMT_RGB24     ||   \
 +        (x)==PIX_FMT_RGB565BE  ||   \
 +        (x)==PIX_FMT_RGB565LE  ||   \
 +        (x)==PIX_FMT_RGB555BE  ||   \
 +        (x)==PIX_FMT_RGB555LE  ||   \
 +        (x)==PIX_FMT_RGB444BE  ||   \
 +        (x)==PIX_FMT_RGB444LE  ||   \
 +        (x)==PIX_FMT_RGB8      ||   \
 +        (x)==PIX_FMT_RGB4      ||   \
 +        (x)==PIX_FMT_RGB4_BYTE ||   \
 +        (x)==PIX_FMT_MONOBLACK ||   \
 +        (x)==PIX_FMT_MONOWHITE   \
 +    )
 +#define isBGRinInt(x) \
 +    (           \
 +         (x)==PIX_FMT_BGR48BE  ||   \
 +         (x)==PIX_FMT_BGR48LE  ||   \
 +         (x)==PIX_FMT_BGRA64BE ||   \
 +         (x)==PIX_FMT_BGRA64LE ||   \
 +         (x)==PIX_FMT_BGR32    ||   \
 +         (x)==PIX_FMT_BGR32_1  ||   \
 +         (x)==PIX_FMT_BGR24    ||   \
 +         (x)==PIX_FMT_BGR565BE ||   \
 +         (x)==PIX_FMT_BGR565LE ||   \
 +         (x)==PIX_FMT_BGR555BE ||   \
 +         (x)==PIX_FMT_BGR555LE ||   \
 +         (x)==PIX_FMT_BGR444BE ||   \
 +         (x)==PIX_FMT_BGR444LE ||   \
 +         (x)==PIX_FMT_BGR8     ||   \
 +         (x)==PIX_FMT_BGR4     ||   \
 +         (x)==PIX_FMT_BGR4_BYTE||   \
 +         (x)==PIX_FMT_MONOBLACK||   \
 +         (x)==PIX_FMT_MONOWHITE   \
 +    )
 +
 +#define isRGBinBytes(x) (           \
 +           (x)==PIX_FMT_RGB48BE     \
 +        || (x)==PIX_FMT_RGB48LE     \
 +        || (x)==PIX_FMT_RGBA64BE    \
 +        || (x)==PIX_FMT_RGBA64LE    \
 +        || (x)==PIX_FMT_RGBA        \
 +        || (x)==PIX_FMT_ARGB        \
 +        || (x)==PIX_FMT_RGB24       \
 +    )
 +#define isBGRinBytes(x) (           \
 +           (x)==PIX_FMT_BGR48BE     \
 +        || (x)==PIX_FMT_BGR48LE     \
 +        || (x)==PIX_FMT_BGRA64BE    \
 +        || (x)==PIX_FMT_BGRA64LE    \
 +        || (x)==PIX_FMT_BGRA        \
 +        || (x)==PIX_FMT_ABGR        \
 +        || (x)==PIX_FMT_BGR24       \
 +    )
 +
 +#define isAnyRGB(x) \
 +    (           \
 +          isRGBinInt(x)       ||    \
 +          isBGRinInt(x)       ||    \
 +          (x)==PIX_FMT_GBR24P     \
 +    )
  
- #define isALPHA(x) \
-     (av_pix_fmt_descriptors[x].nb_components == 2 || \
+ #define isALPHA(x)                                             \
+     (av_pix_fmt_descriptors[x].nb_components == 2          ||  \
       av_pix_fmt_descriptors[x].nb_components == 4)
  
 +#if 1
 +#define isPacked(x)         (       \
 +           (x)==PIX_FMT_PAL8        \
 +        || (x)==PIX_FMT_YUYV422     \
 +        || (x)==PIX_FMT_UYVY422     \
 +        || (x)==PIX_FMT_Y400A       \
 +        ||  isRGBinInt(x)           \
 +        ||  isBGRinInt(x)           \
 +    )
 +#else
  #define isPacked(x)                                            \
      ((av_pix_fmt_descriptors[x].nb_components >= 2         &&  \
        !(av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR)) ||  \
       (x) == PIX_FMT_PAL8)
  
- #define isPlanar(x) \
 +#endif
+ #define isPlanar(x)                                            \
      (av_pix_fmt_descriptors[x].nb_components >= 2          &&  \
       (av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR))
  
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
- #define _SVID_SOURCE //needed for MAP_ANONYMOUS
+ #include "config.h"
+ #define _SVID_SOURCE // needed for MAP_ANONYMOUS
 +#define _DARWIN_C_SOURCE // needed for MAP_ANON
+ #include <assert.h>
  #include <inttypes.h>
- #include <string.h>
  #include <math.h>
  #include <stdio.h>
- #include "config.h"
- #include <assert.h>
+ #include <string.h>
  #if HAVE_SYS_MMAN_H
  #include <sys/mman.h>
  #if defined(MAP_ANON) && !defined(MAP_ANONYMOUS)
  #define WIN32_LEAN_AND_MEAN
  #include <windows.h>
  #endif
- #include "swscale.h"
- #include "swscale_internal.h"
- #include "rgb2rgb.h"
- #include "libavutil/intreadwrite.h"
- #include "libavutil/x86_cpu.h"
- #include "libavutil/cpu.h"
++#include "libavutil/avassert.h"
  #include "libavutil/avutil.h"
  #include "libavutil/bswap.h"
+ #include "libavutil/cpu.h"
+ #include "libavutil/intreadwrite.h"
  #include "libavutil/mathematics.h"
  #include "libavutil/opt.h"
  #include "libavutil/pixdesc.h"
@@@ -63,101 -62,92 +65,101 @@@ const char *swscale_configuration(void
  const char *swscale_license(void)
  {
  #define LICENSE_PREFIX "libswscale license: "
 -    return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
 +    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  }
  
- #define RET 0xC3 //near return opcode for x86
+ #define RET 0xC3 // near return opcode for x86
  
  typedef struct FormatEntry {
      int is_supported_in, is_supported_out;
  } FormatEntry;
  
  static const FormatEntry format_entries[PIX_FMT_NB] = {
-     [PIX_FMT_YUV420P]     = { 1 , 1 },
-     [PIX_FMT_YUYV422]     = { 1 , 1 },
-     [PIX_FMT_RGB24]       = { 1 , 1 },
-     [PIX_FMT_BGR24]       = { 1 , 1 },
-     [PIX_FMT_YUV422P]     = { 1 , 1 },
-     [PIX_FMT_YUV444P]     = { 1 , 1 },
-     [PIX_FMT_YUV410P]     = { 1 , 1 },
-     [PIX_FMT_YUV411P]     = { 1 , 1 },
-     [PIX_FMT_GRAY8]       = { 1 , 1 },
-     [PIX_FMT_MONOWHITE]   = { 1 , 1 },
-     [PIX_FMT_MONOBLACK]   = { 1 , 1 },
-     [PIX_FMT_PAL8]        = { 1 , 0 },
-     [PIX_FMT_YUVJ420P]    = { 1 , 1 },
-     [PIX_FMT_YUVJ422P]    = { 1 , 1 },
-     [PIX_FMT_YUVJ444P]    = { 1 , 1 },
-     [PIX_FMT_UYVY422]     = { 1 , 1 },
-     [PIX_FMT_UYYVYY411]   = { 0 , 0 },
-     [PIX_FMT_BGR8]        = { 1 , 1 },
-     [PIX_FMT_BGR4]        = { 0 , 1 },
-     [PIX_FMT_BGR4_BYTE]   = { 1 , 1 },
-     [PIX_FMT_RGB8]        = { 1 , 1 },
-     [PIX_FMT_RGB4]        = { 0 , 1 },
-     [PIX_FMT_RGB4_BYTE]   = { 1 , 1 },
-     [PIX_FMT_NV12]        = { 1 , 1 },
-     [PIX_FMT_NV21]        = { 1 , 1 },
-     [PIX_FMT_ARGB]        = { 1 , 1 },
-     [PIX_FMT_RGBA]        = { 1 , 1 },
-     [PIX_FMT_ABGR]        = { 1 , 1 },
-     [PIX_FMT_BGRA]        = { 1 , 1 },
-     [PIX_FMT_0RGB]        = { 1 , 1 },
-     [PIX_FMT_RGB0]        = { 1 , 1 },
-     [PIX_FMT_0BGR]        = { 1 , 1 },
-     [PIX_FMT_BGR0]        = { 1 , 1 },
-     [PIX_FMT_GRAY16BE]    = { 1 , 1 },
-     [PIX_FMT_GRAY16LE]    = { 1 , 1 },
-     [PIX_FMT_YUV440P]     = { 1 , 1 },
-     [PIX_FMT_YUVJ440P]    = { 1 , 1 },
-     [PIX_FMT_YUVA420P]    = { 1 , 1 },
-     [PIX_FMT_YUVA444P]    = { 1 , 1 },
-     [PIX_FMT_RGB48BE]     = { 1 , 1 },
-     [PIX_FMT_RGB48LE]     = { 1 , 1 },
-     [PIX_FMT_RGBA64BE]    = { 1 , 0 },
-     [PIX_FMT_RGBA64LE]    = { 1 , 0 },
-     [PIX_FMT_RGB565BE]    = { 1 , 1 },
-     [PIX_FMT_RGB565LE]    = { 1 , 1 },
-     [PIX_FMT_RGB555BE]    = { 1 , 1 },
-     [PIX_FMT_RGB555LE]    = { 1 , 1 },
-     [PIX_FMT_BGR565BE]    = { 1 , 1 },
-     [PIX_FMT_BGR565LE]    = { 1 , 1 },
-     [PIX_FMT_BGR555BE]    = { 1 , 1 },
-     [PIX_FMT_BGR555LE]    = { 1 , 1 },
-     [PIX_FMT_YUV420P16LE] = { 1 , 1 },
-     [PIX_FMT_YUV420P16BE] = { 1 , 1 },
-     [PIX_FMT_YUV422P16LE] = { 1 , 1 },
-     [PIX_FMT_YUV422P16BE] = { 1 , 1 },
-     [PIX_FMT_YUV444P16LE] = { 1 , 1 },
-     [PIX_FMT_YUV444P16BE] = { 1 , 1 },
-     [PIX_FMT_RGB444LE]    = { 1 , 1 },
-     [PIX_FMT_RGB444BE]    = { 1 , 1 },
-     [PIX_FMT_BGR444LE]    = { 1 , 1 },
-     [PIX_FMT_BGR444BE]    = { 1 , 1 },
-     [PIX_FMT_Y400A]       = { 1 , 0 },
-     [PIX_FMT_BGR48BE]     = { 1 , 1 },
-     [PIX_FMT_BGR48LE]     = { 1 , 1 },
-     [PIX_FMT_BGRA64BE]    = { 0 , 0 },
-     [PIX_FMT_BGRA64LE]    = { 0 , 0 },
-     [PIX_FMT_YUV420P9BE]  = { 1 , 1 },
-     [PIX_FMT_YUV420P9LE]  = { 1 , 1 },
-     [PIX_FMT_YUV420P10BE] = { 1 , 1 },
-     [PIX_FMT_YUV420P10LE] = { 1 , 1 },
-     [PIX_FMT_YUV422P9BE]  = { 1 , 1 },
-     [PIX_FMT_YUV422P9LE]  = { 1 , 1 },
-     [PIX_FMT_YUV422P10BE] = { 1 , 1 },
-     [PIX_FMT_YUV422P10LE] = { 1 , 1 },
-     [PIX_FMT_YUV444P9BE]  = { 1 , 1 },
-     [PIX_FMT_YUV444P9LE]  = { 1 , 1 },
-     [PIX_FMT_YUV444P10BE] = { 1 , 1 },
-     [PIX_FMT_YUV444P10LE] = { 1 , 1 },
-     [PIX_FMT_GBRP]        = { 1 , 0 },
-     [PIX_FMT_GBRP9LE]     = { 1 , 0 },
-     [PIX_FMT_GBRP9BE]     = { 1 , 0 },
-     [PIX_FMT_GBRP10LE]    = { 1 , 0 },
-     [PIX_FMT_GBRP10BE]    = { 1 , 0 },
-     [PIX_FMT_GBRP16LE]    = { 1 , 0 },
-     [PIX_FMT_GBRP16BE]    = { 1 , 0 },
+     [PIX_FMT_YUV420P]     = { 1, 1 },
+     [PIX_FMT_YUYV422]     = { 1, 1 },
+     [PIX_FMT_RGB24]       = { 1, 1 },
+     [PIX_FMT_BGR24]       = { 1, 1 },
+     [PIX_FMT_YUV422P]     = { 1, 1 },
+     [PIX_FMT_YUV444P]     = { 1, 1 },
+     [PIX_FMT_YUV410P]     = { 1, 1 },
+     [PIX_FMT_YUV411P]     = { 1, 1 },
+     [PIX_FMT_GRAY8]       = { 1, 1 },
+     [PIX_FMT_MONOWHITE]   = { 1, 1 },
+     [PIX_FMT_MONOBLACK]   = { 1, 1 },
+     [PIX_FMT_PAL8]        = { 1, 0 },
+     [PIX_FMT_YUVJ420P]    = { 1, 1 },
+     [PIX_FMT_YUVJ422P]    = { 1, 1 },
+     [PIX_FMT_YUVJ444P]    = { 1, 1 },
+     [PIX_FMT_UYVY422]     = { 1, 1 },
+     [PIX_FMT_UYYVYY411]   = { 0, 0 },
+     [PIX_FMT_BGR8]        = { 1, 1 },
+     [PIX_FMT_BGR4]        = { 0, 1 },
+     [PIX_FMT_BGR4_BYTE]   = { 1, 1 },
+     [PIX_FMT_RGB8]        = { 1, 1 },
+     [PIX_FMT_RGB4]        = { 0, 1 },
+     [PIX_FMT_RGB4_BYTE]   = { 1, 1 },
+     [PIX_FMT_NV12]        = { 1, 1 },
+     [PIX_FMT_NV21]        = { 1, 1 },
+     [PIX_FMT_ARGB]        = { 1, 1 },
+     [PIX_FMT_RGBA]        = { 1, 1 },
+     [PIX_FMT_ABGR]        = { 1, 1 },
+     [PIX_FMT_BGRA]        = { 1, 1 },
++    [PIX_FMT_0RGB]        = { 1, 1 },
++    [PIX_FMT_RGB0]        = { 1, 1 },
++    [PIX_FMT_0BGR]        = { 1, 1 },
++    [PIX_FMT_BGR0]        = { 1, 1 },
+     [PIX_FMT_GRAY16BE]    = { 1, 1 },
+     [PIX_FMT_GRAY16LE]    = { 1, 1 },
+     [PIX_FMT_YUV440P]     = { 1, 1 },
+     [PIX_FMT_YUVJ440P]    = { 1, 1 },
+     [PIX_FMT_YUVA420P]    = { 1, 1 },
++    [PIX_FMT_YUVA444P]    = { 1, 1 },
+     [PIX_FMT_RGB48BE]     = { 1, 1 },
+     [PIX_FMT_RGB48LE]     = { 1, 1 },
++    [PIX_FMT_RGBA64BE]    = { 1, 0 },
++    [PIX_FMT_RGBA64LE]    = { 1, 0 },
+     [PIX_FMT_RGB565BE]    = { 1, 1 },
+     [PIX_FMT_RGB565LE]    = { 1, 1 },
+     [PIX_FMT_RGB555BE]    = { 1, 1 },
+     [PIX_FMT_RGB555LE]    = { 1, 1 },
+     [PIX_FMT_BGR565BE]    = { 1, 1 },
+     [PIX_FMT_BGR565LE]    = { 1, 1 },
+     [PIX_FMT_BGR555BE]    = { 1, 1 },
+     [PIX_FMT_BGR555LE]    = { 1, 1 },
+     [PIX_FMT_YUV420P16LE] = { 1, 1 },
+     [PIX_FMT_YUV420P16BE] = { 1, 1 },
+     [PIX_FMT_YUV422P16LE] = { 1, 1 },
+     [PIX_FMT_YUV422P16BE] = { 1, 1 },
+     [PIX_FMT_YUV444P16LE] = { 1, 1 },
+     [PIX_FMT_YUV444P16BE] = { 1, 1 },
+     [PIX_FMT_RGB444LE]    = { 1, 1 },
+     [PIX_FMT_RGB444BE]    = { 1, 1 },
+     [PIX_FMT_BGR444LE]    = { 1, 1 },
+     [PIX_FMT_BGR444BE]    = { 1, 1 },
+     [PIX_FMT_Y400A]       = { 1, 0 },
+     [PIX_FMT_BGR48BE]     = { 1, 1 },
+     [PIX_FMT_BGR48LE]     = { 1, 1 },
++    [PIX_FMT_BGRA64BE]    = { 0, 0 },
++    [PIX_FMT_BGRA64LE]    = { 0, 0 },
+     [PIX_FMT_YUV420P9BE]  = { 1, 1 },
+     [PIX_FMT_YUV420P9LE]  = { 1, 1 },
+     [PIX_FMT_YUV420P10BE] = { 1, 1 },
+     [PIX_FMT_YUV420P10LE] = { 1, 1 },
+     [PIX_FMT_YUV422P9BE]  = { 1, 1 },
+     [PIX_FMT_YUV422P9LE]  = { 1, 1 },
+     [PIX_FMT_YUV422P10BE] = { 1, 1 },
+     [PIX_FMT_YUV422P10LE] = { 1, 1 },
+     [PIX_FMT_YUV444P9BE]  = { 1, 1 },
+     [PIX_FMT_YUV444P9LE]  = { 1, 1 },
+     [PIX_FMT_YUV444P10BE] = { 1, 1 },
+     [PIX_FMT_YUV444P10LE] = { 1, 1 },
+     [PIX_FMT_GBRP]        = { 1, 0 },
+     [PIX_FMT_GBRP9LE]     = { 1, 0 },
+     [PIX_FMT_GBRP9BE]     = { 1, 0 },
+     [PIX_FMT_GBRP10LE]    = { 1, 0 },
+     [PIX_FMT_GBRP10BE]    = { 1, 0 },
+     [PIX_FMT_GBRP16LE]    = { 1, 0 },
+     [PIX_FMT_GBRP16BE]    = { 1, 0 },
  };
  
  int sws_isSupportedInput(enum PixelFormat pix_fmt)
@@@ -174,85 -164,96 +176,94 @@@ int sws_isSupportedOutput(enum PixelFor
  
  extern const int32_t ff_yuv2rgb_coeffs[8][4];
  
 +#if FF_API_SWS_FORMAT_NAME
  const char *sws_format_name(enum PixelFormat format)
  {
 -    if ((unsigned)format < PIX_FMT_NB && av_pix_fmt_descriptors[format].name)
 -        return av_pix_fmt_descriptors[format].name;
 -    else
 -        return "Unknown format";
 +    return av_get_pix_fmt_name(format);
  }
 +#endif
  
- static double getSplineCoeff(double a, double b, double c, double d, double dist)
+ static double getSplineCoeff(double a, double b, double c, double d,
+                              double dist)
  {
-     if (dist<=1.0) return ((d*dist + c)*dist + b)*dist +a;
-     else           return getSplineCoeff(        0.0,
-                                           b+ 2.0*c + 3.0*d,
-                                                  c + 3.0*d,
-                                          -b- 3.0*c - 6.0*d,
-                                          dist-1.0);
+     if (dist <= 1.0)
+         return ((d * dist + c) * dist + b) * dist + a;
+     else
+         return getSplineCoeff(0.0,
+                                b + 2.0 * c + 3.0 * d,
+                                c + 3.0 * d,
+                               -b - 3.0 * c - 6.0 * d,
+                               dist - 1.0);
  }
  
- static int initFilter(int16_t **outFilter, int32_t **filterPos, int *outFilterSize, int xInc,
-                       int srcW, int dstW, int filterAlign, int one, int flags, int cpu_flags,
-                       SwsVector *srcFilter, SwsVector *dstFilter, double param[2])
+ static int initFilter(int16_t **outFilter, int32_t **filterPos,
+                       int *outFilterSize, int xInc, int srcW, int dstW,
+                       int filterAlign, int one, int flags, int cpu_flags,
+                       SwsVector *srcFilter, SwsVector *dstFilter,
 -                      double param[2], int is_horizontal)
++                      double param[2])
  {
      int i;
      int filterSize;
      int filter2Size;
      int minFilterSize;
-     int64_t *filter=NULL;
-     int64_t *filter2=NULL;
-     const int64_t fone= 1LL<<54;
-     int ret= -1;
+     int64_t *filter    = NULL;
+     int64_t *filter2   = NULL;
+     const int64_t fone = 1LL << 54;
+     int ret            = -1;
  
-     emms_c(); //FIXME this should not be required but it IS (even for non-MMX versions)
+     emms_c(); // FIXME should not be required but IS (even for non-MMX versions)
  
-     // NOTE: the +3 is for the MMX(+1)/SSE(+3) scaler which reads over the end
-     FF_ALLOC_OR_GOTO(NULL, *filterPos, (dstW+3)*sizeof(**filterPos), fail);
+     // NOTE: the +3 is for the MMX(+1) / SSE(+3) scaler which reads over the end
+     FF_ALLOC_OR_GOTO(NULL, *filterPos, (dstW + 3) * sizeof(**filterPos), fail);
  
-     if (FFABS(xInc - 0x10000) <10) { // unscaled
+     if (FFABS(xInc - 0x10000) < 10) { // unscaled
          int i;
-         filterSize= 1;
-         FF_ALLOCZ_OR_GOTO(NULL, filter, dstW*sizeof(*filter)*filterSize, fail);
+         filterSize = 1;
+         FF_ALLOCZ_OR_GOTO(NULL, filter,
+                           dstW * sizeof(*filter) * filterSize, fail);
  
-         for (i=0; i<dstW; i++) {
-             filter[i*filterSize]= fone;
-             (*filterPos)[i]=i;
+         for (i = 0; i < dstW; i++) {
+             filter[i * filterSize] = fone;
+             (*filterPos)[i]        = i;
          }
-     } else if (flags&SWS_POINT) { // lame looking point sampling mode
+     } else if (flags & SWS_POINT) { // lame looking point sampling mode
          int i;
 -        int xDstInSrc;
 +        int64_t xDstInSrc;
-         filterSize= 1;
-         FF_ALLOC_OR_GOTO(NULL, filter, dstW*sizeof(*filter)*filterSize, fail);
+         filterSize = 1;
+         FF_ALLOC_OR_GOTO(NULL, filter,
+                          dstW * sizeof(*filter) * filterSize, fail);
  
-         xDstInSrc= xInc/2 - 0x8000;
-         for (i=0; i<dstW; i++) {
-             int xx= (xDstInSrc - ((filterSize-1)<<15) + (1<<15))>>16;
+         xDstInSrc = xInc / 2 - 0x8000;
+         for (i = 0; i < dstW; i++) {
+             int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
  
-             (*filterPos)[i]= xx;
-             filter[i]= fone;
-             xDstInSrc+= xInc;
+             (*filterPos)[i] = xx;
+             filter[i]       = fone;
+             xDstInSrc      += xInc;
          }
-     } else if ((xInc <= (1<<16) && (flags&SWS_AREA)) || (flags&SWS_FAST_BILINEAR)) { // bilinear upscale
+     } else if ((xInc <= (1 << 16) && (flags & SWS_AREA)) ||
+                (flags & SWS_FAST_BILINEAR)) { // bilinear upscale
          int i;
 -        int xDstInSrc;
 +        int64_t xDstInSrc;
-         filterSize= 2;
-         FF_ALLOC_OR_GOTO(NULL, filter, dstW*sizeof(*filter)*filterSize, fail);
+         filterSize = 2;
+         FF_ALLOC_OR_GOTO(NULL, filter,
+                          dstW * sizeof(*filter) * filterSize, fail);
  
-         xDstInSrc= xInc/2 - 0x8000;
-         for (i=0; i<dstW; i++) {
-             int xx= (xDstInSrc - ((filterSize-1)<<15) + (1<<15))>>16;
+         xDstInSrc = xInc / 2 - 0x8000;
+         for (i = 0; i < dstW; i++) {
+             int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
              int j;
  
-             (*filterPos)[i]= xx;
-             //bilinear upscale / linear interpolate / area averaging
-             for (j=0; j<filterSize; j++) {
+             (*filterPos)[i] = xx;
+             // bilinear upscale / linear interpolate / area averaging
+             for (j = 0; j < filterSize; j++) {
 -                int64_t coeff = fone - FFABS((xx << 16) - xDstInSrc) *
 -                                (fone >> 16);
 +                int64_t coeff= fone - FFABS(((int64_t)xx<<16) - xDstInSrc)*(fone>>16);
-                 if (coeff<0) coeff=0;
-                 filter[i*filterSize + j]= coeff;
+                 if (coeff < 0)
+                     coeff = 0;
+                 filter[i * filterSize + j] = coeff;
                  xx++;
              }
-             xDstInSrc+= xInc;
+             xDstInSrc += xInc;
          }
      } else {
          int64_t xDstInSrc;
          }
      }
  
-     //FIXME try to align filterPos if possible
+     // FIXME try to align filterPos if possible
  
-     //fix borders
-     for (i=0; i<dstW; i++) {
+     // fix borders
 -    if (is_horizontal) {
 -        for (i = 0; i < dstW; i++) {
 -            int j;
 -            if ((*filterPos)[i] < 0) {
 -                // move filter coefficients left to compensate for filterPos
 -                for (j = 1; j < filterSize; j++) {
 -                    int left = FFMAX(j + (*filterPos)[i], 0);
 -                    filter[i * filterSize + left] += filter[i * filterSize + j];
 -                    filter[i * filterSize + j]     = 0;
 -                }
 -                (*filterPos)[i] = 0;
++    for (i = 0; i < dstW; i++) {
 +        int j;
 +        if ((*filterPos)[i] < 0) {
 +            // move filter coefficients left to compensate for filterPos
-             for (j=1; j<filterSize; j++) {
-                 int left= FFMAX(j + (*filterPos)[i], 0);
-                 filter[i*filterSize + left] += filter[i*filterSize + j];
-                 filter[i*filterSize + j]=0;
++            for (j = 1; j < filterSize; j++) {
++                int left = FFMAX(j + (*filterPos)[i], 0);
++                filter[i * filterSize + left] += filter[i * filterSize + j];
++                filter[i * filterSize + j]     = 0;
              }
 +            (*filterPos)[i]= 0;
 +        }
  
 -            if ((*filterPos)[i] + filterSize > srcW) {
 -                int shift = (*filterPos)[i] + filterSize - srcW;
 -                // move filter coefficients right to compensate for filterPos
 -                for (j = filterSize - 2; j >= 0; j--) {
 -                    int right = FFMIN(j + shift, filterSize - 1);
 -                    filter[i * filterSize + right] += filter[i * filterSize + j];
 -                    filter[i * filterSize + j]      = 0;
 -                }
 -                (*filterPos)[i] = srcW - filterSize;
 +        if ((*filterPos)[i] + filterSize > srcW) {
-             int shift= (*filterPos)[i] + filterSize - srcW;
++            int shift = (*filterPos)[i] + filterSize - srcW;
 +            // move filter coefficients right to compensate for filterPos
-             for (j=filterSize-2; j>=0; j--) {
-                 int right= FFMIN(j + shift, filterSize-1);
-                 filter[i*filterSize +right] += filter[i*filterSize +j];
-                 filter[i*filterSize +j]=0;
++            for (j = filterSize - 2; j >= 0; j--) {
++                int right = FFMIN(j + shift, filterSize - 1);
++                filter[i * filterSize + right] += filter[i * filterSize + j];
++                filter[i * filterSize + j]      = 0;
              }
 +            (*filterPos)[i]= srcW - filterSize;
          }
      }
  
@@@ -729,15 -779,16 +787,16 @@@ int sws_getColorspaceDetails(struct Sws
                               int *srcRange, int **table, int *dstRange,
                               int *brightness, int *contrast, int *saturation)
  {
-     if (!c || isYUV(c->dstFormat) || isGray(c->dstFormat)) return -1;
 -    if (isYUV(c->dstFormat) || isGray(c->dstFormat))
++    if (!c || isYUV(c->dstFormat) || isGray(c->dstFormat))
+         return -1;
  
-     *inv_table = c->srcColorspaceTable;
-     *table     = c->dstColorspaceTable;
-     *srcRange  = c->srcRange;
-     *dstRange  = c->dstRange;
-     *brightness= c->brightness;
-     *contrast  = c->contrast;
-     *saturation= c->saturation;
+     *inv_table  = c->srcColorspaceTable;
+     *table      = c->dstColorspaceTable;
+     *srcRange   = c->srcRange;
+     *dstRange   = c->dstRange;
+     *brightness = c->brightness;
+     *contrast   = c->contrast;
+     *saturation = c->saturation;
  
      return 0;
  }
@@@ -753,20 -813,9 +821,20 @@@ static int handle_jpeg(enum PixelForma
      }
  }
  
 +static int handle_0alpha(enum PixelFormat *format)
 +{
 +    switch (*format) {
 +    case PIX_FMT_0BGR    : *format = PIX_FMT_ABGR   ; return 1;
 +    case PIX_FMT_BGR0    : *format = PIX_FMT_BGRA   ; return 4;
 +    case PIX_FMT_0RGB    : *format = PIX_FMT_ARGB   ; return 1;
 +    case PIX_FMT_RGB0    : *format = PIX_FMT_RGBA   ; return 4;
 +    default:                                          return 0;
 +    }
 +}
 +
  SwsContext *sws_alloc_context(void)
  {
-     SwsContext *c= av_mallocz(sizeof(SwsContext));
+     SwsContext *c = av_mallocz(sizeof(SwsContext));
  
      c->av_class = &sws_context_class;
      av_opt_set_defaults(c);
  
  int sws_init_context(SwsContext *c, SwsFilter *srcFilter, SwsFilter *dstFilter)
  {
 -    int i;
 +    int i, j;
      int usesVFilter, usesHFilter;
      int unscaled;
-     SwsFilter dummyFilter= {NULL, NULL, NULL, NULL};
-     int srcW= c->srcW;
-     int srcH= c->srcH;
-     int dstW= c->dstW;
-     int dstH= c->dstH;
-     int dst_stride = FFALIGN(dstW * sizeof(int16_t)+66, 16);
+     SwsFilter dummyFilter = { NULL, NULL, NULL, NULL };
+     int srcW              = c->srcW;
+     int srcH              = c->srcH;
+     int dstW              = c->dstW;
+     int dstH              = c->dstH;
 -    int dst_stride        = FFALIGN(dstW * sizeof(int16_t) + 16, 16);
 -    int dst_stride_px     = dst_stride >> 1;
++    int dst_stride        = FFALIGN(dstW * sizeof(int16_t) + 66, 16);
      int flags, cpu_flags;
-     enum PixelFormat srcFormat= c->srcFormat;
-     enum PixelFormat dstFormat= c->dstFormat;
+     enum PixelFormat srcFormat = c->srcFormat;
+     enum PixelFormat dstFormat = c->dstFormat;
  
      cpu_flags = av_get_cpu_flags();
      flags     = c->flags;
  
      unscaled = (srcW == dstW && srcH == dstH);
  
 +    handle_jpeg(&srcFormat);
 +    handle_jpeg(&dstFormat);
 +    handle_0alpha(&srcFormat);
 +    handle_0alpha(&dstFormat);
 +
 +    if(srcFormat!=c->srcFormat || dstFormat!=c->dstFormat){
 +        av_log(c, AV_LOG_WARNING, "deprecated pixel format used, make sure you did set range correctly\n");
 +        c->srcFormat= srcFormat;
 +        c->dstFormat= dstFormat;
 +    }
 +
      if (!sws_isSupportedInput(srcFormat)) {
-         av_log(c, AV_LOG_ERROR, "%s is not supported as input pixel format\n", av_get_pix_fmt_name(srcFormat));
+         av_log(c, AV_LOG_ERROR, "%s is not supported as input pixel format\n",
 -               sws_format_name(srcFormat));
++               av_get_pix_fmt_name(srcFormat));
          return AVERROR(EINVAL);
      }
      if (!sws_isSupportedOutput(dstFormat)) {
-         av_log(c, AV_LOG_ERROR, "%s is not supported as output pixel format\n", av_get_pix_fmt_name(dstFormat));
+         av_log(c, AV_LOG_ERROR, "%s is not supported as output pixel format\n",
 -               sws_format_name(dstFormat));
++               av_get_pix_fmt_name(dstFormat));
          return AVERROR(EINVAL);
      }
  
-     i= flags & ( SWS_POINT
-                 |SWS_AREA
-                 |SWS_BILINEAR
-                 |SWS_FAST_BILINEAR
-                 |SWS_BICUBIC
-                 |SWS_X
-                 |SWS_GAUSS
-                 |SWS_LANCZOS
-                 |SWS_SINC
-                 |SWS_SPLINE
-                 |SWS_BICUBLIN);
-     if(!i || (i & (i-1))) {
+     i = flags & (SWS_POINT         |
+                  SWS_AREA          |
+                  SWS_BILINEAR      |
+                  SWS_FAST_BILINEAR |
+                  SWS_BICUBIC       |
+                  SWS_X             |
+                  SWS_GAUSS         |
+                  SWS_LANCZOS       |
+                  SWS_SINC          |
+                  SWS_SPLINE        |
+                  SWS_BICUBLIN);
+     if (!i || (i & (i - 1))) {
 -        av_log(c, AV_LOG_ERROR,
 -               "Exactly one scaler algorithm must be chosen\n");
 +        av_log(c, AV_LOG_ERROR, "Exactly one scaler algorithm must be chosen, got %X\n", i);
          return AVERROR(EINVAL);
      }
      /* sanity check */
      getSubSampleFactors(&c->chrSrcHSubSample, &c->chrSrcVSubSample, srcFormat);
      getSubSampleFactors(&c->chrDstHSubSample, &c->chrDstVSubSample, dstFormat);
  
-     // reuse chroma for 2 pixels RGB/BGR unless user wants full chroma interpolation
 +
 +    if (isAnyRGB(dstFormat) && !(flags&SWS_FULL_CHR_H_INT)) {
 +        if (dstW&1) {
 +            av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to odd output size\n");
 +            flags |= SWS_FULL_CHR_H_INT;
 +            c->flags = flags;
 +        }
 +    }
+     /* reuse chroma for 2 pixels RGB/BGR unless user wants full
+      * chroma interpolation */
      if (flags & SWS_FULL_CHR_H_INT &&
-         isAnyRGB(dstFormat)       &&
-         dstFormat != PIX_FMT_RGBA &&
-         dstFormat != PIX_FMT_ARGB &&
-         dstFormat != PIX_FMT_BGRA &&
-         dstFormat != PIX_FMT_ABGR &&
+         isAnyRGB(dstFormat)        &&
+         dstFormat != PIX_FMT_RGBA  &&
+         dstFormat != PIX_FMT_ARGB  &&
+         dstFormat != PIX_FMT_BGRA  &&
+         dstFormat != PIX_FMT_ABGR  &&
          dstFormat != PIX_FMT_RGB24 &&
          dstFormat != PIX_FMT_BGR24) {
 -        av_log(c, AV_LOG_ERROR,
 +        av_log(c, AV_LOG_WARNING,
                 "full chroma interpolation for destination format '%s' not yet implemented\n",
--               sws_format_name(dstFormat));
-         flags &= ~SWS_FULL_CHR_H_INT;
++               av_get_pix_fmt_name(dstFormat));
+         flags   &= ~SWS_FULL_CHR_H_INT;
          c->flags = flags;
      }
-     if (isAnyRGB(dstFormat) && !(flags&SWS_FULL_CHR_H_INT)) c->chrDstHSubSample=1;
+     if (isAnyRGB(dstFormat) && !(flags & SWS_FULL_CHR_H_INT))
+         c->chrDstHSubSample = 1;
  
      // drop some chroma lines if the user wants it
-     c->vChrDrop= (flags&SWS_SRC_V_CHR_DROP_MASK)>>SWS_SRC_V_CHR_DROP_SHIFT;
-     c->chrSrcVSubSample+= c->vChrDrop;
-     // drop every other pixel for chroma calculation unless user wants full chroma
-     if (isAnyRGB(srcFormat) && !(flags&SWS_FULL_CHR_H_INP)
-       && srcFormat!=PIX_FMT_RGB8      && srcFormat!=PIX_FMT_BGR8
-       && srcFormat!=PIX_FMT_RGB4      && srcFormat!=PIX_FMT_BGR4
-       && srcFormat!=PIX_FMT_RGB4_BYTE && srcFormat!=PIX_FMT_BGR4_BYTE
-       && ((dstW>>c->chrDstHSubSample) <= (srcW>>1) || (flags&SWS_FAST_BILINEAR)))
-         c->chrSrcHSubSample=1;
+     c->vChrDrop          = (flags & SWS_SRC_V_CHR_DROP_MASK) >>
+                            SWS_SRC_V_CHR_DROP_SHIFT;
+     c->chrSrcVSubSample += c->vChrDrop;
+     /* drop every other pixel for chroma calculation unless user
+      * wants full chroma */
+     if (isAnyRGB(srcFormat) && !(flags & SWS_FULL_CHR_H_INP)   &&
+         srcFormat != PIX_FMT_RGB8 && srcFormat != PIX_FMT_BGR8 &&
+         srcFormat != PIX_FMT_RGB4 && srcFormat != PIX_FMT_BGR4 &&
+         srcFormat != PIX_FMT_RGB4_BYTE && srcFormat != PIX_FMT_BGR4_BYTE &&
+         ((dstW >> c->chrDstHSubSample) <= (srcW >> 1) ||
+          (flags & SWS_FAST_BILINEAR)))
+         c->chrSrcHSubSample = 1;
  
      // Note the -((-x)>>y) is so that we always round toward +inf.
-     c->chrSrcW= -((-srcW) >> c->chrSrcHSubSample);
-     c->chrSrcH= -((-srcH) >> c->chrSrcVSubSample);
-     c->chrDstW= -((-dstW) >> c->chrDstHSubSample);
-     c->chrDstH= -((-dstH) >> c->chrDstVSubSample);
+     c->chrSrcW = -((-srcW) >> c->chrSrcHSubSample);
+     c->chrSrcH = -((-srcH) >> c->chrSrcVSubSample);
+     c->chrDstW = -((-dstW) >> c->chrDstHSubSample);
+     c->chrDstH = -((-dstH) >> c->chrDstVSubSample);
  
      /* unscaled special cases */
-     if (unscaled && !usesHFilter && !usesVFilter && (c->srcRange == c->dstRange || isAnyRGB(dstFormat))) {
+     if (unscaled && !usesHFilter && !usesVFilter &&
+         (c->srcRange == c->dstRange || isAnyRGB(dstFormat))) {
          ff_get_unscaled_swscale(c);
  
          if (c->swScale) {
-             if (flags&SWS_PRINT_INFO)
-                 av_log(c, AV_LOG_INFO, "using unscaled %s -> %s special converter\n",
+             if (flags & SWS_PRINT_INFO)
+                 av_log(c, AV_LOG_INFO,
+                        "using unscaled %s -> %s special converter\n",
 -                       sws_format_name(srcFormat), sws_format_name(dstFormat));
 +                       av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
              return 0;
          }
      }
      c->dstBpc = 1 + av_pix_fmt_descriptors[dstFormat].comp[0].depth_minus1;
      if (c->dstBpc < 8)
          c->dstBpc = 8;
 +    if (isAnyRGB(srcFormat) || srcFormat == PIX_FMT_PAL8)
 +        c->srcBpc = 16;
      if (c->dstBpc == 16)
          dst_stride <<= 1;
 -    FF_ALLOC_OR_GOTO(c, c->formatConvBuffer,
 -                     (FFALIGN(srcW, 16) * 2 * FFALIGN(c->srcBpc, 8) >> 3) + 16,
 -                     fail);
 +    FF_ALLOC_OR_GOTO(c, c->formatConvBuffer, FFALIGN(srcW*2+78, 16) * 2, fail);
-     if (HAVE_MMX2 && cpu_flags & AV_CPU_FLAG_MMX2 && c->srcBpc == 8 && c->dstBpc <= 10) {
-         c->canMMX2BeUsed= (dstW >=srcW && (dstW&31)==0 && (srcW&15)==0) ? 1 : 0;
-         if (!c->canMMX2BeUsed && dstW >=srcW && (srcW&15)==0 && (flags&SWS_FAST_BILINEAR)) {
-             if (flags&SWS_PRINT_INFO)
-                 av_log(c, AV_LOG_INFO, "output width is not a multiple of 32 -> no MMX2 scaler\n");
+     if (HAVE_MMX2 && cpu_flags & AV_CPU_FLAG_MMX2 &&
+         c->srcBpc == 8 && c->dstBpc <= 10) {
+         c->canMMX2BeUsed = (dstW >= srcW && (dstW & 31) == 0 &&
+                             (srcW & 15) == 0) ? 1 : 0;
+         if (!c->canMMX2BeUsed && dstW >= srcW && (srcW & 15) == 0
+             && (flags & SWS_FAST_BILINEAR)) {
+             if (flags & SWS_PRINT_INFO)
+                 av_log(c, AV_LOG_INFO,
+                        "output width is not a multiple of 32 -> no MMX2 scaler\n");
          }
-         if (usesHFilter || isNBPS(c->srcFormat) || is16BPS(c->srcFormat) || isAnyRGB(c->srcFormat)) c->canMMX2BeUsed=0;
-     }
-     else
-         c->canMMX2BeUsed=0;
-     c->chrXInc= (((int64_t)c->chrSrcW<<16) + (c->chrDstW>>1))/c->chrDstW;
-     c->chrYInc= (((int64_t)c->chrSrcH<<16) + (c->chrDstH>>1))/c->chrDstH;
-     // match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src to pixel n-2 of dst
-     // but only for the FAST_BILINEAR mode otherwise do correct scaling
-     // n-2 is the last chrominance sample available
-     // this is not perfect, but no one should notice the difference, the more correct variant
-     // would be like the vertical one, but that would require some special code for the
-     // first and last pixel
-     if (flags&SWS_FAST_BILINEAR) {
 -        if (usesHFilter)
 -            c->canMMX2BeUsed = 0;
++        if (usesHFilter || isNBPS(c->srcFormat) || is16BPS(c->srcFormat) || isAnyRGB(c->srcFormat))
++            c->canMMX2BeUsed=0;
+     } else
+         c->canMMX2BeUsed = 0;
+     c->chrXInc = (((int64_t)c->chrSrcW << 16) + (c->chrDstW >> 1)) / c->chrDstW;
+     c->chrYInc = (((int64_t)c->chrSrcH << 16) + (c->chrDstH >> 1)) / c->chrDstH;
+     /* Match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src
+      * to pixel n-2 of dst, but only for the FAST_BILINEAR mode otherwise do
+      * correct scaling.
+      * n-2 is the last chrominance sample available.
+      * This is not perfect, but no one should notice the difference, the more
+      * correct variant would be like the vertical one, but that would require
+      * some special code for the first and last pixel */
+     if (flags & SWS_FAST_BILINEAR) {
          if (c->canMMX2BeUsed) {
-             c->lumXInc+= 20;
-             c->chrXInc+= 20;
+             c->lumXInc += 20;
+             c->chrXInc += 20;
          }
-         //we don't use the x86 asm scaler if MMX is available
+         // we don't use the x86 asm scaler if MMX is available
 -        else if (HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) {
 +        else if (HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX && c->dstBpc <= 10) {
-             c->lumXInc = ((int64_t)(srcW-2)<<16)/(dstW-2) - 20;
-             c->chrXInc = ((int64_t)(c->chrSrcW-2)<<16)/(c->chrDstW-2) - 20;
+             c->lumXInc = ((int64_t)(srcW       - 2) << 16) / (dstW       - 2) - 20;
+             c->chrXInc = ((int64_t)(c->chrSrcW - 2) << 16) / (c->chrDstW - 2) - 20;
          }
      }
  
              c->chrMmx2FilterCode = av_malloc(c->chrMmx2FilterCodeSize);
  #endif
  
 +#ifdef MAP_ANONYMOUS
 +            if (c->lumMmx2FilterCode == MAP_FAILED || c->chrMmx2FilterCode == MAP_FAILED)
 +#else
              if (!c->lumMmx2FilterCode || !c->chrMmx2FilterCode)
 +#endif
 +            {
 +                av_log(c, AV_LOG_ERROR, "Failed to allocate MMX2FilterCode\n");
                  return AVERROR(ENOMEM);
-             FF_ALLOCZ_OR_GOTO(c, c->hLumFilter   , (dstW        /8+8)*sizeof(int16_t), fail);
-             FF_ALLOCZ_OR_GOTO(c, c->hChrFilter   , (c->chrDstW  /4+8)*sizeof(int16_t), fail);
-             FF_ALLOCZ_OR_GOTO(c, c->hLumFilterPos, (dstW      /2/8+8)*sizeof(int32_t), fail);
-             FF_ALLOCZ_OR_GOTO(c, c->hChrFilterPos, (c->chrDstW/2/4+8)*sizeof(int32_t), fail);
 +            }
-             initMMX2HScaler(      dstW, c->lumXInc, c->lumMmx2FilterCode, c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8);
-             initMMX2HScaler(c->chrDstW, c->chrXInc, c->chrMmx2FilterCode, c->hChrFilter, (uint32_t*)c->hChrFilterPos, 4);
 +
 -            initMMX2HScaler(dstW, c->lumXInc, c->lumMmx2FilterCode,
 -                            c->hLumFilter, c->hLumFilterPos, 8);
+             FF_ALLOCZ_OR_GOTO(c, c->hLumFilter,    (dstW           / 8 + 8) * sizeof(int16_t), fail);
+             FF_ALLOCZ_OR_GOTO(c, c->hChrFilter,    (c->chrDstW     / 4 + 8) * sizeof(int16_t), fail);
+             FF_ALLOCZ_OR_GOTO(c, c->hLumFilterPos, (dstW       / 2 / 8 + 8) * sizeof(int32_t), fail);
+             FF_ALLOCZ_OR_GOTO(c, c->hChrFilterPos, (c->chrDstW / 2 / 4 + 8) * sizeof(int32_t), fail);
 -                            c->hChrFilter, c->hChrFilterPos, 4);
++            initMMX2HScaler(      dstW, c->lumXInc, c->lumMmx2FilterCode,
++                            c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8);
+             initMMX2HScaler(c->chrDstW, c->chrXInc, c->chrMmx2FilterCode,
++                            c->hChrFilter, (uint32_t*)c->hChrFilterPos, 4);
  
  #ifdef MAP_ANONYMOUS
              mprotect(c->lumMmx2FilterCode, c->lumMmx2FilterCodeSize, PROT_EXEC | PROT_READ);
                  (HAVE_ALTIVEC && cpu_flags & AV_CPU_FLAG_ALTIVEC) ? 8 :
                  1;
  
-             if (initFilter(&c->hLumFilter, &c->hLumFilterPos, &c->hLumFilterSize, c->lumXInc,
-                            srcW      ,       dstW, filterAlign, 1<<14,
-                            (flags&SWS_BICUBLIN) ? (flags|SWS_BICUBIC)  : flags, cpu_flags,
-                            srcFilter->lumH, dstFilter->lumH, c->param) < 0)
+             if (initFilter(&c->hLumFilter, &c->hLumFilterPos,
+                            &c->hLumFilterSize, c->lumXInc,
+                            srcW, dstW, filterAlign, 1 << 14,
+                            (flags & SWS_BICUBLIN) ? (flags | SWS_BICUBIC) : flags,
+                            cpu_flags, srcFilter->lumH, dstFilter->lumH,
 -                           c->param, 1) < 0)
++                           c->param) < 0)
                  goto fail;
-             if (initFilter(&c->hChrFilter, &c->hChrFilterPos, &c->hChrFilterSize, c->chrXInc,
-                            c->chrSrcW, c->chrDstW, filterAlign, 1<<14,
-                            (flags&SWS_BICUBLIN) ? (flags|SWS_BILINEAR) : flags, cpu_flags,
-                            srcFilter->chrH, dstFilter->chrH, c->param) < 0)
+             if (initFilter(&c->hChrFilter, &c->hChrFilterPos,
+                            &c->hChrFilterSize, c->chrXInc,
+                            c->chrSrcW, c->chrDstW, filterAlign, 1 << 14,
+                            (flags & SWS_BICUBLIN) ? (flags | SWS_BILINEAR) : flags,
+                            cpu_flags, srcFilter->chrH, dstFilter->chrH,
 -                           c->param, 1) < 0)
++                           c->param) < 0)
                  goto fail;
          }
      } // initialize horizontal stuff
              (HAVE_ALTIVEC && cpu_flags & AV_CPU_FLAG_ALTIVEC) ? 8 :
              1;
  
-         if (initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize, c->lumYInc,
-                        srcH      ,        dstH, filterAlign, (1<<12),
-                        (flags&SWS_BICUBLIN) ? (flags|SWS_BICUBIC)  : flags, cpu_flags,
-                        srcFilter->lumV, dstFilter->lumV, c->param) < 0)
+         if (initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize,
+                        c->lumYInc, srcH, dstH, filterAlign, (1 << 12),
+                        (flags & SWS_BICUBLIN) ? (flags | SWS_BICUBIC) : flags,
+                        cpu_flags, srcFilter->lumV, dstFilter->lumV,
 -                       c->param, 0) < 0)
++                       c->param) < 0)
              goto fail;
-         if (initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize, c->chrYInc,
-                        c->chrSrcH, c->chrDstH, filterAlign, (1<<12),
-                        (flags&SWS_BICUBLIN) ? (flags|SWS_BILINEAR) : flags, cpu_flags,
-                        srcFilter->chrV, dstFilter->chrV, c->param) < 0)
+         if (initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize,
+                        c->chrYInc, c->chrSrcH, c->chrDstH,
+                        filterAlign, (1 << 12),
+                        (flags & SWS_BICUBLIN) ? (flags | SWS_BILINEAR) : flags,
+                        cpu_flags, srcFilter->chrV, dstFilter->chrV,
 -                       c->param, 0) < 0)
++                       c->param) < 0)
              goto fail;
  
  #if HAVE_ALTIVEC
      }
  
      // calculate buffer sizes so that they won't run out while handling these damn slices
-     c->vLumBufSize= c->vLumFilterSize;
-     c->vChrBufSize= c->vChrFilterSize;
-     for (i=0; i<dstH; i++) {
-         int chrI = (int64_t) i * c->chrDstH / dstH;
-         int nextSlice= FFMAX(c->vLumFilterPos[i   ] + c->vLumFilterSize - 1,
-                            ((c->vChrFilterPos[chrI] + c->vChrFilterSize - 1)<<c->chrSrcVSubSample));
-         nextSlice>>= c->chrSrcVSubSample;
-         nextSlice<<= c->chrSrcVSubSample;
-         if (c->vLumFilterPos[i   ] + c->vLumBufSize < nextSlice)
-             c->vLumBufSize= nextSlice - c->vLumFilterPos[i];
-         if (c->vChrFilterPos[chrI] + c->vChrBufSize < (nextSlice>>c->chrSrcVSubSample))
-             c->vChrBufSize= (nextSlice>>c->chrSrcVSubSample) - c->vChrFilterPos[chrI];
+     c->vLumBufSize = c->vLumFilterSize;
+     c->vChrBufSize = c->vChrFilterSize;
+     for (i = 0; i < dstH; i++) {
+         int chrI      = (int64_t)i * c->chrDstH / dstH;
+         int nextSlice = FFMAX(c->vLumFilterPos[i] + c->vLumFilterSize - 1,
+                               ((c->vChrFilterPos[chrI] + c->vChrFilterSize - 1)
+                                << c->chrSrcVSubSample));
+         nextSlice >>= c->chrSrcVSubSample;
+         nextSlice <<= c->chrSrcVSubSample;
+         if (c->vLumFilterPos[i] + c->vLumBufSize < nextSlice)
+             c->vLumBufSize = nextSlice - c->vLumFilterPos[i];
+         if (c->vChrFilterPos[chrI] + c->vChrBufSize <
+             (nextSlice >> c->chrSrcVSubSample))
+             c->vChrBufSize = (nextSlice >> c->chrSrcVSubSample) -
+                              c->vChrFilterPos[chrI];
      }
  
-     // allocate pixbufs (we use dynamic allocation because otherwise we would need to
-     // allocate several megabytes to handle all possible cases)
-     FF_ALLOC_OR_GOTO(c, c->lumPixBuf, c->vLumBufSize*2*sizeof(int16_t*), fail);
-     FF_ALLOC_OR_GOTO(c, c->chrUPixBuf, c->vChrBufSize*2*sizeof(int16_t*), fail);
-     FF_ALLOC_OR_GOTO(c, c->chrVPixBuf, c->vChrBufSize*2*sizeof(int16_t*), fail);
+     /* Allocate pixbufs (we use dynamic allocation because otherwise we would
+      * need to allocate several megabytes to handle all possible cases) */
+     FF_ALLOC_OR_GOTO(c, c->lumPixBuf,  c->vLumBufSize * 3 * sizeof(int16_t *), fail);
+     FF_ALLOC_OR_GOTO(c, c->chrUPixBuf, c->vChrBufSize * 3 * sizeof(int16_t *), fail);
+     FF_ALLOC_OR_GOTO(c, c->chrVPixBuf, c->vChrBufSize * 3 * sizeof(int16_t *), fail);
      if (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat) && isALPHA(c->dstFormat))
-         FF_ALLOCZ_OR_GOTO(c, c->alpPixBuf, c->vLumBufSize*2*sizeof(int16_t*), fail);
-     //Note we need at least one pixel more at the end because of the MMX code (just in case someone wanna replace the 4000/8000)
+         FF_ALLOCZ_OR_GOTO(c, c->alpPixBuf, c->vLumBufSize * 3 * sizeof(int16_t *), fail);
+     /* Note we need at least one pixel more at the end because of the MMX code
+      * (just in case someone wants to replace the 4000/8000). */
      /* align at 16 bytes for AltiVec */
-     for (i=0; i<c->vLumBufSize; i++) {
-         FF_ALLOCZ_OR_GOTO(c, c->lumPixBuf[i+c->vLumBufSize], dst_stride+16, fail);
-         c->lumPixBuf[i] = c->lumPixBuf[i+c->vLumBufSize];
+     for (i = 0; i < c->vLumBufSize; i++) {
+         FF_ALLOCZ_OR_GOTO(c, c->lumPixBuf[i + c->vLumBufSize],
+                           dst_stride + 16, fail);
+         c->lumPixBuf[i] = c->lumPixBuf[i + c->vLumBufSize];
      }
 -    // 64 / (c->dstBpc & ~7) is the same as 16 / sizeof(scaling_intermediate)
 -    c->uv_off_px   = dst_stride_px + 64 / (c->dstBpc & ~7);
 -    c->uv_off_byte = dst_stride + 16;
 +    // 64 / c->scalingBpp is the same as 16 / sizeof(scaling_intermediate)
 +    c->uv_off   = (dst_stride>>1) + 64 / (c->dstBpc &~ 7);
 +    c->uv_offx2 = dst_stride + 16;
-     for (i=0; i<c->vChrBufSize; i++) {
-         FF_ALLOC_OR_GOTO(c, c->chrUPixBuf[i+c->vChrBufSize], dst_stride*2+32, fail);
-         c->chrUPixBuf[i] = c->chrUPixBuf[i+c->vChrBufSize];
-         c->chrVPixBuf[i] = c->chrVPixBuf[i+c->vChrBufSize] = c->chrUPixBuf[i] + (dst_stride >> 1) + 8;
+     for (i = 0; i < c->vChrBufSize; i++) {
+         FF_ALLOC_OR_GOTO(c, c->chrUPixBuf[i + c->vChrBufSize],
+                          dst_stride * 2 + 32, fail);
+         c->chrUPixBuf[i] = c->chrUPixBuf[i + c->vChrBufSize];
+         c->chrVPixBuf[i] = c->chrVPixBuf[i + c->vChrBufSize]
+                          = c->chrUPixBuf[i] + (dst_stride >> 1) + 8;
      }
      if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf)
-         for (i=0; i<c->vLumBufSize; i++) {
-             FF_ALLOCZ_OR_GOTO(c, c->alpPixBuf[i+c->vLumBufSize], dst_stride+16, fail);
-             c->alpPixBuf[i] = c->alpPixBuf[i+c->vLumBufSize];
+         for (i = 0; i < c->vLumBufSize; i++) {
+             FF_ALLOCZ_OR_GOTO(c, c->alpPixBuf[i + c->vLumBufSize],
+                               dst_stride + 16, fail);
+             c->alpPixBuf[i] = c->alpPixBuf[i + c->vLumBufSize];
          }
  
-     //try to avoid drawing green stuff between the right end and the stride end
-     for (i=0; i<c->vChrBufSize; i++)
+     // try to avoid drawing green stuff between the right end and the stride end
+     for (i = 0; i < c->vChrBufSize; i++)
 -        memset(c->chrUPixBuf[i], 64, dst_stride * 2 + 1);
 +        if(av_pix_fmt_descriptors[c->dstFormat].comp[0].depth_minus1 == 15){
 +            av_assert0(c->dstBpc > 10);
 +            for(j=0; j<dst_stride/2+1; j++)
 +                ((int32_t*)(c->chrUPixBuf[i]))[j] = 1<<18;
 +        } else
 +            for(j=0; j<dst_stride+1; j++)
 +                ((int16_t*)(c->chrUPixBuf[i]))[j] = 1<<14;
  
      assert(c->chrDstH <= dstH);
  
-     if (flags&SWS_PRINT_INFO) {
-         if      (flags&SWS_FAST_BILINEAR) av_log(c, AV_LOG_INFO, "FAST_BILINEAR scaler, ");
-         else if (flags&SWS_BILINEAR)      av_log(c, AV_LOG_INFO, "BILINEAR scaler, ");
-         else if (flags&SWS_BICUBIC)       av_log(c, AV_LOG_INFO, "BICUBIC scaler, ");
-         else if (flags&SWS_X)             av_log(c, AV_LOG_INFO, "Experimental scaler, ");
-         else if (flags&SWS_POINT)         av_log(c, AV_LOG_INFO, "Nearest Neighbor / POINT scaler, ");
-         else if (flags&SWS_AREA)          av_log(c, AV_LOG_INFO, "Area Averaging scaler, ");
-         else if (flags&SWS_BICUBLIN)      av_log(c, AV_LOG_INFO, "luma BICUBIC / chroma BILINEAR scaler, ");
-         else if (flags&SWS_GAUSS)         av_log(c, AV_LOG_INFO, "Gaussian scaler, ");
-         else if (flags&SWS_SINC)          av_log(c, AV_LOG_INFO, "Sinc scaler, ");
-         else if (flags&SWS_LANCZOS)       av_log(c, AV_LOG_INFO, "Lanczos scaler, ");
-         else if (flags&SWS_SPLINE)        av_log(c, AV_LOG_INFO, "Bicubic spline scaler, ");
-         else                              av_log(c, AV_LOG_INFO, "ehh flags invalid?! ");
+     if (flags & SWS_PRINT_INFO) {
+         if (flags & SWS_FAST_BILINEAR)
+             av_log(c, AV_LOG_INFO, "FAST_BILINEAR scaler, ");
+         else if (flags & SWS_BILINEAR)
+             av_log(c, AV_LOG_INFO, "BILINEAR scaler, ");
+         else if (flags & SWS_BICUBIC)
+             av_log(c, AV_LOG_INFO, "BICUBIC scaler, ");
+         else if (flags & SWS_X)
+             av_log(c, AV_LOG_INFO, "Experimental scaler, ");
+         else if (flags & SWS_POINT)
+             av_log(c, AV_LOG_INFO, "Nearest Neighbor / POINT scaler, ");
+         else if (flags & SWS_AREA)
+             av_log(c, AV_LOG_INFO, "Area Averaging scaler, ");
+         else if (flags & SWS_BICUBLIN)
+             av_log(c, AV_LOG_INFO, "luma BICUBIC / chroma BILINEAR scaler, ");
+         else if (flags & SWS_GAUSS)
+             av_log(c, AV_LOG_INFO, "Gaussian scaler, ");
+         else if (flags & SWS_SINC)
+             av_log(c, AV_LOG_INFO, "Sinc scaler, ");
+         else if (flags & SWS_LANCZOS)
+             av_log(c, AV_LOG_INFO, "Lanczos scaler, ");
+         else if (flags & SWS_SPLINE)
+             av_log(c, AV_LOG_INFO, "Bicubic spline scaler, ");
+         else
+             av_log(c, AV_LOG_INFO, "ehh flags invalid?! ");
  
          av_log(c, AV_LOG_INFO, "from %s to %s%s ",
 -               sws_format_name(srcFormat),
 +               av_get_pix_fmt_name(srcFormat),
  #ifdef DITHER1XBPP
-                dstFormat == PIX_FMT_BGR555 || dstFormat == PIX_FMT_BGR565 ||
+                dstFormat == PIX_FMT_BGR555   || dstFormat == PIX_FMT_BGR565   ||
                 dstFormat == PIX_FMT_RGB444BE || dstFormat == PIX_FMT_RGB444LE ||
-                dstFormat == PIX_FMT_BGR444BE || dstFormat == PIX_FMT_BGR444LE ? "dithered " : "",
+                dstFormat == PIX_FMT_BGR444BE || dstFormat == PIX_FMT_BGR444LE ?
+                                                              "dithered " : "",
  #else
                 "",
  #endif
 -               sws_format_name(dstFormat));
 +               av_get_pix_fmt_name(dstFormat));
  
-         if      (HAVE_MMX2     && cpu_flags & AV_CPU_FLAG_MMX2)    av_log(c, AV_LOG_INFO, "using MMX2\n");
-         else if (HAVE_AMD3DNOW && cpu_flags & AV_CPU_FLAG_3DNOW)   av_log(c, AV_LOG_INFO, "using 3DNOW\n");
-         else if (HAVE_MMX      && cpu_flags & AV_CPU_FLAG_MMX)     av_log(c, AV_LOG_INFO, "using MMX\n");
-         else if (HAVE_ALTIVEC  && cpu_flags & AV_CPU_FLAG_ALTIVEC) av_log(c, AV_LOG_INFO, "using AltiVec\n");
-         else                                   av_log(c, AV_LOG_INFO, "using C\n");
+         if (HAVE_MMX2 && cpu_flags & AV_CPU_FLAG_MMX2)
+             av_log(c, AV_LOG_INFO, "using MMX2\n");
+         else if (HAVE_AMD3DNOW && cpu_flags & AV_CPU_FLAG_3DNOW)
+             av_log(c, AV_LOG_INFO, "using 3DNOW\n");
+         else if (HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX)
+             av_log(c, AV_LOG_INFO, "using MMX\n");
+         else if (HAVE_ALTIVEC && cpu_flags & AV_CPU_FLAG_ALTIVEC)
+             av_log(c, AV_LOG_INFO, "using AltiVec\n");
+         else
+             av_log(c, AV_LOG_INFO, "using C\n");
  
          av_log(c, AV_LOG_VERBOSE, "%dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
-         av_log(c, AV_LOG_DEBUG, "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
+         av_log(c, AV_LOG_DEBUG,
+                "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
                 c->srcW, c->srcH, c->dstW, c->dstH, c->lumXInc, c->lumYInc);
-         av_log(c, AV_LOG_DEBUG, "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
-                c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH, c->chrXInc, c->chrYInc);
+         av_log(c, AV_LOG_DEBUG,
+                "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
+                c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH,
+                c->chrXInc, c->chrYInc);
      }
  
-     c->swScale= ff_getSwsFunc(c);
+     c->swScale = ff_getSwsFunc(c);
      return 0;
- fail: //FIXME replace things by appropriate error codes
+ fail: // FIXME replace things by appropriate error codes
      return -1;
  }
  
@@@ -1162,20 -1241,18 +1291,20 @@@ SwsContext *sws_getContext(int srcW, in
  {
      SwsContext *c;
  
-     if(!(c=sws_alloc_context()))
+     if (!(c = sws_alloc_context()))
          return NULL;
  
-     c->flags= flags;
-     c->srcW= srcW;
-     c->srcH= srcH;
-     c->dstW= dstW;
-     c->dstH= dstH;
-     c->srcRange = handle_jpeg(&srcFormat);
-     c->dstRange = handle_jpeg(&dstFormat);
+     c->flags     = flags;
+     c->srcW      = srcW;
+     c->srcH      = srcH;
+     c->dstW      = dstW;
+     c->dstH      = dstH;
+     c->srcRange  = handle_jpeg(&srcFormat);
+     c->dstRange  = handle_jpeg(&dstFormat);
 +    c->src0Alpha = handle_0alpha(&srcFormat);
 +    c->dst0Alpha = handle_0alpha(&dstFormat);
-     c->srcFormat= srcFormat;
-     c->dstFormat= dstFormat;
+     c->srcFormat = srcFormat;
+     c->dstFormat = dstFormat;
  
      if (param) {
          c->param[0] = param[0];
index 0000000,7f37799..68d5381
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,9 +1,11 @@@
++$(SUBDIR)x86/swscale_mmx.o: CFLAGS += $(NOREDZONE_FLAGS)
++
+ OBJS-$(CONFIG_XMM_CLOBBER_TEST) += x86/w64xmmtest.o
+ MMX-OBJS                        += x86/rgb2rgb.o                        \
+                                    x86/swscale_mmx.o                    \
+                                    x86/yuv2rgb_mmx.o                    \
+ YASM-OBJS                       += x86/input.o                          \
+                                    x86/output.o                         \
+                                    x86/scale.o                          \