pa_asio.cpp

ppciaxclient softphone

//-------------------------------------------------------------------------------------------------------------------------------------------------------
static void Input_Int32_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++ ) {
                        long *asioBufPtr = &((long*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                        char *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                        for (i= 0; i < framePerBuffer; i++)
                        { 
                                temp = asioBufPtr[i];
                                if (swap) temp = SwapLong(temp);
                                *userBufPtr = (char)(temp>>24);
                                userBufPtr += NumInputChannels;
                        }
                }
        }
        else
        {
                for( j=0; j<NumInputChannels; j++ ) {
                        long *asioBufPtr = &((long*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                        char *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                        for (i= 0; i < framePerBuffer; i++)
                        { 
                                temp = asioBufPtr[i];
                                if (swap) temp = SwapLong(temp);
                                temp = temp>>16;  // Shift to get a 16 bit value, then use the 16 bits to 8 bits code (MUST BE CHECHED)
                                temp += Pa_TriangularDither() >> 8;
                                temp = ClipShort(temp);
                                *userBufPtr = (char)(temp >> 8);
                                userBufPtr += NumInputChannels;
                        }
                }
        }
}

//-------------------------------------------------------------------------------------------------------------------------------------------------------
// MUST BE TESTED

static void Input_Float32_Int8 (ASIOBufferInfo* nativeBuffer, char *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];
                        char *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                        for (i= 0; i < framePerBuffer; i++)
                        { 
                                temp = asioBufPtr[i];
                                if (swap) temp = SwapLong(temp);
                                *userBufPtr = (char)((float)temp*MAX_INT8_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];
                        char *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 = (char)(((float)temp * MAX_INT8_FP) + dither);
                                temp = ClipChar(temp);
                                *userBufPtr = (char)temp;
                                userBufPtr += NumInputChannels;
                        }
                }
        }
}

//-------------------------------------------------------------------------------------------------------------------------------------------------------
static void Input_Int16_IntU8 (ASIOBufferInfo* nativeBuffer, unsigned 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];
                        unsigned char *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                        for (i= 0; i < framePerBuffer; i++)
                        { 
                                temp = asioBufPtr[i];
                                if (swap) temp = SwapShort(temp);
                                *userBufPtr = (unsigned char)((temp>>8) + 0x80); 
                                userBufPtr += NumInputChannels;
                        }
                }
        }
        else
        {
                for( j=0; j<NumInputChannels; j++ ) {
                        short *asioBufPtr = &((short*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                        unsigned 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 = (unsigned char)((temp>>8) + 0x80); 
                                userBufPtr += NumInputChannels;
                        }
                }
        }
}

//-------------------------------------------------------------------------------------------------------------------------------------------------------
static void Input_Int32_IntU8 (ASIOBufferInfo* nativeBuffer, unsigned 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++ ) {
                        long *asioBufPtr = &((long*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                        unsigned char *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                        for (i= 0; i < framePerBuffer; i++)
                        { 
                                temp = asioBufPtr[i];
                                if (swap) temp = SwapLong(temp);
                                *userBufPtr = (unsigned char)((temp>>24) + 0x80); 
                                userBufPtr += NumInputChannels;
                        }
                }
        }
        else
        {
                for( j=0; j<NumInputChannels; j++ ) {
                        long *asioBufPtr = &((long*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                        unsigned char *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                        for (i= 0; i < framePerBuffer; i++)
                        { 
                                temp = asioBufPtr[i];
                                if (swap) temp = SwapLong(temp);
                                temp = temp>>16; // Shift to get a 16 bit value, then use the 16 bits to 8 bits code (MUST BE CHECHED)
                                temp += Pa_TriangularDither() >> 8;
                                temp = ClipShort(temp);
                                *userBufPtr = (unsigned char)((temp>>8) + 0x80); 
                                userBufPtr += NumInputChannels;
                        }
                }
        }
}

//-------------------------------------------------------------------------------------------------------------------------------------------------------
// MUST BE TESTED

static void Input_Float32_IntU8 (ASIOBufferInfo* nativeBuffer, unsigned char *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];
                        unsigned char *userBufPtr = &inBufPtr[j+(userFrameOffset*NumInputChannels)];
                        for (i= 0; i < framePerBuffer; i++)
                        { 
                                temp = asioBufPtr[i];
                                if (swap) temp = SwapLong(temp);
                                *userBufPtr = (unsigned char)(((float)temp*MAX_INT8_FP) + 0x80);
                                userBufPtr += NumInputChannels;
                        }
                }
        }
        else
        {       
                for( j=0; j<NumInputChannels; j++ ) {
                        unsigned long *asioBufPtr = &((unsigned long*)nativeBuffer[j].buffers[index])[hostFrameOffset];
                        unsigned char *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 = (char)(((float)temp * MAX_INT8_FP) + dither);
                                temp = ClipChar(temp);
                                *userBufPtr =  (unsigned char)(temp + 0x80); 
                                userBufPtr += NumInputChannels;
                        }
                }
        }
}

                
// OUPUT 
//-------------------------------------------------------------------------------------------------------------------------------------------------------
static void Output_Float32_Int16 (ASIOBufferInfo* nativeBuffer, float *outBufPtr, int framePerBuffer, int NumInputChannels, int NumOuputChannels, int index, int hostFrameOffset, int userFrameOffset,uint32 flags, bool swap)
{
        long temp;
        int i,j;

        if( flags & paDitherOff )
                {
                        if( flags & paClipOff ) /* NOTHING */
                        {
                                for( j=0; j<NumOuputChannels; j++ ) {
                                        short *asioBufPtr = &((short*)nativeBuffer[j+NumInputChannels].buffers[index])[hostFrameOffset];
                                        float *userBufPtr = &outBufPtr[j+(userFrameOffset*NumOuputChannels)];
                                        
                                        for (i= 0; i < framePerBuffer; i++) 
                                        {
                                                temp = (short) (*userBufPtr * MAX_INT16_FP);
                                                if (swap) temp = SwapShort(temp);
                                                asioBufPtr[i] = (short)temp;
                                                userBufPtr += NumOuputChannels;
                                        }
                                }
                        }
                        else /* CLIP */
                        {
                                for( j=0; j<NumOuputChannels; j++ ) {
                                        short *asioBufPtr = &((short*)nativeBuffer[j+NumInputChannels].buffers[index])[hostFrameOffset];
                                        float *userBufPtr = &outBufPtr[j+(userFrameOffset*NumOuputChannels)];
                                        
                                        for (i= 0; i < framePerBuffer; i++) 
                                        {
                                                temp = (long) (*userBufPtr * MAX_INT16_FP);
                                                temp = ClipShort(temp);
                                                if (swap) temp = SwapShort(temp);
                                                asioBufPtr[i] = (short)temp;
                                                userBufPtr += NumOuputChannels;
                                        }
                                }
                        }
                }
                else
                {
                        /* If you dither then you have to clip because dithering could push the signal out of range! */
                        for( j=0; j<NumOuputChannels; j++ ) {
                                short *asioBufPtr = &((short*)nativeBuffer[j+NumInputChannels].buffers[index])[hostFrameOffset];
                                float *userBufPtr = &outBufPtr[j+(userFrameOffset*NumOuputChannels)];
                                
                                for (i= 0; i < framePerBuffer; i++) 
                                {
                                        float dither = Pa_TriangularDither()*DITHER_SCALE;
                                        temp = (long) ((*userBufPtr * MAX_INT16_FP) + dither);
                                        temp = ClipShort(temp);
                                        if (swap) temp = SwapShort(temp);
                                        asioBufPtr[i] = (short)temp;
                                        userBufPtr += NumOuputChannels;
                                }
                        }
                }
}

//-------------------------------------------------------------------------------------------------------------------------------------------------------
static void Output_Float32_Int32 (ASIOBufferInfo* nativeBuffer, float *outBufPtr, int framePerBuffer, int NumInputChannels, int NumOuputChannels, int index, int hostFrameOffset, int userFrameOffset,uint32 flags,bool swap)
{
        long temp;
        int i,j;
        
        if( flags & paClipOff )
        {
                for (j= 0; j < NumOuputChannels; j++) 
                {