Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Tue, 10 Jan 2012 01:50:54 +0000 (02:50 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Tue, 10 Jan 2012 02:50:41 +0000 (03:50 +0100)
* qatar/master:
  fate: Add tests for more AAC features.
  aacps: Add missing newline in error message.
  fate: Add tests for vc1/wmapro in ism.
  aacdec: Add a fate test for 5.1 channel SBR.
  aacdec: Turn off PS for multichannel files that use PCE based configs.
  cabac: remove put_cabac_u/ueg from cabac-test.
  swscale: RGB4444 and BGR444 input
  FATE: add test for xWMA demuxer.
  FATE: add test for SMJPEG demuxer and associated IMA ADPCM audio decoder.
  mpegaudiodec: optimized iMDCT transform
  mpegaudiodec: change imdct window arrangment for better pointer alignment
  mpegaudiodec: move imdct and windowing function to mpegaudiodsp
  mpegaudiodec: interleave iMDCT buffer to simplify future SIMD implementations
  swscale: convert yuy2/uyvy/nv12/nv21ToY/UV from inline asm to yasm.
  FATE: test to exercise WTV demuxer.
  mjpegdec: K&R formatting cosmetics
  swscale: K&R formatting cosmetics for code examples
  swscale: K&R reformatting cosmetics for header files
  FATE test: cvid-grayscale; ensures that the grayscale Cinepak variant is exercised.

Conflicts:
libavcodec/cabac.c
libavcodec/mjpegdec.c
libavcodec/mpegaudiodec.c
libavcodec/mpegaudiodsp.c
libavcodec/mpegaudiodsp.h
libavcodec/mpegaudiodsp_template.c
libavcodec/x86/Makefile
libavcodec/x86/imdct36_sse.asm
libavcodec/x86/mpegaudiodec_mmx.c
libswscale/swscale-test.c
libswscale/swscale.c
libswscale/swscale_internal.h
libswscale/x86/swscale_template.c
tests/fate/demux.mak
tests/fate/microsoft.mak
tests/fate/video.mak
tests/fate/wma.mak
tests/ref/lavfi/pixfmts_scale

Merged-by: Michael Niedermayer <michaelni@gmx.at>
31 files changed:
1  2 
libavcodec/aac.h
libavcodec/aacdec.c
libavcodec/aacps.c
libavcodec/cabac.c
libavcodec/mpegaudiodec.c
libavcodec/mpegaudiodsp.c
libavcodec/mpegaudiodsp.h
libavcodec/mpegaudiodsp_template.c
libavcodec/x86/mpegaudiodec_mmx.c
libavutil/x86/x86inc.asm
libswscale/Makefile
libswscale/colorspace-test.c
libswscale/ppc/yuv2rgb_altivec.h
libswscale/rgb2rgb.h
libswscale/swscale-test.c
libswscale/swscale.c
libswscale/swscale.h
libswscale/swscale_internal.h
libswscale/utils.c
libswscale/x86/input.asm
libswscale/x86/swscale_mmx.c
libswscale/x86/swscale_template.c
tests/fate/demux.mak
tests/fate/microsoft.mak
tests/fate/video.mak
tests/fate/wma.mak
tests/ref/lavfi/pixdesc
tests/ref/lavfi/pixfmts_copy
tests/ref/lavfi/pixfmts_null
tests/ref/lavfi/pixfmts_scale
tests/ref/lavfi/pixfmts_vflip

Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -28,8 -29,10 +29,11 @@@ typedef struct MPADSPContext 
                                 int *dither_state, int16_t *samples, int incr);
      void (*dct32_float)(float *dst, const float *src);
      void (*dct32_fixed)(int *dst, const int *src);
-     void (*imdct36_float)(float *out, float *buf, float *in, float *win);
-     void (*imdct36_fixed)(int *out, int *buf, int *in, int *win);
++
+     void (*imdct36_blocks_float)(float *out, float *buf, float *in,
+                                  int count, int switch_point, int block_type);
+     void (*imdct36_blocks_fixed)(int *out, int *buf, int *in,
+                                  int count, int switch_point, int block_type);
  } MPADSPContext;
  
  void ff_mpadsp_init(MPADSPContext *s);
@@@ -326,9 -374,27 +374,28 @@@ static void imdct36(INTFLOAT *out, INTF
      s1 = MULH3(tmp[17], icos36h[4], 2);
      t0 = s0 + s1;
      t1 = s0 - s1;
-     out[(9 + 4)*SBLIMIT] =  MULH3(t1, win[9 + 4], 1) + buf[9 + 4];
-     out[(8 - 4)*SBLIMIT] =  MULH3(t1, win[8 - 4], 1) + buf[8 - 4];
-     buf[9 + 4] = MULH3(t0, win[20 + 9 + 4], 1);
-     buf[8 - 4] = MULH3(t0, win[20 + 8 - 4], 1);
+     out[(9 + 4) * SBLIMIT] = MULH3(t1, win[     9 + 4], 1) + buf[4*(9 + 4)];
+     out[(8 - 4) * SBLIMIT] = MULH3(t1, win[     8 - 4], 1) + buf[4*(8 - 4)];
+     buf[4 * ( 9 + 4     )] = MULH3(t0, win[MDCT_BUF_SIZE/2 + 9 + 4], 1);
+     buf[4 * ( 8 - 4     )] = MULH3(t0, win[MDCT_BUF_SIZE/2 + 8 - 4], 1);
+ }
+ void RENAME(ff_imdct36_blocks)(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in,
+                                int count, int switch_point, int block_type)
+ {
+     int j;
+     for (j=0 ; j < count; j++) {
+         /* apply window & overlap with previous buffer */
+         /* select window */
+         int win_idx = (switch_point && j < 2) ? 0 : block_type;
+         INTFLOAT *win = RENAME(ff_mdct_win)[win_idx + (4 & -(j & 1))];
+         imdct36(out, buf, in, win);
+         in  += 18;
+         buf += ((j&3) != 3 ? 1 : (72-3));
+         out++;
+     }
  }
 +
Simple merge
Simple merge
@@@ -19,11 -17,10 +19,12 @@@ OBJS-$(HAVE_MMX)           +=  x86/rgb2
                                 x86/swscale_mmx.o        \
                                 x86/yuv2rgb_mmx.o
  OBJS-$(HAVE_VIS)           +=  sparc/yuv2rgb_vis.o
- MMX-OBJS-$(HAVE_YASM)      +=  x86/output.o             \
+ MMX-OBJS-$(HAVE_YASM)      +=  x86/input.o              \
+                                x86/output.o             \
                                 x86/scale.o
  
 +$(SUBDIR)x86/swscale_mmx.o: CFLAGS += $(NOREDZONE_FLAGS)
 +
  TESTPROGS = colorspace swscale
  
  DIRS = bfin mlib ppc sparc x86
Simple merge
Simple merge
Simple merge
@@@ -104,9 -103,8 +103,9 @@@ static int doTest(uint8_t *ref[4], int 
  
          av_image_fill_linesizes(srcStride, srcFormat, srcW);
          for (p = 0; p < 4; p++) {
 +            srcStride[p] = FFALIGN(srcStride[p], 16);
              if (srcStride[p])
-                 src[p] = av_mallocz(srcStride[p]*srcH+16);
+                 src[p] = av_mallocz(srcStride[p] * srcH + 16);
              if (srcStride[p] && !src[p]) {
                  perror("Malloc");
                  res = -1;
           * allocated with av_malloc). */
          /* An extra 16 bytes is being allocated because some scalers may write
           * out of bounds. */
 +        dstStride[i] = FFALIGN(dstStride[i], 16);
          if (dstStride[i])
-             dst[i]= av_mallocz(dstStride[i]*dstH+16);
+             dst[i] = av_mallocz(dstStride[i] * dstH + 16);
          if (dstStride[i] && !dst[i]) {
              perror("Malloc");
              res = -1;
          ssdV = r->ssdV;
          ssdA = r->ssdA;
      } else {
-         for (i=0; i<4; i++) {
+         for (i = 0; i < 4; i++) {
 +            refStride[i] = FFALIGN(refStride[i], 16);
              if (refStride[i])
-                 out[i]= av_mallocz(refStride[i]*h);
+                 out[i] = av_mallocz(refStride[i] * h);
              if (refStride[i] && !out[i]) {
                  perror("Malloc");
                  res = -1;
@@@ -1637,29 -1537,18 +1637,33 @@@ rgb16_32_wrapper(PIX_FMT_RGB32,    rgb3
  rgb16_32_wrapper(PIX_FMT_RGB32_1,  rgb321,  0, 0, 16, 8,   0x00FF, 0xFF00, 0xFF0000,  8, 0,  8, RGB2YUV_SHIFT+8)
  rgb16_32_wrapper(PIX_FMT_BGR565LE, bgr16le, 0, 0,  0, 0,   0x001F, 0x07E0,   0xF800, 11, 5,  0, RGB2YUV_SHIFT+8)
  rgb16_32_wrapper(PIX_FMT_BGR555LE, bgr15le, 0, 0,  0, 0,   0x001F, 0x03E0,   0x7C00, 10, 5,  0, RGB2YUV_SHIFT+7)
+ rgb16_32_wrapper(PIX_FMT_BGR444LE, bgr12le, 0, 0,  0, 0,   0x000F, 0x00F0,   0x0F00,  8, 4,  0, RGB2YUV_SHIFT+4)
  rgb16_32_wrapper(PIX_FMT_RGB565LE, rgb16le, 0, 0,  0, 0,   0xF800, 0x07E0,   0x001F,  0, 5, 11, RGB2YUV_SHIFT+8)
  rgb16_32_wrapper(PIX_FMT_RGB555LE, rgb15le, 0, 0,  0, 0,   0x7C00, 0x03E0,   0x001F,  0, 5, 10, RGB2YUV_SHIFT+7)
+ rgb16_32_wrapper(PIX_FMT_RGB444LE, rgb12le, 0, 0,  0, 0,   0x0F00, 0x00F0,   0x000F,  0, 4,  8, RGB2YUV_SHIFT+4)
  rgb16_32_wrapper(PIX_FMT_BGR565BE, bgr16be, 0, 0,  0, 0,   0x001F, 0x07E0,   0xF800, 11, 5,  0, RGB2YUV_SHIFT+8)
  rgb16_32_wrapper(PIX_FMT_BGR555BE, bgr15be, 0, 0,  0, 0,   0x001F, 0x03E0,   0x7C00, 10, 5,  0, RGB2YUV_SHIFT+7)
+ rgb16_32_wrapper(PIX_FMT_BGR444BE, bgr12be, 0, 0,  0, 0,   0x000F, 0x00F0,   0x0F00,  8, 4,  0, RGB2YUV_SHIFT+4)
  rgb16_32_wrapper(PIX_FMT_RGB565BE, rgb16be, 0, 0,  0, 0,   0xF800, 0x07E0,   0x001F,  0, 5, 11, RGB2YUV_SHIFT+8)
  rgb16_32_wrapper(PIX_FMT_RGB555BE, rgb15be, 0, 0,  0, 0,   0x7C00, 0x03E0,   0x001F,  0, 5, 10, RGB2YUV_SHIFT+7)
+ rgb16_32_wrapper(PIX_FMT_RGB444BE, rgb12be, 0, 0,  0, 0,   0x0F00, 0x00F0,   0x000F,  0, 4,  8, RGB2YUV_SHIFT+4)
  
 -static void abgrToA_c(uint8_t *dst, const uint8_t *src, int width, uint32_t *unused)
 +static void gbr24pToUV_half_c(uint16_t *dstU, uint16_t *dstV,
 +                         const uint8_t *gsrc, const uint8_t *bsrc, const uint8_t *rsrc,
 +                         int width, enum PixelFormat origin)
 +{
 +    int i;
 +    for (i = 0; i < width; i++) {
 +        unsigned int g   = gsrc[2*i] + gsrc[2*i+1];
 +        unsigned int b   = bsrc[2*i] + bsrc[2*i+1];
 +        unsigned int r   = rsrc[2*i] + rsrc[2*i+1];
 +
 +        dstU[i] = (RU*r + GU*g + BU*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
 +        dstV[i] = (RV*r + GV*g + BV*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
 +    }
 +}
 +
 +static void abgrToA_c(int16_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
  {
      int i;
      for (i=0; i<width; i++) {
@@@ -2894,7 -2761,8 +2900,9 @@@ static av_cold void sws_init_swScale_c(
          case PIX_FMT_RGB565BE: c->chrToYV12 = rgb16beToUV_half_c; break;
          case PIX_FMT_RGB555LE: c->chrToYV12 = rgb15leToUV_half_c; break;
          case PIX_FMT_RGB555BE: c->chrToYV12 = rgb15beToUV_half_c; break;
 +        case PIX_FMT_GBR24P  : c->chrToYV12 = gbr24pToUV_half_c;  break;
+         case PIX_FMT_RGB444LE: c->chrToYV12 = rgb12leToUV_half_c; break;
+         case PIX_FMT_RGB444BE: c->chrToYV12 = rgb12beToUV_half_c; break;
          }
      } else {
          switch(srcFormat) {
Simple merge
@@@ -423,21 -426,25 +429,25 @@@ typedef struct SwsContext 
      yuv2packed2_fn yuv2packed2;
      yuv2packedX_fn yuv2packedX;
  
 -    void (*lumToYV12)(uint8_t *dst, const uint8_t *src,
+     /// Unscaled conversion of luma plane to YV12 for horizontal scaler.
-                       int width, uint32_t *pal); ///< Unscaled conversion of luma plane to YV12 for horizontal scaler.
 +    void (*lumToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3,
 -    void (*alpToYV12)(uint8_t *dst, const uint8_t *src,
+                       int width, uint32_t *pal);
+     /// Unscaled conversion of alpha plane to YV12 for horizontal scaler.
-                       int width, uint32_t *pal); ///< Unscaled conversion of alpha plane to YV12 for horizontal scaler.
 +    void (*alpToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3,
+                       int width, uint32_t *pal);
+     /// Unscaled conversion of chroma planes to YV12 for horizontal scaler.
      void (*chrToYV12)(uint8_t *dstU, uint8_t *dstV,
 -                      const uint8_t *src1, const uint8_t *src2,
 +                      const uint8_t *src1, const uint8_t *src2, const uint8_t *src3,
-                       int width, uint32_t *pal); ///< Unscaled conversion of chroma planes to YV12 for horizontal scaler.
+                       int width, uint32_t *pal);
  
      /**
-       * Functions to read planar input, such as planar RGB, and convert
-       * internally to Y/UV.
-       */
+      * Functions to read planar input, such as planar RGB, and convert
+      * internally to Y/UV.
+      */
      /** @{ */
      void (*readLumPlanar)(uint8_t *dst, const uint8_t *src[4], int width);
-     void (*readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4], int width);
+     void (*readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4],
+                           int width);
      /** @} */
  
      /**
@@@ -567,103 -568,64 +578,104 @@@ const char *sws_format_name(enum PixelF
      (!(av_pix_fmt_descriptors[x].flags & PIX_FMT_PAL) && \
       av_pix_fmt_descriptors[x].nb_components <= 2)
  #else
- #define isGray(x)       (           \
-            (x)==PIX_FMT_GRAY8       \
-         || (x)==PIX_FMT_GRAY8A      \
-         || (x)==PIX_FMT_GRAY16BE    \
-         || (x)==PIX_FMT_GRAY16LE    \
-     )
+ #define isGray(x)                      \
+     ((x) == PIX_FMT_GRAY8       ||     \
+      (x) == PIX_FMT_Y400A       ||     \
+      (x) == PIX_FMT_GRAY16BE    ||     \
+      (x) == PIX_FMT_GRAY16LE)
  #endif
  
- #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 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 isALPHA(x)                                            \
 -    (av_pix_fmt_descriptors[x].nb_components == 2          || \
++#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 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 isAnyRGB(x) \
++    (           \
++          isRGBinInt(x)       ||    \
++          isBGRinInt(x)       ||    \
++          (x)==PIX_FMT_GBR24P     \
 +    )
 +
 +#define isALPHA(x) \
 +    (av_pix_fmt_descriptors[x].nb_components == 2 || \
       av_pix_fmt_descriptors[x].nb_components == 4)
  
- #define isPacked(x) (\
-     (av_pix_fmt_descriptors[x].nb_components >= 2 && \
-      !(av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR)) || \
-     (x) == PIX_FMT_PAL8\
-     )
 +#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)
  
 +#endif
  #define isPlanar(x) \
-     (av_pix_fmt_descriptors[x].nb_components >= 2 && \
+     (av_pix_fmt_descriptors[x].nb_components >= 2          &&  \
       (av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR))
  
  #define usePal(x) ((av_pix_fmt_descriptors[x].flags & PIX_FMT_PAL) || (x) == PIX_FMT_Y400A)
Simple merge
index 0000000,4bdb575..af53dab
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,242 +1,242 @@@
 -cglobal %2ToY, 3, 3, %1, dst, src, w
+ ;******************************************************************************
+ ;* x86-optimized input routines; does shuffling of packed
+ ;* YUV formats into individual planes, and converts RGB
+ ;* into YUV planes also.
+ ;* Copyright (c) 2012 Ronald S. Bultje <rsbultje@gmail.com>
+ ;*
+ ;* This file is part of Libav.
+ ;*
+ ;* Libav is free software; you can redistribute it and/or
+ ;* modify it under the terms of the GNU Lesser General Public
+ ;* License as published by the Free Software Foundation; either
+ ;* version 2.1 of the License, or (at your option) any later version.
+ ;*
+ ;* Libav is distributed in the hope that it will be useful,
+ ;* but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ;* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ ;* Lesser General Public License for more details.
+ ;*
+ ;* You should have received a copy of the GNU Lesser General Public
+ ;* License along with Libav; if not, write to the Free Software
+ ;* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ ;******************************************************************************
+ %include "x86inc.asm"
+ %include "x86util.asm"
+ SECTION_RODATA
+ SECTION .text
+ ;-----------------------------------------------------------------------------
+ ; YUYV/UYVY/NV12/NV21 packed pixel shuffling.
+ ;
+ ; void <fmt>ToY_<opt>(uint8_t *dst, const uint8_t *src, int w);
+ ; and
+ ; void <fmt>toUV_<opt>(uint8_t *dstU, uint8_t *dstV, const uint8_t *src,
+ ;                      const uint8_t *unused, int w);
+ ;-----------------------------------------------------------------------------
+ ; %1 = a (aligned) or u (unaligned)
+ ; %2 = yuyv or uyvy
+ %macro LOOP_YUYV_TO_Y 2
+ .loop_%1:
+     mov%1          m0, [srcq+wq*2]        ; (byte) { Y0, U0, Y1, V0, ... }
+     mov%1          m1, [srcq+wq*2+mmsize] ; (byte) { Y8, U4, Y9, V4, ... }
+ %ifidn %2, yuyv
+     pand           m0, m2                 ; (word) { Y0, Y1, ..., Y7 }
+     pand           m1, m2                 ; (word) { Y8, Y9, ..., Y15 }
+ %else ; uyvy
+     psrlw          m0, 8                  ; (word) { Y0, Y1, ..., Y7 }
+     psrlw          m1, 8                  ; (word) { Y8, Y9, ..., Y15 }
+ %endif ; yuyv/uyvy
+     packuswb       m0, m1                 ; (byte) { Y0, ..., Y15 }
+     mova    [dstq+wq], m0
+     add            wq, mmsize
+     jl .loop_%1
+     REP_RET
+ %endmacro
+ ; %1 = nr. of XMM registers
+ ; %2 = yuyv or uyvy
+ ; %3 = if specified, it means that unaligned and aligned code in loop
+ ;      will be the same (i.e. YUYV+AVX), and thus we don't need to
+ ;      split the loop in an aligned and unaligned case
+ %macro YUYV_TO_Y_FN 2-3
 -cglobal %2ToUV, 3, 4, %1, dstU, dstV, src, w
++cglobal %2ToY, 5, 5, %1, dst, unused0, unused1, src, w
+ %ifdef ARCH_X86_64
+     movsxd         wq, wd
+ %endif
+     add          dstq, wq
+ %if mmsize == 16
+     test         srcq, 15
+ %endif
+     lea          srcq, [srcq+wq*2]
+ %ifidn %2, yuyv
+     pcmpeqb        m2, m2                 ; (byte) { 0xff } x 16
+     psrlw          m2, 8                  ; (word) { 0x00ff } x 8
+ %endif ; yuyv
+ %if mmsize == 16
+     jnz .loop_u_start
+     neg            wq
+     LOOP_YUYV_TO_Y  a, %2
+ .loop_u_start:
+     neg            wq
+     LOOP_YUYV_TO_Y  u, %2
+ %else ; mmsize == 8
+     neg            wq
+     LOOP_YUYV_TO_Y  a, %2
+ %endif ; mmsize == 8/16
+ %endmacro
+ ; %1 = a (aligned) or u (unaligned)
+ ; %2 = yuyv or uyvy
+ %macro LOOP_YUYV_TO_UV 2
+ .loop_%1:
+ %ifidn %2, yuyv
+     mov%1          m0, [srcq+wq*4]        ; (byte) { Y0, U0, Y1, V0, ... }
+     mov%1          m1, [srcq+wq*4+mmsize] ; (byte) { Y8, U4, Y9, V4, ... }
+     psrlw          m0, 8                  ; (word) { U0, V0, ..., U3, V3 }
+     psrlw          m1, 8                  ; (word) { U4, V4, ..., U7, V7 }
+ %else ; uyvy
+ %if cpuflag(avx)
+     vpand          m0, m2, [srcq+wq*4]        ; (word) { U0, V0, ..., U3, V3 }
+     vpand          m1, m2, [srcq+wq*4+mmsize] ; (word) { U4, V4, ..., U7, V7 }
+ %else
+     mov%1          m0, [srcq+wq*4]        ; (byte) { Y0, U0, Y1, V0, ... }
+     mov%1          m1, [srcq+wq*4+mmsize] ; (byte) { Y8, U4, Y9, V4, ... }
+     pand           m0, m2                 ; (word) { U0, V0, ..., U3, V3 }
+     pand           m1, m2                 ; (word) { U4, V4, ..., U7, V7 }
+ %endif
+ %endif ; yuyv/uyvy
+     packuswb       m0, m1                 ; (byte) { U0, V0, ..., U7, V7 }
+     pand           m1, m0, m2             ; (word) { U0, U1, ..., U7 }
+     psrlw          m0, 8                  ; (word) { V0, V1, ..., V7 }
+ %if mmsize == 16
+     packuswb       m1, m0                 ; (byte) { U0, ... U7, V1, ... V7 }
+     movh   [dstUq+wq], m1
+     movhps [dstVq+wq], m1
+ %else ; mmsize == 8
+     packuswb       m1, m1                 ; (byte) { U0, ... U3 }
+     packuswb       m0, m0                 ; (byte) { V0, ... V3 }
+     movh   [dstUq+wq], m1
+     movh   [dstVq+wq], m0
+ %endif ; mmsize == 8/16
+     add            wq, mmsize / 2
+     jl .loop_%1
+     REP_RET
+ %endmacro
+ ; %1 = nr. of XMM registers
+ ; %2 = yuyv or uyvy
+ ; %3 = if specified, it means that unaligned and aligned code in loop
+ ;      will be the same (i.e. UYVY+AVX), and thus we don't need to
+ ;      split the loop in an aligned and unaligned case
+ %macro YUYV_TO_UV_FN 2-3
 -    movsxd         wq, r4m
++cglobal %2ToUV, 4, 5, %1, dstU, dstV, unused, src, w
+ %ifdef ARCH_X86_64
 -    mov            wq, r4m
++    movsxd         wq, r5m
+ %else ; x86-32
 -    pand           m2, m0, m4             ; (word) { U0, U1, ..., U7 }
 -    pand           m3, m1, m4             ; (word) { U8, U9, ..., U15 }
++    mov            wq, r5m
+ %endif
+     add         dstUq, wq
+     add         dstVq, wq
+ %if mmsize == 16 && %0 == 2
+     test         srcq, 15
+ %endif
+     lea          srcq, [srcq+wq*4]
+     pcmpeqb        m2, m2                 ; (byte) { 0xff } x 16
+     psrlw          m2, 8                  ; (word) { 0x00ff } x 8
+     ; NOTE: if uyvy+avx, u/a are identical
+ %if mmsize == 16 && %0 == 2
+     jnz .loop_u_start
+     neg            wq
+     LOOP_YUYV_TO_UV a, %2
+ .loop_u_start:
+     neg            wq
+     LOOP_YUYV_TO_UV u, %2
+ %else ; mmsize == 8
+     neg            wq
+     LOOP_YUYV_TO_UV a, %2
+ %endif ; mmsize == 8/16
+ %endmacro
+ ; %1 = a (aligned) or u (unaligned)
+ ; %2 = nv12 or nv21
+ %macro LOOP_NVXX_TO_UV 2
+ .loop_%1:
+     mov%1          m0, [srcq+wq*2]        ; (byte) { U0, V0, U1, V1, ... }
+     mov%1          m1, [srcq+wq*2+mmsize] ; (byte) { U8, V8, U9, V9, ... }
 -cglobal %2ToUV, 3, 4, %1, dstU, dstV, src, w
++    pand           m2, m0, m5             ; (word) { U0, U1, ..., U7 }
++    pand           m3, m1, m5             ; (word) { U8, U9, ..., U15 }
+     psrlw          m0, 8                  ; (word) { V0, V1, ..., V7 }
+     psrlw          m1, 8                  ; (word) { V8, V9, ..., V15 }
+     packuswb       m2, m3                 ; (byte) { U0, ..., U15 }
+     packuswb       m0, m1                 ; (byte) { V0, ..., V15 }
+ %ifidn %2, nv12
+     mova   [dstUq+wq], m2
+     mova   [dstVq+wq], m0
+ %else ; nv21
+     mova   [dstVq+wq], m2
+     mova   [dstUq+wq], m0
+ %endif ; nv12/21
+     add            wq, mmsize
+     jl .loop_%1
+     REP_RET
+ %endmacro
+ ; %1 = nr. of XMM registers
+ ; %2 = nv12 or nv21
+ %macro NVXX_TO_UV_FN 2
 -    movsxd         wq, r4m
++cglobal %2ToUV, 4, 5, %1, dstU, dstV, unused, src, w
+ %ifdef ARCH_X86_64
 -    mov            wq, r4m
++    movsxd         wq, r5m
+ %else ; x86-32
 -    pcmpeqb        m4, m4                 ; (byte) { 0xff } x 16
 -    psrlw          m4, 8                  ; (word) { 0x00ff } x 8
++    mov            wq, r5m
+ %endif
+     add         dstUq, wq
+     add         dstVq, wq
+ %if mmsize == 16
+     test         srcq, 15
+ %endif
+     lea          srcq, [srcq+wq*2]
++    pcmpeqb        m5, m5                 ; (byte) { 0xff } x 16
++    psrlw          m5, 8                  ; (word) { 0x00ff } x 8
+ %if mmsize == 16
+     jnz .loop_u_start
+     neg            wq
+     LOOP_NVXX_TO_UV a, %2
+ .loop_u_start:
+     neg            wq
+     LOOP_NVXX_TO_UV u, %2
+ %else ; mmsize == 8
+     neg            wq
+     LOOP_NVXX_TO_UV a, %2
+ %endif ; mmsize == 8/16
+ %endmacro
+ %ifdef ARCH_X86_32
+ INIT_MMX mmx
+ YUYV_TO_Y_FN  0, yuyv
+ YUYV_TO_Y_FN  0, uyvy
+ YUYV_TO_UV_FN 0, yuyv
+ YUYV_TO_UV_FN 0, uyvy
+ NVXX_TO_UV_FN 0, nv12
+ NVXX_TO_UV_FN 0, nv21
+ %endif
+ INIT_XMM sse2
+ YUYV_TO_Y_FN  3, yuyv
+ YUYV_TO_Y_FN  2, uyvy
+ YUYV_TO_UV_FN 3, yuyv
+ YUYV_TO_UV_FN 3, uyvy
+ NVXX_TO_UV_FN 5, nv12
+ NVXX_TO_UV_FN 5, nv21
+ INIT_XMM avx
+ ; in theory, we could write a yuy2-to-y using vpand (i.e. AVX), but
+ ; that's not faster in practice
+ YUYV_TO_UV_FN 3, yuyv
+ YUYV_TO_UV_FN 3, uyvy, 1
+ NVXX_TO_UV_FN 5, nv12
+ NVXX_TO_UV_FN 5, nv21
Simple merge
@@@ -1435,148 -1361,7 +1435,7 @@@ static void RENAME(yuv2yuyv422_1)(SwsCo
      }
  }
  
- #if !COMPILE_TEMPLATE_MMX2
- //FIXME yuy2* can read up to 7 samples too much
- static void RENAME(yuy2ToY)(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
-                             int width, uint32_t *unused)
- {
-     __asm__ volatile(
-         "movq "MANGLE(bm01010101)", %%mm2           \n\t"
-         "mov                    %0, %%"REG_a"       \n\t"
-         "1:                                         \n\t"
-         "movq    (%1, %%"REG_a",2), %%mm0           \n\t"
-         "movq   8(%1, %%"REG_a",2), %%mm1           \n\t"
-         "pand                %%mm2, %%mm0           \n\t"
-         "pand                %%mm2, %%mm1           \n\t"
-         "packuswb            %%mm1, %%mm0           \n\t"
-         "movq                %%mm0, (%2, %%"REG_a") \n\t"
-         "add                    $8, %%"REG_a"       \n\t"
-         " js                    1b                  \n\t"
-         : : "g" ((x86_reg)-width), "r" (src+width*2), "r" (dst+width)
-         : "%"REG_a
-     );
- }
- static void RENAME(yuy2ToUV)(uint8_t *dstU, uint8_t *dstV,
-                              const uint8_t *unused1, const uint8_t *src1, const uint8_t *src2,
-                              int width, uint32_t *unused)
- {
-     __asm__ volatile(
-         "movq "MANGLE(bm01010101)", %%mm4           \n\t"
-         "mov                    %0, %%"REG_a"       \n\t"
-         "1:                                         \n\t"
-         "movq    (%1, %%"REG_a",4), %%mm0           \n\t"
-         "movq   8(%1, %%"REG_a",4), %%mm1           \n\t"
-         "psrlw                  $8, %%mm0           \n\t"
-         "psrlw                  $8, %%mm1           \n\t"
-         "packuswb            %%mm1, %%mm0           \n\t"
-         "movq                %%mm0, %%mm1           \n\t"
-         "psrlw                  $8, %%mm0           \n\t"
-         "pand                %%mm4, %%mm1           \n\t"
-         "packuswb            %%mm0, %%mm0           \n\t"
-         "packuswb            %%mm1, %%mm1           \n\t"
-         "movd                %%mm0, (%3, %%"REG_a") \n\t"
-         "movd                %%mm1, (%2, %%"REG_a") \n\t"
-         "add                    $4, %%"REG_a"       \n\t"
-         " js                    1b                  \n\t"
-         : : "g" ((x86_reg)-width), "r" (src1+width*4), "r" (dstU+width), "r" (dstV+width)
-         : "%"REG_a
-     );
-     assert(src1 == src2);
- }
- /* This is almost identical to the previous, end exists only because
-  * yuy2ToY/UV)(dst, src+1, ...) would have 100% unaligned accesses. */
- static void RENAME(uyvyToY)(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
-                             int width, uint32_t *unused)
- {
-     __asm__ volatile(
-         "mov                  %0, %%"REG_a"         \n\t"
-         "1:                                         \n\t"
-         "movq  (%1, %%"REG_a",2), %%mm0             \n\t"
-         "movq 8(%1, %%"REG_a",2), %%mm1             \n\t"
-         "psrlw                $8, %%mm0             \n\t"
-         "psrlw                $8, %%mm1             \n\t"
-         "packuswb          %%mm1, %%mm0             \n\t"
-         "movq              %%mm0, (%2, %%"REG_a")   \n\t"
-         "add                  $8, %%"REG_a"         \n\t"
-         " js                  1b                    \n\t"
-         : : "g" ((x86_reg)-width), "r" (src+width*2), "r" (dst+width)
-         : "%"REG_a
-     );
- }
- static void RENAME(uyvyToUV)(uint8_t *dstU, uint8_t *dstV,
-                              const uint8_t *unused1, const uint8_t *src1, const uint8_t *src2,
-                              int width, uint32_t *unused)
- {
-     __asm__ volatile(
-         "movq "MANGLE(bm01010101)", %%mm4           \n\t"
-         "mov                    %0, %%"REG_a"       \n\t"
-         "1:                                         \n\t"
-         "movq    (%1, %%"REG_a",4), %%mm0           \n\t"
-         "movq   8(%1, %%"REG_a",4), %%mm1           \n\t"
-         "pand                %%mm4, %%mm0           \n\t"
-         "pand                %%mm4, %%mm1           \n\t"
-         "packuswb            %%mm1, %%mm0           \n\t"
-         "movq                %%mm0, %%mm1           \n\t"
-         "psrlw                  $8, %%mm0           \n\t"
-         "pand                %%mm4, %%mm1           \n\t"
-         "packuswb            %%mm0, %%mm0           \n\t"
-         "packuswb            %%mm1, %%mm1           \n\t"
-         "movd                %%mm0, (%3, %%"REG_a") \n\t"
-         "movd                %%mm1, (%2, %%"REG_a") \n\t"
-         "add                    $4, %%"REG_a"       \n\t"
-         " js                    1b                  \n\t"
-         : : "g" ((x86_reg)-width), "r" (src1+width*4), "r" (dstU+width), "r" (dstV+width)
-         : "%"REG_a
-     );
-     assert(src1 == src2);
- }
- static av_always_inline void RENAME(nvXXtoUV)(uint8_t *dst1, uint8_t *dst2,
-                                               const uint8_t *src, int width)
- {
-     __asm__ volatile(
-         "movq "MANGLE(bm01010101)", %%mm4           \n\t"
-         "mov                    %0, %%"REG_a"       \n\t"
-         "1:                                         \n\t"
-         "movq    (%1, %%"REG_a",2), %%mm0           \n\t"
-         "movq   8(%1, %%"REG_a",2), %%mm1           \n\t"
-         "movq                %%mm0, %%mm2           \n\t"
-         "movq                %%mm1, %%mm3           \n\t"
-         "pand                %%mm4, %%mm0           \n\t"
-         "pand                %%mm4, %%mm1           \n\t"
-         "psrlw                  $8, %%mm2           \n\t"
-         "psrlw                  $8, %%mm3           \n\t"
-         "packuswb            %%mm1, %%mm0           \n\t"
-         "packuswb            %%mm3, %%mm2           \n\t"
-         "movq                %%mm0, (%2, %%"REG_a") \n\t"
-         "movq                %%mm2, (%3, %%"REG_a") \n\t"
-         "add                    $8, %%"REG_a"       \n\t"
-         " js                    1b                  \n\t"
-         : : "g" ((x86_reg)-width), "r" (src+width*2), "r" (dst1+width), "r" (dst2+width)
-         : "%"REG_a
-     );
- }
- static void RENAME(nv12ToUV)(uint8_t *dstU, uint8_t *dstV,
-                              const uint8_t *unused1, const uint8_t *src1, const uint8_t *src2,
-                              int width, uint32_t *unused)
- {
-     RENAME(nvXXtoUV)(dstU, dstV, src1, width);
- }
- static void RENAME(nv21ToUV)(uint8_t *dstU, uint8_t *dstV,
-                              const uint8_t *unused1, const uint8_t *src1, const uint8_t *src2,
-                              int width, uint32_t *unused)
- {
-     RENAME(nvXXtoUV)(dstV, dstU, src1, width);
- }
- #endif /* !COMPILE_TEMPLATE_MMX2 */
 -static av_always_inline void RENAME(bgr24ToY_mmx)(uint8_t *dst, const uint8_t *src,
 +static av_always_inline void RENAME(bgr24ToY_mmx)(int16_t *dst, const uint8_t *src,
                                                    int width, enum PixelFormat srcFormat)
  {
  
@@@ -1,89 -1,95 +1,98 @@@
 -FATE_TESTS += fate-adts-demux
 +FATE_DEMUX += fate-adts-demux
  fate-adts-demux: CMD = crc -i $(SAMPLES)/aac/ct_faac-adts.aac -acodec copy
  
 -FATE_TESTS += fate-aea-demux
 +FATE_DEMUX += fate-aea-demux
  fate-aea-demux: CMD = crc -i $(SAMPLES)/aea/chirp.aea -acodec copy
  
 -FATE_TESTS += fate-bink-demux
 +FATE_DEMUX += fate-bink-demux
  fate-bink-demux: CMD = crc -i $(SAMPLES)/bink/Snd0a7d9b58.dee -vn -acodec copy
  
 -FATE_TESTS += fate-bink-demux-video
 +FATE_DEMUX += fate-bink-demux-video
  fate-bink-demux-video: CMD = framecrc -i $(SAMPLES)/bink/hol2br.bik
  
 -FATE_TESTS += fate-bmv
 +FATE_DEMUX += fate-bmv
  fate-bmv: CMD = framecrc -i $(SAMPLES)/bmv/SURFING-partial.BMV -pix_fmt rgb24
  
 -FATE_TESTS += fate-caf
 +FATE_DEMUX += fate-caf
  fate-caf: CMD = crc -i $(SAMPLES)/caf/caf-pcm16.caf
  
 -FATE_TESTS += fate-cryo-apc
 +FATE_DEMUX += fate-cryo-apc
  fate-cryo-apc: CMD = md5 -i $(SAMPLES)/cryo-apc/cine007.APC -f s16le
  
 -FATE_TESTS += fate-d-cinema-demux
 +FATE_DEMUX += fate-d-cinema-demux
  fate-d-cinema-demux: CMD = framecrc -i $(SAMPLES)/d-cinema/THX_Science_FLT_1920-partial.302 -acodec copy -pix_fmt rgb24
  
 -FATE_TESTS += fate-funcom-iss
 +FATE_DEMUX += fate-funcom-iss
  fate-funcom-iss: CMD = md5 -i $(SAMPLES)/funcom-iss/0004010100.iss -f s16le
  
 -FATE_TESTS += fate-interplay-mve-16bit
 +FATE_DEMUX += fate-interplay-mve-16bit
  fate-interplay-mve-16bit: CMD = framecrc -i $(SAMPLES)/interplay-mve/descent3-level5-16bit-partial.mve -pix_fmt rgb24
  
 -FATE_TESTS += fate-interplay-mve-8bit
 +FATE_DEMUX += fate-interplay-mve-8bit
  fate-interplay-mve-8bit: CMD = framecrc -i $(SAMPLES)/interplay-mve/interplay-logo-2MB.mve -pix_fmt rgb24
  
 -FATE_TESTS += fate-iv8-demux
 +FATE_DEMUX += fate-iv8-demux
  fate-iv8-demux: CMD = framecrc -i $(SAMPLES)/iv8/zzz-partial.mpg -vsync 0 -vcodec copy
  
 -FATE_TESTS += fate-lmlm4-demux
 +FATE_DEMUX += fate-lmlm4-demux
  fate-lmlm4-demux: CMD = framecrc -i $(SAMPLES)/lmlm4/LMLM4_CIFat30fps.divx -t 3 -acodec copy -vcodec copy
  
 -FATE_TESTS += fate-maxis-xa
 +FATE_DEMUX += fate-maxis-xa
  fate-maxis-xa: CMD = md5 -i $(SAMPLES)/maxis-xa/SC2KBUG.XA -f s16le
  
 -FATE_TESTS += fate-mtv
 +FATE_DEMUX += fate-mtv
  fate-mtv: CMD = framecrc -i $(SAMPLES)/mtv/comedian_auto-partial.mtv -acodec copy -pix_fmt rgb24
  
 -FATE_TESTS += fate-mxf-demux
 +FATE_DEMUX += fate-mxf-demux
  fate-mxf-demux: CMD = framecrc -i $(SAMPLES)/mxf/C0023S01.mxf -acodec copy -vcodec copy
  
 -FATE_TESTS += fate-nc-demux
 +FATE_DEMUX += fate-nc-demux
  fate-nc-demux: CMD = framecrc -i $(SAMPLES)/nc-camera/nc-sample-partial -vcodec copy
  
 -FATE_TESTS += fate-nsv-demux
 +FATE_DEMUX += fate-nsv-demux
  fate-nsv-demux: CMD = framecrc -i $(SAMPLES)/nsv/witchblade-51kbps.nsv -t 6 -vcodec copy -acodec copy
  
 -FATE_TESTS += fate-oma-demux
 +FATE_DEMUX += fate-oma-demux
  fate-oma-demux: CMD = crc -i $(SAMPLES)/oma/01-Untitled-partial.oma -acodec copy
  
 -FATE_TESTS += fate-psx-str
 +FATE_DEMUX += fate-psx-str
  fate-psx-str: CMD = framecrc -i $(SAMPLES)/psx-str/descent-partial.str
  
 -FATE_TESTS += fate-psx-str-v3-mdec
 +FATE_DEMUX += fate-psx-str-v3-mdec
  fate-psx-str-v3-mdec: CMD = framecrc -i $(SAMPLES)/psx-str/abc000_cut.str -an
  
 -FATE_TESTS += fate-pva-demux
 +FATE_DEMUX += fate-pva-demux
  fate-pva-demux: CMD = framecrc -idct simple -i $(SAMPLES)/pva/PVA_test-partial.pva -t 0.6 -acodec copy
  
 -FATE_TESTS += fate-qcp-demux
 +FATE_DEMUX += fate-qcp-demux
  fate-qcp-demux: CMD = crc -i $(SAMPLES)/qcp/0036580847.QCP -acodec copy
  
 -FATE_TESTS += fate-redcode-demux
 +FATE_DEMUX += fate-redcode-demux
  fate-redcode-demux: CMD = framecrc -i $(SAMPLES)/r3d/4MB-sample.r3d -vcodec copy -acodec copy
  
 -FATE_TESTS += fate-sierra-audio
 +FATE_DEMUX += fate-sierra-audio
  fate-sierra-audio: CMD = md5 -i $(SAMPLES)/sol/lsl7sample.sol -f s16le
  
 -FATE_TESTS += fate-sierra-vmd
 +FATE_DEMUX += fate-sierra-vmd
  fate-sierra-vmd: CMD = framecrc -i $(SAMPLES)/vmd/12.vmd -vsync 0 -pix_fmt rgb24
  
 -FATE_TESTS += fate-siff
 +FATE_DEMUX += fate-siff
  fate-siff: CMD = framecrc -i $(SAMPLES)/SIFF/INTRO_B.VB -t 3 -pix_fmt rgb24
  
 -FATE_TESTS += fate-smjpeg
++FATE_DEMUX += fate-smjpeg
+ fate-smjpeg: CMD = framecrc -i $(SAMPLES)/smjpeg/scenwin.mjpg -vcodec copy
 -FATE_TESTS += fate-westwood-aud
 +FATE_DEMUX += fate-westwood-aud
  fate-westwood-aud: CMD = md5 -i $(SAMPLES)/westwood-aud/excellent.aud -f s16le
  
 -FATE_TESTS += fate-wtv-demux
++FATE_DEMUX += fate-wtv-demux
+ fate-wtv-demux: CMD = framecrc -i $(SAMPLES)/wtv/law-and-order-partial.wtv -vcodec copy -acodec copy
 -FATE_TESTS += fate-xmv-demux
 +FATE_DEMUX += fate-xmv-demux
  fate-xmv-demux: CMD = framecrc -i $(SAMPLES)/xmv/logos1p.fmv -vcodec copy -acodec copy
  
 -FATE_TESTS += fate-xwma-demux
++FATE_DEMUX += fate-xwma-demux
+ fate-xwma-demux: CMD = crc -i $(SAMPLES)/xwma/ergon.xwma -acodec copy
++
 +FATE_TESTS += $(FATE_DEMUX)
 +fate-demux: $(FATE_DEMUX)
@@@ -11,23 -11,20 +11,26 @@@ FATE_MICROSOFT += fate-wmv8-dr
  # discard last packet to avoid fails due to overread of VC-1 decoder
  fate-wmv8-drm: CMD = framecrc -cryptokey 137381538c84c068111902a59c5cf6c340247c39 -i $(SAMPLES)/wmv8/wmv_drm.wmv -an -vframes 162
  
 -FATE_TESTS += fate-wmv8-drm-nodec
 +FATE_MICROSOFT += fate-wmv8-drm-nodec
  fate-wmv8-drm-nodec: CMD = framecrc -cryptokey 137381538c84c068111902a59c5cf6c340247c39 -i $(SAMPLES)/wmv8/wmv_drm.wmv -acodec copy -vcodec copy
  
 -FATE_TESTS += fate-vc1
 +FATE_MICROSOFT += fate-wmv8-x8intra
 +fate-wmv8-x8intra: CMD = framecrc -flags +bitexact -idct 19 -i $(SAMPLES)/wmv8/wmv8_x8intra.wmv -an
 +
 +FATE_MICROSOFT += fate-vc1
  fate-vc1: CMD = framecrc -i $(SAMPLES)/vc1/SA00040.vc1
  
 -FATE_TESTS += fate-vc1_sa00050
 +FATE_MICROSOFT += fate-vc1_sa00050
  fate-vc1_sa00050: CMD = framecrc -i $(SAMPLES)/vc1/SA00050.vc1
  
 -FATE_TESTS += fate-vc1_sa10091
 +FATE_MICROSOFT += fate-vc1_sa10091
  fate-vc1_sa10091: CMD = framecrc -i $(SAMPLES)/vc1/SA10091.vc1
  
 -FATE_TESTS += fate-vc1_sa20021
 +FATE_MICROSOFT += fate-vc1_sa20021
  fate-vc1_sa20021: CMD = framecrc -i $(SAMPLES)/vc1/SA20021.vc1
  
 -FATE_TESTS += fate-vc1-ism
++FATE_MICROSOFT += fate-vc1-ism
+ fate-vc1-ism: CMD = framecrc -i $(SAMPLES)/isom/vc1-wmapro.ism -an
++
 +FATE_TESTS += $(FATE_MICROSOFT)
 +fate-microsoft: $(FATE_MICROSOFT)
 -FATE_TESTS += fate-4xm-1
 +FATE_VIDEO += fate-4xm-1
  fate-4xm-1: CMD = framecrc -i $(SAMPLES)/4xm/version1.4xm -pix_fmt rgb24 -an
  
 -FATE_TESTS += fate-4xm-2
 +FATE_VIDEO += fate-4xm-2
  fate-4xm-2: CMD = framecrc -i $(SAMPLES)/4xm/version2.4xm -pix_fmt rgb24 -an
  
 -FATE_TESTS += fate-aasc
 +FATE_VIDEO += fate-aasc
  fate-aasc: CMD = framecrc -i $(SAMPLES)/aasc/AASC-1.5MB.AVI -pix_fmt rgb24
  
 -FATE_TESTS += fate-alg-mm
 +FATE_VIDEO += fate-alg-mm
  fate-alg-mm: CMD = framecrc -i $(SAMPLES)/alg-mm/ibmlogo.mm -an -pix_fmt rgb24
  
 -FATE_TESTS += fate-amv
 +FATE_VIDEO += fate-amv
  fate-amv: CMD = framecrc -idct simple -i $(SAMPLES)/amv/MTV_high_res_320x240_sample_Penguin_Joke_MTV_from_WMV.amv -t 10
  
 -FATE_TESTS += fate-ansi
 +FATE_VIDEO += fate-ansi
  fate-ansi: CMD = framecrc -chars_per_frame 44100 -i $(SAMPLES)/ansi/TRE-IOM5.ANS -pix_fmt rgb24
  
 -FATE_TESTS += fate-armovie-escape124
 +FATE_VIDEO += fate-armovie-escape124
  fate-armovie-escape124: CMD = framecrc -i $(SAMPLES)/rpl/ESCAPE.RPL -pix_fmt rgb24
  
 -FATE_TESTS += fate-auravision
 +FATE_VIDEO += fate-auravision
  fate-auravision: CMD = framecrc -i $(SAMPLES)/auravision/SOUVIDEO.AVI -an
  
 -FATE_TESTS += fate-auravision-v2
 +FATE_VIDEO += fate-auravision-v2
  fate-auravision-v2: CMD = framecrc -i $(SAMPLES)/auravision/salma-hayek-in-ugly-betty-partial-avi -an
  
 -FATE_TESTS += fate-bethsoft-vid
 +FATE_VIDEO += fate-bethsoft-vid
  fate-bethsoft-vid: CMD = framecrc -i $(SAMPLES)/bethsoft-vid/ANIM0001.VID -vsync 0 -t 5 -pix_fmt rgb24
  
 -FATE_TESTS += fate-bfi
 +FATE_VIDEO += fate-bfi
  fate-bfi: CMD = framecrc -i $(SAMPLES)/bfi/2287.bfi -pix_fmt rgb24
  
 -FATE_TESTS += fate-cdgraphics
 +FATE_VIDEO += fate-cdgraphics
  fate-cdgraphics: CMD = framecrc -i $(SAMPLES)/cdgraphics/BrotherJohn.cdg -pix_fmt rgb24 -t 1
  
 -FATE_TESTS += fate-cljr
 +FATE_VIDEO += fate-cljr
  fate-cljr: CMD = framecrc -i $(SAMPLES)/cljr/testcljr-partial.avi
  
 -FATE_TESTS += fate-corepng
 +FATE_VIDEO += fate-corepng
  fate-corepng: CMD = framecrc -i $(SAMPLES)/png1/corepng-partial.avi
  
 -FATE_TESTS += fate-creatureshock-avs
 +FATE_VIDEO += fate-creatureshock-avs
  fate-creatureshock-avs: CMD = framecrc -i $(SAMPLES)/creatureshock-avs/OUTATIME.AVS -pix_fmt rgb24
  
 -FATE_TESTS += fate-cvid
 +FATE_VIDEO += fate-cvid
  fate-cvid: CMD = framecrc -i $(SAMPLES)/cvid/laracroft-cinepak-partial.avi -an
  
 -FATE_TESTS += fate-cvid-palette
 +FATE_VIDEO += fate-cvid-palette
  fate-cvid-palette: CMD = framecrc -i $(SAMPLES)/cvid/catfight-cvid-pal8-partial.mov -pix_fmt rgb24 -an
  
 -FATE_TESTS += fate-cvid-grayscale
++FATE_VIDEO += fate-cvid-grayscale
+ fate-cvid-grayscale: CMD = framecrc -i $(SAMPLES)/cvid/pcitva15.avi -an
 -FATE_TESTS += fate-cyberia-c93
 +FATE_VIDEO += fate-cyberia-c93
  fate-cyberia-c93: CMD = framecrc -i $(SAMPLES)/cyberia-c93/intro1.c93 -t 3 -pix_fmt rgb24
  
 -FATE_TESTS += fate-cyuv
 +FATE_VIDEO += fate-cyuv
  fate-cyuv: CMD = framecrc -i $(SAMPLES)/cyuv/cyuv.avi
  
 -FATE_TESTS += fate-delphine-cin
 +FATE_VIDEO += fate-delphine-cin
  fate-delphine-cin: CMD = framecrc -i $(SAMPLES)/delphine-cin/LOGO-partial.CIN -pix_fmt rgb24 -vsync 0
  
 -FATE_TESTS += fate-deluxepaint-anm
 +FATE_VIDEO += fate-deluxepaint-anm
  fate-deluxepaint-anm: CMD = framecrc -i $(SAMPLES)/deluxepaint-anm/INTRO1.ANM -pix_fmt rgb24
  
 -FATE_TESTS += fate-duck-tm2
 +FATE_VIDEO += fate-duck-tm2
  fate-duck-tm2: CMD = framecrc -i $(SAMPLES)/duck/tm20.avi
  
 -FATE_TESTS += fate-dxa-scummvm
 +FATE_VIDEO += fate-dxa-scummvm
  fate-dxa-scummvm: CMD = framecrc -i $(SAMPLES)/dxa/scummvm.dxa -pix_fmt rgb24
  
 -FATE_TESTS += fate-feeble-dxa
 +FATE_VIDEO += fate-feeble-dxa
  fate-feeble-dxa: CMD = framecrc -i $(SAMPLES)/dxa/meetsquid.dxa -t 2 -pix_fmt rgb24
  
 -FATE_TESTS += fate-flic-af11-palette-change
 +FATE_VIDEO += fate-flic-af11-palette-change
  fate-flic-af11-palette-change: CMD = framecrc -i $(SAMPLES)/fli/fli-engines.fli -t 3.3 -pix_fmt rgb24
  
 -FATE_TESTS += fate-flic-af12
 +FATE_VIDEO += fate-flic-af12
  fate-flic-af12: CMD = framecrc -i $(SAMPLES)/fli/jj00c2.fli -pix_fmt rgb24
  
 -FATE_TESTS += fate-flic-magiccarpet
 +FATE_VIDEO += fate-flic-magiccarpet
  fate-flic-magiccarpet: CMD = framecrc -i $(SAMPLES)/fli/intel.dat -pix_fmt rgb24
  
 -FATE_TESTS += fate-frwu
 +FATE_VIDEO += fate-frwu
  fate-frwu: CMD = framecrc -i $(SAMPLES)/frwu/frwu.avi
  
 -FATE_TESTS += fate-id-cin-video
 +FATE_VIDEO += fate-id-cin-video
  fate-id-cin-video: CMD = framecrc -i $(SAMPLES)/idcin/idlog-2MB.cin -pix_fmt rgb24
  
 -FATE_TESTS-$(CONFIG_AVFILTER) += fate-idroq-video-encode
 +FATE_VIDEO-$(CONFIG_AVFILTER) += fate-idroq-video-encode
  fate-idroq-video-encode: CMD = md5 -f image2 -vcodec pgmyuv -i $(SAMPLES)/ffmpeg-synthetic/vsynth1/%02d.pgm -sws_flags +bitexact -vf pad=512:512:80:112 -f RoQ -t 0.2
  
 -FATE_TESTS += fate-iff-byterun1
 +FATE_VIDEO += fate-iff-byterun1
  fate-iff-byterun1: CMD = framecrc -i $(SAMPLES)/iff/ASH.LBM -pix_fmt rgb24
  
 -FATE_TESTS += fate-iff-fibonacci
 +FATE_VIDEO += fate-iff-fibonacci
  fate-iff-fibonacci: CMD = md5 -i $(SAMPLES)/iff/dasboot-in-compressed -f s16le
  
 -FATE_TESTS += fate-iff-ilbm
 +FATE_VIDEO += fate-iff-ilbm
  fate-iff-ilbm: CMD = framecrc -i $(SAMPLES)/iff/lms-matriks.ilbm -pix_fmt rgb24
  
 -FATE_TESTS += fate-kmvc
 +FATE_VIDEO += fate-kmvc
  fate-kmvc: CMD = framecrc -i $(SAMPLES)/KMVC/LOGO1.AVI -an -t 3 -pix_fmt rgb24
  
 -FATE_TESTS += fate-mimic
 +FATE_VIDEO += fate-mimic
  fate-mimic: CMD = framecrc -idct simple -i $(SAMPLES)/mimic/mimic2-womanloveffmpeg.cam -vsync 0
  
 -FATE_TESTS += fate-mjpegb
 +FATE_VIDEO += fate-mjpegb
  fate-mjpegb: CMD = framecrc -idct simple -flags +bitexact -i $(SAMPLES)/mjpegb/mjpegb_part.mov -an
  
 -FATE_TESTS += fate-motionpixels
 +FATE_VIDEO += fate-motionpixels
  fate-motionpixels: CMD = framecrc -i $(SAMPLES)/motion-pixels/INTRO-partial.MVI -an -pix_fmt rgb24 -vframes 111
  
 -FATE_TESTS += fate-mpeg2-field-enc
 +FATE_VIDEO += fate-mpeg2-field-enc
  fate-mpeg2-field-enc: CMD = framecrc -flags +bitexact -dct fastint -idct simple -i $(SAMPLES)/mpeg2/mpeg2_field_encoding.ts -an
  
 -FATE_TESTS += fate-nuv
 +FATE_VIDEO += fate-nuv
  fate-nuv: CMD = framecrc -idct simple -i $(SAMPLES)/nuv/Today.nuv -vsync 0
  
 -FATE_TESTS += fate-qpeg
 +FATE_VIDEO += fate-qpeg
  fate-qpeg: CMD = framecrc -i $(SAMPLES)/qpeg/Clock.avi -an -pix_fmt rgb24
  
 -FATE_TESTS += fate-r210
 +FATE_VIDEO += fate-r210
  fate-r210: CMD = framecrc -i $(SAMPLES)/r210/r210.avi -pix_fmt rgb48le
  
 -FATE_TESTS += fate-rl2
 +FATE_VIDEO += fate-rl2
  fate-rl2: CMD = framecrc -i $(SAMPLES)/rl2/Z4915300.RL2 -pix_fmt rgb24 -an -vsync 0
  
 -FATE_TESTS += fate-smacker
 +FATE_VIDEO += fate-smacker
  fate-smacker: CMD = framecrc -i $(SAMPLES)/smacker/wetlogo.smk -pix_fmt rgb24
  
 -FATE_TESTS += fate-smc
 +FATE_VIDEO += fate-smc
  fate-smc: CMD = framecrc -i $(SAMPLES)/smc/cass_schi.qt -vsync 0 -pix_fmt rgb24
  
 -FATE_TESTS += fate-sp5x
 +FATE_VIDEO += fate-sp5x
  fate-sp5x: CMD = framecrc -idct simple -i $(SAMPLES)/sp5x/sp5x_problem.avi
  
 -FATE_TESTS += fate-sub-srt
 +FATE_VIDEO += fate-sub-srt
  fate-sub-srt: CMD = md5 -i $(SAMPLES)/sub/SubRip_capability_tester.srt -f ass
  
 -FATE_TESTS += fate-tiertex-seq
 +FATE_VIDEO += fate-tiertex-seq
  fate-tiertex-seq: CMD = framecrc -i $(SAMPLES)/tiertex-seq/Gameover.seq -pix_fmt rgb24
  
 -FATE_TESTS += fate-tmv
 +FATE_VIDEO += fate-tmv
  fate-tmv: CMD = framecrc -i $(SAMPLES)/tmv/pop-partial.tmv -pix_fmt rgb24
  
 -FATE_TESTS += fate-truemotion1-15
 +FATE_VIDEO += fate-truemotion1-15
  fate-truemotion1-15: CMD = framecrc -i $(SAMPLES)/duck/phant2-940.duk -pix_fmt rgb24
  
 -FATE_TESTS += fate-truemotion1-24
 +FATE_VIDEO += fate-truemotion1-24
  fate-truemotion1-24: CMD = framecrc -i $(SAMPLES)/duck/sonic3dblast_intro-partial.avi -pix_fmt rgb24
  
 -FATE_TESTS += fate-txd-16bpp
 +FATE_VIDEO += fate-txd-16bpp
  fate-txd-16bpp: CMD = framecrc -i $(SAMPLES)/txd/misc.txd -pix_fmt bgra -an
  
 -FATE_TESTS += fate-txd-pal8
 +FATE_VIDEO += fate-txd-pal8
  fate-txd-pal8: CMD = framecrc -i $(SAMPLES)/txd/outro.txd -pix_fmt rgb24 -an
  
 -FATE_TESTS += fate-ulti
 +FATE_VIDEO += fate-ulti
  fate-ulti: CMD = framecrc -i $(SAMPLES)/ulti/hit12w.avi -an
  
 -FATE_TESTS += fate-v210
 +FATE_VIDEO += fate-v210
  fate-v210: CMD = framecrc -i $(SAMPLES)/v210/v210_720p-partial.avi -pix_fmt yuv422p16be -an
  
 -FATE_TESTS += fate-v410dec
 +FATE_VIDEO += fate-v410dec
  fate-v410dec: CMD = framecrc -i $(SAMPLES)/v410/lenav410.mov -pix_fmt yuv444p10le
  
 -FATE_TESTS += fate-v410enc
 +FATE_VIDEO += fate-v410enc
  fate-v410enc: tests/vsynth1/00.pgm
  fate-v410enc: CMD = md5 -f image2 -vcodec pgmyuv -i $(TARGET_PATH)/tests/vsynth1/%02d.pgm -flags +bitexact -vcodec v410 -f avi
  
@@@ -8,7 -8,12 +8,12 @@@ fate-wmapro-5.1: CMD = pcm -i $(SAMPLES
  fate-wmapro-5.1: CMP = oneoff
  fate-wmapro-5.1: REF = $(SAMPLES)/wmapro/latin_192_mulitchannel_cut.pcm
  
 -FATE_TESTS += fate-wmapro-ism
++FATE_WMA += fate-wmapro-ism
+ fate-wmapro-ism: CMD = pcm -i $(SAMPLES)/isom/vc1-wmapro.ism -vn
+ fate-wmapro-ism: CMP = oneoff
+ fate-wmapro-ism: REF = $(SAMPLES)/isom/vc1-wmapro.pcm
 -FATE_TESTS += fate-wmavoice-7k
 +FATE_WMA += fate-wmavoice-7k
  fate-wmavoice-7k: CMD = pcm -i $(SAMPLES)/wmavoice/streaming_CBR-7K.wma
  fate-wmavoice-7k: CMP = stddev
  fate-wmavoice-7k: REF = $(SAMPLES)/wmavoice/streaming_CBR-7K.pcm
@@@ -1,9 -1,8 +1,11 @@@
 +0bgr                8fb023c3c8f8e64254e807543b29ad61
 +0rgb                0570cd4801a1c613a9815e98872246d4
  abgr                037bf9df6a765520ad6d490066bf4b89
  argb                c442a8261c2265a07212ef0f72e35f5a
 +bgr0                0ef8ffe42bfe53be74973a0c118b775e
  bgr24               0d0cb38ab3fa0b2ec0865c14f78b217b
+ bgr444be            d9ea9307d21b162225b8b2c524cf9477
+ bgr444le            88035350e9da3a8f67387890b956f0bc
  bgr48be             00624e6c7ec7ab19897ba2f0a3257fe8
  bgr48le             d02c235ebba7167881ca2d576497ff84
  bgr4_byte           50d23cc82d9dcef2fd12adb81fb9b806
@@@ -20,8 -19,9 +22,10 @@@ monob               668ebe8b8103b9046b2
  monow               9251497f3b0634f1165d12d5a289d943
  nv12                e0af357888584d36eec5aa0f673793ef
  nv21                9a3297f3b34baa038b1f37cb202b512f
 +rgb0                7c03f81f5e5346bf8ea42c4187f20605
  rgb24               b41eba9651e1b5fe386289b506188105
+ rgb444be            9e89db334568c6b2e3d5d0540f4ba960
+ rgb444le            0a68cb6de8bf530aa30c5c1205c25155
  rgb48be             cc139ec1dd9451f0e049c0cb3a0c8aa2
  rgb48le             86c5608904f75360d492dbc5c9589969
  rgb4_byte           c93ba89b74c504e7f5ae9d9ab1546c73
@@@ -1,9 -1,8 +1,11 @@@
 +0bgr                73847fb78ab01d040bc65307aa2e772d
 +0rgb                68262dbda747e9552cf04a06632a7cee
  abgr                037bf9df6a765520ad6d490066bf4b89
  argb                c442a8261c2265a07212ef0f72e35f5a
 +bgr0                328a76e72c55508cdf04dc93a5b056fc
  bgr24               0d0cb38ab3fa0b2ec0865c14f78b217b
+ bgr444be            d9ea9307d21b162225b8b2c524cf9477
+ bgr444le            88035350e9da3a8f67387890b956f0bc
  bgr48be             00624e6c7ec7ab19897ba2f0a3257fe8
  bgr48le             d02c235ebba7167881ca2d576497ff84
  bgr4_byte           50d23cc82d9dcef2fd12adb81fb9b806
@@@ -20,9 -19,9 +22,11 @@@ monob               668ebe8b8103b9046b2
  monow               9251497f3b0634f1165d12d5a289d943
  nv12                e0af357888584d36eec5aa0f673793ef
  nv21                9a3297f3b34baa038b1f37cb202b512f
 +pal8                dec8ed2258ec89b8a796f21cad4df867
 +rgb0                ff1a9f355d43f9d25f07a191b5aa906c
  rgb24               b41eba9651e1b5fe386289b506188105
+ rgb444be            9e89db334568c6b2e3d5d0540f4ba960
+ rgb444le            0a68cb6de8bf530aa30c5c1205c25155
  rgb48be             cc139ec1dd9451f0e049c0cb3a0c8aa2
  rgb48le             86c5608904f75360d492dbc5c9589969
  rgb4_byte           c93ba89b74c504e7f5ae9d9ab1546c73
@@@ -1,9 -1,8 +1,11 @@@
 +0bgr                73847fb78ab01d040bc65307aa2e772d
 +0rgb                68262dbda747e9552cf04a06632a7cee
  abgr                037bf9df6a765520ad6d490066bf4b89
  argb                c442a8261c2265a07212ef0f72e35f5a
 +bgr0                328a76e72c55508cdf04dc93a5b056fc
  bgr24               0d0cb38ab3fa0b2ec0865c14f78b217b
+ bgr444be            d9ea9307d21b162225b8b2c524cf9477
+ bgr444le            88035350e9da3a8f67387890b956f0bc
  bgr48be             00624e6c7ec7ab19897ba2f0a3257fe8
  bgr48le             d02c235ebba7167881ca2d576497ff84
  bgr4_byte           50d23cc82d9dcef2fd12adb81fb9b806
@@@ -20,9 -19,9 +22,11 @@@ monob               668ebe8b8103b9046b2
  monow               9251497f3b0634f1165d12d5a289d943
  nv12                e0af357888584d36eec5aa0f673793ef
  nv21                9a3297f3b34baa038b1f37cb202b512f
 +pal8                dec8ed2258ec89b8a796f21cad4df867
 +rgb0                ff1a9f355d43f9d25f07a191b5aa906c
  rgb24               b41eba9651e1b5fe386289b506188105
+ rgb444be            9e89db334568c6b2e3d5d0540f4ba960
+ rgb444le            0a68cb6de8bf530aa30c5c1205c25155
  rgb48be             cc139ec1dd9451f0e049c0cb3a0c8aa2
  rgb48le             86c5608904f75360d492dbc5c9589969
  rgb4_byte           c93ba89b74c504e7f5ae9d9ab1546c73
@@@ -1,28 -1,27 +1,32 @@@
 -abgr                d894cb97f6c80eb21bdbe8a4eea62d86
 -argb                54346f2b2eef10919e0f247241df3b24
 -bgr24               570f8d6b51a838aed022ef67535f6bdc
 -bgr444be            25fe04f73a3bad4140d1c4f96ca5b670
 -bgr444le            2fde227e6cea6dca5decdd0b7c0866f7
 +0bgr                1c9ce2c650cc9afc669e3a9a15842c9d
 +0rgb                87749d52eb3056848cccea5875622a86
 +abgr                cff82561a074874027ac1cc896fd2730
 +argb                756dd1eaa5baca2238ce23dbdc452684
 +bgr0                ff6e1dfa26d4c2ada3a59e8b0b600d1f
 +bgr24               e44192347a45586c6c157e3059610cd1
++bgr444be            c23768338d76693f0da76e8a9b6fd8df
++bgr444le            846c431a47bfb745437941bde768469c
  bgr48be             390d3058a12a99c2b153ed7922508bea
  bgr48le             39fe06feb4ec1d9730dccc04a0cfac4c
  bgr4_byte           ee1d35a7baf8e9016891929a2f565c0b
 -bgr555be            de8901c1358834fddea060fcb3a67beb
 -bgr555le            36b745067197f9ca8c1731cac51329c9
 -bgr565be            922a2503767036ae9536f4f7823c04ee
 -bgr565le            3a514a298c6161a071ddf9963c06509d
 +bgr555be            6a2d335856db12e3ea72173d71610e21
 +bgr555le            41e3e0961478dc634bf68a7bbd670cc9
 +bgr565be            21077a3744c889b97032414b11232933
 +bgr565le            614897eaeb422bd9a972f8ee51909be5
  bgr8                7f007fa6c153a16e808a9c51605a4016
 -bgra                a5e7040f9a80cccd65e5acf2ca09ace5
 +bgra                01cfdda1f72fcabb6c46424e27f8c519
  gray                d7786a7d9d99ac74230cc045cab5632c
 -gray16be            b554d6c1cc8da23967445be4dd3e4a86
 -gray16le            715a33aa1c19cb26b14f5cc000e7a3d1
 -monob               88c4c050758e64d120f50c7eff694381
 -monow               d31772ebaa877fc2a78565937f7f9673
 +gray16be            a8fc0d7fea36407b5c319e3e736c7127
 +gray16le            495c89186178308ef171d385bbd8bd70
 +monob               cb62f31b701c6e987b574974d1b31e32
 +monow               fd5d417ab7728acddffc06870661df61
  nv12                4676d59db43d657dc12841f6bc3ab452
  nv21                69c699510ff1fb777b118ebee1002f14
 -rgb24               514692e28e8ff6860e415ce4fcf6eb8c
 -rgb444be            12254053ae93373869fca18b2afcba31
 -rgb444le            badbd68b59c87df6ae73248309637634
 +pal8                6324fa058e1bc157ed7132bfe4022317
 +rgb0                1bd6f54ad067503ac9783a70062c8f87
 +rgb24               13ff53ebeab74dc05492836f1cfbd2c1
++rgb444be            46e466b2709f62b2fffc63708063eaaf
++rgb444le            f0c57a48be671428e2e53c9b54a6c4e2
  rgb48be             8fac63787a711886030f8e056872b488
  rgb48le             ab92f2763a2eb264c3870cc758f97149
  rgb4_byte           d81ffd3add95842a618eec81024f0b5c
@@@ -1,9 -1,8 +1,11 @@@
 +0bgr                39270c968598bac0ef53faaa5f9ab7cd
 +0rgb                099dc071d7385b2958e36604c2fbf4ef
  abgr                25e72e9dbd01ab00727c976d577f7be5
  argb                19869bf1a5ac0b6af4d8bbe2c104533c
 +bgr0                e03d3ee0b977f6d86e5116b20494bef5
  bgr24               89108a4ba00201f79b75b9305c42352d
+ bgr444be            9ef12c42fb791948ca4423c452dc6b9a
+ bgr444le            3650ecfc163abd1596c0cd29d130c4b0
  bgr48be             2f23931844f57641f3737348182d118c
  bgr48le             4242a026012b6c135a6aa138a6d67031
  bgr4_byte           407fcf564ed764c38e1d748f700ab921
@@@ -20,9 -19,9 +22,11 @@@ monob               d0cf8732677a5360b61
  monow               ff9869d067ecb94eb9d90c9750c31fea
  nv12                046f00f598ce14d9854a3534a5c99114
  nv21                01ea369dd2d0d3ed7451dc5c8d61497f
 +pal8                47ed19a7e128b0e33c25d2a463b0611a
 +rgb0                330bd6168e46c0d5eb4acbdbb50afa2e
  rgb24               eaefabc168d0b14576bab45bc1e56e1e
+ rgb444be            06722e03f8404e7d2226665ed2444a32
+ rgb444le            185c9a5d9c2877484310d4196ef4cd6f
  rgb48be             62dd185862ed142283bd300eb6dbd216
  rgb48le             dcb76353268bc5862194d131762220da
  rgb4_byte           8c6ff02df0b06dd2d574836c3741b2a2