@@ -68,6 +68,7 @@ ELF     .size   \name, . - \name

         .purgem endfunc

     .endm

         .text

+        .align          2

     .if \export

         .global EXTERN_ASM\name

 EXTERN_ASM\name:

@@ -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

@@ -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);

@@ -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 */

new file mode 100644

@@ -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 */

@@ -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>

@@ -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

@@ -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;

@@ -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);

@@ -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 };

@@ -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) (\

@@ -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

new file mode 100644

@@ -0,0 +1 @@

+0, 0, 16384, 0x267e21ef

new file mode 100644

@@ -0,0 +1 @@

+0, 0, 32768, 0xa6b3d20d

new file mode 100644

@@ -0,0 +1 @@

+0, 0, 49152, 0xaca4bc29

new file mode 100644

@@ -0,0 +1 @@

+0, 0, 65536, 0xcf98bc29

new file mode 100644

@@ -0,0 +1 @@

+0, 0, 16384, 0x267e21ef

new file mode 100644

@@ -0,0 +1 @@

+0, 0, 32768, 0xa6b3d20d

new file mode 100644

@@ -0,0 +1 @@

+0, 0, 49152, 0xaca4bc29

new file mode 100644

@@ -0,0 +1 @@

+0, 0, 65536, 0xcf98bc29

new file mode 100644

@@ -0,0 +1 @@

+0, 0, 196608, 0xb29ec51a