pa_asio.cpp

ppciaxclient softphone

inline static long Pa_TriangularDither( void )
{
        static unsigned long previous = 0;
        static unsigned long randSeed1 = 22222;
        static unsigned long randSeed2 = 5555555;
        long current, highPass;
/* Generate two random numbers. */
        randSeed1 = (randSeed1 * 196314165) + 907633515;
        randSeed2 = (randSeed2 * 196314165) + 907633515;
/* Generate triangular distribution about 0. */
        current = (((long)randSeed1)>>(32-DITHER_BITS)) + (((long)randSeed2)>>(32-DITHER_BITS));
 /* High pass filter to reduce audibility. */
        highPass = current - previous;
        previous = current;
        return highPass;
}

// TO BE COMPLETED WITH ALL SUPPORTED PA SAMPLE TYPES

//-------------------------------------------------------------------------------------------------------------------------------------------------------
static void Input_Int16_Float32 (ASIOBufferInfo* nativeBuffer, float *inBufPtr, int framePerBuffer, int NumInputChannels, int index, int hostFrameOffset,int userFrameOffset, bool swap)
{
        long temp;
        int i,j;
        
        for( j=0; j<NumInputChannels; j++ ) {
                short *asioBufPtr = &((short*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                float *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                for (i= 0; i < framePerBuffer; i++)
                { 
                        temp = asioBufPtr[i];
                        if (swap) temp = SwapShort(temp);
                        *userBufPtr = (1.0f / MAX_INT16_FP) * temp;
                        userBufPtr += NumInputChannels;
                }
        }
        
}

//-------------------------------------------------------------------------------------------------------------------------------------------------------
static void Input_Int32_Float32 (ASIOBufferInfo* nativeBuffer, float *inBufPtr, int framePerBuffer, int NumInputChannels, int index, int hostFrameOffset,int userFrameOffset,bool swap)
{
        long temp;
        int i,j;
        
        for( j=0; j<NumInputChannels; j++ ) {
                long *asioBufPtr = &((long*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                float *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                for (i= 0; i < framePerBuffer; i++)
                { 
                        temp = asioBufPtr[i];
                        if (swap) temp = SwapLong(temp);
                        *userBufPtr = (1.0f / MAX_INT32_FP) * temp;
                        userBufPtr += NumInputChannels;
                }
        }
}

//-------------------------------------------------------------------------------------------------------------------------------------------------------
// MUST BE TESTED
static void Input_Float32_Float32 (ASIOBufferInfo* nativeBuffer, float *inBufPtr, int framePerBuffer, int NumInputChannels, int index, int hostFrameOffset,int userFrameOffset,bool swap)
{
        unsigned long temp;
        int i,j;
        
        for( j=0; j<NumInputChannels; j++ ) {
                unsigned long *asioBufPtr = &((unsigned long*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                float *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                for (i= 0; i < framePerBuffer; i++)
                { 
                        temp = asioBufPtr[i];
                        if (swap) temp = SwapLong(temp);
                        *userBufPtr = (float)temp;
                        userBufPtr += NumInputChannels;
                }
        }
}

//-------------------------------------------------------------------------------------------------------------------------------------------------------
static  void Input_Int16_Int32 (ASIOBufferInfo* nativeBuffer, long *inBufPtr, int framePerBuffer, int NumInputChannels, int index, int hostFrameOffset,int userFrameOffset,bool swap)
{
        long temp;
        int i,j;
        
        for( j=0; j<NumInputChannels; j++ ) {
                short *asioBufPtr = &((short*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                long *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                for (i= 0; i < framePerBuffer; i++)
                { 
                        temp = asioBufPtr[i];
                        if (swap) temp = SwapShort(temp);
                        *userBufPtr = temp<<16;
                        userBufPtr += NumInputChannels;
                }
        }
}

//-------------------------------------------------------------------------------------------------------------------------------------------------------
static  void Input_Int32_Int32 (ASIOBufferInfo* nativeBuffer, long *inBufPtr, int framePerBuffer, int NumInputChannels, int index, int hostFrameOffset,int userFrameOffset,bool swap)
{
        long temp;
        int i,j;
        
        for( j=0; j<NumInputChannels; j++ ) {
                long *asioBufPtr = &((long*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                long *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                for (i= 0; i < framePerBuffer; i++)
                { 
                        temp = asioBufPtr[i];
                        if (swap) temp = SwapLong(temp);
                        *userBufPtr = temp;
                        userBufPtr += NumInputChannels;
                }
        }
}

//-------------------------------------------------------------------------------------------------------------------------------------------------------
// MUST BE TESTED
static  void Input_Float32_Int32 (ASIOBufferInfo* nativeBuffer, long *inBufPtr, int framePerBuffer, int NumInputChannels, int index, int hostFrameOffset,int userFrameOffset,bool swap)
{
        unsigned long temp;
        int i,j;

        for( j=0; j<NumInputChannels; j++ ) {
                unsigned long *asioBufPtr = &((unsigned long*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                long *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                for (i= 0; i < framePerBuffer; i++)
                { 
                        temp = asioBufPtr[i];
                        if (swap) temp = SwapLong(temp);
                        *userBufPtr = (long)((float)temp * MAX_INT32_FP); // Is temp a value between -1.0 and 1.0 ??
                        userBufPtr += NumInputChannels;
                }
        }
}


//-------------------------------------------------------------------------------------------------------------------------------------------------------
static  void Input_Int16_Int16 (ASIOBufferInfo* nativeBuffer, short *inBufPtr, int framePerBuffer, int NumInputChannels, int index, int hostFrameOffset,int userFrameOffset,bool swap)
{
        long temp;
        int i,j;

        for( j=0; j<NumInputChannels; j++ ) {
                short *asioBufPtr = &((short*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                short *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                for (i= 0; i < framePerBuffer; i++)
                { 
                        temp = asioBufPtr[i];
                        if (swap) temp = SwapShort(temp);
                        *userBufPtr = (short)temp;
                        userBufPtr += NumInputChannels;
                }
        }
}
 
 //-------------------------------------------------------------------------------------------------------------------------------------------------------
static  void Input_Int32_Int16 (ASIOBufferInfo* nativeBuffer, short *inBufPtr, int framePerBuffer, int NumInputChannels, int index, int hostFrameOffset, int userFrameOffset,uint32 flags,bool swap)
{
        long temp;
        int i,j;
        
        if( flags & paDitherOff )
        {
                for( j=0; j<NumInputChannels; j++ ) {
                        long *asioBufPtr = &((long*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                        short *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                        for (i= 0; i < framePerBuffer; i++)
                        { 
                                temp = asioBufPtr[i];
                                if (swap) temp = SwapLong(temp);
                                *userBufPtr = (short)(temp>>16);
                                userBufPtr += NumInputChannels;
                        }
                }
        }
        else
        {
                for( j=0; j<NumInputChannels; j++ ) {
                        long *asioBufPtr = &((long*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                        short *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                        for (i= 0; i < framePerBuffer; i++)
                        { 
                                temp = asioBufPtr[i];
                                if (swap) temp = SwapLong(temp);
                                temp = (temp >> 1) + Pa_TriangularDither();
                                temp = temp >> 15;
                                temp = (short) ClipShort(temp);
                                *userBufPtr = (short)temp;
                                userBufPtr += NumInputChannels;
                        }
                }
        
        }
}

//-------------------------------------------------------------------------------------------------------------------------------------------------------
// MUST BE TESTED
static void Input_Float32_Int16 (ASIOBufferInfo* nativeBuffer, short *inBufPtr, int framePerBuffer, int NumInputChannels, int index, int hostFrameOffset,int userFrameOffset,uint32 flags,bool swap)
{
        unsigned long temp;
        int i,j;
        
        if( flags & paDitherOff )
        {
                for( j=0; j<NumInputChannels; j++ ) {
                        unsigned long *asioBufPtr = &((unsigned long*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                        short *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                        for (i= 0; i < framePerBuffer; i++)
                        { 
                                temp = asioBufPtr[i];
                                if (swap) temp = SwapLong(temp);
                                *userBufPtr = (short)((float)temp * MAX_INT16_FP); // Is temp a value between -1.0 and 1.0 ??
                                userBufPtr += NumInputChannels;
                        }
                }
        }
        else
        {
                for( j=0; j<NumInputChannels; j++ ) {
                        unsigned long *asioBufPtr = &((unsigned long*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                        short *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                        for (i= 0; i < framePerBuffer; i++)
                        { 
                                float dither  = Pa_TriangularDither()*DITHER_SCALE;
                                temp = asioBufPtr[i];
                                if (swap) temp = SwapLong(temp);
                                temp = (short)(((float)temp * MAX_INT16_FP) + dither);
                                temp = ClipShort(temp);
                                *userBufPtr = (short)temp;
                                userBufPtr += NumInputChannels;
                        }
                }
        }
}

//-------------------------------------------------------------------------------------------------------------------------------------------------------
static void Input_Int16_Int8 (ASIOBufferInfo* nativeBuffer, char *inBufPtr, int framePerBuffer, int NumInputChannels, int index, int hostFrameOffset,int userFrameOffset, uint32 flags,bool swap)
{
        long temp;
        int i,j;
        
        if( flags & paDitherOff )
        {
                for( j=0; j<NumInputChannels; j++ ) {
                        short *asioBufPtr = &((short*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                        char *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                        for (i= 0; i < framePerBuffer; i++)
                        { 
                                temp = asioBufPtr[i];
                                if (swap) temp = SwapShort(temp);
                                *userBufPtr = (char)(temp>>8);
                                userBufPtr += NumInputChannels;
                        }
                }
        }
        else
        {
                for( j=0; j<NumInputChannels; j++ ) {
                        short *asioBufPtr = &((short*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                        char *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                        for (i= 0; i < framePerBuffer; i++)
                        { 
                                temp = asioBufPtr[i];
                                if (swap) temp = SwapShort(temp);
                                temp += Pa_TriangularDither() >> 8;
                                temp = ClipShort(temp);
                                *userBufPtr = (char)(temp>>8);
                                userBufPtr += NumInputChannels;
                        }
                }
        }
}