static av_noinline void FUNC(hl_decode_mb_444)(H264Context *h)

{

    const int mb_x    = h->mb_x;

    const int mb_y    = h->mb_y;

    const int mb_xy   = h->mb_xy;

    const int mb_type = h->cur_pic.f.mb_type[mb_xy];

    uint8_t *dest[3];

    int linesize;

    int i, j, p;

    int *block_offset = &h->block_offset[0];

    const int transform_bypass = !SIMPLE && (h->qscale == 0 && h->sps.transform_bypass);

    const int plane_count      = (SIMPLE || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) ? 3 : 1;



    for (p = 0; p < plane_count; p++) {

        dest[p] = h->cur_pic.f.data[p] +

                  ((mb_x << PIXEL_SHIFT) + mb_y * h->linesize) * 16;

        h->vdsp.prefetch(dest[p] + (h->mb_x & 3) * 4 * h->linesize + (64 << PIXEL_SHIFT),

                         h->linesize, 4);

    }



    h->list_counts[mb_xy] = h->list_count;



    if (!SIMPLE && MB_FIELD) {

        linesize     = h->mb_linesize = h->mb_uvlinesize = h->linesize * 2;

        block_offset = &h->block_offset[48];

        if (mb_y & 1) // FIXME move out of this function?

            for (p = 0; p < 3; p++)

                dest[p] -= h->linesize * 15;

        if (FRAME_MBAFF) {

            int list;

            for (list = 0; list < h->list_count; list++) {

                if (!USES_LIST(mb_type, list))

                    continue;

                if (IS_16X16(mb_type)) {

                    int8_t *ref = &h->ref_cache[list][scan8[0]];

                    fill_rectangle(ref, 4, 4, 8, (16 + *ref) ^ (h->mb_y & 1), 1);

                } else {

                    for (i = 0; i < 16; i += 4) {

                        int ref = h->ref_cache[list][scan8[i]];

                        if (ref >= 0)

                            fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2,

                                           8, (16 + ref) ^ (h->mb_y & 1), 1);

                    }

                }

            }

        }

    } else {

        linesize = h->mb_linesize = h->mb_uvlinesize = h->linesize;

    }



    if (!SIMPLE && IS_INTRA_PCM(mb_type)) {

        if (PIXEL_SHIFT) {

            const int bit_depth = h->sps.bit_depth_luma;

            GetBitContext gb;

            init_get_bits(&gb, (uint8_t *)h->intra_pcm_ptr, 768 * bit_depth);



            for (p = 0; p < plane_count; p++)

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

                    uint16_t *tmp = (uint16_t *)(dest[p] + i * linesize);

                    for (j = 0; j < 16; j++)

                        tmp[j] = get_bits(&gb, bit_depth);

                }

        } else {

            for (p = 0; p < plane_count; p++)

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

                    memcpy(dest[p] + i * linesize,

                           (uint8_t *)h->intra_pcm_ptr + p * 256 + i * 16, 16);

        }

    } else {

        if (IS_INTRA(mb_type)) {

            if (h->deblocking_filter)

                xchg_mb_border(h, dest[0], dest[1], dest[2], linesize,

                               linesize, 1, 1, SIMPLE, PIXEL_SHIFT);



            for (p = 0; p < plane_count; p++)

                hl_decode_mb_predict_luma(h, mb_type, 1, SIMPLE,

                                          transform_bypass, PIXEL_SHIFT,

                                          block_offset, linesize, dest[p], p);



            if (h->deblocking_filter)

                xchg_mb_border(h, dest[0], dest[1], dest[2], linesize,

                               linesize, 0, 1, SIMPLE, PIXEL_SHIFT);

        } else {

            FUNC(hl_motion_444)(h, dest[0], dest[1], dest[2],

                      h->me.qpel_put, h->h264chroma.put_h264_chroma_pixels_tab,

                      h->me.qpel_avg, h->h264chroma.avg_h264_chroma_pixels_tab,

                      h->h264dsp.weight_h264_pixels_tab,

                      h->h264dsp.biweight_h264_pixels_tab);

        }



        for (p = 0; p < plane_count; p++)

            hl_decode_mb_idct_luma(h, mb_type, 1, SIMPLE, transform_bypass,

                                   PIXEL_SHIFT, block_offset, linesize,

                                   dest[p], p);



        if (h->cbp || IS_INTRA(mb_type)) {

            h->dsp.clear_blocks(h->mb);

            h->dsp.clear_blocks(h->mb + (24 * 16 << PIXEL_SHIFT));

        }

    }

}

static av_noinline void FUNC(hl_decode_mb_444)(H264Context *h)

{

    const int mb_x    = h->mb_x;

    const int mb_y    = h->mb_y;

    const int mb_xy   = h->mb_xy;

    const int mb_type = h->cur_pic.f.mb_type[mb_xy];

    uint8_t *dest[3];

    int linesize;

    int i, j, p;

    int *block_offset = &h->block_offset[0];

    const int transform_bypass = !SIMPLE && (h->qscale == 0 && h->sps.transform_bypass);

    const int plane_count      = (SIMPLE || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) ? 3 : 1;



    for (p = 0; p < plane_count; p++) {

        dest[p] = h->cur_pic.f.data[p] +

                  ((mb_x << PIXEL_SHIFT) + mb_y * h->linesize) * 16;

        h->vdsp.prefetch(dest[p] + (h->mb_x & 3) * 4 * h->linesize + (64 << PIXEL_SHIFT),

                         h->linesize, 4);

    }



    h->list_counts[mb_xy] = h->list_count;



    if (!SIMPLE && MB_FIELD) {

        linesize     = h->mb_linesize = h->mb_uvlinesize = h->linesize * 2;

        block_offset = &h->block_offset[48];

        if (mb_y & 1) 

            for (p = 0; p < 3; p++)

                dest[p] -= h->linesize * 15;

        if (FRAME_MBAFF) {

            int list;

            for (list = 0; list < h->list_count; list++) {

                if (!USES_LIST(mb_type, list))

                    continue;

                if (IS_16X16(mb_type)) {

                    int8_t *ref = &h->ref_cache[list][scan8[0]];

                    fill_rectangle(ref, 4, 4, 8, (16 + *ref) ^ (h->mb_y & 1), 1);

                } else {

                    for (i = 0; i < 16; i += 4) {

                        int ref = h->ref_cache[list][scan8[i]];

                        if (ref >= 0)

                            fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2,

                                           8, (16 + ref) ^ (h->mb_y & 1), 1);

                    }

                }

            }

        }

    } else {

        linesize = h->mb_linesize = h->mb_uvlinesize = h->linesize;

    }



    if (!SIMPLE && IS_INTRA_PCM(mb_type)) {

        if (PIXEL_SHIFT) {

            const int bit_depth = h->sps.bit_depth_luma;

            GetBitContext gb;

            init_get_bits(&gb, (uint8_t *)h->intra_pcm_ptr, 768 * bit_depth);



            for (p = 0; p < plane_count; p++)

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

                    uint16_t *tmp = (uint16_t *)(dest[p] + i * linesize);

                    for (j = 0; j < 16; j++)

                        tmp[j] = get_bits(&gb, bit_depth);

                }

        } else {

            for (p = 0; p < plane_count; p++)

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

                    memcpy(dest[p] + i * linesize,

                           (uint8_t *)h->intra_pcm_ptr + p * 256 + i * 16, 16);

        }

    } else {

        if (IS_INTRA(mb_type)) {

            if (h->deblocking_filter)

                xchg_mb_border(h, dest[0], dest[1], dest[2], linesize,

                               linesize, 1, 1, SIMPLE, PIXEL_SHIFT);



            for (p = 0; p < plane_count; p++)

                hl_decode_mb_predict_luma(h, mb_type, 1, SIMPLE,

                                          transform_bypass, PIXEL_SHIFT,

                                          block_offset, linesize, dest[p], p);



            if (h->deblocking_filter)

                xchg_mb_border(h, dest[0], dest[1], dest[2], linesize,

                               linesize, 0, 1, SIMPLE, PIXEL_SHIFT);

        } else {

            FUNC(hl_motion_444)(h, dest[0], dest[1], dest[2],

                      h->me.qpel_put, h->h264chroma.put_h264_chroma_pixels_tab,

                      h->me.qpel_avg, h->h264chroma.avg_h264_chroma_pixels_tab,

                      h->h264dsp.weight_h264_pixels_tab,

                      h->h264dsp.biweight_h264_pixels_tab);

        }



        for (p = 0; p < plane_count; p++)

            hl_decode_mb_idct_luma(h, mb_type, 1, SIMPLE, transform_bypass,

                                   PIXEL_SHIFT, block_offset, linesize,

                                   dest[p], p);



        if (h->cbp || IS_INTRA(mb_type)) {

            h->dsp.clear_blocks(h->mb);

            h->dsp.clear_blocks(h->mb + (24 * 16 << PIXEL_SHIFT));

        }

    }

}

static av_noinline void FUNC_0(hl_decode_mb_444)(H264Context *h)

{

    const int VAR_0    = h->VAR_0;

    const int VAR_1    = h->VAR_1;

    const int VAR_2   = h->VAR_2;

    const int VAR_3 = h->cur_pic.f.VAR_3[VAR_2];

    uint8_t *dest[3];

    int VAR_4;

    int VAR_5, VAR_6, VAR_7;

    int *VAR_8 = &h->VAR_8[0];

    const int VAR_9 = !SIMPLE && (h->qscale == 0 && h->sps.VAR_9);

    const int VAR_10      = (SIMPLE || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) ? 3 : 1;



    for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++) {

        dest[VAR_7] = h->cur_pic.f.data[VAR_7] +

                  ((VAR_0 << PIXEL_SHIFT) + VAR_1 * h->VAR_4) * 16;

        h->vdsp.prefetch(dest[VAR_7] + (h->VAR_0 & 3) * 4 * h->VAR_4 + (64 << PIXEL_SHIFT),

                         h->VAR_4, 4);

    }



    h->list_counts[VAR_2] = h->list_count;



    if (!SIMPLE && MB_FIELD) {

        VAR_4     = h->mb_linesize = h->mb_uvlinesize = h->VAR_4 * 2;

        VAR_8 = &h->VAR_8[48];

        if (VAR_1 & 1) 

            for (VAR_7 = 0; VAR_7 < 3; VAR_7++)

                dest[VAR_7] -= h->VAR_4 * 15;

        if (FRAME_MBAFF) {

            int VAR_11;

            for (VAR_11 = 0; VAR_11 < h->list_count; VAR_11++) {

                if (!USES_LIST(VAR_3, VAR_11))

                    continue;

                if (IS_16X16(VAR_3)) {

                    int8_t *ref = &h->ref_cache[VAR_11][scan8[0]];

                    fill_rectangle(ref, 4, 4, 8, (16 + *ref) ^ (h->VAR_1 & 1), 1);

                } else {

                    for (VAR_5 = 0; VAR_5 < 16; VAR_5 += 4) {

                        int ref = h->ref_cache[VAR_11][scan8[VAR_5]];

                        if (ref >= 0)

                            fill_rectangle(&h->ref_cache[VAR_11][scan8[VAR_5]], 2, 2,

                                           8, (16 + ref) ^ (h->VAR_1 & 1), 1);

                    }

                }

            }

        }

    } else {

        VAR_4 = h->mb_linesize = h->mb_uvlinesize = h->VAR_4;

    }



    if (!SIMPLE && IS_INTRA_PCM(VAR_3)) {

        if (PIXEL_SHIFT) {

            const int VAR_12 = h->sps.bit_depth_luma;

            GetBitContext gb;

            init_get_bits(&gb, (uint8_t *)h->intra_pcm_ptr, 768 * VAR_12);



            for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++)

                for (VAR_5 = 0; VAR_5 < 16; VAR_5++) {

                    uint16_t *tmp = (uint16_t *)(dest[VAR_7] + VAR_5 * VAR_4);

                    for (VAR_6 = 0; VAR_6 < 16; VAR_6++)

                        tmp[VAR_6] = get_bits(&gb, VAR_12);

                }

        } else {

            for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++)

                for (VAR_5 = 0; VAR_5 < 16; VAR_5++)

                    memcpy(dest[VAR_7] + VAR_5 * VAR_4,

                           (uint8_t *)h->intra_pcm_ptr + VAR_7 * 256 + VAR_5 * 16, 16);

        }

    } else {

        if (IS_INTRA(VAR_3)) {

            if (h->deblocking_filter)

                xchg_mb_border(h, dest[0], dest[1], dest[2], VAR_4,

                               VAR_4, 1, 1, SIMPLE, PIXEL_SHIFT);



            for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++)

                hl_decode_mb_predict_luma(h, VAR_3, 1, SIMPLE,

                                          VAR_9, PIXEL_SHIFT,

                                          VAR_8, VAR_4, dest[VAR_7], VAR_7);



            if (h->deblocking_filter)

                xchg_mb_border(h, dest[0], dest[1], dest[2], VAR_4,

                               VAR_4, 0, 1, SIMPLE, PIXEL_SHIFT);

        } else {

            FUNC_0(hl_motion_444)(h, dest[0], dest[1], dest[2],

                      h->me.qpel_put, h->h264chroma.put_h264_chroma_pixels_tab,

                      h->me.qpel_avg, h->h264chroma.avg_h264_chroma_pixels_tab,

                      h->h264dsp.weight_h264_pixels_tab,

                      h->h264dsp.biweight_h264_pixels_tab);

        }



        for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++)

            hl_decode_mb_idct_luma(h, VAR_3, 1, SIMPLE, VAR_9,

                                   PIXEL_SHIFT, VAR_8, VAR_4,

                                   dest[VAR_7], VAR_7);



        if (h->cbp || IS_INTRA(VAR_3)) {

            h->dsp.clear_blocks(h->mb);

            h->dsp.clear_blocks(h->mb + (24 * 16 << PIXEL_SHIFT));

        }

    }

}

static av_noinline void FUNC_0(hl_decode_mb_444)(H264Context *h)
{ const int VAR_0    = h->VAR_0; const int VAR_1    = h->VAR_1; const int VAR_2   = h->VAR_2; const int VAR_3 = h->cur_pic.f.VAR_3[VAR_2]; uint8_t *dest[3]; int VAR_4; int VAR_5, VAR_6, VAR_7; int *VAR_8 = &h->VAR_8[0]; const int VAR_9 = !SIMPLE && (h->qscale == 0 && h->sps.VAR_9); const int VAR_10      = (SIMPLE || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) ? 3 : 1; for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++) { dest[VAR_7] = h->cur_pic.f.data[VAR_7] +
((VAR_0 << PIXEL_SHIFT) + VAR_1 * h->VAR_4) * 16; h->vdsp.prefetch(dest[VAR_7] + (h->VAR_0 & 3) * 4 * h->VAR_4 + (64 << PIXEL_SHIFT),
h->VAR_4, 4); } h->list_counts[VAR_2] = h->list_count; if (!SIMPLE && MB_FIELD) { VAR_4     = h->mb_linesize = h->mb_uvlinesize = h->VAR_4 * 2; VAR_8 = &h->VAR_8[48]; if (VAR_1 & 1)
for (VAR_7 = 0; VAR_7 < 3; VAR_7++) dest[VAR_7] -= h->VAR_4 * 15; if (FRAME_MBAFF) { int VAR_11; for (VAR_11 = 0; VAR_11 < h->list_count; VAR_11++) { if (!USES_LIST(VAR_3, VAR_11))
continue; if (IS_16X16(VAR_3)) { int8_t *ref = &h->ref_cache[VAR_11][scan8[0]]; fill_rectangle(ref, 4, 4, 8, (16 + *ref) ^ (h->VAR_1 & 1), 1); } else { for (VAR_5 = 0; VAR_5 < 16; VAR_5 += 4) { int ref = h->ref_cache[VAR_11][scan8[VAR_5]]; if (ref >= 0)
fill_rectangle(&h->ref_cache[VAR_11][scan8[VAR_5]], 2, 2,
8, (16 + ref) ^ (h->VAR_1 & 1), 1); } } } } } else { VAR_4 = h->mb_linesize = h->mb_uvlinesize = h->VAR_4; } if (!SIMPLE && IS_INTRA_PCM(VAR_3)) { if (PIXEL_SHIFT) { const int VAR_12 = h->sps.bit_depth_luma; GetBitContext gb; init_get_bits(&gb, (uint8_t *)h->intra_pcm_ptr, 768 * VAR_12); for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++) for (VAR_5 = 0; VAR_5 < 16; VAR_5++) { uint16_t *tmp = (uint16_t *)(dest[VAR_7] + VAR_5 * VAR_4); for (VAR_6 = 0; VAR_6 < 16; VAR_6++) tmp[VAR_6] = get_bits(&gb, VAR_12); } } else { for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++) for (VAR_5 = 0; VAR_5 < 16; VAR_5++) memcpy(dest[VAR_7] + VAR_5 * VAR_4,
(uint8_t *)h->intra_pcm_ptr + VAR_7 * 256 + VAR_5 * 16, 16); } } else { if (IS_INTRA(VAR_3)) { if (h->deblocking_filter)
xchg_mb_border(h, dest[0], dest[1], dest[2], VAR_4,
VAR_4, 1, 1, SIMPLE, PIXEL_SHIFT); for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++) hl_decode_mb_predict_luma(h, VAR_3, 1, SIMPLE,
VAR_9, PIXEL_SHIFT,
VAR_8, VAR_4, dest[VAR_7], VAR_7); if (h->deblocking_filter)
xchg_mb_border(h, dest[0], dest[1], dest[2], VAR_4,
VAR_4, 0, 1, SIMPLE, PIXEL_SHIFT); } else { FUNC_0(hl_motion_444)(h, dest[0], dest[1], dest[2],
h->me.qpel_put, h->h264chroma.put_h264_chroma_pixels_tab,
h->me.qpel_avg, h->h264chroma.avg_h264_chroma_pixels_tab,
h->h264dsp.weight_h264_pixels_tab,
h->h264dsp.biweight_h264_pixels_tab); } for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++) hl_decode_mb_idct_luma(h, VAR_3, 1, SIMPLE, VAR_9,
PIXEL_SHIFT, VAR_8, VAR_4,
dest[VAR_7], VAR_7); if (h->cbp || IS_INTRA(VAR_3)) { h->dsp.clear_blocks(h->mb); h->dsp.clear_blocks(h->mb + (24 * 16 << PIXEL_SHIFT)); } } }