libavcodec/h264_cavlc.c:781: error: Buffer Overrun L1
  Offset: [13, 18] (⇐ [0, 3] + [13, 15]) Size: 4 by call to `fill_decode_caches`.

libavcodec/h264_cavlc.c:780:5: Call
778.     }
779. 
780.     fill_decode_neighbors(h, mb_type);
         ^
781.     fill_decode_caches(h, mb_type);
782. 

libavcodec/h264_mvpred.h:354:5: Array declaration
  352.     const int mb_xy = h->mb_xy;
  353.     int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS];
  354.     static const uint8_t left_block_options[4][32] = {
           ^
  355.         { 0, 1, 2, 3, 7, 10, 8, 11, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4, 3 + 3 * 4, 1 + 4 * 4, 1 + 8 * 4, 1 + 5 * 4, 1 + 9 * 4 },
  356.         { 2, 2, 3, 3, 8, 11, 8, 11, 3 + 2 * 4, 3 + 2 * 4, 3 + 3 * 4, 3 + 3 * 4, 1 + 5 * 4, 1 + 9 * 4, 1 + 5 * 4, 1 + 9 * 4 },

libavcodec/h264_mvpred.h:371:5: Assignment
  369.     topright_xy   = top_xy + 1;
  370.     left_xy[LBOT] = left_xy[LTOP] = mb_xy - 1;
  371.     h->left_block = left_block_options[0];
           ^
  372.     if (FRAME_MBAFF) {
  373.         const int left_mb_field_flag = IS_INTERLACED(h->cur_pic.mb_type[mb_xy - 1]);

libavcodec/h264_cavlc.c:781:5: Call
779. 
780.     fill_decode_neighbors(h, mb_type);
781.     fill_decode_caches(h, mb_type);
         ^
782. 
783.     //mb_pred

libavcodec/h264_mvpred.h:554:14: <Offset trace>
552.         }
553. 
554.         for (i = 0; i < 2; i++) {
                  ^
555.             if (left_type[LEFT(i)]) {
556.                 nnz = h->non_zero_count[left_xy[LEFT(i)]];

libavcodec/h264_mvpred.h:554:14: Assignment
  552.         }
  553. 
  554.         for (i = 0; i < 2; i++) {
                    ^
  555.             if (left_type[LEFT(i)]) {
  556.                 nnz = h->non_zero_count[left_xy[LEFT(i)]];

libavcodec/h264_mvpred.h:439:1: <Length trace>
437. }
438. 
439. static void fill_decode_caches(H264Context *h, int mb_type)
     ^
440. {
441.     int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS];

libavcodec/h264_mvpred.h:439:1: Parameter `*h->left_block`
  437. }
  438. 
  439. static void fill_decode_caches(H264Context *h, int mb_type)
       ^
  440. {
  441.     int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS];

libavcodec/h264_mvpred.h:443:5: Assignment
  441.     int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS];
  442.     int topleft_type, top_type, topright_type, left_type[LEFT_MBS];
  443.     const uint8_t *left_block = h->left_block;
           ^
  444.     int i;
  445.     uint8_t *nnz;

libavcodec/h264_mvpred.h:571:57: Array access: Offset: [13, 18] (⇐ [0, 3] + [13, 15]) Size: 4 by call to `fill_decode_caches` 
  569.                 } else {
  570.                     nnz_cache[3 + 8 *  6 + 8 * i] = nnz[left_block[8 + 4 + 2 * i]];
  571.                     nnz_cache[3 + 8 * 11 + 8 * i] = nnz[left_block[8 + 5 + 2 * i]];
                                                               ^
  572.                 }
  573.             } else {

static void fill_decode_caches(H264Context *h, int mb_type)
{
    int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS];
    int topleft_type, top_type, topright_type, left_type[LEFT_MBS];
    const uint8_t *left_block = h->left_block;
    int i;
    uint8_t *nnz;
    uint8_t *nnz_cache;
    topleft_xy      = h->topleft_mb_xy;
    top_xy          = h->top_mb_xy;
    topright_xy     = h->topright_mb_xy;
    left_xy[LTOP]   = h->left_mb_xy[LTOP];
    left_xy[LBOT]   = h->left_mb_xy[LBOT];
    topleft_type    = h->topleft_type;
    top_type        = h->top_type;
    topright_type   = h->topright_type;
    left_type[LTOP] = h->left_type[LTOP];
    left_type[LBOT] = h->left_type[LBOT];
    if (!IS_SKIP(mb_type)) {
        if (IS_INTRA(mb_type)) {
            int type_mask = h->pps.constrained_intra_pred ? IS_INTRA(-1) : -1;
            h->topleft_samples_available      =
                h->top_samples_available      =
                    h->left_samples_available = 0xFFFF;
            h->topright_samples_available     = 0xEEEA;
            if (!(top_type & type_mask)) {
                h->topleft_samples_available  = 0xB3FF;
                h->top_samples_available      = 0x33FF;
                h->topright_samples_available = 0x26EA;
            }
            if (IS_INTERLACED(mb_type) != IS_INTERLACED(left_type[LTOP])) {
                if (IS_INTERLACED(mb_type)) {
                    if (!(left_type[LTOP] & type_mask)) {
                        h->topleft_samples_available &= 0xDFFF;
                        h->left_samples_available    &= 0x5FFF;
                    }
                    if (!(left_type[LBOT] & type_mask)) {
                        h->topleft_samples_available &= 0xFF5F;
                        h->left_samples_available    &= 0xFF5F;
                    }
                } else {
                    int left_typei = h->cur_pic.mb_type[left_xy[LTOP] + h->mb_stride];
                    assert(left_xy[LTOP] == left_xy[LBOT]);
                    if (!((left_typei & type_mask) && (left_type[LTOP] & type_mask))) {
                        h->topleft_samples_available &= 0xDF5F;
                        h->left_samples_available    &= 0x5F5F;
                    }
                }
            } else {
                if (!(left_type[LTOP] & type_mask)) {
                    h->topleft_samples_available &= 0xDF5F;
                    h->left_samples_available    &= 0x5F5F;
                }
            }
            if (!(topleft_type & type_mask))
                h->topleft_samples_available &= 0x7FFF;
            if (!(topright_type & type_mask))
                h->topright_samples_available &= 0xFBFF;
            if (IS_INTRA4x4(mb_type)) {
                if (IS_INTRA4x4(top_type)) {
                    AV_COPY32(h->intra4x4_pred_mode_cache + 4 + 8 * 0, h->intra4x4_pred_mode + h->mb2br_xy[top_xy]);
                } else {
                    h->intra4x4_pred_mode_cache[4 + 8 * 0] =
                    h->intra4x4_pred_mode_cache[5 + 8 * 0] =
                    h->intra4x4_pred_mode_cache[6 + 8 * 0] =
                    h->intra4x4_pred_mode_cache[7 + 8 * 0] = 2 - 3 * !(top_type & type_mask);
                }
                for (i = 0; i < 2; i++) {
                    if (IS_INTRA4x4(left_type[LEFT(i)])) {
                        int8_t *mode = h->intra4x4_pred_mode + h->mb2br_xy[left_xy[LEFT(i)]];
                        h->intra4x4_pred_mode_cache[3 + 8 * 1 + 2 * 8 * i] = mode[6 - left_block[0 + 2 * i]];
                        h->intra4x4_pred_mode_cache[3 + 8 * 2 + 2 * 8 * i] = mode[6 - left_block[1 + 2 * i]];
                    } else {
                        h->intra4x4_pred_mode_cache[3 + 8 * 1 + 2 * 8 * i] =
                        h->intra4x4_pred_mode_cache[3 + 8 * 2 + 2 * 8 * i] = 2 - 3 * !(left_type[LEFT(i)] & type_mask);
                    }
                }
            }
        }
        nnz_cache = h->non_zero_count_cache;
        if (top_type) {
            nnz = h->non_zero_count[top_xy];
            AV_COPY32(&nnz_cache[4 + 8 * 0], &nnz[4 * 3]);
            if (!h->chroma_y_shift) {
                AV_COPY32(&nnz_cache[4 + 8 *  5], &nnz[4 *  7]);
                AV_COPY32(&nnz_cache[4 + 8 * 10], &nnz[4 * 11]);
            } else {
                AV_COPY32(&nnz_cache[4 + 8 *  5], &nnz[4 * 5]);
                AV_COPY32(&nnz_cache[4 + 8 * 10], &nnz[4 * 9]);
            }
        } else {
            uint32_t top_empty = CABAC && !IS_INTRA(mb_type) ? 0 : 0x40404040;
            AV_WN32A(&nnz_cache[4 + 8 *  0], top_empty);
            AV_WN32A(&nnz_cache[4 + 8 *  5], top_empty);
            AV_WN32A(&nnz_cache[4 + 8 * 10], top_empty);
        }
        for (i = 0; i < 2; i++) {
            if (left_type[LEFT(i)]) {
                nnz = h->non_zero_count[left_xy[LEFT(i)]];
                nnz_cache[3 + 8 * 1 + 2 * 8 * i] = nnz[left_block[8 + 0 + 2 * i]];
                nnz_cache[3 + 8 * 2 + 2 * 8 * i] = nnz[left_block[8 + 1 + 2 * i]];
                if (CHROMA444) {
                    nnz_cache[3 + 8 *  6 + 2 * 8 * i] = nnz[left_block[8 + 0 + 2 * i] + 4 * 4];
                    nnz_cache[3 + 8 *  7 + 2 * 8 * i] = nnz[left_block[8 + 1 + 2 * i] + 4 * 4];
                    nnz_cache[3 + 8 * 11 + 2 * 8 * i] = nnz[left_block[8 + 0 + 2 * i] + 8 * 4];
                    nnz_cache[3 + 8 * 12 + 2 * 8 * i] = nnz[left_block[8 + 1 + 2 * i] + 8 * 4];
                } else if (CHROMA422) {
                    nnz_cache[3 + 8 *  6 + 2 * 8 * i] = nnz[left_block[8 + 0 + 2 * i] - 2 + 4 * 4];
                    nnz_cache[3 + 8 *  7 + 2 * 8 * i] = nnz[left_block[8 + 1 + 2 * i] - 2 + 4 * 4];
                    nnz_cache[3 + 8 * 11 + 2 * 8 * i] = nnz[left_block[8 + 0 + 2 * i] - 2 + 8 * 4];
                    nnz_cache[3 + 8 * 12 + 2 * 8 * i] = nnz[left_block[8 + 1 + 2 * i] - 2 + 8 * 4];
                } else {
                    nnz_cache[3 + 8 *  6 + 8 * i] = nnz[left_block[8 + 4 + 2 * i]];
                    nnz_cache[3 + 8 * 11 + 8 * i] = nnz[left_block[8 + 5 + 2 * i]];
                }
            } else {
                nnz_cache[3 + 8 *  1 + 2 * 8 * i] =
                nnz_cache[3 + 8 *  2 + 2 * 8 * i] =
                nnz_cache[3 + 8 *  6 + 2 * 8 * i] =
                nnz_cache[3 + 8 *  7 + 2 * 8 * i] =
                nnz_cache[3 + 8 * 11 + 2 * 8 * i] =
                nnz_cache[3 + 8 * 12 + 2 * 8 * i] = CABAC && !IS_INTRA(mb_type) ? 0 : 64;
            }
        }
        if (CABAC) {
            if (top_type)
                h->top_cbp = h->cbp_table[top_xy];
            else
                h->top_cbp = IS_INTRA(mb_type) ? 0x7CF : 0x00F;
            if (left_type[LTOP]) {
                h->left_cbp =   (h->cbp_table[left_xy[LTOP]] & 0x7F0) |
                               ((h->cbp_table[left_xy[LTOP]] >> (left_block[0] & (~1))) & 2) |
                              (((h->cbp_table[left_xy[LBOT]] >> (left_block[2] & (~1))) & 2) << 2);
            } else {
                h->left_cbp = IS_INTRA(mb_type) ? 0x7CF : 0x00F;
            }
        }
    }
    if (IS_INTER(mb_type) || (IS_DIRECT(mb_type) && h->direct_spatial_mv_pred)) {
        int list;
        int b_stride = h->b_stride;
        for (list = 0; list < h->list_count; list++) {
            int8_t *ref_cache = &h->ref_cache[list][scan8[0]];
            int8_t *ref       = h->cur_pic.ref_index[list];
            int16_t(*mv_cache)[2] = &h->mv_cache[list][scan8[0]];
            int16_t(*mv)[2]       = h->cur_pic.motion_val[list];
            if (!USES_LIST(mb_type, list))
                continue;
            assert(!(IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred));
            if (USES_LIST(top_type, list)) {
                const int b_xy = h->mb2b_xy[top_xy] + 3 * b_stride;
                AV_COPY128(mv_cache[0 - 1 * 8], mv[b_xy + 0]);
                ref_cache[0 - 1 * 8] =
                ref_cache[1 - 1 * 8] = ref[4 * top_xy + 2];
                ref_cache[2 - 1 * 8] =
                ref_cache[3 - 1 * 8] = ref[4 * top_xy + 3];
            } else {
                AV_ZERO128(mv_cache[0 - 1 * 8]);
                AV_WN32A(&ref_cache[0 - 1 * 8],
                         ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE) & 0xFF) * 0x01010101u);
            }
            if (mb_type & (MB_TYPE_16x8 | MB_TYPE_8x8)) {
                for (i = 0; i < 2; i++) {
                    int cache_idx = -1 + i * 2 * 8;
                    if (USES_LIST(left_type[LEFT(i)], list)) {
                        const int b_xy  = h->mb2b_xy[left_xy[LEFT(i)]] + 3;
                        const int b8_xy = 4 * left_xy[LEFT(i)] + 1;
                        AV_COPY32(mv_cache[cache_idx],
                                  mv[b_xy + b_stride * left_block[0 + i * 2]]);
                        AV_COPY32(mv_cache[cache_idx + 8],
                                  mv[b_xy + b_stride * left_block[1 + i * 2]]);
                        ref_cache[cache_idx]     = ref[b8_xy + (left_block[0 + i * 2] & ~1)];
                        ref_cache[cache_idx + 8] = ref[b8_xy + (left_block[1 + i * 2] & ~1)];
                    } else {
                        AV_ZERO32(mv_cache[cache_idx]);
                        AV_ZERO32(mv_cache[cache_idx + 8]);
                        ref_cache[cache_idx]     =
                        ref_cache[cache_idx + 8] = (left_type[LEFT(i)]) ? LIST_NOT_USED
                                                                        : PART_NOT_AVAILABLE;
                    }
                }
            } else {
                if (USES_LIST(left_type[LTOP], list)) {
                    const int b_xy  = h->mb2b_xy[left_xy[LTOP]] + 3;
                    const int b8_xy = 4 * left_xy[LTOP] + 1;
                    AV_COPY32(mv_cache[-1], mv[b_xy + b_stride * left_block[0]]);
                    ref_cache[-1] = ref[b8_xy + (left_block[0] & ~1)];
                } else {
                    AV_ZERO32(mv_cache[-1]);
                    ref_cache[-1] = left_type[LTOP] ? LIST_NOT_USED
                                                    : PART_NOT_AVAILABLE;
                }
            }
            if (USES_LIST(topright_type, list)) {
                const int b_xy = h->mb2b_xy[topright_xy] + 3 * b_stride;
                AV_COPY32(mv_cache[4 - 1 * 8], mv[b_xy]);
                ref_cache[4 - 1 * 8] = ref[4 * topright_xy + 2];
            } else {
                AV_ZERO32(mv_cache[4 - 1 * 8]);
                ref_cache[4 - 1 * 8] = topright_type ? LIST_NOT_USED
                                                     : PART_NOT_AVAILABLE;
            }
            if (ref_cache[4 - 1 * 8] < 0) {
                if (USES_LIST(topleft_type, list)) {
                    const int b_xy  = h->mb2b_xy[topleft_xy] + 3 + b_stride +
                                      (h->topleft_partition & 2 * b_stride);
                    const int b8_xy = 4 * topleft_xy + 1 + (h->topleft_partition & 2);
                    AV_COPY32(mv_cache[-1 - 1 * 8], mv[b_xy]);
                    ref_cache[-1 - 1 * 8] = ref[b8_xy];
                } else {
                    AV_ZERO32(mv_cache[-1 - 1 * 8]);
                    ref_cache[-1 - 1 * 8] = topleft_type ? LIST_NOT_USED
                                                         : PART_NOT_AVAILABLE;
                }
            }
            if ((mb_type & (MB_TYPE_SKIP | MB_TYPE_DIRECT2)) && !FRAME_MBAFF)
                continue;
            if (!(mb_type & (MB_TYPE_SKIP | MB_TYPE_DIRECT2))) {
                uint8_t(*mvd_cache)[2]   = &h->mvd_cache[list][scan8[0]];
                uint8_t(*mvd)[2]         = h->mvd_table[list];
                ref_cache[2 + 8 * 0] =
                ref_cache[2 + 8 * 2] = PART_NOT_AVAILABLE;
                AV_ZERO32(mv_cache[2 + 8 * 0]);
                AV_ZERO32(mv_cache[2 + 8 * 2]);
                if (CABAC) {
                    if (USES_LIST(top_type, list)) {
                        const int b_xy = h->mb2br_xy[top_xy];
                        AV_COPY64(mvd_cache[0 - 1 * 8], mvd[b_xy + 0]);
                    } else {
                        AV_ZERO64(mvd_cache[0 - 1 * 8]);
                    }
                    if (USES_LIST(left_type[LTOP], list)) {
                        const int b_xy = h->mb2br_xy[left_xy[LTOP]] + 6;
                        AV_COPY16(mvd_cache[-1 + 0 * 8], mvd[b_xy - left_block[0]]);
                        AV_COPY16(mvd_cache[-1 + 1 * 8], mvd[b_xy - left_block[1]]);
                    } else {
                        AV_ZERO16(mvd_cache[-1 + 0 * 8]);
                        AV_ZERO16(mvd_cache[-1 + 1 * 8]);
                    }
                    if (USES_LIST(left_type[LBOT], list)) {
                        const int b_xy = h->mb2br_xy[left_xy[LBOT]] + 6;
                        AV_COPY16(mvd_cache[-1 + 2 * 8], mvd[b_xy - left_block[2]]);
                        AV_COPY16(mvd_cache[-1 + 3 * 8], mvd[b_xy - left_block[3]]);
                    } else {
                        AV_ZERO16(mvd_cache[-1 + 2 * 8]);
                        AV_ZERO16(mvd_cache[-1 + 3 * 8]);
                    }
                    AV_ZERO16(mvd_cache[2 + 8 * 0]);
                    AV_ZERO16(mvd_cache[2 + 8 * 2]);
                    if (h->slice_type_nos == AV_PICTURE_TYPE_B) {
                        uint8_t *direct_cache = &h->direct_cache[scan8[0]];
                        uint8_t *direct_table = h->direct_table;
                        fill_rectangle(direct_cache, 4, 4, 8, MB_TYPE_16x16 >> 1, 1);
                        if (IS_DIRECT(top_type)) {
                            AV_WN32A(&direct_cache[-1 * 8],
                                     0x01010101u * (MB_TYPE_DIRECT2 >> 1));
                        } else if (IS_8X8(top_type)) {
                            int b8_xy = 4 * top_xy;
                            direct_cache[0 - 1 * 8] = direct_table[b8_xy + 2];
                            direct_cache[2 - 1 * 8] = direct_table[b8_xy + 3];
                        } else {
                            AV_WN32A(&direct_cache[-1 * 8],
                                     0x01010101 * (MB_TYPE_16x16 >> 1));
                        }
                        if (IS_DIRECT(left_type[LTOP]))
                            direct_cache[-1 + 0 * 8] = MB_TYPE_DIRECT2 >> 1;
                        else if (IS_8X8(left_type[LTOP]))
                            direct_cache[-1 + 0 * 8] = direct_table[4 * left_xy[LTOP] + 1 + (left_block[0] & ~1)];
                        else
                            direct_cache[-1 + 0 * 8] = MB_TYPE_16x16 >> 1;
                        if (IS_DIRECT(left_type[LBOT]))
                            direct_cache[-1 + 2 * 8] = MB_TYPE_DIRECT2 >> 1;
                        else if (IS_8X8(left_type[LBOT]))
                            direct_cache[-1 + 2 * 8] = direct_table[4 * left_xy[LBOT] + 1 + (left_block[2] & ~1)];
                        else
                            direct_cache[-1 + 2 * 8] = MB_TYPE_16x16 >> 1;
                    }
                }
            }
#define MAP_MVS                                                         \
    MAP_F2F(scan8[0] - 1 - 1 * 8, topleft_type)                         \
    MAP_F2F(scan8[0] + 0 - 1 * 8, top_type)                             \
    MAP_F2F(scan8[0] + 1 - 1 * 8, top_type)                             \
    MAP_F2F(scan8[0] + 2 - 1 * 8, top_type)                             \
    MAP_F2F(scan8[0] + 3 - 1 * 8, top_type)                             \
    MAP_F2F(scan8[0] + 4 - 1 * 8, topright_type)                        \
    MAP_F2F(scan8[0] - 1 + 0 * 8, left_type[LTOP])                      \
    MAP_F2F(scan8[0] - 1 + 1 * 8, left_type[LTOP])                      \
    MAP_F2F(scan8[0] - 1 + 2 * 8, left_type[LBOT])                      \
    MAP_F2F(scan8[0] - 1 + 3 * 8, left_type[LBOT])
            if (FRAME_MBAFF) {
                if (MB_FIELD) {
#define MAP_F2F(idx, mb_type)                                           \
    if (!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0) {      \
        h->ref_cache[list][idx]    <<= 1;                               \
        h->mv_cache[list][idx][1]   /= 2;                               \
        h->mvd_cache[list][idx][1] >>= 1;                               \
    }
                    MAP_MVS
                } else {
#undef MAP_F2F
#define MAP_F2F(idx, mb_type)                                           \
    if (IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0) {       \
        h->ref_cache[list][idx]    >>= 1;                               \
        h->mv_cache[list][idx][1]  <<= 1;                               \
        h->mvd_cache[list][idx][1] <<= 1;                               \
    }
                    MAP_MVS
#undef MAP_F2F
                }
            }
        }
    }
    h->neighbor_transform_size = !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[LTOP]);
}
['int ff_h264_decode_mb_cavlc(H264Context *h){\n    int mb_xy;\n    int partition_count;\n    unsigned int mb_type, cbp;\n    int dct8x8_allowed= h->pps.transform_8x8_mode;\n    int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;\n    const int pixel_shift = h->pixel_shift;\n    mb_xy = h->mb_xy = h->mb_x + h->mb_y*h->mb_stride;\n    tprintf(h->avctx, "pic:%d mb:%d/%d\\n", h->frame_num, h->mb_x, h->mb_y);\n    cbp = 0;\n    if(h->slice_type_nos != AV_PICTURE_TYPE_I){\n        if(h->mb_skip_run==-1)\n            h->mb_skip_run= get_ue_golomb(&h->gb);\n        if (h->mb_skip_run--) {\n            if(FRAME_MBAFF && (h->mb_y&1) == 0){\n                if(h->mb_skip_run==0)\n                    h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&h->gb);\n            }\n            decode_mb_skip(h);\n            return 0;\n        }\n    }\n    if(FRAME_MBAFF){\n        if( (h->mb_y&1) == 0 )\n            h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&h->gb);\n    }\n    h->prev_mb_skipped= 0;\n    mb_type= get_ue_golomb(&h->gb);\n    if(h->slice_type_nos == AV_PICTURE_TYPE_B){\n        if(mb_type < 23){\n            partition_count= b_mb_type_info[mb_type].partition_count;\n            mb_type=         b_mb_type_info[mb_type].type;\n        }else{\n            mb_type -= 23;\n            goto decode_intra_mb;\n        }\n    }else if(h->slice_type_nos == AV_PICTURE_TYPE_P){\n        if(mb_type < 5){\n            partition_count= p_mb_type_info[mb_type].partition_count;\n            mb_type=         p_mb_type_info[mb_type].type;\n        }else{\n            mb_type -= 5;\n            goto decode_intra_mb;\n        }\n    }else{\n       assert(h->slice_type_nos == AV_PICTURE_TYPE_I);\n        if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)\n            mb_type--;\ndecode_intra_mb:\n        if(mb_type > 25){\n            av_log(h->avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\\n", mb_type, av_get_picture_type_char(h->slice_type), h->mb_x, h->mb_y);\n            return -1;\n        }\n        partition_count=0;\n        cbp= i_mb_type_info[mb_type].cbp;\n        h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;\n        mb_type= i_mb_type_info[mb_type].type;\n    }\n    if(MB_FIELD)\n        mb_type |= MB_TYPE_INTERLACED;\n    h->slice_table[ mb_xy ]= h->slice_num;\n    if(IS_INTRA_PCM(mb_type)){\n        const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *\n                            h->sps.bit_depth_luma;\n        h->intra_pcm_ptr = align_get_bits(&h->gb);\n        skip_bits_long(&h->gb, mb_size);\n        h->cur_pic.qscale_table[mb_xy] = 0;\n        memset(h->non_zero_count[mb_xy], 16, 48);\n        h->cur_pic.mb_type[mb_xy] = mb_type;\n        return 0;\n    }\n    fill_decode_neighbors(h, mb_type);\n    fill_decode_caches(h, mb_type);\n    if(IS_INTRA(mb_type)){\n        int pred_mode;\n        if(IS_INTRA4x4(mb_type)){\n            int i;\n            int di = 1;\n            if(dct8x8_allowed && get_bits1(&h->gb)){\n                mb_type |= MB_TYPE_8x8DCT;\n                di = 4;\n            }\n            for(i=0; i<16; i+=di){\n                int mode= pred_intra_mode(h, i);\n                if(!get_bits1(&h->gb)){\n                    const int rem_mode= get_bits(&h->gb, 3);\n                    mode = rem_mode + (rem_mode >= mode);\n                }\n                if(di==4)\n                    fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );\n                else\n                    h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;\n            }\n            write_back_intra_pred_mode(h);\n            if( ff_h264_check_intra4x4_pred_mode(h) < 0)\n                return -1;\n        }else{\n            h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode(h, h->intra16x16_pred_mode, 0);\n            if(h->intra16x16_pred_mode < 0)\n                return -1;\n        }\n        if(decode_chroma){\n            pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&h->gb), 1);\n            if(pred_mode < 0)\n                return -1;\n            h->chroma_pred_mode= pred_mode;\n        } else {\n            h->chroma_pred_mode = DC_128_PRED8x8;\n        }\n    }else if(partition_count==4){\n        int i, j, sub_partition_count[4], list, ref[2][4];\n        if(h->slice_type_nos == AV_PICTURE_TYPE_B){\n            for(i=0; i<4; i++){\n                h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);\n                if(h->sub_mb_type[i] >=13){\n                    av_log(h->avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\\n", h->sub_mb_type[i], h->mb_x, h->mb_y);\n                    return -1;\n                }\n                sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;\n                h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;\n            }\n            if( IS_DIRECT(h->sub_mb_type[0]|h->sub_mb_type[1]|h->sub_mb_type[2]|h->sub_mb_type[3])) {\n                ff_h264_pred_direct_motion(h, &mb_type);\n                h->ref_cache[0][scan8[4]] =\n                h->ref_cache[1][scan8[4]] =\n                h->ref_cache[0][scan8[12]] =\n                h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;\n            }\n        }else{\n            assert(h->slice_type_nos == AV_PICTURE_TYPE_P);\n            for(i=0; i<4; i++){\n                h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);\n                if(h->sub_mb_type[i] >=4){\n                    av_log(h->avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\\n", h->sub_mb_type[i], h->mb_x, h->mb_y);\n                    return -1;\n                }\n                sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;\n                h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;\n            }\n        }\n        for(list=0; list<h->list_count; list++){\n            int ref_count = IS_REF0(mb_type) ? 1 : h->ref_count[list] << MB_MBAFF;\n            for(i=0; i<4; i++){\n                if(IS_DIRECT(h->sub_mb_type[i])) continue;\n                if(IS_DIR(h->sub_mb_type[i], 0, list)){\n                    unsigned int tmp;\n                    if(ref_count == 1){\n                        tmp= 0;\n                    }else if(ref_count == 2){\n                        tmp= get_bits1(&h->gb)^1;\n                    }else{\n                        tmp= get_ue_golomb_31(&h->gb);\n                        if(tmp>=ref_count){\n                            av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\\n", tmp);\n                            return -1;\n                        }\n                    }\n                    ref[list][i]= tmp;\n                }else{\n                    ref[list][i] = -1;\n                }\n            }\n        }\n        if(dct8x8_allowed)\n            dct8x8_allowed = get_dct8x8_allowed(h);\n        for(list=0; list<h->list_count; list++){\n            for(i=0; i<4; i++){\n                if(IS_DIRECT(h->sub_mb_type[i])) {\n                    h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];\n                    continue;\n                }\n                h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ]=\n                h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];\n                if(IS_DIR(h->sub_mb_type[i], 0, list)){\n                    const int sub_mb_type= h->sub_mb_type[i];\n                    const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;\n                    for(j=0; j<sub_partition_count[i]; j++){\n                        int mx, my;\n                        const int index= 4*i + block_width*j;\n                        int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];\n                        pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);\n                        mx += get_se_golomb(&h->gb);\n                        my += get_se_golomb(&h->gb);\n                        tprintf(h->avctx, "final mv:%d %d\\n", mx, my);\n                        if(IS_SUB_8X8(sub_mb_type)){\n                            mv_cache[ 1 ][0]=\n                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;\n                            mv_cache[ 1 ][1]=\n                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;\n                        }else if(IS_SUB_8X4(sub_mb_type)){\n                            mv_cache[ 1 ][0]= mx;\n                            mv_cache[ 1 ][1]= my;\n                        }else if(IS_SUB_4X8(sub_mb_type)){\n                            mv_cache[ 8 ][0]= mx;\n                            mv_cache[ 8 ][1]= my;\n                        }\n                        mv_cache[ 0 ][0]= mx;\n                        mv_cache[ 0 ][1]= my;\n                    }\n                }else{\n                    uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];\n                    p[0] = p[1]=\n                    p[8] = p[9]= 0;\n                }\n            }\n        }\n    }else if(IS_DIRECT(mb_type)){\n        ff_h264_pred_direct_motion(h, &mb_type);\n        dct8x8_allowed &= h->sps.direct_8x8_inference_flag;\n    }else{\n        int list, mx, my, i;\n        if(IS_16X16(mb_type)){\n            for(list=0; list<h->list_count; list++){\n                    unsigned int val;\n                    if(IS_DIR(mb_type, 0, list)){\n                        int rc = h->ref_count[list] << MB_MBAFF;\n                        if (rc == 1) {\n                            val= 0;\n                        } else if (rc == 2) {\n                            val= get_bits1(&h->gb)^1;\n                        }else{\n                            val= get_ue_golomb_31(&h->gb);\n                            if (val >= rc) {\n                                av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\\n", val);\n                                return -1;\n                            }\n                        }\n                    fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);\n                    }\n            }\n            for(list=0; list<h->list_count; list++){\n                if(IS_DIR(mb_type, 0, list)){\n                    pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);\n                    mx += get_se_golomb(&h->gb);\n                    my += get_se_golomb(&h->gb);\n                    tprintf(h->avctx, "final mv:%d %d\\n", mx, my);\n                    fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);\n                }\n            }\n        }\n        else if(IS_16X8(mb_type)){\n            for(list=0; list<h->list_count; list++){\n                    for(i=0; i<2; i++){\n                        unsigned int val;\n                        if(IS_DIR(mb_type, i, list)){\n                            int rc = h->ref_count[list] << MB_MBAFF;\n                            if (rc == 1) {\n                                val= 0;\n                            } else if (rc == 2) {\n                                val= get_bits1(&h->gb)^1;\n                            }else{\n                                val= get_ue_golomb_31(&h->gb);\n                                if (val >= rc) {\n                                    av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\\n", val);\n                                    return -1;\n                                }\n                            }\n                        }else\n                            val= LIST_NOT_USED&0xFF;\n                        fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);\n                    }\n            }\n            for(list=0; list<h->list_count; list++){\n                for(i=0; i<2; i++){\n                    unsigned int val;\n                    if(IS_DIR(mb_type, i, list)){\n                        pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);\n                        mx += get_se_golomb(&h->gb);\n                        my += get_se_golomb(&h->gb);\n                        tprintf(h->avctx, "final mv:%d %d\\n", mx, my);\n                        val= pack16to32(mx,my);\n                    }else\n                        val=0;\n                    fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);\n                }\n            }\n        }else{\n            assert(IS_8X16(mb_type));\n            for(list=0; list<h->list_count; list++){\n                    for(i=0; i<2; i++){\n                        unsigned int val;\n                        if(IS_DIR(mb_type, i, list)){\n                            int rc = h->ref_count[list] << MB_MBAFF;\n                            if (rc == 1) {\n                                val= 0;\n                            } else if (rc == 2) {\n                                val= get_bits1(&h->gb)^1;\n                            }else{\n                                val= get_ue_golomb_31(&h->gb);\n                                if (val >= rc) {\n                                    av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\\n", val);\n                                    return -1;\n                                }\n                            }\n                        }else\n                            val= LIST_NOT_USED&0xFF;\n                        fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);\n                    }\n            }\n            for(list=0; list<h->list_count; list++){\n                for(i=0; i<2; i++){\n                    unsigned int val;\n                    if(IS_DIR(mb_type, i, list)){\n                        pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);\n                        mx += get_se_golomb(&h->gb);\n                        my += get_se_golomb(&h->gb);\n                        tprintf(h->avctx, "final mv:%d %d\\n", mx, my);\n                        val= pack16to32(mx,my);\n                    }else\n                        val=0;\n                    fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);\n                }\n            }\n        }\n    }\n    if(IS_INTER(mb_type))\n        write_back_motion(h, mb_type);\n    if(!IS_INTRA16x16(mb_type)){\n        cbp= get_ue_golomb(&h->gb);\n        if(decode_chroma){\n            if(cbp > 47){\n                av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\\n", cbp, h->mb_x, h->mb_y);\n                return -1;\n            }\n            if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];\n            else                     cbp= golomb_to_inter_cbp   [cbp];\n        }else{\n            if(cbp > 15){\n                av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\\n", cbp, h->mb_x, h->mb_y);\n                return -1;\n            }\n            if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];\n            else                     cbp= golomb_to_inter_cbp_gray[cbp];\n        }\n    }\n    if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){\n        mb_type |= MB_TYPE_8x8DCT*get_bits1(&h->gb);\n    }\n    h->cbp=\n    h->cbp_table[mb_xy]= cbp;\n    h->cur_pic.mb_type[mb_xy] = mb_type;\n    if(cbp || IS_INTRA16x16(mb_type)){\n        int i4x4, i8x8, chroma_idx;\n        int dquant;\n        int ret;\n        GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;\n        const uint8_t *scan, *scan8x8;\n        const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);\n        if(IS_INTERLACED(mb_type)){\n            scan8x8= h->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;\n            scan= h->qscale ? h->field_scan : h->field_scan_q0;\n        }else{\n            scan8x8= h->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;\n            scan= h->qscale ? h->zigzag_scan : h->zigzag_scan_q0;\n        }\n        dquant= get_se_golomb(&h->gb);\n        h->qscale += dquant;\n        if(((unsigned)h->qscale) > max_qp){\n            if(h->qscale<0) h->qscale+= max_qp+1;\n            else            h->qscale-= max_qp+1;\n            if(((unsigned)h->qscale) > max_qp){\n                av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\\n", dquant, h->mb_x, h->mb_y);\n                return -1;\n            }\n        }\n        h->chroma_qp[0]= get_chroma_qp(h, 0, h->qscale);\n        h->chroma_qp[1]= get_chroma_qp(h, 1, h->qscale);\n        if( (ret = decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ){\n            return -1;\n        }\n        h->cbp_table[mb_xy] |= ret << 12;\n        if(CHROMA444){\n            if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ){\n                return -1;\n            }\n            if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ){\n                return -1;\n            }\n        } else if (CHROMA422) {\n            if(cbp&0x30){\n                for(chroma_idx=0; chroma_idx<2; chroma_idx++)\n                    if (decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift),\n                                        CHROMA_DC_BLOCK_INDEX+chroma_idx, chroma422_dc_scan,\n                                        NULL, 8) < 0) {\n                        return -1;\n                    }\n            }\n            if(cbp&0x20){\n                for(chroma_idx=0; chroma_idx<2; chroma_idx++){\n                    const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];\n                    int16_t *mb = h->mb + (16*(16 + 16*chroma_idx) << pixel_shift);\n                    for (i8x8 = 0; i8x8 < 2; i8x8++) {\n                        for (i4x4 = 0; i4x4 < 4; i4x4++) {\n                            const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;\n                            if (decode_residual(h, gb, mb, index, scan + 1, qmul, 15) < 0)\n                                return -1;\n                            mb += 16 << pixel_shift;\n                        }\n                    }\n                }\n            }else{\n                fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);\n                fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);\n            }\n        } else   {\n            if(cbp&0x30){\n                for(chroma_idx=0; chroma_idx<2; chroma_idx++)\n                    if( decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift), CHROMA_DC_BLOCK_INDEX+chroma_idx, chroma_dc_scan, NULL, 4) < 0){\n                        return -1;\n                    }\n            }\n            if(cbp&0x20){\n                for(chroma_idx=0; chroma_idx<2; chroma_idx++){\n                    const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];\n                    for(i4x4=0; i4x4<4; i4x4++){\n                        const int index= 16 + 16*chroma_idx + i4x4;\n                        if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index, scan + 1, qmul, 15) < 0){\n                            return -1;\n                        }\n                    }\n                }\n            }else{\n                fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);\n                fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);\n            }\n        }\n    }else{\n        fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);\n        fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);\n        fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);\n    }\n    h->cur_pic.qscale_table[mb_xy] = h->qscale;\n    write_back_non_zero_count(h);\n    return 0;\n}', 'static void fill_decode_neighbors(H264Context *h, int mb_type)\n{\n    const int mb_xy = h->mb_xy;\n    int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS];\n    static const uint8_t left_block_options[4][32] = {\n        { 0, 1, 2, 3, 7, 10, 8, 11, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4, 3 + 3 * 4, 1 + 4 * 4, 1 + 8 * 4, 1 + 5 * 4, 1 + 9 * 4 },\n        { 2, 2, 3, 3, 8, 11, 8, 11, 3 + 2 * 4, 3 + 2 * 4, 3 + 3 * 4, 3 + 3 * 4, 1 + 5 * 4, 1 + 9 * 4, 1 + 5 * 4, 1 + 9 * 4 },\n        { 0, 0, 1, 1, 7, 10, 7, 10, 3 + 0 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 1 * 4, 1 + 4 * 4, 1 + 8 * 4, 1 + 4 * 4, 1 + 8 * 4 },\n        { 0, 2, 0, 2, 7, 10, 7, 10, 3 + 0 * 4, 3 + 2 * 4, 3 + 0 * 4, 3 + 2 * 4, 1 + 4 * 4, 1 + 8 * 4, 1 + 4 * 4, 1 + 8 * 4 }\n    };\n    h->topleft_partition = -1;\n    top_xy = mb_xy - (h->mb_stride << MB_FIELD);\n    topleft_xy    = top_xy - 1;\n    topright_xy   = top_xy + 1;\n    left_xy[LBOT] = left_xy[LTOP] = mb_xy - 1;\n    h->left_block = left_block_options[0];\n    if (FRAME_MBAFF) {\n        const int left_mb_field_flag = IS_INTERLACED(h->cur_pic.mb_type[mb_xy - 1]);\n        const int curr_mb_field_flag = IS_INTERLACED(mb_type);\n        if (h->mb_y & 1) {\n            if (left_mb_field_flag != curr_mb_field_flag) {\n                left_xy[LBOT] = left_xy[LTOP] = mb_xy - h->mb_stride - 1;\n                if (curr_mb_field_flag) {\n                    left_xy[LBOT] += h->mb_stride;\n                    h->left_block  = left_block_options[3];\n                } else {\n                    topleft_xy += h->mb_stride;\n                    h->topleft_partition = 0;\n                    h->left_block        = left_block_options[1];\n                }\n            }\n        } else {\n            if (curr_mb_field_flag) {\n                topleft_xy  += h->mb_stride & (((h->cur_pic.mb_type[top_xy - 1] >> 7) & 1) - 1);\n                topright_xy += h->mb_stride & (((h->cur_pic.mb_type[top_xy + 1] >> 7) & 1) - 1);\n                top_xy      += h->mb_stride & (((h->cur_pic.mb_type[top_xy]     >> 7) & 1) - 1);\n            }\n            if (left_mb_field_flag != curr_mb_field_flag) {\n                if (curr_mb_field_flag) {\n                    left_xy[LBOT] += h->mb_stride;\n                    h->left_block  = left_block_options[3];\n                } else {\n                    h->left_block = left_block_options[2];\n                }\n            }\n        }\n    }\n    h->topleft_mb_xy    = topleft_xy;\n    h->top_mb_xy        = top_xy;\n    h->topright_mb_xy   = topright_xy;\n    h->left_mb_xy[LTOP] = left_xy[LTOP];\n    h->left_mb_xy[LBOT] = left_xy[LBOT];\n    h->topleft_type    = h->cur_pic.mb_type[topleft_xy];\n    h->top_type        = h->cur_pic.mb_type[top_xy];\n    h->topright_type   = h->cur_pic.mb_type[topright_xy];\n    h->left_type[LTOP] = h->cur_pic.mb_type[left_xy[LTOP]];\n    h->left_type[LBOT] = h->cur_pic.mb_type[left_xy[LBOT]];\n    if (FMO) {\n        if (h->slice_table[topleft_xy] != h->slice_num)\n            h->topleft_type = 0;\n        if (h->slice_table[top_xy] != h->slice_num)\n            h->top_type = 0;\n        if (h->slice_table[left_xy[LTOP]] != h->slice_num)\n            h->left_type[LTOP] = h->left_type[LBOT] = 0;\n    } else {\n        if (h->slice_table[topleft_xy] != h->slice_num) {\n            h->topleft_type = 0;\n            if (h->slice_table[top_xy] != h->slice_num)\n                h->top_type = 0;\n            if (h->slice_table[left_xy[LTOP]] != h->slice_num)\n                h->left_type[LTOP] = h->left_type[LBOT] = 0;\n        }\n    }\n    if (h->slice_table[topright_xy] != h->slice_num)\n        h->topright_type = 0;\n}', 'static void fill_decode_caches(H264Context *h, int mb_type)\n{\n    int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS];\n    int topleft_type, top_type, topright_type, left_type[LEFT_MBS];\n    const uint8_t *left_block = h->left_block;\n    int i;\n    uint8_t *nnz;\n    uint8_t *nnz_cache;\n    topleft_xy      = h->topleft_mb_xy;\n    top_xy          = h->top_mb_xy;\n    topright_xy     = h->topright_mb_xy;\n    left_xy[LTOP]   = h->left_mb_xy[LTOP];\n    left_xy[LBOT]   = h->left_mb_xy[LBOT];\n    topleft_type    = h->topleft_type;\n    top_type        = h->top_type;\n    topright_type   = h->topright_type;\n    left_type[LTOP] = h->left_type[LTOP];\n    left_type[LBOT] = h->left_type[LBOT];\n    if (!IS_SKIP(mb_type)) {\n        if (IS_INTRA(mb_type)) {\n            int type_mask = h->pps.constrained_intra_pred ? IS_INTRA(-1) : -1;\n            h->topleft_samples_available      =\n                h->top_samples_available      =\n                    h->left_samples_available = 0xFFFF;\n            h->topright_samples_available     = 0xEEEA;\n            if (!(top_type & type_mask)) {\n                h->topleft_samples_available  = 0xB3FF;\n                h->top_samples_available      = 0x33FF;\n                h->topright_samples_available = 0x26EA;\n            }\n            if (IS_INTERLACED(mb_type) != IS_INTERLACED(left_type[LTOP])) {\n                if (IS_INTERLACED(mb_type)) {\n                    if (!(left_type[LTOP] & type_mask)) {\n                        h->topleft_samples_available &= 0xDFFF;\n                        h->left_samples_available    &= 0x5FFF;\n                    }\n                    if (!(left_type[LBOT] & type_mask)) {\n                        h->topleft_samples_available &= 0xFF5F;\n                        h->left_samples_available    &= 0xFF5F;\n                    }\n                } else {\n                    int left_typei = h->cur_pic.mb_type[left_xy[LTOP] + h->mb_stride];\n                    assert(left_xy[LTOP] == left_xy[LBOT]);\n                    if (!((left_typei & type_mask) && (left_type[LTOP] & type_mask))) {\n                        h->topleft_samples_available &= 0xDF5F;\n                        h->left_samples_available    &= 0x5F5F;\n                    }\n                }\n            } else {\n                if (!(left_type[LTOP] & type_mask)) {\n                    h->topleft_samples_available &= 0xDF5F;\n                    h->left_samples_available    &= 0x5F5F;\n                }\n            }\n            if (!(topleft_type & type_mask))\n                h->topleft_samples_available &= 0x7FFF;\n            if (!(topright_type & type_mask))\n                h->topright_samples_available &= 0xFBFF;\n            if (IS_INTRA4x4(mb_type)) {\n                if (IS_INTRA4x4(top_type)) {\n                    AV_COPY32(h->intra4x4_pred_mode_cache + 4 + 8 * 0, h->intra4x4_pred_mode + h->mb2br_xy[top_xy]);\n                } else {\n                    h->intra4x4_pred_mode_cache[4 + 8 * 0] =\n                    h->intra4x4_pred_mode_cache[5 + 8 * 0] =\n                    h->intra4x4_pred_mode_cache[6 + 8 * 0] =\n                    h->intra4x4_pred_mode_cache[7 + 8 * 0] = 2 - 3 * !(top_type & type_mask);\n                }\n                for (i = 0; i < 2; i++) {\n                    if (IS_INTRA4x4(left_type[LEFT(i)])) {\n                        int8_t *mode = h->intra4x4_pred_mode + h->mb2br_xy[left_xy[LEFT(i)]];\n                        h->intra4x4_pred_mode_cache[3 + 8 * 1 + 2 * 8 * i] = mode[6 - left_block[0 + 2 * i]];\n                        h->intra4x4_pred_mode_cache[3 + 8 * 2 + 2 * 8 * i] = mode[6 - left_block[1 + 2 * i]];\n                    } else {\n                        h->intra4x4_pred_mode_cache[3 + 8 * 1 + 2 * 8 * i] =\n                        h->intra4x4_pred_mode_cache[3 + 8 * 2 + 2 * 8 * i] = 2 - 3 * !(left_type[LEFT(i)] & type_mask);\n                    }\n                }\n            }\n        }\n        nnz_cache = h->non_zero_count_cache;\n        if (top_type) {\n            nnz = h->non_zero_count[top_xy];\n            AV_COPY32(&nnz_cache[4 + 8 * 0], &nnz[4 * 3]);\n            if (!h->chroma_y_shift) {\n                AV_COPY32(&nnz_cache[4 + 8 *  5], &nnz[4 *  7]);\n                AV_COPY32(&nnz_cache[4 + 8 * 10], &nnz[4 * 11]);\n            } else {\n                AV_COPY32(&nnz_cache[4 + 8 *  5], &nnz[4 * 5]);\n                AV_COPY32(&nnz_cache[4 + 8 * 10], &nnz[4 * 9]);\n            }\n        } else {\n            uint32_t top_empty = CABAC && !IS_INTRA(mb_type) ? 0 : 0x40404040;\n            AV_WN32A(&nnz_cache[4 + 8 *  0], top_empty);\n            AV_WN32A(&nnz_cache[4 + 8 *  5], top_empty);\n            AV_WN32A(&nnz_cache[4 + 8 * 10], top_empty);\n        }\n        for (i = 0; i < 2; i++) {\n            if (left_type[LEFT(i)]) {\n                nnz = h->non_zero_count[left_xy[LEFT(i)]];\n                nnz_cache[3 + 8 * 1 + 2 * 8 * i] = nnz[left_block[8 + 0 + 2 * i]];\n                nnz_cache[3 + 8 * 2 + 2 * 8 * i] = nnz[left_block[8 + 1 + 2 * i]];\n                if (CHROMA444) {\n                    nnz_cache[3 + 8 *  6 + 2 * 8 * i] = nnz[left_block[8 + 0 + 2 * i] + 4 * 4];\n                    nnz_cache[3 + 8 *  7 + 2 * 8 * i] = nnz[left_block[8 + 1 + 2 * i] + 4 * 4];\n                    nnz_cache[3 + 8 * 11 + 2 * 8 * i] = nnz[left_block[8 + 0 + 2 * i] + 8 * 4];\n                    nnz_cache[3 + 8 * 12 + 2 * 8 * i] = nnz[left_block[8 + 1 + 2 * i] + 8 * 4];\n                } else if (CHROMA422) {\n                    nnz_cache[3 + 8 *  6 + 2 * 8 * i] = nnz[left_block[8 + 0 + 2 * i] - 2 + 4 * 4];\n                    nnz_cache[3 + 8 *  7 + 2 * 8 * i] = nnz[left_block[8 + 1 + 2 * i] - 2 + 4 * 4];\n                    nnz_cache[3 + 8 * 11 + 2 * 8 * i] = nnz[left_block[8 + 0 + 2 * i] - 2 + 8 * 4];\n                    nnz_cache[3 + 8 * 12 + 2 * 8 * i] = nnz[left_block[8 + 1 + 2 * i] - 2 + 8 * 4];\n                } else {\n                    nnz_cache[3 + 8 *  6 + 8 * i] = nnz[left_block[8 + 4 + 2 * i]];\n                    nnz_cache[3 + 8 * 11 + 8 * i] = nnz[left_block[8 + 5 + 2 * i]];\n                }\n            } else {\n                nnz_cache[3 + 8 *  1 + 2 * 8 * i] =\n                nnz_cache[3 + 8 *  2 + 2 * 8 * i] =\n                nnz_cache[3 + 8 *  6 + 2 * 8 * i] =\n                nnz_cache[3 + 8 *  7 + 2 * 8 * i] =\n                nnz_cache[3 + 8 * 11 + 2 * 8 * i] =\n                nnz_cache[3 + 8 * 12 + 2 * 8 * i] = CABAC && !IS_INTRA(mb_type) ? 0 : 64;\n            }\n        }\n        if (CABAC) {\n            if (top_type)\n                h->top_cbp = h->cbp_table[top_xy];\n            else\n                h->top_cbp = IS_INTRA(mb_type) ? 0x7CF : 0x00F;\n            if (left_type[LTOP]) {\n                h->left_cbp =   (h->cbp_table[left_xy[LTOP]] & 0x7F0) |\n                               ((h->cbp_table[left_xy[LTOP]] >> (left_block[0] & (~1))) & 2) |\n                              (((h->cbp_table[left_xy[LBOT]] >> (left_block[2] & (~1))) & 2) << 2);\n            } else {\n                h->left_cbp = IS_INTRA(mb_type) ? 0x7CF : 0x00F;\n            }\n        }\n    }\n    if (IS_INTER(mb_type) || (IS_DIRECT(mb_type) && h->direct_spatial_mv_pred)) {\n        int list;\n        int b_stride = h->b_stride;\n        for (list = 0; list < h->list_count; list++) {\n            int8_t *ref_cache = &h->ref_cache[list][scan8[0]];\n            int8_t *ref       = h->cur_pic.ref_index[list];\n            int16_t(*mv_cache)[2] = &h->mv_cache[list][scan8[0]];\n            int16_t(*mv)[2]       = h->cur_pic.motion_val[list];\n            if (!USES_LIST(mb_type, list))\n                continue;\n            assert(!(IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred));\n            if (USES_LIST(top_type, list)) {\n                const int b_xy = h->mb2b_xy[top_xy] + 3 * b_stride;\n                AV_COPY128(mv_cache[0 - 1 * 8], mv[b_xy + 0]);\n                ref_cache[0 - 1 * 8] =\n                ref_cache[1 - 1 * 8] = ref[4 * top_xy + 2];\n                ref_cache[2 - 1 * 8] =\n                ref_cache[3 - 1 * 8] = ref[4 * top_xy + 3];\n            } else {\n                AV_ZERO128(mv_cache[0 - 1 * 8]);\n                AV_WN32A(&ref_cache[0 - 1 * 8],\n                         ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE) & 0xFF) * 0x01010101u);\n            }\n            if (mb_type & (MB_TYPE_16x8 | MB_TYPE_8x8)) {\n                for (i = 0; i < 2; i++) {\n                    int cache_idx = -1 + i * 2 * 8;\n                    if (USES_LIST(left_type[LEFT(i)], list)) {\n                        const int b_xy  = h->mb2b_xy[left_xy[LEFT(i)]] + 3;\n                        const int b8_xy = 4 * left_xy[LEFT(i)] + 1;\n                        AV_COPY32(mv_cache[cache_idx],\n                                  mv[b_xy + b_stride * left_block[0 + i * 2]]);\n                        AV_COPY32(mv_cache[cache_idx + 8],\n                                  mv[b_xy + b_stride * left_block[1 + i * 2]]);\n                        ref_cache[cache_idx]     = ref[b8_xy + (left_block[0 + i * 2] & ~1)];\n                        ref_cache[cache_idx + 8] = ref[b8_xy + (left_block[1 + i * 2] & ~1)];\n                    } else {\n                        AV_ZERO32(mv_cache[cache_idx]);\n                        AV_ZERO32(mv_cache[cache_idx + 8]);\n                        ref_cache[cache_idx]     =\n                        ref_cache[cache_idx + 8] = (left_type[LEFT(i)]) ? LIST_NOT_USED\n                                                                        : PART_NOT_AVAILABLE;\n                    }\n                }\n            } else {\n                if (USES_LIST(left_type[LTOP], list)) {\n                    const int b_xy  = h->mb2b_xy[left_xy[LTOP]] + 3;\n                    const int b8_xy = 4 * left_xy[LTOP] + 1;\n                    AV_COPY32(mv_cache[-1], mv[b_xy + b_stride * left_block[0]]);\n                    ref_cache[-1] = ref[b8_xy + (left_block[0] & ~1)];\n                } else {\n                    AV_ZERO32(mv_cache[-1]);\n                    ref_cache[-1] = left_type[LTOP] ? LIST_NOT_USED\n                                                    : PART_NOT_AVAILABLE;\n                }\n            }\n            if (USES_LIST(topright_type, list)) {\n                const int b_xy = h->mb2b_xy[topright_xy] + 3 * b_stride;\n                AV_COPY32(mv_cache[4 - 1 * 8], mv[b_xy]);\n                ref_cache[4 - 1 * 8] = ref[4 * topright_xy + 2];\n            } else {\n                AV_ZERO32(mv_cache[4 - 1 * 8]);\n                ref_cache[4 - 1 * 8] = topright_type ? LIST_NOT_USED\n                                                     : PART_NOT_AVAILABLE;\n            }\n            if (ref_cache[4 - 1 * 8] < 0) {\n                if (USES_LIST(topleft_type, list)) {\n                    const int b_xy  = h->mb2b_xy[topleft_xy] + 3 + b_stride +\n                                      (h->topleft_partition & 2 * b_stride);\n                    const int b8_xy = 4 * topleft_xy + 1 + (h->topleft_partition & 2);\n                    AV_COPY32(mv_cache[-1 - 1 * 8], mv[b_xy]);\n                    ref_cache[-1 - 1 * 8] = ref[b8_xy];\n                } else {\n                    AV_ZERO32(mv_cache[-1 - 1 * 8]);\n                    ref_cache[-1 - 1 * 8] = topleft_type ? LIST_NOT_USED\n                                                         : PART_NOT_AVAILABLE;\n                }\n            }\n            if ((mb_type & (MB_TYPE_SKIP | MB_TYPE_DIRECT2)) && !FRAME_MBAFF)\n                continue;\n            if (!(mb_type & (MB_TYPE_SKIP | MB_TYPE_DIRECT2))) {\n                uint8_t(*mvd_cache)[2]   = &h->mvd_cache[list][scan8[0]];\n                uint8_t(*mvd)[2]         = h->mvd_table[list];\n                ref_cache[2 + 8 * 0] =\n                ref_cache[2 + 8 * 2] = PART_NOT_AVAILABLE;\n                AV_ZERO32(mv_cache[2 + 8 * 0]);\n                AV_ZERO32(mv_cache[2 + 8 * 2]);\n                if (CABAC) {\n                    if (USES_LIST(top_type, list)) {\n                        const int b_xy = h->mb2br_xy[top_xy];\n                        AV_COPY64(mvd_cache[0 - 1 * 8], mvd[b_xy + 0]);\n                    } else {\n                        AV_ZERO64(mvd_cache[0 - 1 * 8]);\n                    }\n                    if (USES_LIST(left_type[LTOP], list)) {\n                        const int b_xy = h->mb2br_xy[left_xy[LTOP]] + 6;\n                        AV_COPY16(mvd_cache[-1 + 0 * 8], mvd[b_xy - left_block[0]]);\n                        AV_COPY16(mvd_cache[-1 + 1 * 8], mvd[b_xy - left_block[1]]);\n                    } else {\n                        AV_ZERO16(mvd_cache[-1 + 0 * 8]);\n                        AV_ZERO16(mvd_cache[-1 + 1 * 8]);\n                    }\n                    if (USES_LIST(left_type[LBOT], list)) {\n                        const int b_xy = h->mb2br_xy[left_xy[LBOT]] + 6;\n                        AV_COPY16(mvd_cache[-1 + 2 * 8], mvd[b_xy - left_block[2]]);\n                        AV_COPY16(mvd_cache[-1 + 3 * 8], mvd[b_xy - left_block[3]]);\n                    } else {\n                        AV_ZERO16(mvd_cache[-1 + 2 * 8]);\n                        AV_ZERO16(mvd_cache[-1 + 3 * 8]);\n                    }\n                    AV_ZERO16(mvd_cache[2 + 8 * 0]);\n                    AV_ZERO16(mvd_cache[2 + 8 * 2]);\n                    if (h->slice_type_nos == AV_PICTURE_TYPE_B) {\n                        uint8_t *direct_cache = &h->direct_cache[scan8[0]];\n                        uint8_t *direct_table = h->direct_table;\n                        fill_rectangle(direct_cache, 4, 4, 8, MB_TYPE_16x16 >> 1, 1);\n                        if (IS_DIRECT(top_type)) {\n                            AV_WN32A(&direct_cache[-1 * 8],\n                                     0x01010101u * (MB_TYPE_DIRECT2 >> 1));\n                        } else if (IS_8X8(top_type)) {\n                            int b8_xy = 4 * top_xy;\n                            direct_cache[0 - 1 * 8] = direct_table[b8_xy + 2];\n                            direct_cache[2 - 1 * 8] = direct_table[b8_xy + 3];\n                        } else {\n                            AV_WN32A(&direct_cache[-1 * 8],\n                                     0x01010101 * (MB_TYPE_16x16 >> 1));\n                        }\n                        if (IS_DIRECT(left_type[LTOP]))\n                            direct_cache[-1 + 0 * 8] = MB_TYPE_DIRECT2 >> 1;\n                        else if (IS_8X8(left_type[LTOP]))\n                            direct_cache[-1 + 0 * 8] = direct_table[4 * left_xy[LTOP] + 1 + (left_block[0] & ~1)];\n                        else\n                            direct_cache[-1 + 0 * 8] = MB_TYPE_16x16 >> 1;\n                        if (IS_DIRECT(left_type[LBOT]))\n                            direct_cache[-1 + 2 * 8] = MB_TYPE_DIRECT2 >> 1;\n                        else if (IS_8X8(left_type[LBOT]))\n                            direct_cache[-1 + 2 * 8] = direct_table[4 * left_xy[LBOT] + 1 + (left_block[2] & ~1)];\n                        else\n                            direct_cache[-1 + 2 * 8] = MB_TYPE_16x16 >> 1;\n                    }\n                }\n            }\n#define MAP_MVS                                                         \\\n    MAP_F2F(scan8[0] - 1 - 1 * 8, topleft_type)                         \\\n    MAP_F2F(scan8[0] + 0 - 1 * 8, top_type)                             \\\n    MAP_F2F(scan8[0] + 1 - 1 * 8, top_type)                             \\\n    MAP_F2F(scan8[0] + 2 - 1 * 8, top_type)                             \\\n    MAP_F2F(scan8[0] + 3 - 1 * 8, top_type)                             \\\n    MAP_F2F(scan8[0] + 4 - 1 * 8, topright_type)                        \\\n    MAP_F2F(scan8[0] - 1 + 0 * 8, left_type[LTOP])                      \\\n    MAP_F2F(scan8[0] - 1 + 1 * 8, left_type[LTOP])                      \\\n    MAP_F2F(scan8[0] - 1 + 2 * 8, left_type[LBOT])                      \\\n    MAP_F2F(scan8[0] - 1 + 3 * 8, left_type[LBOT])\n            if (FRAME_MBAFF) {\n                if (MB_FIELD) {\n#define MAP_F2F(idx, mb_type)                                           \\\n    if (!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0) {      \\\n        h->ref_cache[list][idx]    <<= 1;                               \\\n        h->mv_cache[list][idx][1]   /= 2;                               \\\n        h->mvd_cache[list][idx][1] >>= 1;                               \\\n    }\n                    MAP_MVS\n                } else {\n#undef MAP_F2F\n#define MAP_F2F(idx, mb_type)                                           \\\n    if (IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0) {       \\\n        h->ref_cache[list][idx]    >>= 1;                               \\\n        h->mv_cache[list][idx][1]  <<= 1;                               \\\n        h->mvd_cache[list][idx][1] <<= 1;                               \\\n    }\n                    MAP_MVS\n#undef MAP_F2F\n                }\n            }\n        }\n    }\n    h->neighbor_transform_size = !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[LTOP]);\n}']