Merge commit '5c4b98de4d101ea715ef86847306a510afd0db0c'
[ffmpeg.git] / libavcodec / h264.c
index 1849cc3..dd324a9 100644 (file)
@@ -66,9 +66,9 @@ static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
     H264Context *h = opaque;
     H264SliceContext *sl = &h->slice_ctx[0];
 
-    h->mb_x  = mb_x;
-    h->mb_y  = mb_y;
-    h->mb_xy = mb_x + mb_y * h->mb_stride;
+    sl->mb_x = mb_x;
+    sl->mb_y = mb_y;
+    sl->mb_xy = mb_x + mb_y * h->mb_stride;
     memset(sl->non_zero_count_cache, 0, sizeof(sl->non_zero_count_cache));
     av_assert1(ref >= 0);
     /* FIXME: It is possible albeit uncommon that slice references
@@ -85,21 +85,21 @@ static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
         av_log(h->avctx, AV_LOG_DEBUG, "Reference invalid\n");
         return;
     }
-    fill_rectangle(&h->cur_pic.ref_index[0][4 * h->mb_xy],
+    fill_rectangle(&h->cur_pic.ref_index[0][4 * sl->mb_xy],
                    2, 2, 2, ref, 1);
     fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
     fill_rectangle(sl->mv_cache[0][scan8[0]], 4, 4, 8,
                    pack16to32((*mv)[0][0][0], (*mv)[0][0][1]), 4);
-    h->mb_mbaff =
-    h->mb_field_decoding_flag = 0;
+    sl->mb_mbaff =
+    sl->mb_field_decoding_flag = 0;
     ff_h264_hl_decode_mb(h, &h->slice_ctx[0]);
 }
 
-void ff_h264_draw_horiz_band(H264Context *h, H264SliceContext *sl,
+void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl,
                              int y, int height)
 {
     AVCodecContext *avctx = h->avctx;
-    AVFrame *cur  = &h->cur_pic.f;
+    const AVFrame   *cur  = &h->cur_pic.f;
     AVFrame *last = sl->ref_list[0][0].f.data[0] ? &sl->ref_list[0][0].f : NULL;
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
     int vshift = desc->log2_chroma_h;
@@ -115,7 +115,7 @@ void ff_h264_draw_horiz_band(H264Context *h, H264SliceContext *sl,
         return;
 
     if (avctx->draw_horiz_band) {
-        AVFrame *src;
+        const AVFrame *src;
         int offset[AV_NUM_DATA_POINTERS];
         int i;
 
@@ -144,7 +144,7 @@ void ff_h264_draw_horiz_band(H264Context *h, H264SliceContext *sl,
  * Check if the top & left blocks are available if needed and
  * change the dc mode so it only uses the available blocks.
  */
-int ff_h264_check_intra4x4_pred_mode(H264Context *h, H264SliceContext *sl)
+int ff_h264_check_intra4x4_pred_mode(const H264Context *h, H264SliceContext *sl)
 {
     static const int8_t top[12] = {
         -1, 0, LEFT_DC_PRED, -1, -1, -1, -1, -1, 0
@@ -160,7 +160,7 @@ int ff_h264_check_intra4x4_pred_mode(H264Context *h, H264SliceContext *sl)
             if (status < 0) {
                 av_log(h->avctx, AV_LOG_ERROR,
                        "top block unavailable for requested intra4x4 mode %d at %d %d\n",
-                       status, h->mb_x, h->mb_y);
+                       status, sl->mb_x, sl->mb_y);
                 return AVERROR_INVALIDDATA;
             } else if (status) {
                 sl->intra4x4_pred_mode_cache[scan8[0] + i] = status;
@@ -176,7 +176,7 @@ int ff_h264_check_intra4x4_pred_mode(H264Context *h, H264SliceContext *sl)
                 if (status < 0) {
                     av_log(h->avctx, AV_LOG_ERROR,
                            "left block unavailable for requested intra4x4 mode %d at %d %d\n",
-                           status, h->mb_x, h->mb_y);
+                           status, sl->mb_x, sl->mb_y);
                     return AVERROR_INVALIDDATA;
                 } else if (status) {
                     sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i] = status;
@@ -191,7 +191,7 @@ int ff_h264_check_intra4x4_pred_mode(H264Context *h, H264SliceContext *sl)
  * Check if the top & left blocks are available if needed and
  * change the dc mode so it only uses the available blocks.
  */
-int ff_h264_check_intra_pred_mode(H264Context *h, H264SliceContext *sl,
+int ff_h264_check_intra_pred_mode(const H264Context *h, H264SliceContext *sl,
                                   int mode, int is_chroma)
 {
     static const int8_t top[4]  = { LEFT_DC_PRED8x8, 1, -1, -1 };
@@ -200,7 +200,7 @@ int ff_h264_check_intra_pred_mode(H264Context *h, H264SliceContext *sl,
     if (mode > 3U) {
         av_log(h->avctx, AV_LOG_ERROR,
                "out of range intra chroma pred mode at %d %d\n",
-               h->mb_x, h->mb_y);
+               sl->mb_x, sl->mb_y);
         return AVERROR_INVALIDDATA;
     }
 
@@ -209,7 +209,7 @@ int ff_h264_check_intra_pred_mode(H264Context *h, H264SliceContext *sl,
         if (mode < 0) {
             av_log(h->avctx, AV_LOG_ERROR,
                    "top block unavailable for requested intra mode at %d %d\n",
-                   h->mb_x, h->mb_y);
+                   sl->mb_x, sl->mb_y);
             return AVERROR_INVALIDDATA;
         }
     }
@@ -219,7 +219,7 @@ int ff_h264_check_intra_pred_mode(H264Context *h, H264SliceContext *sl,
         if (mode < 0) {
             av_log(h->avctx, AV_LOG_ERROR,
                    "left block unavailable for requested intra mode at %d %d\n",
-                   h->mb_x, h->mb_y);
+                   sl->mb_x, sl->mb_y);
             return AVERROR_INVALIDDATA;
         }
         if (is_chroma && (sl->left_samples_available & 0x8080)) {
@@ -238,7 +238,6 @@ const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src,
 {
     int i, si, di;
     uint8_t *dst;
-    int bufidx;
 
     // src[0]&0x80; // forbidden bit
     h->nal_ref_idc   = src[0] >> 5;
@@ -294,11 +293,8 @@ const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src,
     }
 #endif
 
-    // use second escape buffer for inter data
-    bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0;
-
-    av_fast_padded_malloc(&h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+MAX_MBPAIR_SIZE);
-    dst = h->rbsp_buffer[bufidx];
+    av_fast_padded_malloc(&h->rbsp_buffer, &h->rbsp_buffer_size, length+MAX_MBPAIR_SIZE);
+    dst = h->rbsp_buffer;
 
     if (!dst)
         return NULL;
@@ -417,10 +413,8 @@ void ff_h264_free_tables(H264Context *h, int free_rbsp)
         av_freep(&hx->er.mbskip_table);
 
         if (free_rbsp) {
-            av_freep(&hx->rbsp_buffer[1]);
-            av_freep(&hx->rbsp_buffer[0]);
-            hx->rbsp_buffer_size[0] = 0;
-            hx->rbsp_buffer_size[1] = 0;
+            av_freep(&hx->rbsp_buffer);
+            hx->rbsp_buffer_size = 0;
         }
         if (i)
             av_freep(&h->thread_context[i]);
@@ -449,6 +443,9 @@ int ff_h264_alloc_tables(H264Context *h)
                       row_mb_num, 16 * sizeof(uint8_t), fail);
     FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[1],
                       row_mb_num, 16 * sizeof(uint8_t), fail);
+    h->slice_ctx[0].mvd_table[0] = h->mvd_table[0];
+    h->slice_ctx[0].mvd_table[1] = h->mvd_table[1];
+
     FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table,
                       4 * big_mb_num * sizeof(uint8_t), fail);
     FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts,
@@ -751,10 +748,8 @@ static int decode_init_thread_copy(AVCodecContext *avctx)
         h->slice_ctx[i].h264 = h;
 
     h->avctx               = avctx;
-    h->rbsp_buffer[0]      = NULL;
-    h->rbsp_buffer[1]      = NULL;
-    h->rbsp_buffer_size[0] = 0;
-    h->rbsp_buffer_size[1] = 0;
+    h->rbsp_buffer         = NULL;
+    h->rbsp_buffer_size    = 0;
     h->context_initialized = 0;
 
     return 0;
@@ -1015,9 +1010,9 @@ int ff_pred_weight_table(H264Context *h, H264SliceContext *sl)
 
     sl->use_weight             = 0;
     sl->use_weight_chroma      = 0;
-    sl->luma_log2_weight_denom = get_ue_golomb(&h->gb);
+    sl->luma_log2_weight_denom = get_ue_golomb(&sl->gb);
     if (h->sps.chroma_format_idc)
-        sl->chroma_log2_weight_denom = get_ue_golomb(&h->gb);
+        sl->chroma_log2_weight_denom = get_ue_golomb(&sl->gb);
 
     if (sl->luma_log2_weight_denom > 7U) {
         av_log(h->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is out of range\n", sl->luma_log2_weight_denom);
@@ -1037,10 +1032,10 @@ int ff_pred_weight_table(H264Context *h, H264SliceContext *sl)
         for (i = 0; i < sl->ref_count[list]; i++) {
             int luma_weight_flag, chroma_weight_flag;
 
-            luma_weight_flag = get_bits1(&h->gb);
+            luma_weight_flag = get_bits1(&sl->gb);
             if (luma_weight_flag) {
-                sl->luma_weight[i][list][0] = get_se_golomb(&h->gb);
-                sl->luma_weight[i][list][1] = get_se_golomb(&h->gb);
+                sl->luma_weight[i][list][0] = get_se_golomb(&sl->gb);
+                sl->luma_weight[i][list][1] = get_se_golomb(&sl->gb);
                 if (sl->luma_weight[i][list][0] != luma_def ||
                     sl->luma_weight[i][list][1] != 0) {
                     sl->use_weight             = 1;
@@ -1052,12 +1047,12 @@ int ff_pred_weight_table(H264Context *h, H264SliceContext *sl)
             }
 
             if (h->sps.chroma_format_idc) {
-                chroma_weight_flag = get_bits1(&h->gb);
+                chroma_weight_flag = get_bits1(&sl->gb);
                 if (chroma_weight_flag) {
                     int j;
                     for (j = 0; j < 2; j++) {
-                        sl->chroma_weight[i][list][j][0] = get_se_golomb(&h->gb);
-                        sl->chroma_weight[i][list][j][1] = get_se_golomb(&h->gb);
+                        sl->chroma_weight[i][list][j][0] = get_se_golomb(&sl->gb);
+                        sl->chroma_weight[i][list][j][1] = get_se_golomb(&sl->gb);
                         if (sl->chroma_weight[i][list][j][0] != chroma_def ||
                             sl->chroma_weight[i][list][j][1] != 0) {
                             sl->use_weight_chroma        = 1;
@@ -1140,7 +1135,7 @@ static void flush_dpb(AVCodecContext *avctx)
     h->cur_pic_ptr = NULL;
     ff_h264_unref_picture(h, &h->cur_pic);
 
-    h->mb_x = h->mb_y = 0;
+    h->mb_y = 0;
 
     ff_h264_free_tables(h, 1);
     h->context_initialized = 0;
@@ -1312,13 +1307,13 @@ int ff_set_ref_count(H264Context *h, H264SliceContext *sl)
         max[0] = max[1] = h->picture_structure == PICT_FRAME ? 15 : 31;
 
         if (sl->slice_type_nos == AV_PICTURE_TYPE_B)
-            sl->direct_spatial_mv_pred = get_bits1(&h->gb);
-        num_ref_idx_active_override_flag = get_bits1(&h->gb);
+            sl->direct_spatial_mv_pred = get_bits1(&sl->gb);
+        num_ref_idx_active_override_flag = get_bits1(&sl->gb);
 
         if (num_ref_idx_active_override_flag) {
-            ref_count[0] = get_ue_golomb(&h->gb) + 1;
+            ref_count[0] = get_ue_golomb(&sl->gb) + 1;
             if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
-                ref_count[1] = get_ue_golomb(&h->gb) + 1;
+                ref_count[1] = get_ue_golomb(&sl->gb) + 1;
             } else
                 // full range is spec-ok in this case, even for frames
                 ref_count[1] = 1;
@@ -1382,6 +1377,7 @@ static int get_last_needed_nal(H264Context *h, const uint8_t *buf, int buf_size)
     int first_slice = 0;
 
     while(1) {
+        GetBitContext gb;
         int nalsize = 0;
         int dst_length, bit_length, consumed;
         const uint8_t *ptr;
@@ -1423,8 +1419,8 @@ static int get_last_needed_nal(H264Context *h, const uint8_t *buf, int buf_size)
         case NAL_DPA:
         case NAL_IDR_SLICE:
         case NAL_SLICE:
-            init_get_bits(&h->gb, ptr, bit_length);
-            if (!get_ue_golomb(&h->gb) ||
+            init_get_bits(&gb, ptr, bit_length);
+            if (!get_ue_golomb(&gb) ||
                 !first_slice ||
                 first_slice != h->nal_unit_type)
                 nals_needed = nal_index;
@@ -1573,9 +1569,7 @@ again:
                 idr_cleared = 1;
                 h->has_recovery_point = 1;
             case NAL_SLICE:
-                init_get_bits(&hx->gb, ptr, bit_length);
-                hx->intra_gb_ptr      =
-                hx->inter_gb_ptr      = &hx->gb;
+                init_get_bits(&sl->gb, ptr, bit_length);
 
                 if ((err = ff_h264_decode_slice_header(hx, sl, h)))
                     break;
@@ -1626,7 +1620,7 @@ again:
                         ff_vdpau_h264_picture_start(h);
                 }
 
-                if (hx->redundant_pic_count == 0) {
+                if (sl->redundant_pic_count == 0) {
                     if (avctx->hwaccel) {
                         ret = avctx->hwaccel->decode_slice(avctx,
                                                            &buf[buf_index - consumed],