libavcodec/h264dec.c:883: error: Buffer Overrun L2
  Offset: [0, 2147483648] Size: 2 by call to `decode_nal_units`.

libavcodec/h264dec.c:883:17: Call
881.     }
882. 
883.     buf_index = decode_nal_units(h, buf, buf_size);
                     ^
884.     if (buf_index < 0)
885.         return AVERROR_INVALIDDATA;

libavcodec/h264dec.c:670:11: Call
  668.     }
  669. 
  670.     ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc,
                 ^
  671.                                 h->nal_length_size, avctx->codec_id);
  672.     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/h264dec.c:883:17: Call
881.     }
882. 
883.     buf_index = decode_nal_units(h, buf, buf_size);
                     ^
884.     if (buf_index < 0)
885.         return AVERROR_INVALIDDATA;

libavcodec/h264dec.c:656:1: Parameter `h->slice_ctx->mb_field_decoding_flag`
  654. }
  655. 
  656. static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
       ^
  657. {
  658.     AVCodecContext *const avctx = h->avctx;

libavcodec/h264dec.c:762:19: Call
  760. 
  761.         if (context_count == h->nb_slice_ctx) {
  762.             ret = ff_h264_execute_decode_slices(h, context_count);
                         ^
  763.             if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
  764.                 goto end;

libavcodec/h264_slice.c:2324:1: Parameter `h->slice_ctx->mb_field_decoding_flag`
    2322.  * @param context_count number of contexts to execute
    2323.  */
    2324. int ff_h264_execute_decode_slices(H264Context *h, unsigned context_count)
          ^
    2325. {
    2326.     AVCodecContext *const avctx = h->avctx;

libavcodec/h264_slice.c:2383:21: Call
    2381.                 for (j = sl->resync_mb_y; j < y_end; j += 1 + FIELD_OR_MBAFF_PICTURE(h)) {
    2382.                     sl->mb_y = j;
    2383.                     loop_filter(h, sl, j > sl->resync_mb_y ? 0 : sl->resync_mb_x,
                              ^
    2384.                                 j == y_end - 1 ? x_end : h->mb_width);
    2385.                 }

libavcodec/h264_slice.c:2000:1: Parameter `sl->mb_field_decoding_flag`
      1998. }
      1999. 
      2000. static void loop_filter(const H264Context *h, H264SliceContext *sl, int start_x, int end_x)
            ^
      2001. {
      2002.     uint8_t *dest_y, *dest_cb, *dest_cr;

libavcodec/h264_slice.c:2058:21: Call
      2056.                                       linesize, uvlinesize);
      2057.                 } else {
      2058.                     ff_h264_filter_mb_fast(h, sl, mb_x, mb_y, dest_y, dest_cb,
                                ^
      2059.                                            dest_cr, linesize, uvlinesize);
      2060.                 }

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

libavcodec/h264_loopfilter.c:427:9: Call
        425.     assert(!FRAME_MBAFF(h));
        426.     if(!h->h264dsp.h264_loop_filter_strength || h->ps.pps->chroma_qp_diff) {
        427.         ff_h264_filter_mb(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize);
                     ^
        428.         return;
        429.     }

libavcodec/h264_loopfilter.c:716:1: <Offset trace>
714. }
715. 
716. void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl,
     ^
717.                        int mb_x, int mb_y,
718.                        uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr,

libavcodec/h264_loopfilter.c:716:1: Parameter `sl->mb_field_decoding_flag`
          714. }
          715. 
          716. void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl,
               ^
          717.                        int mb_x, int mb_y,
          718.                        uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr,

libavcodec/h264_loopfilter.c:750:13: <Length trace>
748.             AV_WN64A(&bS[4], 0x0004000400040004ULL);
749.         } else {
750.             static const uint8_t offset[2][2][8]={
                 ^
751.                 {
752.                     {3+4*0, 3+4*0, 3+4*0, 3+4*0, 3+4*1, 3+4*1, 3+4*1, 3+4*1},

libavcodec/h264_loopfilter.c:750:13: Array declaration
          748.             AV_WN64A(&bS[4], 0x0004000400040004ULL);
          749.         } else {
          750.             static const uint8_t offset[2][2][8]={
                           ^
          751.                 {
          752.                     {3+4*0, 3+4*0, 3+4*0, 3+4*0, 3+4*1, 3+4*1, 3+4*1, 3+4*1},

libavcodec/h264_loopfilter.c:759:13: Array access: Offset: [0, 2147483648] Size: 2 by call to `decode_nal_units` 
          757.                 }
          758.             };
          759.             const uint8_t *off= offset[MB_FIELD(sl)][mb_y&1];
                           ^
          760.             for( i = 0; i < 8; i++ ) {
          761.                 int j= MB_FIELD(sl) ? i>>2 : i&1;
