Merge commit 'd4d9068cdf8f4b2b87ae87a2ef880d243f77b977'
authorMichael Niedermayer <michaelni@gmx.at>
Sat, 21 Mar 2015 15:25:04 +0000 (16:25 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Sat, 21 Mar 2015 15:46:15 +0000 (16:46 +0100)
* commit 'd4d9068cdf8f4b2b87ae87a2ef880d243f77b977':
  h264: move mb_{x,y} into the per-slice context

Conflicts:
libavcodec/h264.c
libavcodec/h264_cavlc.c
libavcodec/h264_mb.c
libavcodec/h264_slice.c
libavcodec/svq3.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
13 files changed:
1  2 
libavcodec/dxva2_h264.c
libavcodec/h264.c
libavcodec/h264.h
libavcodec/h264_cabac.c
libavcodec/h264_cavlc.c
libavcodec/h264_direct.c
libavcodec/h264_mb.c
libavcodec/h264_mb_template.c
libavcodec/h264_mc_template.c
libavcodec/h264_mvpred.h
libavcodec/h264_slice.c
libavcodec/svq3.c
libavcodec/vaapi_h264.c

Simple merge
@@@ -66,11 -58,11 +66,11 @@@ static void h264_er_decode_mb(void *opa
      H264Context *h = opaque;
      H264SliceContext *sl = &h->slice_ctx[0];
  
-     h->mb_x  = mb_x;
-     h->mb_y  = mb_y;
+     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));
 -    assert(ref >= 0);
 +    av_assert1(ref >= 0);
      /* FIXME: It is possible albeit uncommon that slice references
       * differ between slices. We take the easy approach and ignore
       * it for now. If this turns out to have any relevance in
@@@ -219,15 -202,15 +219,15 @@@ int ff_h264_check_intra_pred_mode(H264C
          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)) {
 +            // mad cow disease mode, aka MBAFF + constrained_intra_pred
 +            mode = ALZHEIMER_DC_L0T_PRED8x8 +
 +                   (!(sl->left_samples_available & 0x8000)) +
 +                   2 * (mode == DC_128_PRED8x8);
 +        }
      }
  
      return mode;
Simple merge
@@@ -1915,11 -1913,10 +1915,11 @@@ int ff_h264_decode_mb_cabac(H264Contex
      int dct8x8_allowed= h->pps.transform_8x8_mode;
      int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
      const int pixel_shift = h->pixel_shift;
 +    unsigned local_ref_count[2];
  
-     mb_xy = sl->mb_xy = h->mb_x + h->mb_y*h->mb_stride;
+     mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
  
-     tprintf(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, h->mb_x, h->mb_y);
+     tprintf(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, sl->mb_x, sl->mb_y);
      if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
          int skip;
          /* a skipped mb needs the aff flag from the following mb */
@@@ -627,11 -625,6 +627,11 @@@ static int decode_residual(H264Context 
          STORE_BLOCK(int16_t)
      }
  
-         av_log(h->avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", h->mb_x, h->mb_y);
 +    if(zeros_left<0){
++        av_log(h->avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", sl->mb_x, sl->mb_y);
 +        return -1;
 +    }
 +
      return 0;
  }
  
@@@ -709,19 -702,18 +709,19 @@@ int ff_h264_decode_mb_cavlc(H264Contex
      int dct8x8_allowed= h->pps.transform_8x8_mode;
      int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
      const int pixel_shift = h->pixel_shift;
 +    unsigned local_ref_count[2];
  
-     mb_xy = sl->mb_xy = h->mb_x + h->mb_y*h->mb_stride;
+     mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
  
-     tprintf(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, h->mb_x, h->mb_y);
+     tprintf(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, sl->mb_x, sl->mb_y);
      cbp = 0; /* avoid warning. FIXME: find a solution without slowing
                  down the code */
      if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
          if (sl->mb_skip_run == -1)
 -            sl->mb_skip_run = get_ue_golomb(&h->gb);
 +            sl->mb_skip_run = get_ue_golomb_long(&h->gb);
  
          if (sl->mb_skip_run--) {
-             if(FRAME_MBAFF(h) && (h->mb_y&1) == 0){
+             if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
                  if (sl->mb_skip_run == 0)
                      h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&h->gb);
              }
Simple merge
@@@ -488,18 -482,20 +488,18 @@@ static av_always_inline void prefetch_m
       * optimized for 64byte cache lines */
      const int refn = sl->ref_cache[list][scan8[0]];
      if (refn >= 0) {
-         const int mx  = (sl->mv_cache[list][scan8[0]][0] >> 2) + 16 * h->mb_x + 8;
-         const int my  = (sl->mv_cache[list][scan8[0]][1] >> 2) + 16 * h->mb_y;
+         const int mx  = (sl->mv_cache[list][scan8[0]][0] >> 2) + 16 * sl->mb_x + 8;
+         const int my  = (sl->mv_cache[list][scan8[0]][1] >> 2) + 16 * sl->mb_y;
          uint8_t **src = sl->ref_list[list][refn].f.data;
 -        int off       = (mx << pixel_shift) +
 +        int off       =  mx * (1<< pixel_shift) +
-                         (my + (h->mb_x & 3) * 4) * sl->mb_linesize +
+                         (my + (sl->mb_x & 3) * 4) * sl->mb_linesize +
                          (64 << pixel_shift);
          h->vdsp.prefetch(src[0] + off, h->linesize, 4);
          if (chroma_idc == 3 /* yuv444 */) {
              h->vdsp.prefetch(src[1] + off, h->linesize, 4);
              h->vdsp.prefetch(src[2] + off, h->linesize, 4);
          } else {
-             off= ((mx>>1)+64) * (1<<pixel_shift) + ((my>>1) + (h->mb_x&7))*h->uvlinesize;
 -            off = ((mx >> 1) << pixel_shift) +
 -                  ((my >> 1) + (sl->mb_x & 7)) * h->uvlinesize +
 -                  (64 << pixel_shift);
++            off= ((mx>>1)+64) * (1<<pixel_shift) + ((my>>1) + (sl->mb_x&7))*h->uvlinesize;
              h->vdsp.prefetch(src[1] + off, src[2] - src[1], 2);
          }
      }
@@@ -562,12 -558,14 +562,12 @@@ static av_always_inline void xchg_mb_bo
          }
          XCHG(top_border + (0 << pixel_shift), src_y + (1 << pixel_shift), xchg);
          XCHG(top_border + (8 << pixel_shift), src_y + (9 << pixel_shift), 1);
-         if (h->mb_x + 1 < h->mb_width) {
-             XCHG(h->top_borders[top_idx][h->mb_x + 1],
+         if (sl->mb_x + 1 < h->mb_width) {
+             XCHG(h->top_borders[top_idx][sl->mb_x + 1],
                   src_y + (17 << pixel_shift), 1);
          }
 -    }
 -    if (simple || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) {
 -        if (chroma444) {
 -            if (deblock_top) {
 +        if (simple || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) {
 +            if (chroma444) {
                  if (deblock_topleft) {
                      XCHG(top_border_m1 + (24 << pixel_shift), src_cb - (7 << pixel_shift), 1);
                      XCHG(top_border_m1 + (40 << pixel_shift), src_cr - (7 << pixel_shift), 1);
                  XCHG(top_border + (24 << pixel_shift), src_cb + (9 << pixel_shift), 1);
                  XCHG(top_border + (32 << pixel_shift), src_cr + (1 << pixel_shift), xchg);
                  XCHG(top_border + (40 << pixel_shift), src_cr + (9 << pixel_shift), 1);
-                 if (h->mb_x + 1 < h->mb_width) {
-                     XCHG(h->top_borders[top_idx][h->mb_x + 1] + (16 << pixel_shift), src_cb + (17 << pixel_shift), 1);
-                     XCHG(h->top_borders[top_idx][h->mb_x + 1] + (32 << pixel_shift), src_cr + (17 << pixel_shift), 1);
+                 if (sl->mb_x + 1 < h->mb_width) {
+                     XCHG(h->top_borders[top_idx][sl->mb_x + 1] + (16 << pixel_shift), src_cb + (17 << pixel_shift), 1);
+                     XCHG(h->top_borders[top_idx][sl->mb_x + 1] + (32 << pixel_shift), src_cr + (17 << pixel_shift), 1);
                  }
 -            }
 -        } else {
 -            if (deblock_top) {
 +            } else {
                  if (deblock_topleft) {
                      XCHG(top_border_m1 + (16 << pixel_shift), src_cb - (7 << pixel_shift), 1);
                      XCHG(top_border_m1 + (24 << pixel_shift), src_cr - (7 << pixel_shift), 1);
@@@ -676,7 -671,7 +676,7 @@@ static av_always_inline void hl_decode_
                      uint64_t tr_high;
                      if (dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED) {
                          const int topright_avail = (sl->topright_samples_available << i) & 0x8000;
-                         av_assert2(h->mb_y || linesize <= block_offset[i]);
 -                        assert(sl->mb_y || linesize <= block_offset[i]);
++                        av_assert2(sl->mb_y || linesize <= block_offset[i]);
                          if (!topright_avail) {
                              if (pixel_shift) {
                                  tr_high  = ((uint16_t *)ptr)[3 - linesize / 2] * 0x0001000100010001ULL;
Simple merge
Simple merge
Simple merge
@@@ -1755,12 -1557,12 +1756,12 @@@ int ff_h264_decode_slice_header(H264Con
          av_log(h->avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
          return AVERROR_INVALIDDATA;
      }
-     h->resync_mb_x = h->mb_x =  first_mb_in_slice % h->mb_width;
-     h->resync_mb_y = h->mb_y = (first_mb_in_slice / h->mb_width) <<
+     h->resync_mb_x = sl->mb_x =  first_mb_in_slice % h->mb_width;
+     h->resync_mb_y = sl->mb_y = (first_mb_in_slice / h->mb_width) <<
                                 FIELD_OR_MBAFF_PICTURE(h);
      if (h->picture_structure == PICT_BOTTOM_FIELD)
-         h->resync_mb_y = h->mb_y = h->mb_y + 1;
-     av_assert1(h->mb_y < h->mb_height);
+         h->resync_mb_y = sl->mb_y = sl->mb_y + 1;
 -    assert(sl->mb_y < h->mb_height);
++    av_assert1(sl->mb_y < h->mb_height);
  
      if (h->picture_structure == PICT_FRAME) {
          h->curr_pic_num = h->frame_num;
@@@ -2452,21 -2224,19 +2453,21 @@@ static int decode_slice(struct AVCodecC
  
              if ((h->workaround_bugs & FF_BUG_TRUNCATED) &&
                  sl->cabac.bytestream > sl->cabac.bytestream_end + 2) {
-                 er_add_slice(h, sl, h->resync_mb_x, h->resync_mb_y, h->mb_x - 1,
-                              h->mb_y, ER_MB_END);
-                 if (h->mb_x >= lf_x_start)
-                     loop_filter(h, sl, lf_x_start, h->mb_x + 1);
+                 er_add_slice(h, sl, h->resync_mb_x, h->resync_mb_y, sl->mb_x - 1,
+                              sl->mb_y, ER_MB_END);
+                 if (sl->mb_x >= lf_x_start)
+                     loop_filter(h, sl, lf_x_start, sl->mb_x + 1);
                  return 0;
              }
 -            if (ret < 0 || sl->cabac.bytestream > sl->cabac.bytestream_end + 2) {
 +            if (sl->cabac.bytestream > sl->cabac.bytestream_end + 2 )
 +                av_log(h->avctx, AV_LOG_DEBUG, "bytestream overread %"PTRDIFF_SPECIFIER"\n", sl->cabac.bytestream_end - sl->cabac.bytestream);
 +            if (ret < 0 || sl->cabac.bytestream > sl->cabac.bytestream_end + 4) {
                  av_log(h->avctx, AV_LOG_ERROR,
 -                       "error while decoding MB %d %d, bytestream %td\n",
 +                       "error while decoding MB %d %d, bytestream %"PTRDIFF_SPECIFIER"\n",
-                        h->mb_x, h->mb_y,
+                        sl->mb_x, sl->mb_y,
                         sl->cabac.bytestream_end - sl->cabac.bytestream);
-                 er_add_slice(h, sl, h->resync_mb_x, h->resync_mb_y, h->mb_x,
-                              h->mb_y, ER_MB_ERROR);
+                 er_add_slice(h, sl, h->resync_mb_x, h->resync_mb_y, sl->mb_x,
+                              sl->mb_y, ER_MB_ERROR);
                  return AVERROR_INVALIDDATA;
              }
  
                      tprintf(h->avctx, "slice end %d %d\n",
                              get_bits_count(&h->gb), h->gb.size_in_bits);
  
 -                    if (get_bits_left(&h->gb) == 0) {
 +                    if (   get_bits_left(&h->gb) == 0
 +                        || get_bits_left(&h->gb) > 0 && !(h->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
                          er_add_slice(h, sl, h->resync_mb_x, h->resync_mb_y,
-                                      h->mb_x - 1, h->mb_y, ER_MB_END);
+                                      sl->mb_x - 1, sl->mb_y, ER_MB_END);
  
                          return 0;
                      } else {
                          er_add_slice(h, sl, h->resync_mb_x, h->resync_mb_y,
-                                      h->mb_x, h->mb_y, ER_MB_END);
 -                                     sl->mb_x - 1, sl->mb_y, ER_MB_END);
++                                     sl->mb_x, sl->mb_y, ER_MB_END);
  
                          return AVERROR_INVALIDDATA;
                      }
@@@ -2578,23 -2347,19 +2579,26 @@@ int ff_h264_execute_decode_slices(H264C
  {
      AVCodecContext *const avctx = h->avctx;
      H264Context *hx;
+     H264SliceContext *sl;
      int i;
  
-     av_assert0(h->mb_y < h->mb_height);
 -    if (h->avctx->hwaccel)
++    av_assert0(context_count && h->slice_ctx[context_count - 1].mb_y < h->mb_height);
 +
 +    if (h->avctx->hwaccel ||
 +        h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
          return 0;
      if (context_count == 1) {
-         return decode_slice(avctx, &h->slice_ctx[0]);
+         int ret = decode_slice(avctx, &h->slice_ctx[0]);
+         h->mb_y = h->slice_ctx[0].mb_y;
+         return ret;
      } else {
 +        av_assert0(context_count > 0);
          for (i = 1; i < context_count; i++) {
              hx                 = h->thread_context[i];
 -            hx->er.error_count = 0;
 +            if (CONFIG_ERROR_RESILIENCE) {
 +                hx->er.error_count = 0;
 +            }
 +            hx->x264_build     = h->x264_build;
          }
  
          avctx->execute(avctx, decode_slice, h->slice_ctx,
  
          /* pull back stuff from slices to master context */
          hx                   = h->thread_context[context_count - 1];
-         h->mb_x              = hx->mb_x;
-         h->mb_y              = hx->mb_y;
+         sl                   = &h->slice_ctx[context_count - 1];
+         h->mb_y              = sl->mb_y;
          h->droppable         = hx->droppable;
          h->picture_structure = hx->picture_structure;
 -        for (i = 1; i < context_count; i++)
 -            h->er.error_count += h->thread_context[i]->er.error_count;
 +        if (CONFIG_ERROR_RESILIENCE) {
 +            for (i = 1; i < context_count; i++)
 +                h->er.error_count += h->thread_context[i]->er.error_count;
 +        }
      }
  
      return 0;
@@@ -848,21 -841,21 +848,21 @@@ static int svq3_decode_slice_header(AVC
      skip_bits1(&h->gb);
      skip_bits(&h->gb, 2);
  
 -    while (get_bits1(&h->gb))
 -        skip_bits(&h->gb, 8);
 +    if (skip_1stop_8data_bits(&h->gb) < 0)
 +        return AVERROR_INVALIDDATA;
  
      /* reset intra predictors and invalidate motion vector references */
-     if (h->mb_x > 0) {
+     if (sl->mb_x > 0) {
          memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
                 -1, 4 * sizeof(int8_t));
-         memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_x],
-                -1, 8 * sizeof(int8_t) * h->mb_x);
+         memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - sl->mb_x],
+                -1, 8 * sizeof(int8_t) * sl->mb_x);
      }
-     if (h->mb_y > 0) {
+     if (sl->mb_y > 0) {
          memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_stride],
-                -1, 8 * sizeof(int8_t) * (h->mb_width - h->mb_x));
+                -1, 8 * sizeof(int8_t) * (h->mb_width - sl->mb_x));
  
-         if (h->mb_x > 0)
+         if (sl->mb_x > 0)
              sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] = -1;
      }
  
@@@ -1153,20 -1130,10 +1153,20 @@@ static int svq3_decode_frame(AVCodecCon
          return 0;
      }
  
-     h->mb_x = h->mb_y = sl->mb_xy = 0;
 -    init_get_bits(&h->gb, buf, 8 * buf_size);
 -
+     sl->mb_x = sl->mb_y = sl->mb_xy = 0;
  
 +    if (s->watermark_key) {
 +        av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
 +        if (!s->buf)
 +            return AVERROR(ENOMEM);
 +        memcpy(s->buf, avpkt->data, buf_size);
 +        buf = s->buf;
 +    } else {
 +        buf = avpkt->data;
 +    }
 +
 +    init_get_bits(&h->gb, buf, 8 * buf_size);
 +
      if (svq3_decode_slice_header(avctx))
          return -1;
  
                             h->low_delay);
      }
  
-     if (h->mb_y != h->mb_height || h->mb_x != h->mb_width) {
-         av_log(avctx, AV_LOG_INFO, "frame num %d incomplete pic x %d y %d left %d\n", avctx->frame_number, h->mb_y, h->mb_x, left);
 +    left = buf_size*8 - get_bits_count(&h->gb);
 +
++    if (sl->mb_y != h->mb_height || sl->mb_x != h->mb_width) {
++        av_log(avctx, AV_LOG_INFO, "frame num %d incomplete pic x %d y %d left %d\n", avctx->frame_number, sl->mb_y, sl->mb_x, left);
 +        //av_hex_dump(stderr, buf+buf_size-8, 8);
 +    }
 +
 +    if (left < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
 +        return -1;
 +    }
 +
      if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
          ret = av_frame_ref(data, &s->cur_pic->f);
      else if (s->last_pic->f.data[0])
Simple merge