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

libavcodec/h264.c:1424:17: Call
1422.     }
1423. 
1424.     buf_index = decode_nal_units(h, buf, buf_size, 0);
                      ^
1425.     if (buf_index < 0)
1426.         return AVERROR_INVALIDDATA;

libavcodec/h264.c:1174:11: Call
  1172.     }
  1173. 
  1174.     ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc,
                  ^
  1175.                                 h->nal_length_size, avctx->codec_id);
  1176.     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:384:1: Parameter `bit_size`
      382.  * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
      383.  */
      384. static inline int init_get_bits(GetBitContext *s, const uint8_t *buffer,
           ^
      385.                                 int bit_size)
      386. {

libavcodec/get_bits.h:401:5: Assignment
      399.     s->size_in_bits       = bit_size;
      400. #if !UNCHECKED_BITSTREAM_READER
      401.     s->size_in_bits_plus8 = bit_size + 8;
               ^
      402. #endif
      403.     s->buffer_end         = buffer + buffer_size;

libavcodec/h264.c:1424:17: Call
1422.     }
1423. 
1424.     buf_index = decode_nal_units(h, buf, buf_size, 0);
                      ^
1425.     if (buf_index < 0)
1426.         return AVERROR_INVALIDDATA;

libavcodec/h264.c:1158:1: Parameter `h->slice_ctx->mb_field_decoding_flag`
  1156. }
  1157. 
  1158. static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size,
        ^
  1159.                             int parse_extradata)
  1160. {

libavcodec/h264.c:1328:15: Call
  1326.     }
  1327.     if (context_count) {
  1328.         ret = ff_h264_execute_decode_slices(h, context_count);
                      ^
  1329.         if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
  1330.             goto end;

libavcodec/h264_slice.c:2226:1: Parameter `h->slice_ctx->mb_field_decoding_flag`
    2224.  * @param context_count number of contexts to execute
    2225.  */
    2226. int ff_h264_execute_decode_slices(H264Context *h, unsigned context_count)
          ^
    2227. {
    2228.     AVCodecContext *const avctx = h->avctx;

libavcodec/h264_slice.c:2239:15: Call
    2237.         h->slice_ctx[0].next_slice_idx = h->mb_width * h->mb_height;
    2238. 
    2239.         ret = decode_slice(avctx, &h->slice_ctx[0]);
                        ^
    2240.         h->mb_y = h->slice_ctx[0].mb_y;
    2241.         return ret;

libavcodec/h264_slice.c:2038:1: Parameter `arg->mb_field_decoding_flag`
      2036. }
      2037. 
      2038. static int decode_slice(struct AVCodecContext *avctx, void *arg)
            ^
      2039. {
      2040.     H264SliceContext *sl = arg;

libavcodec/h264_slice.c:2079:19: Call
      2077.             }
      2078. 
      2079.             ret = ff_h264_decode_mb_cabac(h, sl);
                              ^
      2080.             // STOP_TIMER("decode_mb_cabac")
      2081. 

libavcodec/h264_cabac.c:1909:1: Parameter `sl->mb_field_decoding_flag`
        1907.  * @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR if an error is noticed
        1908.  */
        1909. int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl)
              ^
        1910. {
        1911.     int mb_xy;

libavcodec/h264_slice.c:2102:21: Call
      2100.                              sl->mb_y, ER_MB_END);
      2101.                 if (sl->mb_x >= lf_x_start)
      2102.                     loop_filter(h, sl, lf_x_start, sl->mb_x + 1);
                                ^
      2103.                 return 0;
      2104.             }

libavcodec/h264_slice.c:1910:1: Parameter `sl->mb_field_decoding_flag`
        1908. }
        1909. 
        1910. static void loop_filter(const H264Context *h, H264SliceContext *sl, int start_x, int end_x)
              ^
        1911. {
        1912.     uint8_t *dest_y, *dest_cb, *dest_cr;

libavcodec/h264_slice.c:1964:21: Call
        1962. 
        1963.                 if (FRAME_MBAFF(h)) {
        1964.                     ff_h264_filter_mb(h, sl, mb_x, mb_y, dest_y, dest_cb, dest_cr,
                                  ^
        1965.                                       linesize, uvlinesize);
        1966.                 } else {

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

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

libavcodec/h264_loopfilter.c:749:13: <Length trace>
747.             AV_WN64A(&bS[4], 0x0004000400040004ULL);
748.         } else {
749.             static const uint8_t offset[2][2][8]={
                 ^
750.                 {
751.                     {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:749:13: Array declaration
          747.             AV_WN64A(&bS[4], 0x0004000400040004ULL);
          748.         } else {
          749.             static const uint8_t offset[2][2][8]={
                           ^
          750.                 {
          751.                     {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:758:13: Array access: Offset: [0, 2147483648] Size: 2 by call to `decode_nal_units` 
          756.                 }
          757.             };
          758.             const uint8_t *off= offset[MB_FIELD(sl)][mb_y&1];
                           ^
          759.             for( i = 0; i < 8; i++ ) {
          760.                 int j= MB_FIELD(sl) ? i>>2 : i&1;
