PeerStreamer

void ff_vector_fmul_window_c(float *dst, const float *src0, const float *src1, const float *win, float add_bias, int len){

    int i;

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

        dst[i] = src0[i]*win[len-i-1] + src1[i]*win[i] + add_bias;

}

static av_always_inline int float_to_int16_one(const float *src){

    int_fast32_t tmp = *(const int32_t*)src;

    if(tmp & 0xf0000){

        tmp = (0x43c0ffff - tmp)>>31;

        // is this faster on some gcc/cpu combinations?

//      if(tmp > 0x43c0ffff) tmp = 0xFFFF;

//      else                 tmp = 0;

    }

    return tmp - 0x8000;

}

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

        dst[i] = float_to_int16_one(src+i);

}

void ff_float_to_int16_interleave_c(int16_t *dst, const float *src, long len, int channels){

    int i,j,c;

    if(channels==2){

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

            dst[2*i]   = float_to_int16_one(src+i);

            dst[2*i+1] = float_to_int16_one(src+i+len);

    }else{

        for(c=0; c<channels; c++, src+=len)

            for(i=0, j=c; i<len; i++, j+=channels)

                dst[j] = float_to_int16_one(src+i);

    c->vector_fmul_window = ff_vector_fmul_window_c;

    c->float_to_int16_interleave = ff_float_to_int16_interleave_c;

void ff_vector_fmul_window_c(float *dst, const float *src0, const float *src1,

                             const float *win, float add_bias, int len);

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

    void (*vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, float add_bias, int len);

    void (*float_to_int16_interleave)(int16_t *dst, const float *src, long len, int channels);

static void vector_fmul_window_sse(float *dst, const float *src0, const float *src1,

                                   const float *win, float add_bias, int len){

#ifdef HAVE_6REGS

    if(add_bias == 0){

        x86_reg i = -len*2;

        x86_reg j = len*2-16;

        asm volatile(

            "1: \n"

            "movaps       (%5,%0), %%xmm0 \n"

            "movaps       (%5,%1), %%xmm1 \n"

            "movaps        %%xmm0, %%xmm2 \n"

            "movaps        %%xmm1, %%xmm3 \n"

            "shufps $0x1b, %%xmm2, %%xmm2 \n"

            "shufps $0x1b, %%xmm3, %%xmm3 \n"

            "mulps        (%4,%0), %%xmm0 \n"

            "mulps        (%4,%1), %%xmm1 \n"

            "mulps        (%3,%0), %%xmm3 \n"

            "mulps        (%3,%1), %%xmm2 \n"

            "addps         %%xmm3, %%xmm0 \n"

            "addps         %%xmm2, %%xmm1 \n"

            "movaps        %%xmm0, (%2,%0) \n"

            "movaps        %%xmm1, (%2,%1) \n"

            "sub $16, %1 \n"

            "add $16, %0 \n"

            "jl 1b \n"

            :"+r"(i), "+r"(j)

            :"r"(dst+len/2), "r"(src0+len/2), "r"(src1+len/2), "r"(win+len/2)

        );

    }else

#endif

        ff_vector_fmul_window_c(dst, src0, src1, win, add_bias, len);

}

#define FLOAT_TO_INT16_INTERLEAVE(cpu, body) \

/* gcc pessimizes register allocation if this is in the same function as float_to_int16_interleave_sse2*/\

static av_noinline void float_to_int16_interleave2_##cpu(int16_t *dst, const float *src, long len, int channels){\

    DECLARE_ALIGNED_16(int16_t, tmp[len*channels]);\

    int i,j,c;\

    float_to_int16_##cpu(tmp, src, len*channels);\

    for(c=0; c<channels; c++){\

        int16_t *ptmp = tmp+c*len;\

        for(i=0, j=c; i<len; i++, j+=channels)\

            dst[j] = ptmp[i];\

    }\

}\

\

static void float_to_int16_interleave_##cpu(int16_t *dst, const float *src, long len, int channels){\

    if(channels==1)\

        float_to_int16_##cpu(dst, src, len);\

    else if(channels>2)\

        float_to_int16_interleave2_##cpu(dst, src, len, channels);\

    else{\

        float *src1;\

        asm volatile(\

            "shl $2, %0 \n"\

            "add %0, %1 \n"\

            "add %0, %2 \n"\

            "lea (%2,%0), %3 \n"\

            "neg %0 \n"\

            body\

            :"+r"(len), "+r"(dst), "+r"(src), "=r"(src1)\

        );\

    }\

}

FLOAT_TO_INT16_INTERLEAVE(3dnow,

    "1:                         \n"

    "pf2id     (%2,%0), %%mm0   \n"

    "pf2id    8(%2,%0), %%mm1   \n"

    "pf2id     (%3,%0), %%mm2   \n"

    "pf2id    8(%3,%0), %%mm3   \n"

    "packssdw    %%mm1, %%mm0   \n"

    "packssdw    %%mm3, %%mm2   \n"

    "movq        %%mm0, %%mm1   \n"

    "punpcklwd   %%mm2, %%mm0   \n"

    "punpckhwd   %%mm2, %%mm1   \n"

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

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

    "add $16, %0                \n"

    "js 1b                      \n"

    "femms                      \n"

)

FLOAT_TO_INT16_INTERLEAVE(sse,

    "1:                         \n"

    "cvtps2pi  (%2,%0), %%mm0   \n"

    "cvtps2pi 8(%2,%0), %%mm1   \n"

    "cvtps2pi  (%3,%0), %%mm2   \n"

    "cvtps2pi 8(%3,%0), %%mm3   \n"

    "packssdw    %%mm1, %%mm0   \n"

    "packssdw    %%mm3, %%mm2   \n"

    "movq        %%mm0, %%mm1   \n"

    "punpcklwd   %%mm2, %%mm0   \n"

    "punpckhwd   %%mm2, %%mm1   \n"

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

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

    "add $16, %0                \n"

    "js 1b                      \n"

    "emms                       \n"

)

FLOAT_TO_INT16_INTERLEAVE(sse2,

    "1:                         \n"

    "cvtps2dq  (%2,%0), %%xmm0  \n"

    "cvtps2dq  (%3,%0), %%xmm1  \n"

    "packssdw   %%xmm1, %%xmm0  \n"

    "movhlps    %%xmm0, %%xmm1  \n"

    "punpcklwd  %%xmm1, %%xmm0  \n"

    "movdqa     %%xmm0, (%1,%0) \n"

    "add $16, %0                \n"

    "js 1b                      \n"

)

            if(!(avctx->flags & CODEC_FLAG_BITEXACT)){

                c->float_to_int16_interleave = float_to_int16_interleave_3dnow;

            }

            c->float_to_int16_interleave = float_to_int16_interleave_sse;

            c->vector_fmul_window = vector_fmul_window_sse;

            c->float_to_int16_interleave = float_to_int16_interleave_sse2;

    uint_fast8_t previous_window;

    vc->previous_window=0;

static void copy_normalize(float *dst, float *src, int len, int exp_bias, float add_bias)

{

    int i;

    if(exp_bias) {

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

            ((uint32_t*)dst)[i] = ((uint32_t*)src)[i] + exp_bias; // dst[k]=src[i]*(1<<bias)

    } else {

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

            dst[i] = src[i] + add_bias;

    }

}

    uint_fast8_t previous_window=vc->previous_window;

    uint_fast8_t blockflag;

    blockflag=vc->modes[mode_number].blockflag;

    blocksize=vc->blocksize[blockflag];

    if (blockflag) {

        skip_bits(gb, 2); // previous_window, next_window

    retlen = (blocksize + vc->blocksize[previous_window])/4;

        uint_fast16_t bs0=vc->blocksize[0];

        uint_fast16_t bs1=vc->blocksize[1];

        float *saved=vc->saved+j*bs1/2;

        float *ret=vc->ret+j*retlen;

        const float *win=vc->win[blockflag&previous_window];

        vc->mdct[0].fft.imdct_calc(&vc->mdct[blockflag], buf, vc->channel_floors+j*blocksize/2, vc->buf_tmp);

        if(blockflag == previous_window) {

            vc->dsp.vector_fmul_window(ret, saved, buf, win, fadd_bias, blocksize/2);

        } else if(blockflag > previous_window) {

            vc->dsp.vector_fmul_window(ret, saved, buf+(bs1-bs0)/4, win, fadd_bias, bs0/2);

            copy_normalize(ret+bs0/2, buf+(bs1+bs0)/4, (bs1-bs0)/4, vc->exp_bias, fadd_bias);

            copy_normalize(ret, saved, (bs1-bs0)/4, vc->exp_bias, fadd_bias);

            vc->dsp.vector_fmul_window(ret+(bs1-bs0)/4, saved+(bs1-bs0)/4, buf, win, fadd_bias, bs0/2);

        memcpy(saved, buf+blocksize/2, blocksize/2*sizeof(float));

    vc->previous_window = blockflag;

    return retlen;

    vc->dsp.float_to_int16_interleave(data, vc->ret, len, vc->audio_channels);

    *data_size=len*2*vc->audio_channels;

#if defined(ARCH_X86_64) || (defined(ARCH_X86_32) && (defined(HAVE_EBX_AVAILABLE) || defined(HAVE_EBP_AVAILABLE)))

#    define HAVE_6REGS 1

#endif