libavcodec/h264.c:2006: error: Uninitialized Value
  The value read from dest[_] was never initialized.

libavcodec/h264.c:2006:21: 
2004.             for (p = 0; p < plane_count; p++) {
2005.                 for (i = 0; i < 16; i++) {
2006.                     uint16_t *tmp = (uint16_t*)(dest[p] + i*linesize);
                          ^
2007.                     for (j = 0; j < 16; j++)
2008.                         tmp[j] = get_bits(&gb, bit_depth);

static av_always_inline void hl_decode_mb_444_internal(H264Context *h, int simple, int pixel_shift){
    MpegEncContext * const s = &h->s;
    const int mb_x= s->mb_x;
    const int mb_y= s->mb_y;
    const int mb_xy= h->mb_xy;
    const int mb_type= s->current_picture.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 && (s->qscale == 0 && h->sps.transform_bypass);
    const int plane_count = (simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)) ? 3 : 1;
    for (p = 0; p < plane_count; p++)
    {
        dest[p] = s->current_picture.data[p] + ((mb_x << pixel_shift) + mb_y * s->linesize) * 16;
        s->dsp.prefetch(dest[p] + (s->mb_x&3)*4*s->linesize + (64 << pixel_shift), s->linesize, 4);
    }
    h->list_counts[mb_xy]= h->list_count;
    if (!simple && MB_FIELD) {
        linesize   = h->mb_linesize = h->mb_uvlinesize = s->linesize * 2;
        block_offset = &h->block_offset[48];
        if(mb_y&1)
            for (p = 0; p < 3; p++)
                dest[p] -= s->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)^(s->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)^(s->mb_y&1), 1);
                    }
                }
            }
        }
    } else {
        linesize   = h->mb_linesize = h->mb_uvlinesize = s->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->mb, 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, h->mb + p*128 + i*8, 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{
            if (pixel_shift) {
                hl_motion_16(h, dest[0], dest[1], dest[2],
                             s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
                             s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
                             h->h264dsp.weight_h264_pixels_tab,
                             h->h264dsp.biweight_h264_pixels_tab, 1);
            } else
                hl_motion_8(h, dest[0], dest[1], dest[2],
                            s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
                            s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
                            h->h264dsp.weight_h264_pixels_tab,
                            h->h264dsp.biweight_h264_pixels_tab, 1);
        }
        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))
    {
        s->dsp.clear_blocks(h->mb);
        s->dsp.clear_blocks(h->mb+(24*16<<pixel_shift));
    }
}
['static av_always_inline void hl_decode_mb_444_internal(H264Context *h, int simple, int pixel_shift){\n    MpegEncContext * const s = &h->s;\n    const int mb_x= s->mb_x;\n    const int mb_y= s->mb_y;\n    const int mb_xy= h->mb_xy;\n    const int mb_type= s->current_picture.mb_type[mb_xy];\n    uint8_t  *dest[3];\n    int linesize;\n    int i, j, p;\n    int *block_offset = &h->block_offset[0];\n    const int transform_bypass = !simple && (s->qscale == 0 && h->sps.transform_bypass);\n    const int plane_count = (simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)) ? 3 : 1;\n    for (p = 0; p < plane_count; p++)\n    {\n        dest[p] = s->current_picture.data[p] + ((mb_x << pixel_shift) + mb_y * s->linesize) * 16;\n        s->dsp.prefetch(dest[p] + (s->mb_x&3)*4*s->linesize + (64 << pixel_shift), s->linesize, 4);\n    }\n    h->list_counts[mb_xy]= h->list_count;\n    if (!simple && MB_FIELD) {\n        linesize   = h->mb_linesize = h->mb_uvlinesize = s->linesize * 2;\n        block_offset = &h->block_offset[48];\n        if(mb_y&1)\n            for (p = 0; p < 3; p++)\n                dest[p] -= s->linesize*15;\n        if(FRAME_MBAFF) {\n            int list;\n            for(list=0; list<h->list_count; list++){\n                if(!USES_LIST(mb_type, list))\n                    continue;\n                if(IS_16X16(mb_type)){\n                    int8_t *ref = &h->ref_cache[list][scan8[0]];\n                    fill_rectangle(ref, 4, 4, 8, (16+*ref)^(s->mb_y&1), 1);\n                }else{\n                    for(i=0; i<16; i+=4){\n                        int ref = h->ref_cache[list][scan8[i]];\n                        if(ref >= 0)\n                            fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, (16+ref)^(s->mb_y&1), 1);\n                    }\n                }\n            }\n        }\n    } else {\n        linesize   = h->mb_linesize = h->mb_uvlinesize = s->linesize;\n    }\n    if (!simple && IS_INTRA_PCM(mb_type)) {\n        if (pixel_shift) {\n            const int bit_depth = h->sps.bit_depth_luma;\n            GetBitContext gb;\n            init_get_bits(&gb, (uint8_t*)h->mb, 768*bit_depth);\n            for (p = 0; p < plane_count; p++) {\n                for (i = 0; i < 16; i++) {\n                    uint16_t *tmp = (uint16_t*)(dest[p] + i*linesize);\n                    for (j = 0; j < 16; j++)\n                        tmp[j] = get_bits(&gb, bit_depth);\n                }\n            }\n        } else {\n            for (p = 0; p < plane_count; p++) {\n                for (i = 0; i < 16; i++) {\n                    memcpy(dest[p] + i*linesize, h->mb + p*128 + i*8, 16);\n                }\n            }\n        }\n    } else {\n        if(IS_INTRA(mb_type)){\n            if(h->deblocking_filter)\n                xchg_mb_border(h, dest[0], dest[1], dest[2], linesize, linesize, 1, 1, simple, pixel_shift);\n            for (p = 0; p < plane_count; p++)\n                hl_decode_mb_predict_luma(h, mb_type, 1, simple, transform_bypass, pixel_shift, block_offset, linesize, dest[p], p);\n            if(h->deblocking_filter)\n                xchg_mb_border(h, dest[0], dest[1], dest[2], linesize, linesize, 0, 1, simple, pixel_shift);\n        }else{\n            if (pixel_shift) {\n                hl_motion_16(h, dest[0], dest[1], dest[2],\n                             s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,\n                             s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,\n                             h->h264dsp.weight_h264_pixels_tab,\n                             h->h264dsp.biweight_h264_pixels_tab, 1);\n            } else\n                hl_motion_8(h, dest[0], dest[1], dest[2],\n                            s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,\n                            s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,\n                            h->h264dsp.weight_h264_pixels_tab,\n                            h->h264dsp.biweight_h264_pixels_tab, 1);\n        }\n        for (p = 0; p < plane_count; p++)\n            hl_decode_mb_idct_luma(h, mb_type, 1, simple, transform_bypass, pixel_shift, block_offset, linesize, dest[p], p);\n    }\n    if(h->cbp || IS_INTRA(mb_type))\n    {\n        s->dsp.clear_blocks(h->mb);\n        s->dsp.clear_blocks(h->mb+(24*16<<pixel_shift));\n    }\n}']