PeerStreamer

                s->output[i - 448 - k] = (i < 1024)

                                         ? sce->saved[i]

                                         : audio[(i-1024)*chans];

            s->dsp.vector_fmul_reverse(s->output+128, s->output+128, swindow, 128);

            ff_mdct_calc(&s->mdct128, sce->coeffs + k, s->output);

        }

void ff_vp3_v_loop_filter_neon(uint8_t *, int, int *);

void ff_vp3_h_loop_filter_neon(uint8_t *, int, int *);

void ff_vector_fmul_window_neon(float *dst, const float *src0,

                                const float *src1, const float *win,

                                float add_bias, int len);

#include "libavcodec/dsputil.h"

#include "dsputil_arm.h"

void ff_vector_fmul_reverse_vfp(float *dst, const float *src0,

                                const float *src1, int len);

void ff_float_to_int16_vfp(int16_t *dst, const float *src, long len);

endfunc

function ff_vector_fmul_neon, export=1

        vmul.f32        q8,  q0,  q2

        vmul.f32        q9,  q1,  q3

        beq             3f

        beq             2f

1:      subs            ip,  ip,  #16

        vmul.f32        q10, q0,  q2

        vmul.f32        q11, q1,  q3

        vmul.f32        q8,  q0,  q2

        vmul.f32        q9,  q1,  q3

        bne             1b

        beq             3f

        vmul.f32        q8,  q0,  q2

        vmul.f32        q9,  q1,  q3

        bx              lr

endfunc

 * ARM VFP optimized implementation of 'vector_fmul_c' function.

 * Assume that len is a positive number and is multiple of 8

 */

function ff_vector_fmul_vfp, export=1

        vpush           {d8-d15}

        fmrx            r12, fpscr

        orr             r12, r12, #(3 << 16) /* set vector size to 4 */

        fmxr            fpscr, r12

        vmul.f32        s8,  s0,  s8

1:

        vmul.f32        s12, s4,  s12

        vmulge.f32      s24, s16, s24

        vstmia          r0!, {s8-s11}

        vstmia          r0!, {s12-s15}

        vmulge.f32      s28, s20, s28

        vmulge.f32      s8,  s0,  s8

        vstmiage        r0!, {s24-s27}

        vstmiage        r0!, {s28-s31}

    ff_imdct_calc(&q->mdct_ctx,pOutput,pInput);

    /* Perform windowing on the output. */

}

WRAPPER8_16_SQ(rd8x8_c, rd16_c)

WRAPPER8_16_SQ(bit8x8_c, bit16_c)

    int i;

    for(i=0; i<len; i++)

}

static void vector_fmul_reverse_c(float *dst, const float *src0, const float *src1, int len){

    void (*vorbis_inverse_coupling)(float *mag, float *ang, int blocksize);

    void (*ac3_downmix)(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len);

    /* assume len is a multiple of 8, and arrays are 16-byte aligned */

    void (*vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len);

    /* assume len is a multiple of 8, and src arrays are 16-byte aligned */

    void (*vector_fmul_add)(float *dst, const float *src0, const float *src1, const float *src2, int len);

static void apply_mdct(NellyMoserEncodeContext *s)

{

    s->dsp.vector_fmul_reverse(s->in_buff + NELLY_BUF_LEN, s->buf[s->bufsel] + NELLY_BUF_LEN, ff_sine_128,

                               NELLY_BUF_LEN);

    ff_mdct_calc(&s->mdct_ctx, s->mdct_out, s->in_buff);

    s->dsp.vector_fmul_reverse(s->buf[s->bufsel] + 2 * NELLY_BUF_LEN, s->buf[1 - s->bufsel], ff_sine_128,

                               NELLY_BUF_LEN);

    ff_mdct_calc(&s->mdct_ctx, s->mdct_out + NELLY_BUF_LEN, s->buf[s->bufsel] + NELLY_BUF_LEN);

#include "dsputil_altivec.h"

#include "util_altivec.h"

{

    int i;

    vector float d0, d1, s, zero = (vector float)vec_splat_u32(0);

    for(i=0; i<len-7; i+=8) {

        d0 = vec_madd(d0, s, zero);

        vec_st(d0, 0, dst+i);

        vec_st(d1, 16, dst+i);

    }

            dec_bark_env(tctx, bark1[i][j], bark_use_hist[i][j], i,

                         tctx->tmp_buf, gain[sub*i+j], ftype);

                                  block_size);

        }

        dec_lpc_spectrum_inv(tctx, lsp, ftype, tctx->tmp_buf);

        for (j = 0; j < mtab->fmode[ftype].sub; j++) {

            chunk += block_size;

        }

    }

    for (j = vc->audio_channels-1;j >= 0; j--) {

        ch_floor_ptr = vc->channel_floors   + j           * blocksize / 2;

        ch_res_ptr   = vc->channel_residues + res_chan[j] * blocksize / 2;

        ff_imdct_half(&vc->mdct[blockflag], ch_res_ptr, ch_floor_ptr);

    }

    }

}

    x86_reg i = (len-4)*4;

    __asm__ volatile(

        "1: \n\t"

        "movq   %%mm0,  (%1,%0) \n\t"

        "movq   %%mm1, 8(%1,%0) \n\t"

        "sub  $16, %0 \n\t"

        "jge 1b \n\t"

        "femms  \n\t"

        :"+r"(i)

        :"memory"

    );

}

    x86_reg i = (len-8)*4;

    __asm__ volatile(

        "1: \n\t"

        "movaps  %%xmm0,   (%1,%0) \n\t"

        "movaps  %%xmm1, 16(%1,%0) \n\t"

        "sub  $32, %0 \n\t"

        "jge 1b \n\t"

        :"+r"(i)

        :"memory"

    );

}