libavcodec/rv34.c:1151: error: Buffer Overrun L2
  Offset: [1, 16843009] Size: 108 by call to `rv34_decode_block`.

libavcodec/rv34.c:1122:5: Call
1120.     // Calculate which neighbours are available. Maybe it's worth optimizing too.
1121.     memset(r->avail_cache, 0, sizeof(r->avail_cache));
1122.     fill_rectangle(r->avail_cache + 6, 2, 2, 4, 1, 4);
          ^
1123.     dist = (s->mb_x - s->resync_mb_x) + (s->mb_y - s->resync_mb_y) * s->mb_width;
1124.     if(s->mb_x && dist)

libavcodec/rectangle.h:42:1: Parameter `val`
  40.  * @param size the size of val (1, 2 or 4), should be a constant
  41.  */
  42. static av_always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){
      ^
  43.     uint8_t *p= (uint8_t*)vp;
  44.     assert(size==1 || size==2 || size==4);

libavcodec/rectangle.h:109:9: Assignment
  107.         *(uint32_t*)(p + 4+1*stride)= val;
  108.         *(uint32_t*)(p + 8+1*stride)= val;
  109.         *(uint32_t*)(p +12+1*stride)= val;
               ^
  110.         if(h==2) return;
  111.         *(uint32_t*)(p + 0+2*stride)= val;

libavcodec/rv34.c:1151:9: Call
1149.     if(r->is16){
1150.         memset(block16, 0, sizeof(block16));
1151.         rv34_decode_block(block16, gb, r->cur_vlcs, 3, 0);
              ^
1152.         rv34_dequant4x4_16x16(block16, rv34_qscale_tab[luma_dc_quant],rv34_qscale_tab[s->qscale]);
1153.         r->rdsp.rv34_inv_transform_tab[1](block16);

libavcodec/rv34.c:265:1: Parameter `(*rvlc->second_pattern[*].table)[*]`
  263.  */
  264. 
  265. static inline void rv34_decode_block(DCTELEM *dst, GetBitContext *gb, RV34VLC *rvlc, int fc, int sc)
       ^
  266. {
  267.     int code, pattern;

libavcodec/rv34.c:277:16: Call
  275. 
  276.     if(pattern & 4){
  277.         code = get_vlc2(gb, rvlc->second_pattern[sc].table, 9, 2);
                      ^
  278.         decode_subblock(dst + 2, code, 0, gb, &rvlc->coefficient);
  279.     }

libavcodec/get_bits.h:506:1: Parameter `(*table)[*]`
    504.  *                  = (max_vlc_length + bits - 1) / bits
    505.  */
    506. static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2],
         ^
    507.                                   int bits, int max_depth)
    508. {

libavcodec/get_bits.h:514:5: Assignment
    512.     UPDATE_CACHE(re, s);
    513. 
    514.     GET_VLC(code, re, s, table, bits, max_depth);
             ^
    515. 
    516.     CLOSE_READER(re, s);

libavcodec/get_bits.h:517:5: Assignment
    515. 
    516.     CLOSE_READER(re, s);
    517.     return code;
             ^
    518. }
    519. 

libavcodec/rv34.c:277:9: Assignment
  275. 
  276.     if(pattern & 4){
  277.         code = get_vlc2(gb, rvlc->second_pattern[sc].table, 9, 2);
               ^
  278.         decode_subblock(dst + 2, code, 0, gb, &rvlc->coefficient);
  279.     }

libavcodec/rv34.c:278:9: Call
  276.     if(pattern & 4){
  277.         code = get_vlc2(gb, rvlc->second_pattern[sc].table, 9, 2);
  278.         decode_subblock(dst + 2, code, 0, gb, &rvlc->coefficient);
               ^
  279.     }
  280.     if(pattern & 2){ // Looks like coefficients 1 and 2 are swapped for this block

libavcodec/rv34.c:235:1: <Offset trace>
233.  * Decode 2x2 subblock of coefficients.
234.  */
235. static inline void decode_subblock(DCTELEM *dst, int code, const int is_block2, GetBitContext *gb, VLC *vlc)
     ^
236. {
237.     int coeffs[4];

libavcodec/rv34.c:235:1: Parameter `code`
    233.  * Decode 2x2 subblock of coefficients.
    234.  */
    235. static inline void decode_subblock(DCTELEM *dst, int code, const int is_block2, GetBitContext *gb, VLC *vlc)
         ^
    236. {
    237.     int coeffs[4];

libavcodec/rv34data.h:53:1: <Length trace>
51.  * This table allows conversion from a value back to a vector.
52.  */
53. static const uint8_t modulo_three_table[108][4] = {
    ^
54.  { 0, 0, 0, 0 }, { 0, 0, 0, 1 }, { 0, 0, 0, 2 }, { 0, 0, 1, 0 },
55.  { 0, 0, 1, 1 }, { 0, 0, 1, 2 }, { 0, 0, 2, 0 }, { 0, 0, 2, 1 },

libavcodec/rv34data.h:53:1: Array declaration
    51.  * This table allows conversion from a value back to a vector.
    52.  */
    53. static const uint8_t modulo_three_table[108][4] = {
        ^
    54.  { 0, 0, 0, 0 }, { 0, 0, 0, 1 }, { 0, 0, 0, 2 }, { 0, 0, 1, 0 },
    55.  { 0, 0, 1, 1 }, { 0, 0, 1, 2 }, { 0, 0, 2, 0 }, { 0, 0, 2, 1 },

libavcodec/rv34.c:239:17: Array access: Offset: [1, 16843009] Size: 108 by call to `rv34_decode_block` 
    237.     int coeffs[4];
    238. 
    239.     coeffs[0] = modulo_three_table[code][0];
                         ^
    240.     coeffs[1] = modulo_three_table[code][1];
    241.     coeffs[2] = modulo_three_table[code][2];
