@@ -314,7 +314,7 @@ OBJS-$(CONFIG_PNG_ENCODER)             += png.o pngenc.o

 OBJS-$(CONFIG_PPM_DECODER)             += pnmdec.o pnm.o

 OBJS-$(CONFIG_PPM_ENCODER)             += pnmenc.o pnm.o

 OBJS-$(CONFIG_PRORES_GPL_DECODER)      += proresdec_gpl.o

-OBJS-$(CONFIG_PRORES_LGPL_DECODER)     += proresdec_lgpl.o

+OBJS-$(CONFIG_PRORES_LGPL_DECODER)     += proresdec_lgpl.o proresdsp.o

 OBJS-$(CONFIG_PTX_DECODER)             += ptx.o

 OBJS-$(CONFIG_QCELP_DECODER)           += qcelpdec.o celp_math.o         \

                                           celp_filters.o acelp_vectors.o \

@@ -73,8 +73,8 @@ typedef int64_t CoefSumType;

 #define AC3ENC_OPT_OFF              0

 #define AC3ENC_OPT_ON               1

 #define AC3ENC_OPT_NOT_INDICATED    0

-#define AC3ENC_OPT_MODE_ON          1

-#define AC3ENC_OPT_MODE_OFF         2

+#define AC3ENC_OPT_MODE_ON          2

+#define AC3ENC_OPT_MODE_OFF         1

 /* specific option values */

 #define AC3ENC_OPT_LARGE_ROOM       1

@@ -144,6 +144,41 @@ void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_s

     }

 }

+void ff_init_scantable_permutation(uint8_t *idct_permutation,

+                                   int idct_permutation_type)

+{

+    int i;

+

+    switch(idct_permutation_type){

+    case FF_NO_IDCT_PERM:

+        for(i=0; i<64; i++)

+            idct_permutation[i]= i;

+        break;

+    case FF_LIBMPEG2_IDCT_PERM:

+        for(i=0; i<64; i++)

+            idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);

+        break;

+    case FF_SIMPLE_IDCT_PERM:

+        for(i=0; i<64; i++)

+            idct_permutation[i]= simple_mmx_permutation[i];

+        break;

+    case FF_TRANSPOSE_IDCT_PERM:

+        for(i=0; i<64; i++)

+            idct_permutation[i]= ((i&7)<<3) | (i>>3);

+        break;

+    case FF_PARTTRANS_IDCT_PERM:

+        for(i=0; i<64; i++)

+            idct_permutation[i]= (i&0x24) | ((i&3)<<3) | ((i>>3)&3);

+        break;

+    case FF_SSE2_IDCT_PERM:

+        for(i=0; i<64; i++)

+            idct_permutation[i]= (i&0x38) | idct_sse2_row_perm[i&7];

+        break;

+    default:

+        av_log(NULL, AV_LOG_ERROR, "Internal error, IDCT permutation not set\n");

+    }

+}

+

 static int pix_sum_c(uint8_t * pix, int line_size)

 {

     int s, i, j;

@@ -3107,32 +3142,6 @@ av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx)

             c->avg_2tap_qpel_pixels_tab[0][i]= c->avg_h264_qpel_pixels_tab[0][i];

     }

-    switch(c->idct_permutation_type){

-    case FF_NO_IDCT_PERM:

-        for(i=0; i<64; i++)

-            c->idct_permutation[i]= i;

-        break;

-    case FF_LIBMPEG2_IDCT_PERM:

-        for(i=0; i<64; i++)

-            c->idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);

-        break;

-    case FF_SIMPLE_IDCT_PERM:

-        for(i=0; i<64; i++)

-            c->idct_permutation[i]= simple_mmx_permutation[i];

-        break;

-    case FF_TRANSPOSE_IDCT_PERM:

-        for(i=0; i<64; i++)

-            c->idct_permutation[i]= ((i&7)<<3) | (i>>3);

-        break;

-    case FF_PARTTRANS_IDCT_PERM:

-        for(i=0; i<64; i++)

-            c->idct_permutation[i]= (i&0x24) | ((i&3)<<3) | ((i>>3)&3);

-        break;

-    case FF_SSE2_IDCT_PERM:

-        for(i=0; i<64; i++)

-            c->idct_permutation[i]= (i&0x38) | idct_sse2_row_perm[i&7];

-        break;

-    default:

-        av_log(avctx, AV_LOG_ERROR, "Internal error, IDCT permutation not set\n");

-    }

+    ff_init_scantable_permutation(c->idct_permutation,

+                                  c->idct_permutation_type);

 }

@@ -204,6 +204,8 @@ typedef struct ScanTable{

 } ScanTable;

 void ff_init_scantable(uint8_t *, ScanTable *st, const uint8_t *src_scantable);

+void ff_init_scantable_permutation(uint8_t *idct_permutation,

+                                   int idct_permutation_type);

 #define EMULATED_EDGE(depth) \

 void ff_emulated_edge_mc_ ## depth (uint8_t *buf, const uint8_t *src, int linesize,\

@@ -301,7 +301,7 @@ static int flashsv_decode_frame(AVCodecContext *avctx, void *data,

     /* check for changes of image width and image height */

     if (avctx->width != s->image_width || avctx->height != s->image_height) {

         av_log(avctx, AV_LOG_ERROR,

-               "Frame width or height differs from first frames!\n");

+               "Frame width or height differs from first frame!\n");

         av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d  vs  ch = %d, cv = %d\n",

                avctx->height, avctx->width, s->image_height, s->image_width);

         return AVERROR_INVALIDDATA;

@@ -367,7 +367,7 @@ static int flashsv_decode_frame(AVCodecContext *avctx, void *data,

                 if (s->color_depth != 0 && s->color_depth != 2) {

                     av_log(avctx, AV_LOG_ERROR,

                            "%dx%d invalid color depth %d\n", i, j, s->color_depth);

-                    return -1;

+                    return AVERROR_INVALIDDATA;

                 }

                 if (has_diff) {

@@ -75,6 +75,20 @@ static inline int get_ue_golomb(GetBitContext *gb){

     }

 }

+/**

+ * Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.

+ */

+static inline unsigned get_ue_golomb_long(GetBitContext *gb)

+{

+    unsigned buf, log;

+

+    buf = show_bits_long(gb, 32);

+    log = 31 - av_log2(buf);

+    skip_bits_long(gb, log);

+

+    return get_bits_long(gb, log + 1) - 1;

+}

+

  /**

  * read unsigned exp golomb code, constraint to a max of 31.

  * the return value is undefined if the stored value exceeds 31.

@@ -298,17 +298,18 @@ static inline int pred_non_zero_count(H264Context *h, int n){

 }

 static av_cold void init_cavlc_level_tab(void){

-    int suffix_length, mask;

+    int suffix_length;

     unsigned int i;

     for(suffix_length=0; suffix_length<7; suffix_length++){

         for(i=0; i<(1<<LEVEL_TAB_BITS); i++){

             int prefix= LEVEL_TAB_BITS - av_log2(2*i);

-            int level_code= (prefix<<suffix_length) + (i>>(LEVEL_TAB_BITS-prefix-1-suffix_length)) - (1<<suffix_length);

-            mask= -(level_code&1);

-            level_code= (((2+level_code)>>1) ^ mask) - mask;

             if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){

+                int level_code = (prefix << suffix_length) +

+                    (i >> (av_log2(i) - suffix_length)) - (1 << suffix_length);

+                int mask = -(level_code&1);

+                level_code = (((2 + level_code) >> 1) ^ mask) - mask;

                 cavlc_level_tab[suffix_length][i][0]= level_code;

                 cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;

             }else if(prefix + 1 <= LEVEL_TAB_BITS){

@@ -143,8 +143,8 @@ static inline int decode_hrd_parameters(H264Context *h, SPS *sps){

     get_bits(&s->gb, 4); /* bit_rate_scale */

     get_bits(&s->gb, 4); /* cpb_size_scale */

     for(i=0; i<cpb_count; i++){

-        get_ue_golomb(&s->gb); /* bit_rate_value_minus1 */

-        get_ue_golomb(&s->gb); /* cpb_size_value_minus1 */

+        get_ue_golomb_long(&s->gb); /* bit_rate_value_minus1 */

+        get_ue_golomb_long(&s->gb); /* cpb_size_value_minus1 */

         get_bits1(&s->gb);     /* cbr_flag */

     }

     sps->initial_cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;

@@ -494,6 +494,7 @@ int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){

     unsigned int pps_id= get_ue_golomb(&s->gb);

     PPS *pps;

     const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);

+    int bits_left;

     if(pps_id >= MAX_PPS_COUNT) {

         av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);

@@ -570,6 +571,7 @@ int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){

     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));

     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));

+    bits_left = bit_length - get_bits_count(&s->gb);

     if(get_bits_count(&s->gb) < bit_length){

         pps->transform_8x8_mode= get_bits1(&s->gb);

         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);

@@ -52,7 +52,7 @@ static inline int sad_hpel_motion_search(MpegEncContext * s,

                                   int src_index, int ref_index,

                                   int size, int h);

-static inline int update_map_generation(MotionEstContext *c)

+static inline unsigned update_map_generation(MotionEstContext *c)

 {

     c->map_generation+= 1<<(ME_MAP_MV_BITS*2);

     if(c->map_generation==0){

@@ -90,8 +90,8 @@ static int hpel_motion_search(MpegEncContext * s,

                      + (mv_penalty[bx   - pred_x] + mv_penalty[by+2 - pred_y])*c->penalty_factor;

 #if 1

-        int key;

-        int map_generation= c->map_generation;

+        unsigned key;

+        unsigned map_generation= c->map_generation;

 #ifndef NDEBUG

         uint32_t *map= c->map;

 #endif

@@ -210,7 +210,7 @@ static int qpel_motion_search(MpegEncContext * s,

     const int mx = *mx_ptr;

     const int my = *my_ptr;

     const int penalty_factor= c->sub_penalty_factor;

-    const int map_generation= c->map_generation;

+    const unsigned map_generation = c->map_generation;

     const int subpel_quality= c->avctx->me_subpel_quality;

     uint32_t *map= c->map;

     me_cmp_func cmpf, chroma_cmpf;

@@ -356,7 +356,7 @@ static int qpel_motion_search(MpegEncContext * s,

 #define CHECK_MV(x,y)\

 {\

-    const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\

+    const unsigned key = ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\

     const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\

     assert((x) >= xmin);\

     assert((x) <= xmax);\

@@ -384,7 +384,7 @@ static int qpel_motion_search(MpegEncContext * s,

 #define CHECK_MV_DIR(x,y,new_dir)\

 {\

-    const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\

+    const unsigned key = ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\

     const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\

 /*printf("check_mv_dir %d %d %d\n", x, y, new_dir);*/\

     if(map[index]!=key){\

@@ -422,13 +422,13 @@ static av_always_inline int small_diamond_search(MpegEncContext * s, int *best,

     int next_dir=-1;

     LOAD_COMMON

     LOAD_COMMON2

-    int map_generation= c->map_generation;

+    unsigned map_generation = c->map_generation;

     cmpf= s->dsp.me_cmp[size];

     chroma_cmpf= s->dsp.me_cmp[size+1];

     { /* ensure that the best point is in the MAP as h/qpel refinement needs it */

-        const int key= (best[1]<<ME_MAP_MV_BITS) + best[0] + map_generation;

+        const unsigned key = (best[1]<<ME_MAP_MV_BITS) + best[0] + map_generation;

         const int index= ((best[1]<<ME_MAP_SHIFT) + best[0])&(ME_MAP_SIZE-1);

         if(map[index]!=key){ //this will be executed only very rarey

             score_map[index]= cmp(s, best[0], best[1], 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);

@@ -464,7 +464,7 @@ static int funny_diamond_search(MpegEncContext * s, int *best, int dmin,

     int dia_size;

     LOAD_COMMON

     LOAD_COMMON2

-    int map_generation= c->map_generation;

+    unsigned map_generation = c->map_generation;

     cmpf= s->dsp.me_cmp[size];

     chroma_cmpf= s->dsp.me_cmp[size+1];

@@ -505,7 +505,7 @@ static int hex_search(MpegEncContext * s, int *best, int dmin,

     me_cmp_func cmpf, chroma_cmpf;

     LOAD_COMMON

     LOAD_COMMON2

-    int map_generation= c->map_generation;

+    unsigned map_generation = c->map_generation;

     int x,y,d;

     const int dec= dia_size & (dia_size-1);

@@ -539,7 +539,7 @@ static int l2s_dia_search(MpegEncContext * s, int *best, int dmin,

     me_cmp_func cmpf, chroma_cmpf;

     LOAD_COMMON

     LOAD_COMMON2

-    int map_generation= c->map_generation;

+    unsigned map_generation = c->map_generation;

     int x,y,i,d;

     int dia_size= c->dia_size&0xFF;

     const int dec= dia_size & (dia_size-1);

@@ -577,7 +577,7 @@ static int umh_search(MpegEncContext * s, int *best, int dmin,

     me_cmp_func cmpf, chroma_cmpf;

     LOAD_COMMON

     LOAD_COMMON2

-    int map_generation= c->map_generation;

+    unsigned map_generation = c->map_generation;

     int x,y,x2,y2, i, j, d;

     const int dia_size= c->dia_size&0xFE;

     static const int hex[16][2]={{-4,-2}, {-4,-1}, {-4, 0}, {-4, 1}, {-4, 2},

@@ -624,7 +624,7 @@ static int full_search(MpegEncContext * s, int *best, int dmin,

     me_cmp_func cmpf, chroma_cmpf;

     LOAD_COMMON

     LOAD_COMMON2

-    int map_generation= c->map_generation;

+    unsigned map_generation = c->map_generation;

     int x,y, d;

     const int dia_size= c->dia_size&0xFF;

@@ -653,7 +653,7 @@ static int full_search(MpegEncContext * s, int *best, int dmin,

 #define SAB_CHECK_MV(ax,ay)\

 {\

-    const int key= ((ay)<<ME_MAP_MV_BITS) + (ax) + map_generation;\

+    const unsigned key = ((ay)<<ME_MAP_MV_BITS) + (ax) + map_generation;\

     const int index= (((ay)<<ME_MAP_SHIFT) + (ax))&(ME_MAP_SIZE-1);\

 /*printf("sab check %d %d\n", ax, ay);*/\

     if(map[index]!=key){\

@@ -692,7 +692,7 @@ static int sab_diamond_search(MpegEncContext * s, int *best, int dmin,

     int i, j;

     LOAD_COMMON

     LOAD_COMMON2

-    int map_generation= c->map_generation;

+    unsigned map_generation = c->map_generation;

     cmpf= s->dsp.me_cmp[size];

     chroma_cmpf= s->dsp.me_cmp[size+1];

@@ -777,7 +777,7 @@ static int var_diamond_search(MpegEncContext * s, int *best, int dmin,

     int dia_size;

     LOAD_COMMON

     LOAD_COMMON2

-    int map_generation= c->map_generation;

+    unsigned map_generation = c->map_generation;

     cmpf= s->dsp.me_cmp[size];

     chroma_cmpf= s->dsp.me_cmp[size+1];

@@ -869,7 +869,7 @@ static av_always_inline int epzs_motion_search_internal(MpegEncContext * s, int

     int d;                   ///< the score (cmp + penalty) of any given mv

     int dmin;                /**< the best value of d, i.e. the score

                                corresponding to the mv stored in best[]. */

-    int map_generation;

+    unsigned map_generation;

     int penalty_factor;

     const int ref_mv_stride= s->mb_stride; //pass as arg  FIXME

     const int ref_mv_xy= s->mb_x + s->mb_y*ref_mv_stride; //add to last_mv beforepassing FIXME

@@ -997,7 +997,7 @@ static int epzs_motion_search4(MpegEncContext * s,

     MotionEstContext * const c= &s->me;

     int best[2]={0, 0};

     int d, dmin;

-    int map_generation;

+    unsigned map_generation;

     const int penalty_factor= c->penalty_factor;

     const int size=1;

     const int h=8;

@@ -1057,7 +1057,7 @@ static int epzs_motion_search2(MpegEncContext * s,

     MotionEstContext * const c= &s->me;

     int best[2]={0, 0};

     int d, dmin;

-    int map_generation;

+    unsigned map_generation;

     const int penalty_factor= c->penalty_factor;

     const int size=0; //FIXME pass as arg

     const int h=8;

@@ -156,7 +156,7 @@ typedef struct MotionEstContext{

     int best_bits;

     uint32_t *map;                     ///< map to avoid duplicate evaluations

     uint32_t *score_map;               ///< map to store the scores

-    int map_generation;

+    unsigned map_generation;

     int pre_penalty_factor;

     int penalty_factor;                /**< an estimate of the bits required to

                                         code a given mv value, e.g. (1,0) takes

@@ -34,17 +34,19 @@

 #include "libavutil/intmath.h"

 #include "avcodec.h"

-#include "dsputil.h"

+#include "proresdsp.h"

 #include "get_bits.h"

-#define BITS_PER_SAMPLE 10                              ///< output precision of that decoder

-#define BIAS     (1 << (BITS_PER_SAMPLE - 1))           ///< bias value for converting signed pixels into unsigned ones

-#define CLIP_MIN (1 << (BITS_PER_SAMPLE - 8))           ///< minimum value for clipping resulting pixels

-#define CLIP_MAX (1 << BITS_PER_SAMPLE) - CLIP_MIN - 1  ///< maximum value for clipping resulting pixels

-

+typedef struct {

+    const uint8_t *index;            ///< pointers to the data of this slice

+    int slice_num;

+    int x_pos, y_pos;

+    int slice_width;

+    DECLARE_ALIGNED(16, DCTELEM, blocks[8 * 4 * 64]);

+} ProresThreadData;

 typedef struct {

-    DSPContext dsp;

+    ProresDSPContext dsp;

     AVFrame    picture;

     ScanTable  scantable;

     int        scantable_type;           ///< -1 = uninitialized, 0 = progressive, 1/2 = interlaced

@@ -57,9 +59,9 @@ typedef struct {

     int        prev_slice_sf;            ///< scalefactor of the previous decoded slice

     DECLARE_ALIGNED(16, int16_t, qmat_luma_scaled[64]);

     DECLARE_ALIGNED(16, int16_t, qmat_chroma_scaled[64]);

-    DECLARE_ALIGNED(16, DCTELEM, blocks[8 * 4 * 64]);

     int        total_slices;            ///< total number of slices in a picture

-    const uint8_t **slice_data_index;   ///< array of pointers to the data of each slice

+    ProresThreadData *slice_data;

+    int        pic_num;

     int        chroma_factor;

     int        mb_chroma_factor;

     int        num_chroma_blocks;       ///< number of chrominance blocks in a macroblock

@@ -100,12 +102,12 @@ static av_cold int decode_init(AVCodecContext *avctx)

     ProresContext *ctx = avctx->priv_data;

     ctx->total_slices     = 0;

-    ctx->slice_data_index = 0;

+    ctx->slice_data       = NULL;

     avctx->pix_fmt = PIX_FMT_YUV422P10; // set default pixel format

-    avctx->bits_per_raw_sample = BITS_PER_SAMPLE;

-    dsputil_init(&ctx->dsp, avctx);

+    avctx->bits_per_raw_sample = PRORES_BITS_PER_SAMPLE;

+    ff_proresdsp_init(&ctx->dsp);

     avctx->coded_frame = &ctx->picture;

     avcodec_get_frame_defaults(&ctx->picture);

@@ -271,9 +273,9 @@ static int decode_picture_header(ProresContext *ctx, const uint8_t *buf,

     }

     if (ctx->total_slices != num_slices) {

-        av_freep(&ctx->slice_data_index);

-        ctx->slice_data_index = av_malloc((num_slices + 1) * sizeof(uint8_t*));

-        if (!ctx->slice_data_index)

+        av_freep(&ctx->slice_data);

+        ctx->slice_data = av_malloc((num_slices + 1) * sizeof(ctx->slice_data[0]));

+        if (!ctx->slice_data)

             return AVERROR(ENOMEM);

         ctx->total_slices = num_slices;

     }

@@ -288,10 +290,10 @@ static int decode_picture_header(ProresContext *ctx, const uint8_t *buf,

     data_ptr = index_ptr + num_slices * 2;

     for (i = 0; i < num_slices; i++) {

-        ctx->slice_data_index[i] = data_ptr;

+        ctx->slice_data[i].index = data_ptr;

         data_ptr += AV_RB16(index_ptr + i * 2);

     }

-    ctx->slice_data_index[i] = data_ptr;

+    ctx->slice_data[i].index = data_ptr;

     if (data_ptr > buf + data_size) {

         av_log(avctx, AV_LOG_ERROR, "out of slice data\n");

@@ -449,52 +451,11 @@ static inline void decode_ac_coeffs(GetBitContext *gb, DCTELEM *out,

 }

-#define CLIP_AND_BIAS(x) (av_clip((x) + BIAS, CLIP_MIN, CLIP_MAX))

-

-/**

- * Add bias value, clamp and output pixels of a slice

- */

-static void put_pixels(const DCTELEM *in, uint16_t *out, int stride,

-                       int mbs_per_slice, int blocks_per_mb)

-{

-    int mb, x, y, src_offset, dst_offset;

-    const DCTELEM *src1, *src2;

-    uint16_t *dst1, *dst2;

-

-    src1 = in;

-    src2 = in + (blocks_per_mb << 5);

-    dst1 = out;

-    dst2 = out + (stride << 3);

-

-    for (mb = 0; mb < mbs_per_slice; mb++) {

-        for (y = 0, dst_offset = 0; y < 8; y++, dst_offset += stride) {

-            for (x = 0; x < 8; x++) {

-                src_offset = (y << 3) + x;

-

-                dst1[dst_offset + x] = CLIP_AND_BIAS(src1[src_offset]);

-                dst2[dst_offset + x] = CLIP_AND_BIAS(src2[src_offset]);

-

-                if (blocks_per_mb > 2) {

-                    dst1[dst_offset + x + 8] =

-                        CLIP_AND_BIAS(src1[src_offset + 64]);

-                    dst2[dst_offset + x + 8] =

-                        CLIP_AND_BIAS(src2[src_offset + 64]);

-                }

-            }

-        }

-

-        src1 += blocks_per_mb << 6;

-        src2 += blocks_per_mb << 6;

-        dst1 += blocks_per_mb << 2;

-        dst2 += blocks_per_mb << 2;

-    }

-}

-

-

 /**

  * Decode a slice plane (luma or chroma).

  */

-static void decode_slice_plane(ProresContext *ctx, const uint8_t *buf,

+static void decode_slice_plane(ProresContext *ctx, ProresThreadData *td,

+                               const uint8_t *buf,

                                int data_size, uint16_t *out_ptr,

                                int linesize, int mbs_per_slice,

                                int blocks_per_mb, int plane_size_factor,

@@ -502,43 +463,47 @@ static void decode_slice_plane(ProresContext *ctx, const uint8_t *buf,

 {

     GetBitContext gb;

     DCTELEM *block_ptr;

-    int i, blk_num, blocks_per_slice;

+    int mb_num, blocks_per_slice;

     blocks_per_slice = mbs_per_slice * blocks_per_mb;

-    memset(ctx->blocks, 0, 8 * 4 * 64 * sizeof(*ctx->blocks));

+    memset(td->blocks, 0, 8 * 4 * 64 * sizeof(*td->blocks));

     init_get_bits(&gb, buf, data_size << 3);

-    decode_dc_coeffs(&gb, ctx->blocks, blocks_per_slice);

+    decode_dc_coeffs(&gb, td->blocks, blocks_per_slice);

-    decode_ac_coeffs(&gb, ctx->blocks, blocks_per_slice,

+    decode_ac_coeffs(&gb, td->blocks, blocks_per_slice,

                      plane_size_factor, ctx->scantable.permutated);

     /* inverse quantization, inverse transform and output */

-    block_ptr = ctx->blocks;

-

-    for (blk_num = 0; blk_num < blocks_per_slice; blk_num++, block_ptr += 64) {

-        /* TODO: the correct solution shoud be (block_ptr[i] * qmat[i]) >> 1

-         * and the input of the inverse transform should be scaled by 2

-         * in order to avoid rounding errors.

-         * Due to the fact the existing Libav transforms are incompatible with

-         * that input I temporally introduced the coarse solution below... */

-        for (i = 0; i < 64; i++)

-            block_ptr[i] = (block_ptr[i] * qmat[i]) >> 2;

-

-        ctx->dsp.idct(block_ptr);

+    block_ptr = td->blocks;

+

+    for (mb_num = 0; mb_num < mbs_per_slice; mb_num++, out_ptr += blocks_per_mb * 4) {

+        ctx->dsp.idct_put(out_ptr,                    linesize, block_ptr, qmat);

+        block_ptr += 64;

+        if (blocks_per_mb > 2) {

+            ctx->dsp.idct_put(out_ptr + 8,            linesize, block_ptr, qmat);

+            block_ptr += 64;

+        }

+        ctx->dsp.idct_put(out_ptr + linesize * 4,     linesize, block_ptr, qmat);

+        block_ptr += 64;

+        if (blocks_per_mb > 2) {

+            ctx->dsp.idct_put(out_ptr + linesize * 4 + 8, linesize, block_ptr, qmat);

+            block_ptr += 64;

+        }

     }

-

-    put_pixels(ctx->blocks, out_ptr, linesize >> 1, mbs_per_slice,

-               blocks_per_mb);

 }

-static int decode_slice(ProresContext *ctx, int pic_num, int slice_num,

-                        int mb_x_pos, int mb_y_pos, int mbs_per_slice,

-                        AVCodecContext *avctx)

+static int decode_slice(AVCodecContext *avctx, ProresThreadData *td)

 {

+    ProresContext *ctx = avctx->priv_data;

+    int mb_x_pos  = td->x_pos;

+    int mb_y_pos  = td->y_pos;

+    int pic_num   = ctx->pic_num;

+    int slice_num = td->slice_num;

+    int mbs_per_slice = td->slice_width;

     const uint8_t *buf;

     uint8_t *y_data, *u_data, *v_data;

     AVFrame *pic = avctx->coded_frame;

@@ -546,8 +511,8 @@ static int decode_slice(ProresContext *ctx, int pic_num, int slice_num,

     int slice_data_size, hdr_size, y_data_size, u_data_size, v_data_size;

     int y_linesize, u_linesize, v_linesize;

-    buf             = ctx->slice_data_index[slice_num];

-    slice_data_size = ctx->slice_data_index[slice_num + 1] - buf;

+    buf             = ctx->slice_data[slice_num].index;

+    slice_data_size = ctx->slice_data[slice_num + 1].index - buf;

     slice_width_factor = av_log2(mbs_per_slice);

@@ -593,20 +558,20 @@ static int decode_slice(ProresContext *ctx, int pic_num, int slice_num,

     if (ctx->qmat_changed || sf != ctx->prev_slice_sf) {

         ctx->prev_slice_sf = sf;

         for (i = 0; i < 64; i++) {

-            ctx->qmat_luma_scaled[i]   = ctx->qmat_luma[i]   * sf;

-            ctx->qmat_chroma_scaled[i] = ctx->qmat_chroma[i] * sf;

+            ctx->qmat_luma_scaled[ctx->dsp.idct_permutation[i]]   = ctx->qmat_luma[i]   * sf;

+            ctx->qmat_chroma_scaled[ctx->dsp.idct_permutation[i]] = ctx->qmat_chroma[i] * sf;

         }

     }

     /* decode luma plane */

-    decode_slice_plane(ctx, buf + hdr_size, y_data_size,

+    decode_slice_plane(ctx, td, buf + hdr_size, y_data_size,

                        (uint16_t*) (y_data + (mb_y_pos << 4) * y_linesize +

                                     (mb_x_pos << 5)), y_linesize,

                        mbs_per_slice, 4, slice_width_factor + 2,

                        ctx->qmat_luma_scaled);

     /* decode U chroma plane */

-    decode_slice_plane(ctx, buf + hdr_size + y_data_size, u_data_size,

+    decode_slice_plane(ctx, td, buf + hdr_size + y_data_size, u_data_size,

                        (uint16_t*) (u_data + (mb_y_pos << 4) * u_linesize +

                                     (mb_x_pos << ctx->mb_chroma_factor)),

                        u_linesize, mbs_per_slice, ctx->num_chroma_blocks,

@@ -614,7 +579,7 @@ static int decode_slice(ProresContext *ctx, int pic_num, int slice_num,

                        ctx->qmat_chroma_scaled);

     /* decode V chroma plane */

-    decode_slice_plane(ctx, buf + hdr_size + y_data_size + u_data_size,

+    decode_slice_plane(ctx, td, buf + hdr_size + y_data_size + u_data_size,

                        v_data_size,

                        (uint16_t*) (v_data + (mb_y_pos << 4) * v_linesize +

                                     (mb_x_pos << ctx->mb_chroma_factor)),

@@ -633,6 +598,7 @@ static int decode_picture(ProresContext *ctx, int pic_num,

     slice_num = 0;

+    ctx->pic_num = pic_num;

     for (y_pos = 0; y_pos < ctx->num_y_mbs; y_pos++) {

         slice_width = 1 << ctx->slice_width_factor;

@@ -641,15 +607,18 @@ static int decode_picture(ProresContext *ctx, int pic_num,

             while (ctx->num_x_mbs - x_pos < slice_width)

                 slice_width >>= 1;

-            if (decode_slice(ctx, pic_num, slice_num, x_pos, y_pos,

-                             slice_width, avctx) < 0)

-                return -1;

+            ctx->slice_data[slice_num].slice_num   = slice_num;

+            ctx->slice_data[slice_num].x_pos       = x_pos;

+            ctx->slice_data[slice_num].y_pos       = y_pos;

+            ctx->slice_data[slice_num].slice_width = slice_width;

             slice_num++;

         }

     }

-    return 0;

+    return avctx->execute(avctx, (void *) decode_slice,

+                          ctx->slice_data, NULL, slice_num,

+                          sizeof(ctx->slice_data[0]));

 }

@@ -712,7 +681,7 @@ static av_cold int decode_close(AVCodecContext *avctx)

     if (ctx->picture.data[0])

         avctx->release_buffer(avctx, &ctx->picture);

-    av_freep(&ctx->slice_data_index);

+    av_freep(&ctx->slice_data);

     return 0;

 }

@@ -726,6 +695,6 @@ AVCodec ff_prores_lgpl_decoder = {

     .init           = decode_init,

     .close          = decode_close,

     .decode         = decode_frame,

-    .capabilities   = CODEC_CAP_DR1,

+    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,

     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)")

 };

new file mode 100644

@@ -0,0 +1,63 @@

+/*

+ * Apple ProRes compatible decoder

+ *

+ * Copyright (c) 2010-2011 Maxim Poliakovski

+ *

+ * 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 "proresdsp.h"

+#include "simple_idct.h"

+

+#define BIAS     (1 << (PRORES_BITS_PER_SAMPLE - 1))           ///< bias value for converting signed pixels into unsigned ones

+#define CLIP_MIN (1 << (PRORES_BITS_PER_SAMPLE - 8))           ///< minimum value for clipping resulting pixels

+#define CLIP_MAX (1 << PRORES_BITS_PER_SAMPLE) - CLIP_MIN - 1  ///< maximum value for clipping resulting pixels

+

+#define CLIP_AND_BIAS(x) (av_clip((x) + BIAS, CLIP_MIN, CLIP_MAX))

+

+/**

+ * Add bias value, clamp and output pixels of a slice

+ */

+static void put_pixels(uint16_t *dst, int stride, const DCTELEM *in)

+{

+    int x, y, src_offset, dst_offset;

+

+    for (y = 0, dst_offset = 0; y < 8; y++, dst_offset += stride) {

+        for (x = 0; x < 8; x++) {

+            src_offset = (y << 3) + x;

+

+            dst[dst_offset + x] = CLIP_AND_BIAS(in[src_offset]);

+        }

+    }

+}

+

+static void prores_idct_put_c(uint16_t *out, int linesize, DCTELEM *block, const int16_t *qmat)

+{

+    ff_prores_idct(block, qmat);

+    put_pixels(out, linesize >> 1, block);

+}

+

+void ff_proresdsp_init(ProresDSPContext *dsp)

+{

+    dsp->idct_put = prores_idct_put_c;

+    dsp->idct_permutation_type = FF_NO_IDCT_PERM;

+

+    if (HAVE_MMX) ff_proresdsp_x86_init(dsp);

+

+    ff_init_scantable_permutation(dsp->idct_permutation,

+                                  dsp->idct_permutation_type);

+}

new file mode 100644

@@ -0,0 +1,40 @@

+/*

+ * Apple ProRes compatible decoder

+ *

+ * Copyright (c) 2010-2011 Maxim Poliakovski

+ *

+ * 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

+ */

+

+#ifndef AVCODEC_PRORESDSP_H

+#define AVCODEC_PRORESDSP_H

+

+#include "dsputil.h"

+

+#define PRORES_BITS_PER_SAMPLE 10 ///< output precision of prores decoder

+

+typedef struct {

+    int idct_permutation_type;

+    uint8_t idct_permutation[64];

+    void (* idct_put) (uint16_t *out, int linesize, DCTELEM *block, const int16_t *qmat);

+} ProresDSPContext;

+

+void ff_proresdsp_init(ProresDSPContext *dsp);

+

+void ff_proresdsp_x86_init(ProresDSPContext *dsp);

+

+#endif /* AVCODEC_PRORESDSP_H */

@@ -221,3 +221,20 @@ void ff_simple_idct44_add(uint8_t *dest, int line_size, DCTELEM *block)

         idct4col_add(dest + i, line_size, block + i);

     }

 }

+

+void ff_prores_idct(DCTELEM *block, const int16_t *qmat)

+{

+    int i;

+

+    for (i = 0; i < 64; i++)

+        block[i] *= qmat[i];

+

+    for (i = 0; i < 8; i++)

+        idctRowCondDC_10(block + i*8);

+

+    for (i = 0; i < 64; i++)

+        block[i] >>= 2;

+

+    for (i = 0; i < 8; i++)

+        idctSparseCol_10(block + i);

+}

@@ -38,6 +38,12 @@ void ff_simple_idct_8(DCTELEM *block);

 void ff_simple_idct_put_10(uint8_t *dest, int line_size, DCTELEM *block);

 void ff_simple_idct_add_10(uint8_t *dest, int line_size, DCTELEM *block);

 void ff_simple_idct_10(DCTELEM *block);

+/**

+ * Special version of ff_simple_idct_10() which does dequantization

+ * and scales by a factor of 2 more between the two IDCTs to account

+ * for larger scale of input coefficients.

+ */

+void ff_prores_idct(DCTELEM *block, const int16_t *qmat);

 void ff_simple_idct_mmx(int16_t *block);

 void ff_simple_idct_add_mmx(uint8_t *dest, int line_size, int16_t *block);

@@ -194,14 +194,16 @@ static void decode_parameters(SiprParameters* parms, GetBitContext *pgb,

 {

     int i, j;

-    parms->ma_pred_switch           = get_bits(pgb, p->ma_predictor_bits);

+    if (p->ma_predictor_bits)

+        parms->ma_pred_switch       = get_bits(pgb, p->ma_predictor_bits);

     for (i = 0; i < 5; i++)

         parms->vq_indexes[i]        = get_bits(pgb, p->vq_indexes_bits[i]);

     for (i = 0; i < p->subframe_count; i++) {

         parms->pitch_delay[i]       = get_bits(pgb, p->pitch_delay_bits[i]);

-        parms->gp_index[i]          = get_bits(pgb, p->gp_index_bits);

+        if (p->gp_index_bits)

+            parms->gp_index[i]      = get_bits(pgb, p->gp_index_bits);

         for (j = 0; j < p->number_of_fc_indexes; j++)

             parms->fc_indexes[i][j] = get_bits(pgb, p->fc_index_bits[j]);

@@ -560,6 +560,10 @@ static av_cold int decode_end(AVCodecContext *avctx)

 static av_cold int smka_decode_init(AVCodecContext *avctx)

 {

+    if (avctx->channels < 1 || avctx->channels > 2) {

+        av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");

+        return AVERROR(EINVAL);

+    }

     avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;

     avctx->sample_fmt = avctx->bits_per_coded_sample == 8 ? AV_SAMPLE_FMT_U8 : AV_SAMPLE_FMT_S16;

     return 0;

@@ -583,6 +587,11 @@ static int smka_decode_frame(AVCodecContext *avctx, void *data, int *data_size,

     int bits, stereo;

     int pred[2] = {0, 0};

+    if (buf_size <= 4) {

+        av_log(avctx, AV_LOG_ERROR, "packet is too small\n");

+        return AVERROR(EINVAL);

+    }

+

     unp_size = AV_RL32(buf);

     init_get_bits(&gb, buf + 4, (buf_size - 4) * 8);

@@ -598,6 +607,14 @@ static int smka_decode_frame(AVCodecContext *avctx, void *data, int *data_size,

         av_log(avctx, AV_LOG_ERROR, "Frame is too large to fit in buffer\n");

         return -1;

     }

+    if (stereo ^ (avctx->channels != 1)) {

+        av_log(avctx, AV_LOG_ERROR, "channels mismatch\n");

+        return AVERROR(EINVAL);

+    }

+    if (bits && avctx->sample_fmt == AV_SAMPLE_FMT_U8) {

+        av_log(avctx, AV_LOG_ERROR, "sample format mismatch\n");

+        return AVERROR(EINVAL);

+    }

     memset(vlc, 0, sizeof(VLC) * 4);

     memset(h, 0, sizeof(HuffContext) * 4);