libavcodec/amrnbdec.c:1015: error: Buffer Overrun L2
  Offset: [1, 77] Size: 2 by call to `anti_sparseness`.

libavcodec/amrnbdec.c:966:9: Call
964.         const AMRNBSubframe *amr_subframe = &p->frame.subframe[subframe];
965. 
966.         decode_pitch_vector(p, amr_subframe, subframe);
             ^
967. 
968.         decode_fixed_sparse(&fixed_sparse, amr_subframe->pulses,

libavcodec/amrnbdec.c:381:9: Call
  379. 
  380.     if (p->cur_frame_mode == MODE_12k2) {
  381.         decode_pitch_lag_1_6(&pitch_lag_int, &pitch_lag_frac,
               ^
  382.                              amr_subframe->p_lag, p->pitch_lag_int,
  383.                              subframe);

libavcodec/amrnbdec.c:354:1: Parameter `pitch_index`
    352.  * Like ff_decode_pitch_lag(), but with 1/6 resolution
    353.  */
    354. static void decode_pitch_lag_1_6(int *lag_int, int *lag_frac, int pitch_index,
         ^
    355.                                  const int prev_lag_int, const int subframe)
    356. {

libavcodec/amrnbdec.c:359:13: Assignment
    357.     if (subframe == 0 || subframe == 2) {
    358.         if (pitch_index < 463) {
    359.             *lag_int  = (pitch_index + 107) * 10923 >> 16;
                     ^
    360.             *lag_frac = pitch_index - *lag_int * 6 + 105;
    361.         } else {

libavcodec/amrnbdec.c:391:5: Assignment
  389.                             mode <= MODE_6k7 ? 4 : (mode == MODE_7k95 ? 5 : 6));
  390. 
  391.     p->pitch_lag_int = pitch_lag_int; // store previous lag in a uint8_t
           ^
  392. 
  393.     pitch_lag_frac <<= (p->cur_frame_mode != MODE_12k2);

libavcodec/amrnbdec.c:978:9: Call
976.                      &fixed_gain_factor);
977. 
978.         pitch_sharpening(p, subframe, p->cur_frame_mode, &fixed_sparse);
             ^
979. 
980.         if (fixed_sparse.pitch_lag == 0) {

libavcodec/amrnbdec.c:533:1: Parameter `p->pitch_lag_int`
  531.  * @param fixed_sparse sparse respresentation of the fixed vector
  532.  */
  533. static void pitch_sharpening(AMRContext *p, int subframe, enum Mode mode,
       ^
  534.                              AMRFixed *fixed_sparse)
  535. {

libavcodec/amrnbdec.c:542:5: Assignment
  540.         p->beta = FFMIN(p->pitch_gain[4], 1.0);
  541. 
  542.     fixed_sparse->pitch_lag  = p->pitch_lag_int;
           ^
  543.     fixed_sparse->pitch_fac  = p->beta;
  544. 

libavcodec/amrnbdec.c:1015:30: Call
1013.                                              p->lsf_avg, p->cur_frame_mode);
1014. 
1015.         synth_fixed_vector = anti_sparseness(p, &fixed_sparse, p->fixed_vector,
                                   ^
1016.                                              synth_fixed_gain, spare_vector);
1017. 

libavcodec/amrnbdec.c:700:1: Parameter `fixed_sparse->pitch_lag`
  698.  * @param out space for modified vector if necessary
  699.  */
  700. static const float *anti_sparseness(AMRContext *p, AMRFixed *fixed_sparse,
       ^
  701.                                     const float *fixed_vector,
  702.                                     float fixed_gain, float *out)

libavcodec/amrnbdec.c:741:9: Call
  739.     if (p->cur_frame_mode != MODE_7k4 && p->cur_frame_mode < MODE_10k2
  740.          && ir_filter_nr < 2) {
  741.         apply_ir_filter(out, fixed_sparse,
               ^
  742.                         (p->cur_frame_mode == MODE_7k95 ?
  743.                              ir_filters_lookup_MODE_7k95 :

libavcodec/amrnbdec.c:653:1: Parameter `*filter`
    651.  *  out[n] = sum(i,0,len-1){ in[i] * filter[(len + n - i)%len] }
    652.  */
    653. static void apply_ir_filter(float *out, const AMRFixed *in,
         ^
    654.                             const float *filter)
    655. {

libavcodec/amrnbdec.c:663:9: Call
    661. 
    662.     if (lag < AMR_SUBFRAME_SIZE) {
    663.         ff_celp_circ_addf(filter1, filter, filter, lag, fac,
                 ^
    664.                           AMR_SUBFRAME_SIZE);
    665. 

libavcodec/celp_filters.c:48:1: <Offset trace>
46. }
47. 
48. void ff_celp_circ_addf(float *out, const float *in,
    ^
49.                        const float *lagged, int lag, float fac, int n)
50. {

libavcodec/celp_filters.c:48:1: Parameter `lag`
      46. }
      47. 
      48. void ff_celp_circ_addf(float *out, const float *in,
          ^
      49.                        const float *lagged, int lag, float fac, int n)
      50. {

libavcodec/celp_filters.c:48:1: <Length trace>
46. }
47. 
48. void ff_celp_circ_addf(float *out, const float *in,
    ^
49.                        const float *lagged, int lag, float fac, int n)
50. {

libavcodec/celp_filters.c:48:1: Parameter `*lagged`
      46. }
      47. 
      48. void ff_celp_circ_addf(float *out, const float *in,
          ^
      49.                        const float *lagged, int lag, float fac, int n)
      50. {

libavcodec/celp_filters.c:53:32: Array access: Offset: [1, 77] Size: 2 by call to `anti_sparseness` 
      51.     int k;
      52.     for (k = 0; k < lag; k++)
      53.         out[k] = in[k] + fac * lagged[n + k - lag];
                                         ^
      54.     for (; k < n; k++)
      55.         out[k] = in[k] + fac * lagged[    k - lag];
