Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 7 Dec 2011 01:04:00 +0000 (02:04 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 7 Dec 2011 01:04:00 +0000 (02:04 +0100)
* qatar/master:
  Code cleanup - mpegvideo.c - 500-1000line
  rv40: NEON optimised weighted prediction
  rv40: NEON optimised chroma MC
  ARM: move NEON H264 chroma mc to a separate file
  rv34: NEON optimised inverse transform functions

Conflicts:
libavcodec/mpegvideo.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/arm/Makefile
libavcodec/arm/h264dsp_neon.S
libavcodec/mpegvideo.c
libavcodec/rv40dsp.c

Simple merge
Simple merge
@@@ -567,47 -567,56 +567,57 @@@ int ff_mpeg_update_thread_context(AVCod
      s->input_picture_number = s1->input_picture_number;
  
      memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
-     memcpy(&s->last_picture, &s1->last_picture, (char*)&s1->last_picture_ptr - (char*)&s1->last_picture);
+     memcpy(&s->last_picture, &s1->last_picture,
+            (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
  
-     s->last_picture_ptr     = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
-     s->current_picture_ptr  = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
-     s->next_picture_ptr     = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
+     s->last_picture_ptr    = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
+     s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
+     s->next_picture_ptr    = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
  
-     memcpy(s->prev_pict_types, s1->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
+     memcpy(s->prev_pict_types, s1->prev_pict_types,
+            PREV_PICT_TYPES_BUFFER_SIZE);
  
-     //Error/bug resilience
+     // Error/bug resilience
      s->next_p_frame_damaged = s1->next_p_frame_damaged;
      s->workaround_bugs      = s1->workaround_bugs;
 +    s->padding_bug_score    = s1->padding_bug_score;
  
-     //MPEG4 timing info
-     memcpy(&s->time_increment_bits, &s1->time_increment_bits, (char*)&s1->shape - (char*)&s1->time_increment_bits);
-     //B-frame info
-     s->max_b_frames         = s1->max_b_frames;
-     s->low_delay            = s1->low_delay;
-     s->dropable             = s1->dropable;
-     //DivX handling (doesn't work)
-     s->divx_packed          = s1->divx_packed;
-     if(s1->bitstream_buffer){
-         if (s1->bitstream_buffer_size + FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
-             av_fast_malloc(&s->bitstream_buffer, &s->allocated_bitstream_buffer_size, s1->allocated_bitstream_buffer_size);
-         s->bitstream_buffer_size  = s1->bitstream_buffer_size;
-         memcpy(s->bitstream_buffer, s1->bitstream_buffer, s1->bitstream_buffer_size);
-         memset(s->bitstream_buffer+s->bitstream_buffer_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
+     // MPEG4 timing info
+     memcpy(&s->time_increment_bits, &s1->time_increment_bits,
+            (char *) &s1->shape - (char *) &s1->time_increment_bits);
+     // B-frame info
+     s->max_b_frames = s1->max_b_frames;
+     s->low_delay    = s1->low_delay;
+     s->dropable     = s1->dropable;
+     // DivX handling (doesn't work)
+     s->divx_packed  = s1->divx_packed;
+     if (s1->bitstream_buffer) {
+         if (s1->bitstream_buffer_size +
+             FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
+             av_fast_malloc(&s->bitstream_buffer,
+                            &s->allocated_bitstream_buffer_size,
+                            s1->allocated_bitstream_buffer_size);
+             s->bitstream_buffer_size = s1->bitstream_buffer_size;
+         memcpy(s->bitstream_buffer, s1->bitstream_buffer,
+                s1->bitstream_buffer_size);
+         memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
+                FF_INPUT_BUFFER_PADDING_SIZE);
      }
  
-     //MPEG2/interlacing info
-     memcpy(&s->progressive_sequence, &s1->progressive_sequence, (char*)&s1->rtp_mode - (char*)&s1->progressive_sequence);
+     // MPEG2/interlacing info
+     memcpy(&s->progressive_sequence, &s1->progressive_sequence,
+            (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
  
-     if(!s1->first_field){
-         s->last_pict_type= s1->pict_type;
-         if (s1->current_picture_ptr) s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
+     if (!s1->first_field) {
+         s->last_pict_type = s1->pict_type;
+         if (s1->current_picture_ptr)
+             s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
  
          if (s1->pict_type != AV_PICTURE_TYPE_B) {
-             s->last_non_b_pict_type= s1->pict_type;
+             s->last_non_b_pict_type = s1->pict_type;
          }
      }
  
@@@ -682,172 -700,229 +701,172 @@@ av_cold int MPV_common_init(MpegEncCont
  
      ff_dct_common_init(s);
  
-     s->flags= s->avctx->flags;
-     s->flags2= s->avctx->flags2;
+     s->flags  = s->avctx->flags;
+     s->flags2 = s->avctx->flags2;
  
-     s->mb_width  = (s->width  + 15) / 16;
-     s->mb_stride = s->mb_width + 1;
-     s->b8_stride = s->mb_width*2 + 1;
-     s->b4_stride = s->mb_width*4 + 1;
-     mb_array_size= s->mb_height * s->mb_stride;
-     mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
 -    if (s->width && s->height) {
 -        s->mb_width   = (s->width + 15) / 16;
 -        s->mb_stride  = s->mb_width + 1;
 -        s->b8_stride  = s->mb_width * 2 + 1;
 -        s->b4_stride  = s->mb_width * 4 + 1;
 -        mb_array_size = s->mb_height * s->mb_stride;
 -        mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
++    s->mb_width   = (s->width + 15) / 16;
++    s->mb_stride  = s->mb_width + 1;
++    s->b8_stride  = s->mb_width * 2 + 1;
++    s->b4_stride  = s->mb_width * 4 + 1;
++    mb_array_size = s->mb_height * s->mb_stride;
++    mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
  
 -        /* set chroma shifts */
 -        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
 -                                      &(s->chroma_y_shift) );
 +    /* set chroma shifts */
 +    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
 +                                                    &(s->chroma_y_shift) );
  
 -        /* set default edge pos, will be overriden
 -         * in decode_header if needed */
 -        s->h_edge_pos = s->mb_width * 16;
 -        s->v_edge_pos = s->mb_height * 16;
 +    /* set default edge pos, will be overriden in decode_header if needed */
-     s->h_edge_pos= s->mb_width*16;
-     s->v_edge_pos= s->mb_height*16;
++    s->h_edge_pos = s->mb_width * 16;
++    s->v_edge_pos = s->mb_height * 16;
  
 -        s->mb_num     = s->mb_width * s->mb_height;
 +    s->mb_num = s->mb_width * s->mb_height;
  
-     s->block_wrap[0]=
-     s->block_wrap[1]=
-     s->block_wrap[2]=
-     s->block_wrap[3]= s->b8_stride;
-     s->block_wrap[4]=
-     s->block_wrap[5]= s->mb_stride;
 -        s->block_wrap[0] =
 -        s->block_wrap[1] =
 -        s->block_wrap[2] =
 -        s->block_wrap[3] = s->b8_stride;
 -        s->block_wrap[4] =
 -        s->block_wrap[5] = s->mb_stride;
++    s->block_wrap[0] =
++    s->block_wrap[1] =
++    s->block_wrap[2] =
++    s->block_wrap[3] = s->b8_stride;
++    s->block_wrap[4] =
++    s->block_wrap[5] = s->mb_stride;
  
 -        y_size  = s->b8_stride * (2 * s->mb_height + 1);
 -        c_size  = s->mb_stride * (s->mb_height + 1);
 -        yc_size = y_size + 2   * c_size;
 +    y_size = s->b8_stride * (2 * s->mb_height + 1);
 +    c_size = s->mb_stride * (s->mb_height + 1);
 +    yc_size = y_size + 2 * c_size;
  
 -        /* convert fourcc to upper case */
 -        s->codec_tag          = avpriv_toupper4(s->avctx->codec_tag);
 +    /* convert fourcc to upper case */
 +    s->codec_tag        = avpriv_toupper4(s->avctx->codec_tag);
 +    s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
  
-     s->avctx->coded_frame= (AVFrame*)&s->current_picture;
 -        s->stream_codec_tag   = avpriv_toupper4(s->avctx->stream_codec_tag);
++    s->avctx->coded_frame = (AVFrame*)&s->current_picture;
  
-     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num+1)*sizeof(int), fail) //error ressilience code looks cleaner with this
-     for(y=0; y<s->mb_height; y++){
-         for(x=0; x<s->mb_width; x++){
-             s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
-         }
-     }
-     s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
 -        s->avctx->coded_frame = (AVFrame *)&s->current_picture;
++    FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
++    for (y = 0; y < s->mb_height; y++)
++        for (x = 0; x < s->mb_width; x++)
++            s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
 -        FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
 -                          fail); // error ressilience code looks cleaner with this
 -        for (y = 0; y < s->mb_height; y++)
 -            for (x = 0; x < s->mb_width; x++)
 -                s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
++    s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
  
 -        s->mb_index2xy[s->mb_height * s->mb_width] =
 -                       (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
 +    if (s->encoding) {
 +        /* Allocate MV tables */
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t), fail)
 +        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
 +        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
 +        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
 +        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
 +        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
 +        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
 +
 +        if(s->msmpeg4_version){
 +            FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
 +        }
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
  
 -        if (s->encoding) {
 -            /* Allocate MV tables */
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,
 -                              mv_table_size * 2 * sizeof(int16_t), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,
 -                              mv_table_size * 2 * sizeof(int16_t), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,
 -                              mv_table_size * 2 * sizeof(int16_t), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,
 -                              mv_table_size * 2 * sizeof(int16_t), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,
 -                              mv_table_size * 2 * sizeof(int16_t), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,
 -                              mv_table_size * 2 * sizeof(int16_t), fail);
 -            s->p_mv_table            = s->p_mv_table_base +
 -                                       s->mb_stride + 1;
 -            s->b_forw_mv_table       = s->b_forw_mv_table_base +
 -                                       s->mb_stride + 1;
 -            s->b_back_mv_table       = s->b_back_mv_table_base +
 -                                       s->mb_stride + 1;
 -            s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base +
 -                                       s->mb_stride + 1;
 -            s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base +
 -                                       s->mb_stride + 1;
 -            s->b_direct_mv_table     = s->b_direct_mv_table_base +
 -                                       s->mb_stride + 1;
 -
 -            if (s->msmpeg4_version) {
 -                FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
 -                                  2 * 2 * (MAX_LEVEL + 1) *
 -                                  (MAX_RUN + 1) * 2 * sizeof(int), fail);
 -            }
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
 -
 -            /* Allocate MB type table */
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size *
 -                              sizeof(uint16_t), fail); // needed for encoding
 -
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size *
 -                              sizeof(int), fail);
 -
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix,
 -                              64 * 32   * sizeof(int), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix,
 -                              64 * 32   * sizeof(int), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16,
 -                              64 * 32 * 2 * sizeof(uint16_t), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16,
 -                              64 * 32 * 2 * sizeof(uint16_t), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
 -                              MAX_PICTURE_COUNT * sizeof(Picture *), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
 -                              MAX_PICTURE_COUNT * sizeof(Picture *), fail);
 -
 -            if (s->avctx->noise_reduction) {
 -                FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
 -                                  2 * 64 * sizeof(uint16_t), fail);
 -            }
 +        /* Allocate MB type table */
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type  , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
 +
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
 +
-         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix  , 64*32   * sizeof(int), fail)
++        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix         , 64*32   * sizeof(int), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix  , 64*32   * sizeof(int), fail)
-         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix  , 64*32   * sizeof(int), fail)
-         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
++        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix         , 64*32   * sizeof(int), fail)
++        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16       , 64*32*2 * sizeof(uint16_t), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
-         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t), fail)
++        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16       , 64*32*2 * sizeof(uint16_t), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
 +        FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
 +
 +        if(s->avctx->noise_reduction){
 +            FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
          }
      }
  
      s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
-     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, s->picture_count * sizeof(Picture), fail)
-     for(i = 0; i < s->picture_count; i++) {
-         avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
+     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
+                       s->picture_count * sizeof(Picture), fail);
+     for (i = 0; i < s->picture_count; i++) {
+         avcodec_get_frame_defaults((AVFrame *) &s->picture[i]);
      }
  
 -    if (s->width && s->height) {
 -        FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table,
 -                          mb_array_size * sizeof(uint8_t), fail);
 +    FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
  
-     if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
-         /* interlaced direct mode decoding tables */
-             for(i=0; i<2; i++){
 -        if (s->codec_id == CODEC_ID_MPEG4 ||
 -            (s->flags & CODEC_FLAG_INTERLACED_ME)) {
++        if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
+             /* interlaced direct mode decoding tables */
+             for (i = 0; i < 2; i++) {
                  int j, k;
-                 for(j=0; j<2; j++){
-                     for(k=0; k<2; k++){
-                         FF_ALLOCZ_OR_GOTO(s->avctx,    s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
+                 for (j = 0; j < 2; j++) {
+                     for (k = 0; k < 2; k++) {
 -                        FF_ALLOCZ_OR_GOTO(s->avctx,
 -                                          s->b_field_mv_table_base[i][j][k],
 -                                          mv_table_size * 2 * sizeof(int16_t),
 -                                          fail);
 -                        s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
 -                                                       s->mb_stride + 1;
++                        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_mv_table_base[i][j][k],  mv_table_size * 2 * sizeof(int16_t), fail)
 +                        s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
                      }
 -                    FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j],
 -                                      mb_array_size * 2 * sizeof(uint8_t),
 -                                      fail);
 -                    FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j],
 -                                      mv_table_size * 2 * sizeof(int16_t),
 -                                      fail);
 -                    s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]
 -                                                + s->mb_stride + 1;
 +                    FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
 +                    FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
-                     s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]+ s->mb_stride + 1;
++                    s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
                  }
 -                FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i],
 -                                  mb_array_size * 2 * sizeof(uint8_t),
 -                                  fail);
 +                FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
              }
-     }
-     if (s->out_format == FMT_H263) {
-         /* cbp values */
-         FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
-         s->coded_block= s->coded_block_base + s->b8_stride + 1;
-         /* cbp, ac_pred, pred_dir */
-         FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail)
-         FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail)
-     }
+         }
+         if (s->out_format == FMT_H263) {
+             /* cbp values */
+             FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
+             s->coded_block = s->coded_block_base + s->b8_stride + 1;
+             /* cbp, ac_pred, pred_dir */
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table,
 -                              mb_array_size * sizeof(uint8_t), fail);
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table,
 -                              mb_array_size * sizeof(uint8_t), fail);
++            FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail);
++            FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
+         }
  
-     if (s->h263_pred || s->h263_plus || !s->encoding) {
-         /* dc values */
-         //MN: we need these for error resilience of intra-frames
-         FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
-         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
-         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
-         s->dc_val[2] = s->dc_val[1] + c_size;
-         for(i=0;i<yc_size;i++)
-             s->dc_val_base[i] = 1024;
-     }
+         if (s->h263_pred || s->h263_plus || !s->encoding) {
+             /* dc values */
+             // MN: we need these for  error resilience of intra-frames
 -            FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base,
 -                              yc_size * sizeof(int16_t), fail);
++            FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
+             s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
+             s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
+             s->dc_val[2] = s->dc_val[1] + c_size;
+             for (i = 0; i < yc_size; i++)
+                 s->dc_val_base[i] = 1024;
+         }
  
-     /* which mb is a intra block */
-     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
-     memset(s->mbintra_table, 1, mb_array_size);
+         /* which mb is a intra block */
+         FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
+         memset(s->mbintra_table, 1, mb_array_size);
  
-     /* init macroblock skip table */
-     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size+2, fail);
-     //Note the +1 is for a quicker mpeg4 slice_end detection
-     FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE, fail);
+         /* init macroblock skip table */
+         FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
+         // Note the + 1 is for  a quicker mpeg4 slice_end detection
 -        FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types,
 -                          PREV_PICT_TYPES_BUFFER_SIZE, fail);
++        FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE, fail);
  
-     s->parse_context.state= -1;
-     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
-        s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
-        s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
-        s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
-     }
+         s->parse_context.state = -1;
 -        if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
 -            (s->avctx->debug_mv)) {
 -            s->visualization_buffer[0] = av_malloc((s->mb_width * 16 +
 -                        2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
 -            s->visualization_buffer[1] = av_malloc((s->mb_width * 16 +
 -                        2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
 -            s->visualization_buffer[2] = av_malloc((s->mb_width * 16 +
 -                        2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
++        if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)) {
++            s->visualization_buffer[0] = av_malloc((s->mb_width * 16 + 2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
++            s->visualization_buffer[1] = av_malloc((s->mb_width * 16 + 2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
++            s->visualization_buffer[2] = av_malloc((s->mb_width * 16 + 2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
+         }
 -    }
  
--    s->context_initialized = 1;
-     s->thread_context[0]= s;
 -    s->thread_context[0]   = s;
++        s->context_initialized = 1;
++        s->thread_context[0]   = s;
  
-     if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE)) {
-         for(i=1; i<threads; i++){
-             s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
-             memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
-         }
 -    if (s->width && s->height) {
 -        if (s->encoding || (HAVE_THREADS &&
 -                            s->avctx->active_thread_type&FF_THREAD_SLICE)) {
++        if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE)) {
+             for (i = 1; i < threads; i++) {
+                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
+                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
+             }
  
-         for(i=0; i<threads; i++){
-             if(init_duplicate_context(s->thread_context[i], s) < 0)
+             for (i = 0; i < threads; i++) {
+                 if (init_duplicate_context(s->thread_context[i], s) < 0)
+                     goto fail;
 -                    s->thread_context[i]->start_mb_y =
 -                        (s->mb_height * (i) + s->avctx->thread_count / 2) /
 -                        s->avctx->thread_count;
 -                    s->thread_context[i]->end_mb_y   =
 -                        (s->mb_height * (i + 1) + s->avctx->thread_count / 2) /
 -                        s->avctx->thread_count;
++                s->thread_context[i]->start_mb_y = (s->mb_height*(i  ) + s->avctx->thread_count / 2) / s->avctx->thread_count;
++                s->thread_context[i]->end_mb_y   = (s->mb_height*(i+1) + s->avctx->thread_count / 2) / s->avctx->thread_count;
+             }
+         } else {
+             if (init_duplicate_context(s, s) < 0)
                  goto fail;
-             s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
-             s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
+             s->start_mb_y = 0;
+             s->end_mb_y   = s->mb_height;
          }
-     } else {
-         if(init_duplicate_context(s, s) < 0) goto fail;
-         s->start_mb_y = 0;
-         s->end_mb_y   = s->mb_height;
--    }
  
      return 0;
   fail:
@@@ -860,11 -935,12 +879,11 @@@ void MPV_common_end(MpegEncContext *s
  {
      int i, j, k;
  
-     if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE)) {
-         for(i=0; i<s->avctx->thread_count; i++){
 -    if (s->encoding || (HAVE_THREADS &&
 -        s->avctx->active_thread_type & FF_THREAD_SLICE)) {
++    if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type & FF_THREAD_SLICE)) {
+         for (i = 0; i < s->avctx->thread_count; i++) {
              free_duplicate_context(s->thread_context[i]);
          }
-         for(i=1; i<s->avctx->thread_count; i++){
+         for (i = 1; i < s->avctx->thread_count; i++) {
              av_freep(&s->thread_context[i]);
          }
      } else free_duplicate_context(s);
Simple merge