libavcodec/h264.c:4354: error: Uninitialized Value
  The value read from context_count was never initialized.

libavcodec/h264.c:4354:9: 
4352.     }
4353.     if (context_count)
4354.         execute_decode_slices(h, context_count);
              ^
4355.     return buf_index;
4356. }

static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
{
    MpegEncContext *const s     = &h->s;
    AVCodecContext *const avctx = s->avctx;
    H264Context *hx;
    int buf_index;
    int context_count;
    int next_avc;
    int pass = !(avctx->active_thread_type & FF_THREAD_FRAME);
    int nals_needed = 0;
    int nal_index;
    h->max_contexts = s->slice_context_count;
    if (!(s->flags2 & CODEC_FLAG2_CHUNKS)) {
        h->current_slice = 0;
        if (!s->first_field)
            s->current_picture_ptr = NULL;
        ff_h264_reset_sei(h);
    }
    for (; pass <= 1; pass++) {
        buf_index     = 0;
        context_count = 0;
        next_avc      = h->is_avc ? 0 : buf_size;
        nal_index     = 0;
        for (;;) {
            int consumed;
            int dst_length;
            int bit_length;
            const uint8_t *ptr;
            int i, nalsize = 0;
            int err;
            if (buf_index >= next_avc) {
                if (buf_index >= buf_size - h->nal_length_size)
                    break;
                nalsize = 0;
                for (i = 0; i < h->nal_length_size; i++)
                    nalsize = (nalsize << 8) | buf[buf_index++];
                if (nalsize <= 0 || nalsize > buf_size - buf_index) {
                    av_log(h->s.avctx, AV_LOG_ERROR,
                           "AVC: nal size %d\n", nalsize);
                    break;
                }
                next_avc = buf_index + nalsize;
            } else {
                for (; buf_index + 3 < next_avc; buf_index++)
                    if (buf[buf_index]     == 0 &&
                        buf[buf_index + 1] == 0 &&
                        buf[buf_index + 2] == 1)
                        break;
                if (buf_index + 3 >= buf_size)
                    break;
                buf_index += 3;
                if (buf_index >= next_avc)
                    continue;
            }
            hx = h->thread_context[context_count];
            ptr = ff_h264_decode_nal(hx, buf + buf_index, &dst_length,
                                     &consumed, next_avc - buf_index);
            if (ptr == NULL || dst_length < 0)
                return -1;
            i = buf_index + consumed;
            if ((s->workaround_bugs & FF_BUG_AUTODETECT) && i + 3 < next_avc &&
                buf[i]     == 0x00 && buf[i + 1] == 0x00 &&
                buf[i + 2] == 0x01 && buf[i + 3] == 0xE0)
                s->workaround_bugs |= FF_BUG_TRUNCATED;
            if (!(s->workaround_bugs & FF_BUG_TRUNCATED))
                while (ptr[dst_length - 1] == 0 && dst_length > 0)
                    dst_length--;
            bit_length = !dst_length ? 0
                                     : (8 * dst_length -
                                        ff_h264_decode_rbsp_trailing(h, ptr + dst_length - 1));
            if (s->avctx->debug & FF_DEBUG_STARTCODE)
                av_log(h->s.avctx, AV_LOG_DEBUG,
                       "NAL %d at %d/%d length %d\n",
                       hx->nal_unit_type, buf_index, buf_size, dst_length);
            if (h->is_avc && (nalsize != consumed) && nalsize)
                av_log(h->s.avctx, AV_LOG_DEBUG,
                       "AVC: Consumed only %d bytes instead of %d\n",
                       consumed, nalsize);
            buf_index += consumed;
            nal_index++;
            if (pass == 0) {
                switch (hx->nal_unit_type) {
                case NAL_SPS:
                case NAL_PPS:
                    nals_needed = nal_index;
                    break;
                case NAL_IDR_SLICE:
                case NAL_SLICE:
                    init_get_bits(&hx->s.gb, ptr, bit_length);
                    if (!get_ue_golomb(&hx->s.gb))
                        nals_needed = nal_index;
                }
                continue;
            }
            if (avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0)
                continue;
again:
            err = 0;
            switch (hx->nal_unit_type) {
            case NAL_IDR_SLICE:
                if (h->nal_unit_type != NAL_IDR_SLICE) {
                    av_log(h->s.avctx, AV_LOG_ERROR,
                           "Invalid mix of idr and non-idr slices");
                    return -1;
                }
                idr(h);
            case NAL_SLICE:
                init_get_bits(&hx->s.gb, ptr, bit_length);
                hx->intra_gb_ptr        =
                    hx->inter_gb_ptr    = &hx->s.gb;
                hx->s.data_partitioning = 0;
                if ((err = decode_slice_header(hx, h)))
                    break;
                s->current_picture_ptr->f.key_frame |=
                    (hx->nal_unit_type == NAL_IDR_SLICE) ||
                    (h->sei_recovery_frame_cnt >= 0);
                if (h->current_slice == 1) {
                    if (!(s->flags2 & CODEC_FLAG2_CHUNKS))
                        decode_postinit(h, nal_index >= nals_needed);
                    if (s->avctx->hwaccel &&
                        s->avctx->hwaccel->start_frame(s->avctx, NULL, 0) < 0)
                        return -1;
                    if (CONFIG_H264_VDPAU_DECODER &&
                        s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
                        ff_vdpau_h264_picture_start(s);
                }
                if (hx->redundant_pic_count == 0 &&
                    (avctx->skip_frame < AVDISCARD_NONREF ||
                     hx->nal_ref_idc) &&
                    (avctx->skip_frame < AVDISCARD_BIDIR  ||
                     hx->slice_type_nos != AV_PICTURE_TYPE_B) &&
                    (avctx->skip_frame < AVDISCARD_NONKEY ||
                     hx->slice_type_nos == AV_PICTURE_TYPE_I) &&
                    avctx->skip_frame < AVDISCARD_ALL) {
                    if (avctx->hwaccel) {
                        if (avctx->hwaccel->decode_slice(avctx,
                                                         &buf[buf_index - consumed],
                                                         consumed) < 0)
                            return -1;
                    } else if (CONFIG_H264_VDPAU_DECODER &&
                               s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) {
                        static const uint8_t start_code[] = {
                            0x00, 0x00, 0x01 };
                        ff_vdpau_add_data_chunk(s, start_code,
                                                sizeof(start_code));
                        ff_vdpau_add_data_chunk(s, &buf[buf_index - consumed],
                                                consumed);
                    } else
                        context_count++;
                }
                break;
            case NAL_DPA:
                init_get_bits(&hx->s.gb, ptr, bit_length);
                hx->intra_gb_ptr =
                hx->inter_gb_ptr = NULL;
                if ((err = decode_slice_header(hx, h)) < 0)
                    break;
                hx->s.data_partitioning = 1;
                break;
            case NAL_DPB:
                init_get_bits(&hx->intra_gb, ptr, bit_length);
                hx->intra_gb_ptr = &hx->intra_gb;
                break;
            case NAL_DPC:
                init_get_bits(&hx->inter_gb, ptr, bit_length);
                hx->inter_gb_ptr = &hx->inter_gb;
                if (hx->redundant_pic_count == 0 &&
                    hx->intra_gb_ptr &&
                    hx->s.data_partitioning &&
                    s->context_initialized &&
                    (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc) &&
                    (avctx->skip_frame < AVDISCARD_BIDIR  ||
                     hx->slice_type_nos != AV_PICTURE_TYPE_B) &&
                    (avctx->skip_frame < AVDISCARD_NONKEY ||
                     hx->slice_type_nos == AV_PICTURE_TYPE_I) &&
                    avctx->skip_frame < AVDISCARD_ALL)
                    context_count++;
                break;
            case NAL_SEI:
                init_get_bits(&s->gb, ptr, bit_length);
                ff_h264_decode_sei(h);
                break;
            case NAL_SPS:
                init_get_bits(&s->gb, ptr, bit_length);
                if (ff_h264_decode_seq_parameter_set(h) < 0 &&
                    h->is_avc && (nalsize != consumed) && nalsize) {
                    av_log(h->s.avctx, AV_LOG_DEBUG,
                           "SPS decoding failure, try parsing the coomplete NAL\n");
                    init_get_bits(&s->gb, buf + buf_index + 1 - consumed,
                                  8 * (nalsize - 1));
                    ff_h264_decode_seq_parameter_set(h);
                }
                if (s->flags & CODEC_FLAG_LOW_DELAY ||
                    (h->sps.bitstream_restriction_flag &&
                     !h->sps.num_reorder_frames))
                    s->low_delay = 1;
                if (avctx->has_b_frames < 2)
                    avctx->has_b_frames = !s->low_delay;
                if (avctx->bits_per_raw_sample != h->sps.bit_depth_luma ||
                    h->cur_chroma_format_idc   != h->sps.chroma_format_idc) {
                    if (h->sps.bit_depth_luma >= 8 && h->sps.bit_depth_luma <= 10) {
                        avctx->bits_per_raw_sample = h->sps.bit_depth_luma;
                        h->cur_chroma_format_idc   = h->sps.chroma_format_idc;
                        h->pixel_shift             = h->sps.bit_depth_luma > 8;
                        ff_h264dsp_init(&h->h264dsp, h->sps.bit_depth_luma,
                                        h->sps.chroma_format_idc);
                        ff_h264_pred_init(&h->hpc, s->codec_id,
                                          h->sps.bit_depth_luma,
                                          h->sps.chroma_format_idc);
                        s->dsp.dct_bits = h->sps.bit_depth_luma > 8 ? 32 : 16;
                        ff_dsputil_init(&s->dsp, s->avctx);
                    } else {
                        av_log(avctx, AV_LOG_ERROR,
                               "Unsupported bit depth: %d\n",
                               h->sps.bit_depth_luma);
                        return -1;
                    }
                }
                break;
            case NAL_PPS:
                init_get_bits(&s->gb, ptr, bit_length);
                ff_h264_decode_picture_parameter_set(h, bit_length);
                break;
            case NAL_AUD:
            case NAL_END_SEQUENCE:
            case NAL_END_STREAM:
            case NAL_FILLER_DATA:
            case NAL_SPS_EXT:
            case NAL_AUXILIARY_SLICE:
                break;
            default:
                av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n",
                       hx->nal_unit_type, bit_length);
            }
            if (context_count == h->max_contexts) {
                execute_decode_slices(h, context_count);
                context_count = 0;
            }
            if (err < 0)
                av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");
            else if (err == 1) {
                h->nal_unit_type = hx->nal_unit_type;
                h->nal_ref_idc   = hx->nal_ref_idc;
                hx               = h;
                goto again;
            }
        }
    }
    if (context_count)
        execute_decode_slices(h, context_count);
    return buf_index;
}
['static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)\n{\n    MpegEncContext *const s     = &h->s;\n    AVCodecContext *const avctx = s->avctx;\n    H264Context *hx;\n    int buf_index;\n    int context_count;\n    int next_avc;\n    int pass = !(avctx->active_thread_type & FF_THREAD_FRAME);\n    int nals_needed = 0;\n    int nal_index;\n    h->max_contexts = s->slice_context_count;\n    if (!(s->flags2 & CODEC_FLAG2_CHUNKS)) {\n        h->current_slice = 0;\n        if (!s->first_field)\n            s->current_picture_ptr = NULL;\n        ff_h264_reset_sei(h);\n    }\n    for (; pass <= 1; pass++) {\n        buf_index     = 0;\n        context_count = 0;\n        next_avc      = h->is_avc ? 0 : buf_size;\n        nal_index     = 0;\n        for (;;) {\n            int consumed;\n            int dst_length;\n            int bit_length;\n            const uint8_t *ptr;\n            int i, nalsize = 0;\n            int err;\n            if (buf_index >= next_avc) {\n                if (buf_index >= buf_size - h->nal_length_size)\n                    break;\n                nalsize = 0;\n                for (i = 0; i < h->nal_length_size; i++)\n                    nalsize = (nalsize << 8) | buf[buf_index++];\n                if (nalsize <= 0 || nalsize > buf_size - buf_index) {\n                    av_log(h->s.avctx, AV_LOG_ERROR,\n                           "AVC: nal size %d\\n", nalsize);\n                    break;\n                }\n                next_avc = buf_index + nalsize;\n            } else {\n                for (; buf_index + 3 < next_avc; buf_index++)\n                    if (buf[buf_index]     == 0 &&\n                        buf[buf_index + 1] == 0 &&\n                        buf[buf_index + 2] == 1)\n                        break;\n                if (buf_index + 3 >= buf_size)\n                    break;\n                buf_index += 3;\n                if (buf_index >= next_avc)\n                    continue;\n            }\n            hx = h->thread_context[context_count];\n            ptr = ff_h264_decode_nal(hx, buf + buf_index, &dst_length,\n                                     &consumed, next_avc - buf_index);\n            if (ptr == NULL || dst_length < 0)\n                return -1;\n            i = buf_index + consumed;\n            if ((s->workaround_bugs & FF_BUG_AUTODETECT) && i + 3 < next_avc &&\n                buf[i]     == 0x00 && buf[i + 1] == 0x00 &&\n                buf[i + 2] == 0x01 && buf[i + 3] == 0xE0)\n                s->workaround_bugs |= FF_BUG_TRUNCATED;\n            if (!(s->workaround_bugs & FF_BUG_TRUNCATED))\n                while (ptr[dst_length - 1] == 0 && dst_length > 0)\n                    dst_length--;\n            bit_length = !dst_length ? 0\n                                     : (8 * dst_length -\n                                        ff_h264_decode_rbsp_trailing(h, ptr + dst_length - 1));\n            if (s->avctx->debug & FF_DEBUG_STARTCODE)\n                av_log(h->s.avctx, AV_LOG_DEBUG,\n                       "NAL %d at %d/%d length %d\\n",\n                       hx->nal_unit_type, buf_index, buf_size, dst_length);\n            if (h->is_avc && (nalsize != consumed) && nalsize)\n                av_log(h->s.avctx, AV_LOG_DEBUG,\n                       "AVC: Consumed only %d bytes instead of %d\\n",\n                       consumed, nalsize);\n            buf_index += consumed;\n            nal_index++;\n            if (pass == 0) {\n                switch (hx->nal_unit_type) {\n                case NAL_SPS:\n                case NAL_PPS:\n                    nals_needed = nal_index;\n                    break;\n                case NAL_IDR_SLICE:\n                case NAL_SLICE:\n                    init_get_bits(&hx->s.gb, ptr, bit_length);\n                    if (!get_ue_golomb(&hx->s.gb))\n                        nals_needed = nal_index;\n                }\n                continue;\n            }\n            if (avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0)\n                continue;\nagain:\n            err = 0;\n            switch (hx->nal_unit_type) {\n            case NAL_IDR_SLICE:\n                if (h->nal_unit_type != NAL_IDR_SLICE) {\n                    av_log(h->s.avctx, AV_LOG_ERROR,\n                           "Invalid mix of idr and non-idr slices");\n                    return -1;\n                }\n                idr(h);\n            case NAL_SLICE:\n                init_get_bits(&hx->s.gb, ptr, bit_length);\n                hx->intra_gb_ptr        =\n                    hx->inter_gb_ptr    = &hx->s.gb;\n                hx->s.data_partitioning = 0;\n                if ((err = decode_slice_header(hx, h)))\n                    break;\n                s->current_picture_ptr->f.key_frame |=\n                    (hx->nal_unit_type == NAL_IDR_SLICE) ||\n                    (h->sei_recovery_frame_cnt >= 0);\n                if (h->current_slice == 1) {\n                    if (!(s->flags2 & CODEC_FLAG2_CHUNKS))\n                        decode_postinit(h, nal_index >= nals_needed);\n                    if (s->avctx->hwaccel &&\n                        s->avctx->hwaccel->start_frame(s->avctx, NULL, 0) < 0)\n                        return -1;\n                    if (CONFIG_H264_VDPAU_DECODER &&\n                        s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)\n                        ff_vdpau_h264_picture_start(s);\n                }\n                if (hx->redundant_pic_count == 0 &&\n                    (avctx->skip_frame < AVDISCARD_NONREF ||\n                     hx->nal_ref_idc) &&\n                    (avctx->skip_frame < AVDISCARD_BIDIR  ||\n                     hx->slice_type_nos != AV_PICTURE_TYPE_B) &&\n                    (avctx->skip_frame < AVDISCARD_NONKEY ||\n                     hx->slice_type_nos == AV_PICTURE_TYPE_I) &&\n                    avctx->skip_frame < AVDISCARD_ALL) {\n                    if (avctx->hwaccel) {\n                        if (avctx->hwaccel->decode_slice(avctx,\n                                                         &buf[buf_index - consumed],\n                                                         consumed) < 0)\n                            return -1;\n                    } else if (CONFIG_H264_VDPAU_DECODER &&\n                               s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) {\n                        static const uint8_t start_code[] = {\n                            0x00, 0x00, 0x01 };\n                        ff_vdpau_add_data_chunk(s, start_code,\n                                                sizeof(start_code));\n                        ff_vdpau_add_data_chunk(s, &buf[buf_index - consumed],\n                                                consumed);\n                    } else\n                        context_count++;\n                }\n                break;\n            case NAL_DPA:\n                init_get_bits(&hx->s.gb, ptr, bit_length);\n                hx->intra_gb_ptr =\n                hx->inter_gb_ptr = NULL;\n                if ((err = decode_slice_header(hx, h)) < 0)\n                    break;\n                hx->s.data_partitioning = 1;\n                break;\n            case NAL_DPB:\n                init_get_bits(&hx->intra_gb, ptr, bit_length);\n                hx->intra_gb_ptr = &hx->intra_gb;\n                break;\n            case NAL_DPC:\n                init_get_bits(&hx->inter_gb, ptr, bit_length);\n                hx->inter_gb_ptr = &hx->inter_gb;\n                if (hx->redundant_pic_count == 0 &&\n                    hx->intra_gb_ptr &&\n                    hx->s.data_partitioning &&\n                    s->context_initialized &&\n                    (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc) &&\n                    (avctx->skip_frame < AVDISCARD_BIDIR  ||\n                     hx->slice_type_nos != AV_PICTURE_TYPE_B) &&\n                    (avctx->skip_frame < AVDISCARD_NONKEY ||\n                     hx->slice_type_nos == AV_PICTURE_TYPE_I) &&\n                    avctx->skip_frame < AVDISCARD_ALL)\n                    context_count++;\n                break;\n            case NAL_SEI:\n                init_get_bits(&s->gb, ptr, bit_length);\n                ff_h264_decode_sei(h);\n                break;\n            case NAL_SPS:\n                init_get_bits(&s->gb, ptr, bit_length);\n                if (ff_h264_decode_seq_parameter_set(h) < 0 &&\n                    h->is_avc && (nalsize != consumed) && nalsize) {\n                    av_log(h->s.avctx, AV_LOG_DEBUG,\n                           "SPS decoding failure, try parsing the coomplete NAL\\n");\n                    init_get_bits(&s->gb, buf + buf_index + 1 - consumed,\n                                  8 * (nalsize - 1));\n                    ff_h264_decode_seq_parameter_set(h);\n                }\n                if (s->flags & CODEC_FLAG_LOW_DELAY ||\n                    (h->sps.bitstream_restriction_flag &&\n                     !h->sps.num_reorder_frames))\n                    s->low_delay = 1;\n                if (avctx->has_b_frames < 2)\n                    avctx->has_b_frames = !s->low_delay;\n                if (avctx->bits_per_raw_sample != h->sps.bit_depth_luma ||\n                    h->cur_chroma_format_idc   != h->sps.chroma_format_idc) {\n                    if (h->sps.bit_depth_luma >= 8 && h->sps.bit_depth_luma <= 10) {\n                        avctx->bits_per_raw_sample = h->sps.bit_depth_luma;\n                        h->cur_chroma_format_idc   = h->sps.chroma_format_idc;\n                        h->pixel_shift             = h->sps.bit_depth_luma > 8;\n                        ff_h264dsp_init(&h->h264dsp, h->sps.bit_depth_luma,\n                                        h->sps.chroma_format_idc);\n                        ff_h264_pred_init(&h->hpc, s->codec_id,\n                                          h->sps.bit_depth_luma,\n                                          h->sps.chroma_format_idc);\n                        s->dsp.dct_bits = h->sps.bit_depth_luma > 8 ? 32 : 16;\n                        ff_dsputil_init(&s->dsp, s->avctx);\n                    } else {\n                        av_log(avctx, AV_LOG_ERROR,\n                               "Unsupported bit depth: %d\\n",\n                               h->sps.bit_depth_luma);\n                        return -1;\n                    }\n                }\n                break;\n            case NAL_PPS:\n                init_get_bits(&s->gb, ptr, bit_length);\n                ff_h264_decode_picture_parameter_set(h, bit_length);\n                break;\n            case NAL_AUD:\n            case NAL_END_SEQUENCE:\n            case NAL_END_STREAM:\n            case NAL_FILLER_DATA:\n            case NAL_SPS_EXT:\n            case NAL_AUXILIARY_SLICE:\n                break;\n            default:\n                av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\\n",\n                       hx->nal_unit_type, bit_length);\n            }\n            if (context_count == h->max_contexts) {\n                execute_decode_slices(h, context_count);\n                context_count = 0;\n            }\n            if (err < 0)\n                av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\\n");\n            else if (err == 1) {\n                h->nal_unit_type = hx->nal_unit_type;\n                h->nal_ref_idc   = hx->nal_ref_idc;\n                hx               = h;\n                goto again;\n            }\n        }\n    }\n    if (context_count)\n        execute_decode_slices(h, context_count);\n    return buf_index;\n}']