libavcodec/sipr.c:454: error: Buffer Overrun L3
  Offset: [-2, +oo] (⇐ [10, +oo] + [-12, -7]) Size: 58 by call to `eval_ir`.

libavcodec/sipr.c:409:1: Array declaration
407. }
408. 
409. static void decode_frame(SiprContext *ctx, SiprParameters *params,
     ^
410.                          float *out_data)
411. {

libavcodec/sipr.c:419:5: Assignment
417.     float ir_buf[SUBFR_SIZE + LP_FILTER_ORDER];
418.     float lsf_new[LP_FILTER_ORDER];
419.     float *impulse_response = ir_buf + LP_FILTER_ORDER;
         ^
420.     float *synth = ctx->synth_buf + 16; // 16 instead of LP_FILTER_ORDER for
421.                                         // memory alignment

libavcodec/sipr.c:454:9: Call
452.                             ctx->past_pitch_gain < 0.8);
453. 
454.         eval_ir(pAz, T0, impulse_response, modes[ctx->mode].pitch_sharp_factor);
             ^
455. 
456.         convolute_with_sparse(fixed_vector, &fixed_cb, impulse_response,

libavcodec/sipr.c:282:1: Parameter `*freq`
  280.  * Evaluates the adaptative impulse response.
  281.  */
  282. static void eval_ir(const float *Az, int pitch_lag, float *freq,
       ^
  283.                     float pitch_sharp_factor)
  284. {

libavcodec/sipr.c:295:5: Call
  293.     memset(tmp1 + 11, 0, 37 * sizeof(float));
  294. 
  295.     ff_celp_lp_synthesis_filterf(freq, tmp2, tmp1, SUBFR_SIZE,
           ^
  296.                                  LP_FILTER_ORDER);
  297. 

libavcodec/celp_filters.c:83:1: <Offset trace>
81. }
82. 
83. void ff_celp_lp_synthesis_filterf(float *out, const float *filter_coeffs,
    ^
84.                                   const float* in, int buffer_length,
85.                                   int filter_length)

libavcodec/celp_filters.c:83:1: Parameter `filter_length`
    81. }
    82. 
    83. void ff_celp_lp_synthesis_filterf(float *out, const float *filter_coeffs,
        ^
    84.                                   const float* in, int buffer_length,
    85.                                   int filter_length)

libavcodec/celp_filters.c:83:1: <Length trace>
81. }
82. 
83. void ff_celp_lp_synthesis_filterf(float *out, const float *filter_coeffs,
    ^
84.                                   const float* in, int buffer_length,
85.                                   int filter_length)

libavcodec/celp_filters.c:83:1: Parameter `*out`
    81. }
    82. 
    83. void ff_celp_lp_synthesis_filterf(float *out, const float *filter_coeffs,
        ^
    84.                                   const float* in, int buffer_length,
    85.                                   int filter_length)

libavcodec/celp_filters.c:150:24: Array access: Offset: [-2, +oo] (⇐ [10, +oo] + [-12, -7]) Size: 58 by call to `eval_ir` 
    148.             FFSWAP(float, old_out0, old_out2);
    149.             old_out1 = old_out3;
    150.             old_out3 = out[-i-2];
                                ^
    151.         }
    152. 

void ff_celp_lp_synthesis_filterf(float *out, const float *filter_coeffs,
                                  const float* in, int buffer_length,
                                  int filter_length)
{
    int i,n;
    float out0, out1, out2, out3;
    float old_out0, old_out1, old_out2, old_out3;
    float a,b,c;
    a = filter_coeffs[0];
    b = filter_coeffs[1];
    c = filter_coeffs[2];
    b -= filter_coeffs[0] * filter_coeffs[0];
    c -= filter_coeffs[1] * filter_coeffs[0];
    c -= filter_coeffs[0] * b;
    old_out0 = out[-4];
    old_out1 = out[-3];
    old_out2 = out[-2];
    old_out3 = out[-1];
    for (n = 0; n <= buffer_length - 4; n+=4) {
        float tmp0,tmp1,tmp2,tmp3;
        float val;
        out0 = in[0];
        out1 = in[1];
        out2 = in[2];
        out3 = in[3];
        out0 -= filter_coeffs[2] * old_out1;
        out1 -= filter_coeffs[2] * old_out2;
        out2 -= filter_coeffs[2] * old_out3;
        out0 -= filter_coeffs[1] * old_out2;
        out1 -= filter_coeffs[1] * old_out3;
        out0 -= filter_coeffs[0] * old_out3;
        val = filter_coeffs[3];
        out0 -= val * old_out0;
        out1 -= val * old_out1;
        out2 -= val * old_out2;
        out3 -= val * old_out3;
        old_out3 = out[-5];
        for (i = 5; i <= filter_length; i += 2) {
            val = filter_coeffs[i-1];
            out0 -= val * old_out3;
            out1 -= val * old_out0;
            out2 -= val * old_out1;
            out3 -= val * old_out2;
            old_out2 = out[-i-1];
            val = filter_coeffs[i];
            out0 -= val * old_out2;
            out1 -= val * old_out3;
            out2 -= val * old_out0;
            out3 -= val * old_out1;
            FFSWAP(float, old_out0, old_out2);
            old_out1 = old_out3;
            old_out3 = out[-i-2];
        }
        tmp0 = out0;
        tmp1 = out1;
        tmp2 = out2;
        tmp3 = out3;
        out3 -= a * tmp2;
        out2 -= a * tmp1;
        out1 -= a * tmp0;
        out3 -= b * tmp1;
        out2 -= b * tmp0;
        out3 -= c * tmp0;
        out[0] = out0;
        out[1] = out1;
        out[2] = out2;
        out[3] = out3;
        old_out0 = out0;
        old_out1 = out1;
        old_out2 = out2;
        old_out3 = out3;
        out += 4;
        in  += 4;
    }
    out -= n;
    in -= n;
    for (; n < buffer_length; n++) {
        out[n] = in[n];
        for (i = 1; i <= filter_length; i++)
            out[n] -= filter_coeffs[i-1] * out[n-i];
    }
}
['static void decode_frame(SiprContext *ctx, SiprParameters *params,\n                         float *out_data)\n{\n    int i, j;\n    int subframe_count = modes[ctx->mode].subframe_count;\n    int frame_size = subframe_count * SUBFR_SIZE;\n    float Az[LP_FILTER_ORDER * MAX_SUBFRAME_COUNT];\n    float *excitation;\n    float ir_buf[SUBFR_SIZE + LP_FILTER_ORDER];\n    float lsf_new[LP_FILTER_ORDER];\n    float *impulse_response = ir_buf + LP_FILTER_ORDER;\n    float *synth = ctx->synth_buf + 16;\n    int t0_first = 0;\n    AMRFixed fixed_cb;\n    memset(ir_buf, 0, LP_FILTER_ORDER * sizeof(float));\n    lsf_decode_fp(lsf_new, ctx->lsf_history, params);\n    sipr_decode_lp(lsf_new, ctx->lsp_history, Az, subframe_count);\n    memcpy(ctx->lsp_history, lsf_new, LP_FILTER_ORDER * sizeof(float));\n    excitation = ctx->excitation + PITCH_DELAY_MAX + L_INTERPOL;\n    for (i = 0; i < subframe_count; i++) {\n        float *pAz = Az + i*LP_FILTER_ORDER;\n        float fixed_vector[SUBFR_SIZE];\n        int T0,T0_frac;\n        float pitch_gain, gain_code, avg_energy;\n        ff_decode_pitch_lag(&T0, &T0_frac, params->pitch_delay[i], t0_first, i,\n                            ctx->mode == MODE_5k0, 6);\n        if (i == 0 || (i == 2 && ctx->mode == MODE_5k0))\n            t0_first = T0;\n        ff_acelp_interpolatef(excitation, excitation - T0 + (T0_frac <= 0),\n                              ff_b60_sinc, 6,\n                              2 * ((2 + T0_frac)%3 + 1), LP_FILTER_ORDER,\n                              SUBFR_SIZE);\n        decode_fixed_sparse(&fixed_cb, params->fc_indexes[i], ctx->mode,\n                            ctx->past_pitch_gain < 0.8);\n        eval_ir(pAz, T0, impulse_response, modes[ctx->mode].pitch_sharp_factor);\n        convolute_with_sparse(fixed_vector, &fixed_cb, impulse_response,\n                              SUBFR_SIZE);\n        avg_energy =\n            (0.01 + ff_dot_productf(fixed_vector, fixed_vector, SUBFR_SIZE))/\n                SUBFR_SIZE;\n        ctx->past_pitch_gain = pitch_gain = gain_cb[params->gc_index[i]][0];\n        gain_code = ff_amr_set_fixed_gain(gain_cb[params->gc_index[i]][1],\n                                          avg_energy, ctx->energy_history,\n                                          34 - 15.0/(0.05*M_LN10/M_LN2),\n                                          pred);\n        ff_weighted_vector_sumf(excitation, excitation, fixed_vector,\n                                pitch_gain, gain_code, SUBFR_SIZE);\n        pitch_gain *= 0.5 * pitch_gain;\n        pitch_gain = FFMIN(pitch_gain, 0.4);\n        ctx->gain_mem = 0.7 * ctx->gain_mem + 0.3 * pitch_gain;\n        ctx->gain_mem = FFMIN(ctx->gain_mem, pitch_gain);\n        gain_code *= ctx->gain_mem;\n        for (j = 0; j < SUBFR_SIZE; j++)\n            fixed_vector[j] = excitation[j] - gain_code * fixed_vector[j];\n        if (ctx->mode == MODE_5k0) {\n            postfilter_5k0(ctx, pAz, fixed_vector);\n            ff_celp_lp_synthesis_filterf(ctx->postfilter_syn5k0 + LP_FILTER_ORDER + i*SUBFR_SIZE,\n                                         pAz, excitation, SUBFR_SIZE,\n                                         LP_FILTER_ORDER);\n        }\n        ff_celp_lp_synthesis_filterf(synth + i*SUBFR_SIZE, pAz, fixed_vector,\n                                     SUBFR_SIZE, LP_FILTER_ORDER);\n        excitation += SUBFR_SIZE;\n    }\n    memcpy(synth - LP_FILTER_ORDER, synth + frame_size - LP_FILTER_ORDER,\n           LP_FILTER_ORDER * sizeof(float));\n    if (ctx->mode == MODE_5k0) {\n        for (i = 0; i < subframe_count; i++) {\n            float energy = ff_dot_productf(ctx->postfilter_syn5k0 + LP_FILTER_ORDER + i*SUBFR_SIZE,\n                                           ctx->postfilter_syn5k0 + LP_FILTER_ORDER + i*SUBFR_SIZE,\n                                           SUBFR_SIZE);\n            ff_adaptative_gain_control(&synth[i * SUBFR_SIZE], energy,\n                                       SUBFR_SIZE, 0.9, &ctx->postfilter_agc);\n        }\n        memcpy(ctx->postfilter_syn5k0, ctx->postfilter_syn5k0 + frame_size,\n               LP_FILTER_ORDER*sizeof(float));\n    }\n    memcpy(ctx->excitation, excitation - PITCH_DELAY_MAX - L_INTERPOL,\n           (PITCH_DELAY_MAX + L_INTERPOL) * sizeof(float));\n    ff_acelp_apply_order_2_transfer_function(synth,\n                                             (const float[2]) {-1.99997   , 1.000000000},\n                                             (const float[2]) {-1.93307352, 0.935891986},\n                                             0.939805806,\n                                             ctx->highpass_filt_mem,\n                                             frame_size);\n    ctx->dsp.vector_clipf(out_data, synth, -1, 32767./(1<<15), frame_size);\n}', 'static void eval_ir(const float *Az, int pitch_lag, float *freq,\n                    float pitch_sharp_factor)\n{\n    float tmp1[SUBFR_SIZE+1], tmp2[LP_FILTER_ORDER+1];\n    int i;\n    tmp1[0] = 1.;\n    for (i = 0; i < LP_FILTER_ORDER; i++) {\n        tmp1[i+1] = Az[i] * ff_pow_0_55[i];\n        tmp2[i  ] = Az[i] * ff_pow_0_7 [i];\n    }\n    memset(tmp1 + 11, 0, 37 * sizeof(float));\n    ff_celp_lp_synthesis_filterf(freq, tmp2, tmp1, SUBFR_SIZE,\n                                 LP_FILTER_ORDER);\n    pitch_sharpening(pitch_lag, pitch_sharp_factor, freq);\n}', 'void ff_celp_lp_synthesis_filterf(float *out, const float *filter_coeffs,\n                                  const float* in, int buffer_length,\n                                  int filter_length)\n{\n    int i,n;\n    float out0, out1, out2, out3;\n    float old_out0, old_out1, old_out2, old_out3;\n    float a,b,c;\n    a = filter_coeffs[0];\n    b = filter_coeffs[1];\n    c = filter_coeffs[2];\n    b -= filter_coeffs[0] * filter_coeffs[0];\n    c -= filter_coeffs[1] * filter_coeffs[0];\n    c -= filter_coeffs[0] * b;\n    old_out0 = out[-4];\n    old_out1 = out[-3];\n    old_out2 = out[-2];\n    old_out3 = out[-1];\n    for (n = 0; n <= buffer_length - 4; n+=4) {\n        float tmp0,tmp1,tmp2,tmp3;\n        float val;\n        out0 = in[0];\n        out1 = in[1];\n        out2 = in[2];\n        out3 = in[3];\n        out0 -= filter_coeffs[2] * old_out1;\n        out1 -= filter_coeffs[2] * old_out2;\n        out2 -= filter_coeffs[2] * old_out3;\n        out0 -= filter_coeffs[1] * old_out2;\n        out1 -= filter_coeffs[1] * old_out3;\n        out0 -= filter_coeffs[0] * old_out3;\n        val = filter_coeffs[3];\n        out0 -= val * old_out0;\n        out1 -= val * old_out1;\n        out2 -= val * old_out2;\n        out3 -= val * old_out3;\n        old_out3 = out[-5];\n        for (i = 5; i <= filter_length; i += 2) {\n            val = filter_coeffs[i-1];\n            out0 -= val * old_out3;\n            out1 -= val * old_out0;\n            out2 -= val * old_out1;\n            out3 -= val * old_out2;\n            old_out2 = out[-i-1];\n            val = filter_coeffs[i];\n            out0 -= val * old_out2;\n            out1 -= val * old_out3;\n            out2 -= val * old_out0;\n            out3 -= val * old_out1;\n            FFSWAP(float, old_out0, old_out2);\n            old_out1 = old_out3;\n            old_out3 = out[-i-2];\n        }\n        tmp0 = out0;\n        tmp1 = out1;\n        tmp2 = out2;\n        tmp3 = out3;\n        out3 -= a * tmp2;\n        out2 -= a * tmp1;\n        out1 -= a * tmp0;\n        out3 -= b * tmp1;\n        out2 -= b * tmp0;\n        out3 -= c * tmp0;\n        out[0] = out0;\n        out[1] = out1;\n        out[2] = out2;\n        out[3] = out3;\n        old_out0 = out0;\n        old_out1 = out1;\n        old_out2 = out2;\n        old_out3 = out3;\n        out += 4;\n        in  += 4;\n    }\n    out -= n;\n    in -= n;\n    for (; n < buffer_length; n++) {\n        out[n] = in[n];\n        for (i = 1; i <= filter_length; i++)\n            out[n] -= filter_coeffs[i-1] * out[n-i];\n    }\n}']