libavcodec/h264.c:1058: error: Integer Overflow L2
  ([16, 4294967296] + 1):signed32 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->cur_pic.qscale_table`
  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:949:15: Call
  947.     }
  948.     if (context_count) {
  949.         ret = ff_h264_execute_decode_slices(h, context_count);
                     ^
  950.         if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
  951.             goto end;

libavcodec/h264_slice.c:2132:1: Parameter `*h->cur_pic.qscale_table`
    2130.  * @param context_count number of contexts to execute
    2131.  */
    2132. int ff_h264_execute_decode_slices(H264Context *h, unsigned context_count)
          ^
    2133. {
    2134.     AVCodecContext *const avctx = h->avctx;

libavcodec/h264_slice.c:2191:21: Call
    2189.                 for (j = sl->resync_mb_y; j < y_end; j += 1 + FIELD_OR_MBAFF_PICTURE(h)) {
    2190.                     sl->mb_y = j;
    2191.                     loop_filter(h, sl, j > sl->resync_mb_y ? 0 : sl->resync_mb_x,
                              ^
    2192.                                 j == y_end - 1 ? x_end : h->mb_width);
    2193.                 }

libavcodec/h264_slice.c:1807:1: Parameter `*h->cur_pic.qscale_table`
      1805. }
      1806. 
      1807. static void loop_filter(const H264Context *h, H264SliceContext *sl, int start_x, int end_x)
            ^
      1808. {
      1809.     uint8_t *dest_y, *dest_cb, *dest_cr;

libavcodec/h264_slice.c:1865:21: Call
      1863.                                       linesize, uvlinesize);
      1864.                 } else {
      1865.                     ff_h264_filter_mb_fast(h, sl, mb_x, mb_y, dest_y, dest_cb,
                                ^
      1866.                                            dest_cr, linesize, uvlinesize);
      1867.                 }

libavcodec/h264_loopfilter.c:419:1: Parameter `*h->cur_pic.qscale_table`
        417. }
        418. 
        419. void ff_h264_filter_mb_fast(const H264Context *h, H264SliceContext *sl,
             ^
        420.                             int mb_x, int mb_y, uint8_t *img_y,
        421.                             uint8_t *img_cb, uint8_t *img_cr,

libavcodec/h264_loopfilter.c:436:9: Call
        434.         h264_filter_mb_fast_internal(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, 1);
        435.     }else{
        436.         h264_filter_mb_fast_internal(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, 0);
                     ^
        437.     }
        438. #endif

libavcodec/h264_loopfilter.c:237:1: <LHS trace>
235. }
236. 
237. static av_always_inline void h264_filter_mb_fast_internal(const H264Context *h,
     ^
238.                                                           H264SliceContext *sl,
239.                                                           int mb_x, int mb_y,

libavcodec/h264_loopfilter.c:237:1: Parameter `*h->cur_pic.qscale_table`
          235. }
          236. 
          237. static av_always_inline void h264_filter_mb_fast_internal(const H264Context *h,
               ^
          238.                                                           H264SliceContext *sl,
          239.                                                           int mb_x, int mb_y,

libavcodec/h264_loopfilter.c:260:5: Assignment
          258. 
          259.     int mb_type = h->cur_pic.mb_type[mb_xy];
          260.     int qp      = h->cur_pic.qscale_table[mb_xy];
                   ^
          261.     int qp0     = h->cur_pic.qscale_table[mb_xy - 1];
          262.     int qp1     = h->cur_pic.qscale_table[sl->top_mb_xy];

libavcodec/h264_loopfilter.c:266:5: Binary operation: ([16, 4294967296] + 1):signed32 by call to `decode_nal_units` 
          264.     int qpc0 = get_chroma_qp(h->ps.pps, 0, qp0);
          265.     int qpc1 = get_chroma_qp(h->ps.pps, 0, qp1);
          266.     qp0 = (qp + qp0 + 1) >> 1;
                   ^
          267.     qp1 = (qp + qp1 + 1) >> 1;
          268.     qpc0 = (qpc + qpc0 + 1) >> 1;
