libavcodec/ffv1enc.c:922: error: Buffer Overrun L1
  Offset: [256, +oo] Size: 8 by call to `encode_rgb_frame`.

libavcodec/ffv1enc.c:890:9: Call
888.         ffv1_clear_slice_state(f, fs);
889.     if (f->version > 2) {
890.         encode_slice_header(f, fs);
             ^
891.     }
892.     if (!fs->ac) {

libavcodec/ffv1enc.c:863:9: Call
  861.                0);
  862.     for (j = 0; j < f->plane_count; j++) {
  863.         put_symbol(c, state, f->plane[j].quant_table_index, 0);
               ^
  864.         av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
  865.     }

libavcodec/ffv1enc.c:136:5: Call
    134.                                    int v, int is_signed)
    135. {
    136.     put_symbol_inline(c, state, v, is_signed, NULL, NULL);
             ^
    137. }
    138. 

libavcodec/ffv1enc.c:109:13: Call
      107.             for (i = 0; i < e; i++)
      108.                 put_rac(c, state + 1 + i, 1);  // 1..10
      109.             put_rac(c, state + 1 + i, 0);
                       ^
      110. 
      111.             for (i = e - 1; i >= 0; i--)

libavcodec/rangecoder.h:85:1: Parameter `*state`
        83. }
        84. 
        85. static inline void put_rac(RangeCoder *c, uint8_t *const state, int bit)
            ^
        86. {
        87.     int range1 = (c->range * (*state)) >> 8;

libavcodec/rangecoder.h:87:5: Assignment
        85. static inline void put_rac(RangeCoder *c, uint8_t *const state, int bit)
        86. {
        87.     int range1 = (c->range * (*state)) >> 8;
                ^
        88. 
        89.     assert(*state);

libavcodec/rangecoder.h:93:9: Assignment
        91.     assert(range1 > 0);
        92.     if (!bit) {
        93.         c->range -= range1;
                    ^
        94.         *state    = c->zero_state[*state];
        95.     } else {

libavcodec/rangecoder.h:101:5: Call
         99.     }
        100. 
        101.     renorm_encoder(c);
                 ^
        102. }
        103. 

libavcodec/rangecoder.h:52:1: Parameter `c->range`
          50. void ff_build_rac_states(RangeCoder *c, int factor, int max_p);
          51. 
          52. static inline void renorm_encoder(RangeCoder *c)
              ^
          53. {
          54.     // FIXME: optimize

libavcodec/ffv1enc.c:922:9: Call
920.                                      p->data[1] + ps * x + y * p->linesize[1],
921.                                      p->data[2] + ps * x + y * p->linesize[2] };
922.         encode_rgb_frame(fs, planes, width, height, p->linesize);
             ^
923.     }
924.     emms_c();

libavcodec/ffv1enc.c:296:1: Parameter `s->plane[*].quant_table_index`
  294. }
  295. 
  296. static void encode_rgb_frame(FFV1Context *s, const uint8_t *src[3],
       ^
  297.                              int w, int h, const int stride[3])
  298. {

libavcodec/ffv1enc.c:349:17: Call
  347.             sample[p][1][w]  = sample[p][1][w - 1];
  348.             if (lbd)
  349.                 encode_line(s, w, sample[p], (p + 1) / 2, 9);
                       ^
  350.             else
  351.                 encode_line(s, w, sample[p], (p + 1) / 2, bits + 1);

libavcodec/ffv1enc.c:170:1: <Offset trace>
168. }
169. 
170. static av_always_inline int encode_line(FFV1Context *s, int w,
     ^
171.                                         int16_t *sample[3],
172.                                         int plane_index, int bits)

libavcodec/ffv1enc.c:170:1: Parameter `s->plane[*].quant_table_index`
    168. }
    169. 
    170. static av_always_inline int encode_line(FFV1Context *s, int w,
         ^
    171.                                         int16_t *sample[3],
    172.                                         int plane_index, int bits)

libavcodec/ffv1enc.c:170:1: <Length trace>
168. }
169. 
170. static av_always_inline int encode_line(FFV1Context *s, int w,
     ^
171.                                         int16_t *sample[3],
172.                                         int plane_index, int bits)

libavcodec/ffv1enc.c:170:1: Parameter `s->rc_stat2[*]`
    168. }
    169. 
    170. static av_always_inline int encode_line(FFV1Context *s, int w,
         ^
    171.                                         int16_t *sample[3],
    172.                                         int plane_index, int bits)

libavcodec/ffv1enc.c:209:35: Array access: Offset: [256, +oo] Size: 8 by call to `encode_rgb_frame` 
    207.             if (s->flags & AV_CODEC_FLAG_PASS1) {
    208.                 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
    209.                                   s->rc_stat2[p->quant_table_index][context]);
                                           ^
    210.             } else {
    211.                 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
