libavcodec/h264.c:1058: error: Buffer Overrun L2
  Offset: [0, 4294967311] Size: 48 by call to `decode_nal_units`.

libavcodec/h264.c:1058:17: Call
1056.     }
1057. 
1058.     buf_index = decode_nal_units(h, buf, buf_size);
                      ^
1059.     if (buf_index < 0)
1060.         return AVERROR_INVALIDDATA;

libavcodec/h264.c:817:11: Call
  815.     }
  816. 
  817.     ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc,
                 ^
  818.                                 h->nal_length_size, avctx->codec_id);
  819.     if (ret < 0) {

libavcodec/h2645_parse.c:260:15: Call
    258.         nal->size_bits = get_bit_length(nal, skip_trailing_zeros);
    259. 
    260.         ret = init_get_bits(&nal->gb, nal->data, nal->size_bits);
                       ^
    261.         if (ret < 0)
    262.             return ret;

libavcodec/get_bits.h:362:1: Parameter `bit_size`
      360.  * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
      361.  */
      362. static inline int init_get_bits(GetBitContext *s, const uint8_t *buffer,
           ^
      363.                                 int bit_size)
      364. {

libavcodec/get_bits.h:379:5: Assignment
      377.     s->size_in_bits       = bit_size;
      378. #if !UNCHECKED_BITSTREAM_READER
      379.     s->size_in_bits_plus8 = bit_size + 8;
               ^
      380. #endif
      381.     s->buffer_end         = buffer + buffer_size;

libavcodec/h264.c:1058:17: Call
1056.     }
1057. 
1058.     buf_index = decode_nal_units(h, buf, buf_size);
                      ^
1059.     if (buf_index < 0)
1060.         return AVERROR_INVALIDDATA;

libavcodec/h264.c:803:1: Parameter `h->slice_ctx->ref_count[*]`
  801. }
  802. 
  803. static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
       ^
  804. {
  805.     AVCodecContext *const avctx = h->avctx;

libavcodec/h264.c:854:24: Call
  852.             sl->gb = nal->gb;
  853. 
  854.             if ((err = ff_h264_decode_slice_header(h, sl)))
                              ^
  855.                 break;
  856. 

libavcodec/h264_slice.c:1422:1: Parameter `sl->ref_count[*]`
    1420.  * @return 0 if okay, <0 if an error occurred
    1421.  */
    1422. int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl)
          ^
    1423. {
    1424.     int i, j, ret = 0;

libavcodec/h264_slice.c:1426:11: Call
    1424.     int i, j, ret = 0;
    1425. 
    1426.     ret = h264_slice_header_parse(h, sl);
                    ^
    1427.     if (ret < 0)
    1428.         return ret;

libavcodec/h264_slice.c:1166:1: Parameter `sl->ref_count[*]`
      1164. }
      1165. 
      1166. static int h264_slice_header_parse(H264Context *h, H264SliceContext *sl)
            ^
      1167. {
      1168.     const SPS *sps;

libavcodec/h264_slice.c:1464:9: Call
    1462.     if (h->ps.pps->weighted_bipred_idc == 2 &&
    1463.         sl->slice_type_nos == AV_PICTURE_TYPE_B) {
    1464.         implicit_weight_table(h, sl, -1);
                  ^
    1465.         if (FRAME_MBAFF(h)) {
    1466.             implicit_weight_table(h, sl, 0);

libavcodec/h264_slice.c:611:1: <Offset trace>
609.  *                -1 initializes the rest
610.  */
611. static void implicit_weight_table(const H264Context *h, H264SliceContext *sl, int field)
     ^
612. {
613.     int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;

libavcodec/h264_slice.c:611:1: Parameter `sl->ref_count[*]`
      609.  *                -1 initializes the rest
      610.  */
      611. static void implicit_weight_table(const H264Context *h, H264SliceContext *sl, int field)
           ^
      612. {
      613.     int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;

libavcodec/h264_slice.c:634:9: Assignment
      632.         ref_start  = 0;
      633.         ref_count0 = sl->ref_count[0];
      634.         ref_count1 = sl->ref_count[1];
                   ^
      635.     } else {
      636.         cur_poc    = h->cur_pic_ptr->field_poc[field];

libavcodec/h264_slice.c:611:1: <Length trace>
609.  *                -1 initializes the rest
610.  */
611. static void implicit_weight_table(const H264Context *h, H264SliceContext *sl, int field)
     ^
612. {
613.     int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;

libavcodec/h264_slice.c:611:1: Parameter `sl->ref_list[*][*]`
      609.  *                -1 initializes the rest
      610.  */
      611. static void implicit_weight_table(const H264Context *h, H264SliceContext *sl, int field)
           ^
      612. {
      613.     int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;

libavcodec/h264_slice.c:651:61: Array access: Offset: [0, 4294967311] Size: 48 by call to `decode_nal_units` 
      649.         for (ref1 = ref_start; ref1 < ref_count1; ref1++) {
      650.             int w = 32;
      651.             if (!sl->ref_list[0][ref0].parent->long_ref && !sl->ref_list[1][ref1].parent->long_ref) {
                                                                       ^
      652.                 int poc1 = sl->ref_list[1][ref1].poc;
      653.                 int td   = av_clip_int8(poc1 - poc0);
