crsfade.inl

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#ifdef DO_SCALAR
#undef DO_SCALAR
#endif
 
#if defined(__RADX86__) 
 
// for sse intrinsics.
#include <emmintrin.h>
#include <mmintrin.h>
 
#if defined (__RAD64__) || (_M_IX86_FP>=2)  //win64 or arch:SSE2 specified
    #define CallCrossFade CrossFadeSSE2
#else
    // x86 32-bit try sse or fallback to mmx
    #define CallCrossFade CrossFadeDispatch
 
    static void CrossFadeMMX(S16* outp,S16* overlap, U32 windowsize, S32 windowshift)
    {
        U32 i;
        {
            __m64 IVec = _mm_setr_pi16(0, 1, 2, 3);
            __m64 IncVec = _mm_set1_pi16(4);
            __m64 ShiftVec = _mm_set_pi32(0, windowshift);
            __m64 ZeroVec = _mm_setzero_si64();
            __m64 ShiftFor32Bit = _mm_set_pi32(0, 16);
 
            // linearly blend the sample over the window size
            for ( i = 0; i < windowsize ; i+=8 )
            {
                __m64 OutpVec = *(__m64*)((char*)outp + i);
                __m64 OverlapVec = *(__m64*)((char*)overlap + i);
                __m64 OutpVecLow, OutpVecHigh;
                __m64 Temp;
                __m64 OverlapHigh, OverlapLow;
                
                // outp - overlap
                OutpVec = _mm_sub_pi16(OutpVec, OverlapVec);
 
                // *i
                OutpVecHigh = _mm_mulhi_pi16(OutpVec, IVec);
                OutpVecLow = _mm_mullo_pi16(OutpVec, IVec);
 
                // move to something useful.
                Temp = _mm_unpackhi_pi16(OutpVecLow, OutpVecHigh);
                OutpVecLow = _mm_unpacklo_pi16(OutpVecLow, OutpVecHigh);
 
                // /ws
                OutpVecHigh = _mm_sra_pi32(Temp, ShiftVec);
                OutpVecLow = _mm_sra_pi32(OutpVecLow, ShiftVec);
 
                // overlap -> 32 bit
                OverlapHigh = _mm_unpackhi_pi16(ZeroVec, OverlapVec);
                OverlapLow = _mm_unpacklo_pi16(ZeroVec, OverlapVec);
 
                OverlapHigh = _mm_sra_pi32(OverlapHigh, ShiftFor32Bit);
                OverlapLow = _mm_sra_pi32(OverlapLow, ShiftFor32Bit);
 
                // Add overlap
                OutpVecLow = _mm_add_pi32(OutpVecLow, OverlapLow);
                OutpVecHigh = _mm_add_pi32(OutpVecHigh, OverlapHigh);
 
                // back to 16 bit
                OutpVec = _mm_packs_pi32(OutpVecLow, OutpVecHigh);
 
                // inc i.
                IVec = _mm_add_pi16(IVec, IncVec);
 
 
                *(__m64*)((char*)outp + i) =  OutpVec;
            }
            _mm_empty();
        } 
    } 
 
    static void CrossFadeSSE2(S16* outp,S16* overlap, U32 windowsize, S32 windowshift);
    static void CrossFadeDispatch(S16* outp,S16* overlap, U32 windowsize, S32 windowshift)
    {
        if (CPU_can_use(CPU_SSE2))
        {
            CrossFadeSSE2(outp,overlap,windowsize,windowshift);
            return;
        }
 
        CrossFadeMMX(outp,overlap,windowsize,windowshift);
        return;
    }
 
#endif
 
static void CrossFadeSSE2(S16* outp,S16* overlap, U32 windowsize, S32 windowshift)
{
    U32 i;
    {
        __m128i IVec = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7);
        __m128i IncVec = _mm_set1_epi16(8);
        __m128i ShiftVec = _mm_set_epi32(0, 0, 0, windowshift);
        __m128i SizeVec = _mm_set1_epi16((U16)windowsize >> 1);
 
        // linearly blend the sample over the window size
        for ( i = 0; i < windowsize ; i+=16 )
        {
            __m128i OutpVec = _mm_load_si128((__m128i*)((char*)outp + i));
            __m128i OverlapVec = _mm_load_si128((__m128i*)((char*)overlap + i));
 
            __m128i OverlapScale = _mm_sub_epi16(SizeVec, IVec);
 
            // Outp * i
            __m128i OutpLow = _mm_mullo_epi16(OutpVec, IVec);
            __m128i OutpHigh = _mm_mulhi_epi16(OutpVec, IVec);
 
            // Overlap * (ws - i)
            __m128i OverlapLow = _mm_mullo_epi16(OverlapVec, OverlapScale);
            __m128i OverlapHigh = _mm_mulhi_epi16(OverlapVec, OverlapScale);
 
            // Interleave in to 32 bit values.
            __m128i Temp = _mm_unpackhi_epi16(OutpLow, OutpHigh);
            OutpLow = _mm_unpacklo_epi16(OutpLow, OutpHigh);
            OutpHigh = Temp;
 
            Temp = _mm_unpackhi_epi16(OverlapLow, OverlapHigh);
            OverlapLow = _mm_unpacklo_epi16(OverlapLow, OverlapHigh);
            OverlapHigh = Temp;
 
            // (outp[i] * i + overlap[i] * (ws - i))
            OverlapLow = _mm_add_epi32(OverlapLow, OutpLow);
            OverlapHigh = _mm_add_epi32(OverlapHigh, OutpHigh);
 
            // / ws
            OverlapLow = _mm_sra_epi32(OverlapLow, ShiftVec);
            OverlapHigh = _mm_sra_epi32(OverlapHigh, ShiftVec);
 
            // -> 16 bit
            OutpVec = _mm_packs_epi32(OverlapLow, OverlapHigh);
 
            IVec = _mm_add_epi16(IVec, IncVec);
 
            _mm_store_si128((__m128i*)((char*)outp + i), OutpVec);
        }
    } 
}
 
#elif defined(__RADNEON__)
 
#include <arm_neon.h>
 
#define CallCrossFade CrossFadeNeon
 
static RAD_ALIGN( S16, starting_blend[ 8 ], 16 ) = { 0, 1, 2, 3, 4, 5, 6, 7 };
 
static void CrossFadeNeon(S16* outp,S16* overlap, U32 windowsize, S32 windowshift)
{
    int16x8_t IVec = *(int16x8_t*)starting_blend;
    int16x8_t IncVec = vmovq_n_s16(8);
    int32x4_t ShiftVec = vmovq_n_s32(-windowshift);
    int16x8_t SizeVec = vmovq_n_s16((S16)(windowsize >> 1));
 
    // linearly blend the sample over the window size
    for ( U32 i = 0; i < windowsize ; i += 16 )
    {
        int16x8_t OutpVec = vld1q_s16((S16*)((char*)outp + i));
        int16x8_t OverlapVec = vld1q_s16((S16*)((char*)overlap + i));
 
        int16x8_t OverlapScale = vsubq_s16(SizeVec, IVec);
 
        // Outp * i
        int32x4_t OutpLow = vmull_s16(vget_low_s16(OutpVec), vget_low_s16(IVec));
        int32x4_t OutpHigh = vmull_s16(vget_high_s16(OutpVec), vget_high_s16(IVec));
 
        // Overlap * (ws - i)
        int32x4_t OverlapLow = vmull_s16(vget_low_s16(OverlapVec), vget_low_s16(OverlapScale));
        int32x4_t OverlapHigh = vmull_s16(vget_high_s16(OverlapVec), vget_high_s16(OverlapScale));
 
        // (outp[i] * i + overlap[i] * (ws - i))
        OverlapLow = vaddq_s32(OverlapLow, OutpLow);
        OverlapHigh = vaddq_s32(OverlapHigh, OutpHigh);
 
        // / ws
        OverlapLow = vshlq_s32(OverlapLow, ShiftVec);
        OverlapHigh = vshlq_s32(OverlapHigh, ShiftVec);
 
        // -> 16 bit
        OutpVec = vcombine_s16(vmovn_s32(OverlapLow), vmovn_s32(OverlapHigh));
 
        IVec = vaddq_s16(IVec, IncVec);
 
        vst1q_s16((S16*)((char*)outp + i), OutpVec);
    }
}
 
#elif defined(__RADBIGENDIAN__)
 
#include RR_PLATFORM_PATH_STR( __RAD_NDA_PLATFORM__, _crsfade.inl )
 
#elif defined( __RADEMSCRIPTEN__ )
 
// this is just emscripten currently
#define CallCrossFade CrossFade
static void CrossFade(S16* outp,S16* overlap, U32 windowsize, S32 windowshift)
{
    U32 i;
    U32 ws = windowsize / 2;  // convert from bytes to samples
    // bi-linearly blend the sample over the window size
    for ( i = 0; i < ws ; i++ )
    {
        outp[i] = (S16) (((((S32)outp[i] - (S32)overlap[i]) * i) >> windowshift ) + (S32) overlap[i] );
    }
}
 
#else
 
#error crsfade.inl platform
 
#endif