Merge commit '9953ff3cd844eb5f6d8dfce98cad94b78a0fc7dc'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 12 Oct 2012 13:52:55 +0000 (15:52 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 12 Oct 2012 13:57:28 +0000 (15:57 +0200)
* commit '9953ff3cd844eb5f6d8dfce98cad94b78a0fc7dc':
  mpegvideo: fix indentation
  sws: do not use av_pix_fmt_descriptors directly.

Conflicts:
libavcodec/mpegvideo.c
libswscale/swscale_internal.h
libswscale/swscale_unscaled.c
libswscale/utils.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libswscale/output.c
libswscale/swscale-test.c
libswscale/swscale.c
libswscale/swscale_internal.h
libswscale/swscale_unscaled.c
libswscale/utils.c

Simple merge
Simple merge
@@@ -69,12 -69,9 +70,12 @@@ static void hScale16To19_c(SwsContext *
      int i;
      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 bits            = desc->comp[0].depth_minus1;
      int sh              = bits - 4;
  
 +    if((isAnyRGB(c->srcFormat) || c->srcFormat==AV_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];
@@@ -92,13 -89,11 +93,14 @@@ static void hScale16To15_c(SwsContext *
                             const uint8_t *_src, const int16_t *filter,
                             const int32_t *filterPos, int filterSize)
  {
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->srcFormat);
      int i;
      const uint16_t *src = (const uint16_t *) _src;
-     int sh              = av_pix_fmt_descriptors[c->srcFormat].comp[0].depth_minus1;
+     int sh              = desc->comp[0].depth_minus1;
  
 +    if(sh<15)
 +        sh= isAnyRGB(c->srcFormat) || c->srcFormat==AV_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];
@@@ -739,204 -738,3 +741,204 @@@ SwsFunc ff_getSwsFunc(SwsContext *c
  
      return swScale;
  }
-     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt];
 +
 +static void reset_ptr(const uint8_t *src[], int format)
 +{
 +    if (!isALPHA(format))
 +        src[3] = NULL;
 +    if (!isPlanar(format)) {
 +        src[3] = src[2] = NULL;
 +
 +        if (!usePal(format))
 +            src[1] = NULL;
 +    }
 +}
 +
 +static int check_image_pointers(const uint8_t * const data[4], enum AVPixelFormat pix_fmt,
 +                                const int linesizes[4])
 +{
++    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
 +    int i;
 +
 +    for (i = 0; i < 4; i++) {
 +        int plane = desc->comp[i].plane;
 +        if (!data[plane] || !linesizes[plane])
 +            return 0;
 +    }
 +
 +    return 1;
 +}
 +
 +/**
 + * swscale wrapper, so we don't need to export the SwsContext.
 + * Assumes planar YUV to be in YUV order instead of YVU.
 + */
 +int attribute_align_arg sws_scale(struct SwsContext *c,
 +                                  const uint8_t * const srcSlice[],
 +                                  const int srcStride[], int srcSliceY,
 +                                  int srcSliceH, uint8_t *const dst[],
 +                                  const int dstStride[])
 +{
 +    int i, ret;
 +    const uint8_t *src2[4] = { srcSlice[0], srcSlice[1], srcSlice[2], srcSlice[3] };
 +    uint8_t *dst2[4] = { dst[0], dst[1], dst[2], dst[3] };
 +    uint8_t *rgb0_tmp = NULL;
 +
 +    // do not mess up sliceDir if we have a "trailing" 0-size slice
 +    if (srcSliceH == 0)
 +        return 0;
 +
 +    if (!check_image_pointers(srcSlice, c->srcFormat, srcStride)) {
 +        av_log(c, AV_LOG_ERROR, "bad src image pointers\n");
 +        return 0;
 +    }
 +    if (!check_image_pointers((const uint8_t* const*)dst, c->dstFormat, dstStride)) {
 +        av_log(c, AV_LOG_ERROR, "bad dst image pointers\n");
 +        return 0;
 +    }
 +
 +    if (c->sliceDir == 0 && srcSliceY != 0 && srcSliceY + srcSliceH != c->srcH) {
 +        av_log(c, AV_LOG_ERROR, "Slices start in the middle!\n");
 +        return 0;
 +    }
 +    if (c->sliceDir == 0) {
 +        if (srcSliceY == 0) c->sliceDir = 1; else c->sliceDir = -1;
 +    }
 +
 +    if (usePal(c->srcFormat)) {
 +        for (i = 0; i < 256; i++) {
 +            int p, r, g, b, y, u, v, a = 0xff;
 +            if (c->srcFormat == AV_PIX_FMT_PAL8) {
 +                p = ((const uint32_t *)(srcSlice[1]))[i];
 +                a = (p >> 24) & 0xFF;
 +                r = (p >> 16) & 0xFF;
 +                g = (p >>  8) & 0xFF;
 +                b =  p        & 0xFF;
 +            } else if (c->srcFormat == AV_PIX_FMT_RGB8) {
 +                r = ( i >> 5     ) * 36;
 +                g = ((i >> 2) & 7) * 36;
 +                b = ( i       & 3) * 85;
 +            } else if (c->srcFormat == AV_PIX_FMT_BGR8) {
 +                b = ( i >> 6     ) * 85;
 +                g = ((i >> 3) & 7) * 36;
 +                r = ( i       & 7) * 36;
 +            } else if (c->srcFormat == AV_PIX_FMT_RGB4_BYTE) {
 +                r = ( i >> 3     ) * 255;
 +                g = ((i >> 1) & 3) * 85;
 +                b = ( i       & 1) * 255;
 +            } else if (c->srcFormat == AV_PIX_FMT_GRAY8 || c->srcFormat == AV_PIX_FMT_GRAY8A) {
 +                r = g = b = i;
 +            } else {
 +                av_assert1(c->srcFormat == AV_PIX_FMT_BGR4_BYTE);
 +                b = ( i >> 3     ) * 255;
 +                g = ((i >> 1) & 3) * 85;
 +                r = ( i       & 1) * 255;
 +            }
 +#define RGB2YUV_SHIFT 15
 +#define BY ( (int) (0.114 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 +#define BV (-(int) (0.081 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 +#define BU ( (int) (0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 +#define GY ( (int) (0.587 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 +#define GV (-(int) (0.419 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 +#define GU (-(int) (0.331 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 +#define RY ( (int) (0.299 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 +#define RV ( (int) (0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 +#define RU (-(int) (0.169 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
 +
 +            y = av_clip_uint8((RY * r + GY * g + BY * b + ( 33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
 +            u = av_clip_uint8((RU * r + GU * g + BU * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
 +            v = av_clip_uint8((RV * r + GV * g + BV * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
 +            c->pal_yuv[i]= y + (u<<8) + (v<<16) + (a<<24);
 +
 +            switch (c->dstFormat) {
 +            case AV_PIX_FMT_BGR32:
 +#if !HAVE_BIGENDIAN
 +            case AV_PIX_FMT_RGB24:
 +#endif
 +                c->pal_rgb[i]=  r + (g<<8) + (b<<16) + (a<<24);
 +                break;
 +            case AV_PIX_FMT_BGR32_1:
 +#if HAVE_BIGENDIAN
 +            case AV_PIX_FMT_BGR24:
 +#endif
 +                c->pal_rgb[i]= a + (r<<8) + (g<<16) + (b<<24);
 +                break;
 +            case AV_PIX_FMT_RGB32_1:
 +#if HAVE_BIGENDIAN
 +            case AV_PIX_FMT_RGB24:
 +#endif
 +                c->pal_rgb[i]= a + (b<<8) + (g<<16) + (r<<24);
 +                break;
 +            case AV_PIX_FMT_RGB32:
 +#if !HAVE_BIGENDIAN
 +            case AV_PIX_FMT_BGR24:
 +#endif
 +            default:
 +                c->pal_rgb[i]=  b + (g<<8) + (r<<16) + (a<<24);
 +            }
 +        }
 +    }
 +
 +    if (c->src0Alpha && !c->dst0Alpha && isALPHA(c->dstFormat)) {
 +        uint8_t *base;
 +        int x,y;
 +        rgb0_tmp = av_malloc(FFABS(srcStride[0]) * srcSliceH + 32);
 +        base = srcStride[0] < 0 ? rgb0_tmp - srcStride[0] * (srcSliceH-1) : rgb0_tmp;
 +        for (y=0; y<srcSliceH; y++){
 +            memcpy(base + srcStride[0]*y, src2[0] + srcStride[0]*y, 4*c->srcW);
 +            for (x=c->src0Alpha-1; x<4*c->srcW; x+=4) {
 +                base[ srcStride[0]*y + x] = 0xFF;
 +            }
 +        }
 +        src2[0] = base;
 +    }
 +
 +    // copy strides, so they can safely be modified
 +    if (c->sliceDir == 1) {
 +        // slices go from top to bottom
 +        int srcStride2[4] = { srcStride[0], srcStride[1], srcStride[2],
 +                              srcStride[3] };
 +        int dstStride2[4] = { dstStride[0], dstStride[1], dstStride[2],
 +                              dstStride[3] };
 +
 +        reset_ptr(src2, c->srcFormat);
 +        reset_ptr((void*)dst2, c->dstFormat);
 +
 +        /* reset slice direction at end of frame */
 +        if (srcSliceY + srcSliceH == c->srcH)
 +            c->sliceDir = 0;
 +
 +        ret = c->swScale(c, src2, srcStride2, srcSliceY, srcSliceH, dst2,
 +                          dstStride2);
 +    } else {
 +        // slices go from bottom to top => we flip the image internally
 +        int srcStride2[4] = { -srcStride[0], -srcStride[1], -srcStride[2],
 +                              -srcStride[3] };
 +        int dstStride2[4] = { -dstStride[0], -dstStride[1], -dstStride[2],
 +                              -dstStride[3] };
 +
 +        src2[0] += (srcSliceH - 1) * srcStride[0];
 +        if (!usePal(c->srcFormat))
 +            src2[1] += ((srcSliceH >> c->chrSrcVSubSample) - 1) * srcStride[1];
 +        src2[2] += ((srcSliceH >> c->chrSrcVSubSample) - 1) * srcStride[2];
 +        src2[3] += (srcSliceH - 1) * srcStride[3];
 +        dst2[0] += ( c->dstH                         - 1) * dstStride[0];
 +        dst2[1] += ((c->dstH >> c->chrDstVSubSample) - 1) * dstStride[1];
 +        dst2[2] += ((c->dstH >> c->chrDstVSubSample) - 1) * dstStride[2];
 +        dst2[3] += ( c->dstH                         - 1) * dstStride[3];
 +
 +        reset_ptr(src2, c->srcFormat);
 +        reset_ptr((void*)dst2, c->dstFormat);
 +
 +        /* reset slice direction at end of frame */
 +        if (!srcSliceY)
 +            c->sliceDir = 0;
 +
 +        ret = c->swScale(c, src2, srcStride2, c->srcH-srcSliceY-srcSliceH,
 +                          srcSliceH, dst2, dstStride2);
 +    }
 +
 +    av_free(rgb0_tmp);
 +    return ret;
 +}
 +
@@@ -547,36 -541,50 +548,58 @@@ SwsFunc ff_yuv2rgb_init_altivec(SwsCont
  SwsFunc ff_yuv2rgb_get_func_ptr_bfin(SwsContext *c);
  void ff_bfin_get_unscaled_swscale(SwsContext *c);
  
 +#if FF_API_SWS_FORMAT_NAME
 +/**
 + * @deprecated Use av_get_pix_fmt_name() instead.
 + */
 +attribute_deprecated
  const char *sws_format_name(enum AVPixelFormat format);
 +#endif
  
- #define is16BPS(x) \
-     (av_pix_fmt_descriptors[x].comp[0].depth_minus1 == 15)
+ static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
+ {
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+     av_assert0(desc);
+     return desc->comp[0].depth_minus1 == 15;
+ }
  
- #define is9_OR_10BPS(x) \
-     (av_pix_fmt_descriptors[x].comp[0].depth_minus1 >= 8 && \
-      av_pix_fmt_descriptors[x].comp[0].depth_minus1 <= 13)
+ static av_always_inline int is9_OR_10BPS(enum AVPixelFormat pix_fmt)
+ {
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+     av_assert0(desc);
 -    return desc->comp[0].depth_minus1 == 8 || desc->comp[0].depth_minus1 == 9;
++    return desc->comp[0].depth_minus1 >= 8 && desc->comp[0].depth_minus1 <= 13;
+ }
  
- #define isBE(x) \
-     (av_pix_fmt_descriptors[x].flags & PIX_FMT_BE)
 +#define isNBPS(x) is9_OR_10BPS(x)
 +
+ static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
+ {
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+     av_assert0(desc);
+     return desc->flags & PIX_FMT_BE;
+ }
+ static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
+ {
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+     av_assert0(desc);
+     return !(desc->flags & PIX_FMT_RGB) && desc->nb_components >= 2;
+ }
+ static av_always_inline int isPlanarYUV(enum AVPixelFormat pix_fmt)
+ {
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+     av_assert0(desc);
+     return ((desc->flags & PIX_FMT_PLANAR) && isYUV(pix_fmt));
+ }
+ static av_always_inline int isRGB(enum AVPixelFormat pix_fmt)
+ {
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+     av_assert0(desc);
+     return (desc->flags & PIX_FMT_RGB);
+ }
  
- #define isYUV(x) \
-     (!(av_pix_fmt_descriptors[x].flags & PIX_FMT_RGB) && \
-      av_pix_fmt_descriptors[x].nb_components >= 2)
- #define isPlanarYUV(x) \
-     ((av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR) && \
-      isYUV(x))
- #define isRGB(x) \
-     (av_pix_fmt_descriptors[x].flags & PIX_FMT_RGB)
  #if 0 // FIXME
  #define isGray(x) \
      (!(av_pix_fmt_descriptors[x].flags & PIX_FMT_PAL) && \
       (x) == AV_PIX_FMT_BGR4        ||  \
       (x) == AV_PIX_FMT_BGR4_BYTE   ||  \
       (x) == AV_PIX_FMT_MONOBLACK   ||  \
 -     (x) == AV_PIX_FMT_MONOWHITE)
 -
 -#define isAnyRGB(x)                    \
 -    (isRGBinInt(x)              ||     \
 -     isBGRinInt(x))
 +     (x) == AV_PIX_FMT_MONOWHITE   \
 +    )
 +
 +#define isRGBinBytes(x) (           \
 +           (x) == AV_PIX_FMT_RGB48BE     \
 +        || (x) == AV_PIX_FMT_RGB48LE     \
 +        || (x) == AV_PIX_FMT_RGBA64BE    \
 +        || (x) == AV_PIX_FMT_RGBA64LE    \
 +        || (x) == AV_PIX_FMT_RGBA        \
 +        || (x) == AV_PIX_FMT_ARGB        \
 +        || (x) == AV_PIX_FMT_RGB24       \
 +    )
 +#define isBGRinBytes(x) (           \
 +           (x) == AV_PIX_FMT_BGR48BE     \
 +        || (x) == AV_PIX_FMT_BGR48LE     \
 +        || (x) == AV_PIX_FMT_BGRA64BE    \
 +        || (x) == AV_PIX_FMT_BGRA64LE    \
 +        || (x) == AV_PIX_FMT_BGRA        \
 +        || (x) == AV_PIX_FMT_ABGR        \
 +        || (x) == AV_PIX_FMT_BGR24       \
 +    )
 +
 +#define isAnyRGB(x) \
 +    (           \
 +          isRGBinInt(x)       ||    \
 +          isBGRinInt(x)       ||    \
 +          (x)==AV_PIX_FMT_GBR24P     \
 +    )
  
- #define isALPHA(x)                                             \
-     (av_pix_fmt_descriptors[x].nb_components == 2          ||  \
-      av_pix_fmt_descriptors[x].nb_components == 4)
+ static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
+ {
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+     av_assert0(desc);
+     return desc->nb_components == 2 || desc->nb_components == 4;
+ }
  
- #define isPacked(x)                                            \
-     ((av_pix_fmt_descriptors[x].nb_components >= 2         &&  \
-       !(av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR)) ||  \
-      (x) == AV_PIX_FMT_PAL8)
 +#if 1
 +#define isPacked(x)         (       \
 +           (x)==AV_PIX_FMT_PAL8        \
 +        || (x)==AV_PIX_FMT_YUYV422     \
 +        || (x)==AV_PIX_FMT_UYVY422     \
 +        || (x)==AV_PIX_FMT_Y400A       \
 +        ||  isRGBinInt(x)           \
 +        ||  isBGRinInt(x)           \
 +    )
 +#else
+ static av_always_inline int isPacked(enum AVPixelFormat pix_fmt)
+ {
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+     av_assert0(desc);
+     return ((desc->nb_components >= 2 && !(desc->flags & PIX_FMT_PLANAR)) ||
+             pix_fmt == AV_PIX_FMT_PAL8);
+ }
  
- #define isPlanar(x)                                            \
-     (av_pix_fmt_descriptors[x].nb_components >= 2          &&  \
-      (av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR))
- #define isPackedRGB(x)                                         \
-     ((av_pix_fmt_descriptors[x].flags                        & \
-      (PIX_FMT_PLANAR | PIX_FMT_RGB)) == PIX_FMT_RGB)
- #define isPlanarRGB(x)                                         \
-     ((av_pix_fmt_descriptors[x].flags                        & \
-      (PIX_FMT_PLANAR | PIX_FMT_RGB)) == (PIX_FMT_PLANAR | PIX_FMT_RGB))
- #define usePal(x) ((av_pix_fmt_descriptors[x].flags & PIX_FMT_PAL)       || \
-                    (av_pix_fmt_descriptors[x].flags & PIX_FMT_PSEUDOPAL))
 +#endif
 -    return ((desc->flags & PIX_FMT_PAL) || (desc->flags & PIX_FMT_PSEUDOPAL) ||
 -            pix_fmt == AV_PIX_FMT_Y400A);
+ static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
+ {
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+     av_assert0(desc);
+     return (desc->nb_components >= 2 && (desc->flags & PIX_FMT_PLANAR));
+ }
+ static av_always_inline int isPackedRGB(enum AVPixelFormat pix_fmt)
+ {
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+     av_assert0(desc);
+     return ((desc->flags & (PIX_FMT_PLANAR | PIX_FMT_RGB)) == PIX_FMT_RGB);
+ }
+ static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
+ {
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+     av_assert0(desc);
+     return ((desc->flags & (PIX_FMT_PLANAR | PIX_FMT_RGB)) ==
+             (PIX_FMT_PLANAR | PIX_FMT_RGB));
+ }
+ static av_always_inline int usePal(enum AVPixelFormat pix_fmt)
+ {
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+     av_assert0(desc);
++    return (desc->flags & PIX_FMT_PAL) || (desc->flags & PIX_FMT_PSEUDOPAL);
+ }
  
  extern const uint64_t ff_dither4[2];
  extern const uint64_t ff_dither8[2];
@@@ -531,11 -462,17 +531,13 @@@ static rgbConvFn findRgbConvFn(SwsConte
      const int srcId = c->srcFormatBpp;
      const int dstId = c->dstFormatBpp;
      rgbConvFn conv = NULL;
+     const AVPixFmtDescriptor *desc_src = av_pix_fmt_desc_get(srcFormat);
+     const AVPixFmtDescriptor *desc_dst = av_pix_fmt_desc_get(dstFormat);
  
- #define IS_NOT_NE(bpp, fmt) \
+ #define IS_NOT_NE(bpp, desc) \
      (((bpp + 7) >> 3) == 2 && \
-      (!(av_pix_fmt_descriptors[fmt].flags & PIX_FMT_BE) != !HAVE_BIGENDIAN))
+      (!(desc->flags & PIX_FMT_BE) != !HAVE_BIGENDIAN))
  
 -    /* if this is non-native rgb444/555/565, don't handle it here. */
 -    if (IS_NOT_NE(srcId, desc_src) || IS_NOT_NE(dstId, desc_dst))
 -        return NULL;
 -
  #define CONV_IS(src, dst) (srcFormat == AV_PIX_FMT_##src && dstFormat == AV_PIX_FMT_##dst)
  
      if (isRGBA32(srcFormat) && isRGBA32(dstFormat)) {
@@@ -629,6 -540,6 +631,8 @@@ static int rgbToRgbWrapper(SwsContext *
  {
      const enum AVPixelFormat srcFormat = c->srcFormat;
      const enum AVPixelFormat dstFormat = c->dstFormat;
++    const AVPixFmtDescriptor *desc_src = av_pix_fmt_desc_get(c->srcFormat);
++    const AVPixFmtDescriptor *desc_dst = av_pix_fmt_desc_get(c->dstFormat);
      const int srcBpp = (c->srcFormatBpp + 7) >> 3;
      const int dstBpp = (c->dstFormatBpp + 7) >> 3;
      rgbConvFn conv = findRgbConvFn(c);
      } else {
          const uint8_t *srcPtr = src[0];
                uint8_t *dstPtr = dst[0];
-         int src_bswap = IS_NOT_NE(c->srcFormatBpp, srcFormat);
-         int dst_bswap = IS_NOT_NE(c->dstFormatBpp, dstFormat);
++        int src_bswap = IS_NOT_NE(c->srcFormatBpp, desc_src);
++        int dst_bswap = IS_NOT_NE(c->dstFormatBpp, desc_dst);
 +
          if ((srcFormat == AV_PIX_FMT_RGB32_1 || srcFormat == AV_PIX_FMT_BGR32_1) &&
              !isRGBA32(dstFormat))
              srcPtr += ALT32_CORR;
@@@ -775,119 -676,156 +781,119 @@@ static int planarCopyWrapper(SwsContex
          // ignore palette for GRAY8
          if (plane == 1 && !dst[2]) continue;
          if (!src[plane] || (plane == 1 && !src[2])) {
 -            if (is16BPS(c->dstFormat))
 -                length *= 2;
 -            fillPlane(dst[plane], dstStride[plane], length, height, y,
 -                      (plane == 3) ? 255 : 128);
 +            if (is16BPS(c->dstFormat) || isNBPS(c->dstFormat)) {
 +                fillPlane16(dst[plane], dstStride[plane], length, height, y,
-                         plane == 3, av_pix_fmt_descriptors[c->dstFormat].comp[plane].depth_minus1);
++                        plane == 3, desc_dst->comp[plane].depth_minus1);
 +            } else {
 +                fillPlane(dst[plane], dstStride[plane], length, height, y,
 +                        (plane == 3) ? 255 : 128);
 +            }
          } else {
 -            if (is9_OR_10BPS(c->srcFormat)) {
 +            if(isNBPS(c->srcFormat) || isNBPS(c->dstFormat)
 +               || (is16BPS(c->srcFormat) != is16BPS(c->dstFormat))
 +            ) {
-                 const int src_depth = av_pix_fmt_descriptors[c->srcFormat].comp[plane].depth_minus1 + 1;
-                 const int dst_depth = av_pix_fmt_descriptors[c->dstFormat].comp[plane].depth_minus1 + 1;
+                 const int src_depth = desc_src->comp[plane].depth_minus1 + 1;
+                 const int dst_depth = desc_dst->comp[plane].depth_minus1 + 1;
                  const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
 +                uint16_t *dstPtr2 = (uint16_t*)dstPtr;
  
 -                if (is16BPS(c->dstFormat)) {
 -                    uint16_t *dstPtr2 = (uint16_t *) dstPtr;
 -#define COPY9_OR_10TO16(rfunc, wfunc) \
 -                    for (i = 0; i < height; i++) { \
 -                        for (j = 0; j < length; j++) { \
 -                            int srcpx = rfunc(&srcPtr2[j]); \
 -                            wfunc(&dstPtr2[j], (srcpx << (16 - src_depth)) | (srcpx >> (2 * src_depth - 16))); \
 -                        } \
 -                        dstPtr2 += dstStride[plane] / 2; \
 -                        srcPtr2 += srcStride[plane] / 2; \
 +                if (dst_depth == 8) {
 +                    if(isBE(c->srcFormat) == HAVE_BIGENDIAN){
 +                        DITHER_COPY(dstPtr, dstStride[plane], srcPtr2, srcStride[plane]/2, , )
 +                    } else {
 +                        DITHER_COPY(dstPtr, dstStride[plane], srcPtr2, srcStride[plane]/2, av_bswap16, )
                      }
 -                    if (isBE(c->dstFormat)) {
 -                        if (isBE(c->srcFormat)) {
 -                            COPY9_OR_10TO16(AV_RB16, AV_WB16);
 -                        } else {
 -                            COPY9_OR_10TO16(AV_RL16, AV_WB16);
 +                } else if (src_depth == 8) {
 +                    for (i = 0; i < height; i++) {
 +                        #define COPY816(w)\
 +                        if(shiftonly){\
 +                            for (j = 0; j < length; j++)\
 +                                w(&dstPtr2[j], srcPtr[j]<<(dst_depth-8));\
 +                        }else{\
 +                            for (j = 0; j < length; j++)\
 +                                w(&dstPtr2[j], (srcPtr[j]<<(dst_depth-8)) |\
 +                                               (srcPtr[j]>>(2*8-dst_depth)));\
                          }
 -                    } else {
 -                        if (isBE(c->srcFormat)) {
 -                            COPY9_OR_10TO16(AV_RB16, AV_WL16);
 +                        if(isBE(c->dstFormat)){
 +                            COPY816(AV_WB16)
                          } else {
 -                            COPY9_OR_10TO16(AV_RL16, AV_WL16);
 +                            COPY816(AV_WL16)
                          }
 +                        dstPtr2 += dstStride[plane]/2;
 +                        srcPtr  += srcStride[plane];
                      }
 -                } else if (is9_OR_10BPS(c->dstFormat)) {
 -                    uint16_t *dstPtr2 = (uint16_t *) dstPtr;
 -#define COPY9_OR_10TO9_OR_10(loop) \
 -                    for (i = 0; i < height; i++) { \
 -                        for (j = 0; j < length; j++) { \
 -                            loop; \
 -                        } \
 -                        dstPtr2 += dstStride[plane] / 2; \
 -                        srcPtr2 += srcStride[plane] / 2; \
 -                    }
 -#define COPY9_OR_10TO9_OR_10_2(rfunc, wfunc) \
 -                    if (dst_depth > src_depth) { \
 -                        COPY9_OR_10TO9_OR_10(int srcpx = rfunc(&srcPtr2[j]); \
 -                            wfunc(&dstPtr2[j], (srcpx << 1) | (srcpx >> 9))); \
 -                    } else if (dst_depth < src_depth) { \
 -                        DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
 -                                    srcPtr2, srcStride[plane] / 2, rfunc, \
 -                                    dither_8x8_1, 1, clip9); \
 -                    } else { \
 -                        COPY9_OR_10TO9_OR_10(wfunc(&dstPtr2[j], rfunc(&srcPtr2[j]))); \
 -                    }
 -                    if (isBE(c->dstFormat)) {
 -                        if (isBE(c->srcFormat)) {
 -                            COPY9_OR_10TO9_OR_10_2(AV_RB16, AV_WB16);
 -                        } else {
 -                            COPY9_OR_10TO9_OR_10_2(AV_RL16, AV_WB16);
 +                } else if (src_depth <= dst_depth) {
 +                    int orig_length = length;
 +                    for (i = 0; i < height; i++) {
 +                        if(isBE(c->srcFormat) == HAVE_BIGENDIAN &&
 +                           isBE(c->dstFormat) == HAVE_BIGENDIAN &&
 +                           shiftonly) {
 +                             unsigned shift = dst_depth - src_depth;
 +                             length = orig_length;
 +#if HAVE_FAST_64BIT
 +#define FAST_COPY_UP(shift) \
 +    for (j = 0; j < length - 3; j += 4) { \
 +        uint64_t v = AV_RN64A(srcPtr2 + j); \
 +        AV_WN64A(dstPtr2 + j, v << shift); \
 +    } \
 +    length &= 3;
 +#else
 +#define FAST_COPY_UP(shift) \
 +    for (j = 0; j < length - 1; j += 2) { \
 +        uint32_t v = AV_RN32A(srcPtr2 + j); \
 +        AV_WN32A(dstPtr2 + j, v << shift); \
 +    } \
 +    length &= 1;
 +#endif
 +                             switch (shift)
 +                             {
 +                             case 6: FAST_COPY_UP(6); break;
 +                             case 7: FAST_COPY_UP(7); break;
 +                             }
                          }
 -                    } else {
 -                        if (isBE(c->srcFormat)) {
 -                            COPY9_OR_10TO9_OR_10_2(AV_RB16, AV_WL16);
 +#define COPY_UP(r,w) \
 +    if(shiftonly){\
 +        for (j = 0; j < length; j++){ \
 +            unsigned int v= r(&srcPtr2[j]);\
 +            w(&dstPtr2[j], v<<(dst_depth-src_depth));\
 +        }\
 +    }else{\
 +        for (j = 0; j < length; j++){ \
 +            unsigned int v= r(&srcPtr2[j]);\
 +            w(&dstPtr2[j], (v<<(dst_depth-src_depth)) | \
 +                        (v>>(2*src_depth-dst_depth)));\
 +        }\
 +    }
 +                        if(isBE(c->srcFormat)){
 +                            if(isBE(c->dstFormat)){
 +                                COPY_UP(AV_RB16, AV_WB16)
 +                            } else {
 +                                COPY_UP(AV_RB16, AV_WL16)
 +                            }
                          } else {
 -                            COPY9_OR_10TO9_OR_10_2(AV_RL16, AV_WL16);
 +                            if(isBE(c->dstFormat)){
 +                                COPY_UP(AV_RL16, AV_WB16)
 +                            } else {
 +                                COPY_UP(AV_RL16, AV_WL16)
 +                            }
                          }
 +                        dstPtr2 += dstStride[plane]/2;
 +                        srcPtr2 += srcStride[plane]/2;
                      }
                  } else {
 -#define W8(a, b) { *(a) = (b); }
 -#define COPY9_OR_10TO8(rfunc) \
 -                    if (src_depth == 9) { \
 -                        DITHER_COPY(dstPtr,  dstStride[plane],   W8, \
 -                                    srcPtr2, srcStride[plane] / 2, rfunc, \
 -                                    dither_8x8_1, 1, av_clip_uint8); \
 -                    } else { \
 -                        DITHER_COPY(dstPtr,  dstStride[plane],   W8, \
 -                                    srcPtr2, srcStride[plane] / 2, rfunc, \
 -                                    dither_8x8_3, 2, av_clip_uint8); \
 -                    }
 -                    if (isBE(c->srcFormat)) {
 -                        COPY9_OR_10TO8(AV_RB16);
 -                    } else {
 -                        COPY9_OR_10TO8(AV_RL16);
 -                    }
 -                }
 -            } else if (is9_OR_10BPS(c->dstFormat)) {
 -                const int dst_depth = desc_dst->comp[plane].depth_minus1 + 1;
 -                uint16_t *dstPtr2 = (uint16_t *) dstPtr;
 -
 -                if (is16BPS(c->srcFormat)) {
 -                    const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
 -#define COPY16TO9_OR_10(rfunc, wfunc) \
 -                    if (dst_depth == 9) { \
 -                        DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
 -                                    srcPtr2, srcStride[plane] / 2, rfunc, \
 -                                    dither_8x8_128, 7, clip9); \
 -                    } else { \
 -                        DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
 -                                    srcPtr2, srcStride[plane] / 2, rfunc, \
 -                                    dither_8x8_64, 6, clip10); \
 -                    }
 -                    if (isBE(c->dstFormat)) {
 -                        if (isBE(c->srcFormat)) {
 -                            COPY16TO9_OR_10(AV_RB16, AV_WB16);
 +                    if(isBE(c->srcFormat) == HAVE_BIGENDIAN){
 +                        if(isBE(c->dstFormat) == HAVE_BIGENDIAN){
 +                            DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, , )
                          } else {
 -                            COPY16TO9_OR_10(AV_RL16, AV_WB16);
 +                            DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, , av_bswap16)
                          }
 -                    } else {
 -                        if (isBE(c->srcFormat)) {
 -                            COPY16TO9_OR_10(AV_RB16, AV_WL16);
 +                    }else{
 +                        if(isBE(c->dstFormat) == HAVE_BIGENDIAN){
 +                            DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, av_bswap16, )
                          } else {
 -                            COPY16TO9_OR_10(AV_RL16, AV_WL16);
 +                            DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, av_bswap16, av_bswap16)
                          }
                      }
 -                } else /* 8bit */ {
 -#define COPY8TO9_OR_10(wfunc) \
 -                    for (i = 0; i < height; i++) { \
 -                        for (j = 0; j < length; j++) { \
 -                            const int srcpx = srcPtr[j]; \
 -                            wfunc(&dstPtr2[j], (srcpx << (dst_depth - 8)) | (srcpx >> (16 - dst_depth))); \
 -                        } \
 -                        dstPtr2 += dstStride[plane] / 2; \
 -                        srcPtr  += srcStride[plane]; \
 -                    }
 -                    if (isBE(c->dstFormat)) {
 -                        COPY8TO9_OR_10(AV_WB16);
 -                    } else {
 -                        COPY8TO9_OR_10(AV_WL16);
 -                    }
 -                }
 -            } else if (is16BPS(c->srcFormat) && !is16BPS(c->dstFormat)) {
 -                const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
 -#define COPY16TO8(rfunc) \
 -                    DITHER_COPY(dstPtr,  dstStride[plane],   W8, \
 -                                srcPtr2, srcStride[plane] / 2, rfunc, \
 -                                dither_8x8_256, 8, av_clip_uint8);
 -                if (isBE(c->srcFormat)) {
 -                    COPY16TO8(AV_RB16);
 -                } else {
 -                    COPY16TO8(AV_RL16);
 -                }
 -            } else if (!is16BPS(c->srcFormat) && is16BPS(c->dstFormat)) {
 -                for (i = 0; i < height; i++) {
 -                    for (j = 0; j < length; j++) {
 -                        dstPtr[ j << 1     ] = srcPtr[j];
 -                        dstPtr[(j << 1) + 1] = srcPtr[j];
 -                    }
 -                    srcPtr += srcStride[plane];
 -                    dstPtr += dstStride[plane];
                  }
              } else if (is16BPS(c->srcFormat) && is16BPS(c->dstFormat) &&
                        isBE(c->srcFormat) != isBE(c->dstFormat)) {
@@@ -194,12 -166,14 +194,16 @@@ int sws_isSupportedOutput(enum AVPixelF
  
  extern const int32_t ff_yuv2rgb_coeffs[8][4];
  
 +#if FF_API_SWS_FORMAT_NAME
  const char *sws_format_name(enum AVPixelFormat format)
  {
-     return av_get_pix_fmt_name(format);
+     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(format);
+     if (desc)
+         return desc->name;
+     else
+         return "Unknown format";
  }
 +#endif
  
  static double getSplineCoeff(double a, double b, double c, double d,
                               double dist)
@@@ -1015,17 -969,18 +1024,17 @@@ av_cold int sws_init_context(SwsContex
          }
      }
  
-     c->srcBpc = 1 + av_pix_fmt_descriptors[srcFormat].comp[0].depth_minus1;
+     c->srcBpc = 1 + desc_src->comp[0].depth_minus1;
      if (c->srcBpc < 8)
          c->srcBpc = 8;
-     c->dstBpc = 1 + av_pix_fmt_descriptors[dstFormat].comp[0].depth_minus1;
+     c->dstBpc = 1 + desc_dst->comp[0].depth_minus1;
      if (c->dstBpc < 8)
          c->dstBpc = 8;
 +    if (isAnyRGB(srcFormat) || srcFormat == AV_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);
 -    if (INLINE_MMXEXT(cpu_flags) && c->srcBpc == 8 && c->dstBpc <= 10) {
 +    if (INLINE_MMXEXT(cpu_flags) && c->srcBpc == 8 && c->dstBpc <= 14) {
          c->canMMX2BeUsed = (dstW >= srcW && (dstW & 31) == 0 &&
                              (srcW & 15) == 0) ? 1 : 0;
          if (!c->canMMX2BeUsed && dstW >= srcW && (srcW & 15) == 0