Merge remote-tracking branch 'qatar/master'

* qatar/master:
  FATE: add tests for targa
  ARM: fix Thumb-mode simple_idct_arm
  ARM: 4-byte align start of all asm functions
  rgb2rgb: rgb12to15()
  swscale-test: fix stack overread.
  swscale: fix invalid conversions and memory problems.
  cabac: split cabac.h into declarations and function definitions
  cabac: Mark ff_h264_mps_state array as static, it is only used within cabac.c.
  cabac: Remove ff_h264_lps_state array.

Conflicts:
	libswscale/rgb2rgb.h
	libswscale/swscale_unscaled.c
	tests/fate/image.mak

Merged-by: Michael Niedermayer <michaelni@gmx.at>

libavcodec/arm/asm.S

@@ -68,6 +68,7 @@ ELF     .size   \name, . - \name
         .purgem endfunc
     .endm
         .text
+        .align          2
     .if \export
         .global EXTERN_ASM\name
 EXTERN_ASM\name:

libavcodec/arm/simple_idct_arm.S

@@ -491,8 +491,8 @@ __end_bef_a_evaluation:
         bal __end_a_evaluation
 
 
-__constant_ptr__:  @@ see #defines at the beginning of the source code for values.
         .align
+__constant_ptr__:  @@ see #defines at the beginning of the source code for values.
         .word   W1
         .word   W2
         .word   W3

libavcodec/cabac.c

@@ -29,6 +29,7 @@
 #include "libavutil/common.h"
 #include "get_bits.h"
 #include "cabac.h"
+#include "cabac_functions.h"
 
 static const uint8_t lps_range[64][4]= {
 {128,176,208,240}, {128,167,197,227}, {128,158,187,216}, {123,150,178,205},
@@ -51,8 +52,7 @@ static const uint8_t lps_range[64][4]= {
 
 uint8_t ff_h264_mlps_state[4*64];
 uint8_t ff_h264_lps_range[4*2*64];
-uint8_t ff_h264_lps_state[2*64];
-uint8_t ff_h264_mps_state[2*64];
+static uint8_t h264_mps_state[2 * 64];
 
 static const uint8_t mps_state[64]= {
   1, 2, 3, 4, 5, 6, 7, 8,
@@ -141,9 +141,9 @@ void ff_init_cabac_states(CABACContext *c){
         }
 
         ff_h264_mlps_state[128+2*i+0]=
-        ff_h264_mps_state[2*i+0]= 2*mps_state[i]+0;
+        h264_mps_state[2 * i + 0] = 2 * mps_state[i] + 0;
         ff_h264_mlps_state[128+2*i+1]=
-        ff_h264_mps_state[2*i+1]= 2*mps_state[i]+1;
+        h264_mps_state[2 * i + 1] = 2 * mps_state[i] + 1;
 
         if( i ){
             ff_h264_lps_state[2*i+0]=
@@ -196,11 +196,10 @@ static void put_cabac(CABACContext *c, uint8_t * const state, int bit){
 
     if(bit == ((*state)&1)){
         c->range -= RangeLPS;
-        *state= ff_h264_mps_state[*state];
+        *state    = h264_mps_state[*state];
     }else{
         c->low += c->range - RangeLPS;
         c->range = RangeLPS;
-        *state= ff_h264_lps_state[*state];
     }
 
     renorm_cabac_encoder(c);

libavcodec/cabac.h

@@ -27,13 +27,10 @@
 #ifndef AVCODEC_CABAC_H
 #define AVCODEC_CABAC_H
 
-#include <stddef.h>
+#include <stdint.h>
 
 #include "put_bits.h"
 
-//#undef NDEBUG
-#include <assert.h>
-
 #define CABAC_BITS 16
 #define CABAC_MASK ((1<<CABAC_BITS)-1)
 
@@ -47,136 +44,8 @@ typedef struct CABACContext{
     PutBitContext pb;
 }CABACContext;
 
-extern uint8_t ff_h264_mlps_state[4*64];
-extern uint8_t ff_h264_lps_range[4*2*64];  ///< rangeTabLPS
-extern uint8_t ff_h264_mps_state[2*64];     ///< transIdxMPS
-extern uint8_t ff_h264_lps_state[2*64];     ///< transIdxLPS
-extern const uint8_t ff_h264_norm_shift[512];
-
-#if ARCH_X86
-#   include "x86/cabac.h"
-#endif
-
 void ff_init_cabac_encoder(CABACContext *c, uint8_t *buf, int buf_size);
 void ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size);
 void ff_init_cabac_states(CABACContext *c);
 
-
-static void refill(CABACContext *c){
-#if CABAC_BITS == 16
-        c->low+= (c->bytestream[0]<<9) + (c->bytestream[1]<<1);
-#else
-        c->low+= c->bytestream[0]<<1;
-#endif
-    c->low -= CABAC_MASK;
-    c->bytestream+= CABAC_BITS/8;
-}
-
-static inline void renorm_cabac_decoder_once(CABACContext *c){
-    int shift= (uint32_t)(c->range - 0x100)>>31;
-    c->range<<= shift;
-    c->low  <<= shift;
-    if(!(c->low & CABAC_MASK))
-        refill(c);
-}
-
-#ifndef get_cabac_inline
-static void refill2(CABACContext *c){
-    int i, x;
-
-    x= c->low ^ (c->low-1);
-    i= 7 - ff_h264_norm_shift[x>>(CABAC_BITS-1)];
-
-    x= -CABAC_MASK;
-
-#if CABAC_BITS == 16
-        x+= (c->bytestream[0]<<9) + (c->bytestream[1]<<1);
-#else
-        x+= c->bytestream[0]<<1;
-#endif
-
-    c->low += x<<i;
-    c->bytestream+= CABAC_BITS/8;
-}
-
-static av_always_inline int get_cabac_inline(CABACContext *c, uint8_t * const state){
-    int s = *state;
-    int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + s];
-    int bit, lps_mask;
-
-    c->range -= RangeLPS;
-    lps_mask= ((c->range<<(CABAC_BITS+1)) - c->low)>>31;
-
-    c->low -= (c->range<<(CABAC_BITS+1)) & lps_mask;
-    c->range += (RangeLPS - c->range) & lps_mask;
-
-    s^=lps_mask;
-    *state= (ff_h264_mlps_state+128)[s];
-    bit= s&1;
-
-    lps_mask= ff_h264_norm_shift[c->range];
-    c->range<<= lps_mask;
-    c->low  <<= lps_mask;
-    if(!(c->low & CABAC_MASK))
-        refill2(c);
-    return bit;
-}
-#endif
-
-static int av_noinline av_unused get_cabac_noinline(CABACContext *c, uint8_t * const state){
-    return get_cabac_inline(c,state);
-}
-
-static int av_unused get_cabac(CABACContext *c, uint8_t * const state){
-    return get_cabac_inline(c,state);
-}
-
-static int av_unused get_cabac_bypass(CABACContext *c){
-    int range;
-    c->low += c->low;
-
-    if(!(c->low & CABAC_MASK))
-        refill(c);
-
-    range= c->range<<(CABAC_BITS+1);
-    if(c->low < range){
-        return 0;
-    }else{
-        c->low -= range;
-        return 1;
-    }
-}
-
-
-#ifndef get_cabac_bypass_sign
-static av_always_inline int get_cabac_bypass_sign(CABACContext *c, int val){
-    int range, mask;
-    c->low += c->low;
-
-    if(!(c->low & CABAC_MASK))
-        refill(c);
-
-    range= c->range<<(CABAC_BITS+1);
-    c->low -= range;
-    mask= c->low >> 31;
-    range &= mask;
-    c->low += range;
-    return (val^mask)-mask;
-}
-#endif
-
-/**
- *
- * @return the number of bytes read or 0 if no end
- */
-static int av_unused get_cabac_terminate(CABACContext *c){
-    c->range -= 2;
-    if(c->low < c->range<<(CABAC_BITS+1)){
-        renorm_cabac_decoder_once(c);
-        return 0;
-    }else{
-        return c->bytestream - c->bytestream_start;
-    }
-}
-
 #endif /* AVCODEC_CABAC_H */

libavcodec/cabac_functions.h

@@ -0,0 +1,160 @@
+/*
+ * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
+ * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * 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
+ */
+
+/**
+ * @file
+ * Context Adaptive Binary Arithmetic Coder inline functions
+ */
+
+#ifndef AVCODEC_CABAC_FUNCTIONS_H
+#define AVCODEC_CABAC_FUNCTIONS_H
+
+#include <stdint.h>
+
+#include "cabac.h"
+#include "config.h"
+
+#if ARCH_X86
+#   include "x86/cabac.h"
+#endif
+
+extern const uint8_t ff_h264_norm_shift[512];
+extern uint8_t ff_h264_mlps_state[4*64];
+extern uint8_t ff_h264_lps_range[4*2*64];  ///< rangeTabLPS
+
+static void refill(CABACContext *c){
+#if CABAC_BITS == 16
+        c->low+= (c->bytestream[0]<<9) + (c->bytestream[1]<<1);
+#else
+        c->low+= c->bytestream[0]<<1;
+#endif
+    c->low -= CABAC_MASK;
+    c->bytestream+= CABAC_BITS/8;
+}
+
+static inline void renorm_cabac_decoder_once(CABACContext *c){
+    int shift= (uint32_t)(c->range - 0x100)>>31;
+    c->range<<= shift;
+    c->low  <<= shift;
+    if(!(c->low & CABAC_MASK))
+        refill(c);
+}
+
+#ifndef get_cabac_inline
+static void refill2(CABACContext *c){
+    int i, x;
+
+    x= c->low ^ (c->low-1);
+    i= 7 - ff_h264_norm_shift[x>>(CABAC_BITS-1)];
+
+    x= -CABAC_MASK;
+
+#if CABAC_BITS == 16
+        x+= (c->bytestream[0]<<9) + (c->bytestream[1]<<1);
+#else
+        x+= c->bytestream[0]<<1;
+#endif
+
+    c->low += x<<i;
+    c->bytestream+= CABAC_BITS/8;
+}
+
+static av_always_inline int get_cabac_inline(CABACContext *c, uint8_t * const state){
+    int s = *state;
+    int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + s];
+    int bit, lps_mask;
+
+    c->range -= RangeLPS;
+    lps_mask= ((c->range<<(CABAC_BITS+1)) - c->low)>>31;
+
+    c->low -= (c->range<<(CABAC_BITS+1)) & lps_mask;
+    c->range += (RangeLPS - c->range) & lps_mask;
+
+    s^=lps_mask;
+    *state= (ff_h264_mlps_state+128)[s];
+    bit= s&1;
+
+    lps_mask= ff_h264_norm_shift[c->range];
+    c->range<<= lps_mask;
+    c->low  <<= lps_mask;
+    if(!(c->low & CABAC_MASK))
+        refill2(c);
+    return bit;
+}
+#endif
+
+static int av_noinline av_unused get_cabac_noinline(CABACContext *c, uint8_t * const state){
+    return get_cabac_inline(c,state);
+}
+
+static int av_unused get_cabac(CABACContext *c, uint8_t * const state){
+    return get_cabac_inline(c,state);
+}
+
+static int av_unused get_cabac_bypass(CABACContext *c){
+    int range;
+    c->low += c->low;
+
+    if(!(c->low & CABAC_MASK))
+        refill(c);
+
+    range= c->range<<(CABAC_BITS+1);
+    if(c->low < range){
+        return 0;
+    }else{
+        c->low -= range;
+        return 1;
+    }
+}
+
+
+#ifndef get_cabac_bypass_sign
+static av_always_inline int get_cabac_bypass_sign(CABACContext *c, int val){
+    int range, mask;
+    c->low += c->low;
+
+    if(!(c->low & CABAC_MASK))
+        refill(c);
+
+    range= c->range<<(CABAC_BITS+1);
+    c->low -= range;
+    mask= c->low >> 31;
+    range &= mask;
+    c->low += range;
+    return (val^mask)-mask;
+}
+#endif
+
+/**
+ *
+ * @return the number of bytes read or 0 if no end
+ */
+static int av_unused get_cabac_terminate(CABACContext *c){
+    c->range -= 2;
+    if(c->low < c->range<<(CABAC_BITS+1)){
+        renorm_cabac_decoder_once(c);
+        return 0;
+    }else{
+        return c->bytestream - c->bytestream_start;
+    }
+}
+
+#endif /* AVCODEC_CABAC_FUNCTIONS_H */

libavcodec/h264.c

@@ -30,6 +30,8 @@
 #include "libavutil/imgutils.h"
 #include "libavutil/opt.h"
 #include "internal.h"
+#include "cabac.h"
+#include "cabac_functions.h"
 #include "dsputil.h"
 #include "avcodec.h"
 #include "mpegvideo.h"
@@ -43,8 +45,6 @@
 #include "vdpau_internal.h"
 #include "libavutil/avassert.h"
 
-#include "cabac.h"
-
 //#undef NDEBUG
 #include <assert.h>
 

libavcodec/h264_cabac.c

@@ -28,6 +28,9 @@
 #define CABAC 1
 #define UNCHECKED_BITSTREAM_READER 1
 
+#include "config.h"
+#include "cabac.h"
+#include "cabac_functions.h"
 #include "internal.h"
 #include "dsputil.h"
 #include "avcodec.h"
@@ -36,7 +39,6 @@
 #include "h264_mvpred.h"
 #include "golomb.h"
 
-#include "cabac.h"
 #if ARCH_X86
 #include "x86/h264_i386.h"
 #endif

libswscale/rgb2rgb.c

@@ -183,6 +183,25 @@ void rgb16tobgr32(const uint8_t *src, uint8_t *dst, int src_size)
     }
 }
 
+void rgb12to15(const uint8_t *src, uint8_t *dst, int src_size)
+{
+    const uint16_t *end;
+    uint16_t *d = (uint16_t *)dst;
+    const uint16_t *s = (const uint16_t *)src;
+    uint16_t rgb, r, g, b;
+    end = s + src_size / 2;
+    while (s < end) {
+        rgb = *s++;
+        r = rgb & 0xF00;
+        g = rgb & 0x0F0;
+        b = rgb & 0x00F;
+        r = (r << 3) | ((r & 0x800) >> 1);
+        g = (g << 2) | ((g & 0x080) >> 2);
+        b = (b << 1) | ( b          >> 3);
+        *d++ = r | g | b;
+    }
+}
+
 void rgb16to24(const uint8_t *src, uint8_t *dst, int src_size)
 {
     const uint16_t *end;

libswscale/rgb2rgb.h

@@ -63,6 +63,7 @@ void    rgb15to24(const uint8_t *src, uint8_t *dst, int src_size);
 void rgb15tobgr16(const uint8_t *src, uint8_t *dst, int src_size);
 void rgb15tobgr15(const uint8_t *src, uint8_t *dst, int src_size);
 void rgb12tobgr12(const uint8_t *src, uint8_t *dst, int src_size);
+void    rgb12to15(const uint8_t *src, uint8_t *dst, int src_size);
 
 void shuffle_bytes_0321(const uint8_t *src, uint8_t *dst, int src_size);
 void shuffle_bytes_1230(const uint8_t *src, uint8_t *dst, int src_size);

libswscale/swscale-test.c

@@ -340,8 +340,8 @@ int main(int argc, char **argv)
     enum PixelFormat srcFormat = PIX_FMT_NONE;
     enum PixelFormat dstFormat = PIX_FMT_NONE;
     uint8_t *rgb_data   = av_malloc(W * H * 4);
-    uint8_t *rgb_src[3] = { rgb_data, NULL, NULL };
-    int rgb_stride[3]   = { 4 * W, 0, 0 };
+    uint8_t *rgb_src[4] = { rgb_data, NULL, NULL, NULL };
+    int rgb_stride[4]   = { 4 * W, 0, 0, 0 };
     uint8_t *data       = av_malloc(4 * W * H);
     uint8_t *src[4]     = { data, data + W * H, data + W * H * 2, data + W * H * 3 };
     int stride[4]       = { W, W, W, W };

libswscale/swscale_unscaled.c

@@ -396,17 +396,22 @@ static int planarRgbToRgbWrapper(SwsContext *c, const uint8_t* src[], int srcStr
         )
 
 /* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
-static int rgbToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[],
-                           int srcSliceY, int srcSliceH, uint8_t *dst[],
-                           int dstStride[])
+typedef void (* rgbConvFn) (const uint8_t *, uint8_t *, int);
+static rgbConvFn findRgbConvFn(SwsContext *c)
 {
     const enum PixelFormat srcFormat = c->srcFormat;
     const enum PixelFormat dstFormat = c->dstFormat;
-    const int srcBpp = (c->srcFormatBpp + 7) >> 3;
-    const int dstBpp = (c->dstFormatBpp + 7) >> 3;
     const int srcId = c->srcFormatBpp;
     const int dstId = c->dstFormatBpp;
-    void (*conv)(const uint8_t *src, uint8_t *dst, int src_size) = NULL;
+    rgbConvFn conv = NULL;
+
+#define IS_NOT_NE(bpp, fmt) \
+    (((bpp + 7) >> 3) == 2 && \
+     (!(av_pix_fmt_descriptors[fmt].flags & PIX_FMT_BE) != !HAVE_BIGENDIAN))
+
+    /* if this is non-native rgb444/555/565, don't handle it here. */
+    if (IS_NOT_NE(srcId, srcFormat) || IS_NOT_NE(dstId, dstFormat))
+        return NULL;
 
 #define CONV_IS(src, dst) (srcFormat == PIX_FMT_##src && dstFormat == PIX_FMT_##dst)
 
@@ -428,6 +433,7 @@ static int rgbToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[],
     if ((isBGRinInt(srcFormat) && isBGRinInt(dstFormat)) ||
         (isRGBinInt(srcFormat) && isRGBinInt(dstFormat))) {
         switch (srcId | (dstId << 16)) {
+        case 0x000F000C: conv = rgb12to15; break;
         case 0x000F0010: conv = rgb16to15; break;
         case 0x000F0018: conv = rgb24to15; break;
         case 0x000F0020: conv = rgb32to15; break;
@@ -463,6 +469,21 @@ static int rgbToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[],
         }
     }
 
+    return conv;
+}
+
+/* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
+static int rgbToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[],
+                           int srcSliceY, int srcSliceH, uint8_t *dst[],
+                           int dstStride[])
+
+{
+    const enum PixelFormat srcFormat = c->srcFormat;
+    const enum PixelFormat dstFormat = c->dstFormat;
+    const int srcBpp = (c->srcFormatBpp + 7) >> 3;
+    const int dstBpp = (c->dstFormatBpp + 7) >> 3;
+    rgbConvFn conv = findRgbConvFn(c);
+
     if (!conv) {
         av_log(c, AV_LOG_ERROR, "internal error %s -> %s converter\n",
                av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
@@ -694,6 +715,8 @@ static int planarCopyWrapper(SwsContext *c, const uint8_t *src[],
             } else {
                 if (is16BPS(c->srcFormat) && is16BPS(c->dstFormat))
                     length *= 2;
+                else if (!av_pix_fmt_descriptors[c->srcFormat].comp[0].depth_minus1)
+                    length >>= 3; // monowhite/black
                 for (i = 0; i < height; i++) {
                     memcpy(dstPtr, srcPtr, length);
                     srcPtr += srcStride[plane];
@@ -748,24 +771,8 @@ void ff_get_unscaled_swscale(SwsContext *c)
         c->swScale = bgr24ToYv12Wrapper;
 
     /* RGB/BGR -> RGB/BGR (no dither needed forms) */
-    if (   isAnyRGB(srcFormat)
-        && isAnyRGB(dstFormat)
-        && srcFormat != PIX_FMT_BGR8      && dstFormat != PIX_FMT_BGR8
-        && srcFormat != PIX_FMT_RGB8      && dstFormat != PIX_FMT_RGB8
-        && srcFormat != PIX_FMT_BGR4      && dstFormat != PIX_FMT_BGR4
-        && srcFormat != PIX_FMT_RGB4      && dstFormat != PIX_FMT_RGB4
-        && srcFormat != PIX_FMT_BGR4_BYTE && dstFormat != PIX_FMT_BGR4_BYTE
-        && srcFormat != PIX_FMT_RGB4_BYTE && dstFormat != PIX_FMT_RGB4_BYTE
-        && srcFormat != PIX_FMT_MONOBLACK && dstFormat != PIX_FMT_MONOBLACK
-        && srcFormat != PIX_FMT_MONOWHITE && dstFormat != PIX_FMT_MONOWHITE
-        && srcFormat != PIX_FMT_RGB48LE   && dstFormat != PIX_FMT_RGB48LE
-        && srcFormat != PIX_FMT_RGB48BE   && dstFormat != PIX_FMT_RGB48BE
-        && srcFormat != PIX_FMT_BGR48LE   && dstFormat != PIX_FMT_BGR48LE
-        && srcFormat != PIX_FMT_BGR48BE   && dstFormat != PIX_FMT_BGR48BE
-        && (!needsDither || (c->flags&(SWS_FAST_BILINEAR|SWS_POINT)))
-        && (!(av_pix_fmt_descriptors[srcFormat].flags & PIX_FMT_BE) == !HAVE_BIGENDIAN || (c->srcFormatBpp+7)/8!=2)
-        && (!(av_pix_fmt_descriptors[dstFormat].flags & PIX_FMT_BE) == !HAVE_BIGENDIAN || (c->dstFormatBpp+7)/8!=2)
-    )
+    if (isAnyRGB(srcFormat) && isAnyRGB(dstFormat) && findRgbConvFn(c)
+        && (!needsDither || (c->flags&(SWS_FAST_BILINEAR|SWS_POINT))))
         c->swScale= rgbToRgbWrapper;
 
 #define isByteRGB(f) (\

tests/fate/image.mak

@@ -30,6 +30,33 @@ fate-sunraster-24bit-raw: CMD = framecrc -i $(SAMPLES)/sunraster/lena-24bit-raw.
 
 FATE_IMAGE += fate-sunraster-24bit-rle
 fate-sunraster-24bit-rle: CMD = framecrc -i $(SAMPLES)/sunraster/lena-24bit-rle.sun
-
 FATE_TESTS += $(FATE_IMAGE)
 fate-image: $(FATE_IMAGE)
+
+FATE_TARGA = CBW8       \
+             CTC16      \
+             CTC24      \
+             CTC32      \
+             UBW8       \
+             UTC16      \
+             UTC24      \
+             UTC32
+
+FATE_TARGA := $(FATE_TARGA:%=fate-targa-conformance-%)  \
+              fate-targa-top-to-bottom
+
+FATE_TESTS += $(FATE_TARGA)
+fate-targa: $(FATE_TARGA)
+
+fate-targa-conformance-CBW8:  CMD = framecrc -i $(SAMPLES)/targa-conformance/CBW8.TGA
+# fate-targa-conformance-CCM8:  CMD = framecrc -i $(SAMPLES)/targa-conformance/CCM8.TGA
+fate-targa-conformance-CTC16: CMD = framecrc -i $(SAMPLES)/targa-conformance/CTC16.TGA
+fate-targa-conformance-CTC24: CMD = framecrc -i $(SAMPLES)/targa-conformance/CTC24.TGA
+fate-targa-conformance-CTC32: CMD = framecrc -i $(SAMPLES)/targa-conformance/CTC32.TGA
+fate-targa-conformance-UBW8:  CMD = framecrc -i $(SAMPLES)/targa-conformance/UBW8.TGA
+# fate-targa-conformance-UCM8:  CMD = framecrc -i $(SAMPLES)/targa-conformance/UCM8.TGA
+fate-targa-conformance-UTC16: CMD = framecrc -i $(SAMPLES)/targa-conformance/UTC16.TGA
+fate-targa-conformance-UTC24: CMD = framecrc -i $(SAMPLES)/targa-conformance/UTC24.TGA
+fate-targa-conformance-UTC32: CMD = framecrc -i $(SAMPLES)/targa-conformance/UTC32.TGA
+
+fate-targa-top-to-bottom: CMD = framecrc -i $(SAMPLES)/targa/lena-top-to-bottom.tga

tests/ref/fate/targa-conformance-CBW8

@@ -0,0 +1 @@
+0, 0, 16384, 0x267e21ef

tests/ref/fate/targa-conformance-CTC16

@@ -0,0 +1 @@
+0, 0, 32768, 0xa6b3d20d

tests/ref/fate/targa-conformance-CTC24

@@ -0,0 +1 @@
+0, 0, 49152, 0xaca4bc29

tests/ref/fate/targa-conformance-CTC32

@@ -0,0 +1 @@
+0, 0, 65536, 0xcf98bc29

tests/ref/fate/targa-conformance-UBW8

@@ -0,0 +1 @@
+0, 0, 16384, 0x267e21ef

tests/ref/fate/targa-conformance-UTC16

@@ -0,0 +1 @@
+0, 0, 32768, 0xa6b3d20d

tests/ref/fate/targa-conformance-UTC24

@@ -0,0 +1 @@
+0, 0, 49152, 0xaca4bc29

tests/ref/fate/targa-conformance-UTC32

@@ -0,0 +1 @@
+0, 0, 65536, 0xcf98bc29

tests/ref/fate/targa-top-to-bottom

@@ -0,0 +1 @@
+0, 0, 196608, 0xb29ec51a