~ubuntu-branches/ubuntu/gutsy/audacity/gutsy-backports

/*

 * PortAudio Portable Real-Time Audio Library

 * Latest Version at: http://www.portaudio.com

 * OSS implementation by:

 */

 

/*

 * the PortAudio community also makes the following non-binding requests:

 *

 * Any person wishing to distribute modifications to the Software is

 * requested to send the modifications to the original developer so that

 * license above.

 */

 

/**

 @file

*/

 

#include <stdio.h>

#include <limits.h>

#include <semaphore.h>

 

# include <sys/soundcard.h>

# define DEVICE_NAME_BASE            "/dev/dsp"

# include <linux/soundcard.h>

# define DEVICE_NAME_BASE            "/dev/dsp"

# include <machine/soundcard.h> /* JH20010905 */

# define DEVICE_NAME_BASE            "/dev/audio"

#endif

 

#include "portaudio.h"

#include "pa_cpuload.h"

#include "pa_process.h"

#include "pa_unix_util.h"

 

static int sysErr_;

static pthread_t mainThread_;

 */

static int Get_AFMT_S16_NE( void )

{

    char *ptr = (char *) &testData;

    int isLittle = ( *ptr == 1 ); /* Does address point to least significant byte? */

    return isLittle ? AFMT_S16_LE : AFMT_S16_BE;

            PaUtil_FreeAllAllocations( ossHostApi->allocations );

            PaUtil_DestroyAllocationGroup( ossHostApi->allocations );

        }

        PaUtil_FreeMemory( ossHostApi );

    }

    return result;

        PaTime defaultHighOutputLatency, double defaultSampleRate, PaUtilAllocationGroup *allocations  )

{

    PaError result = paNoError;

    deviceInfo->structVersion = 2;

    if( allocations )

    {

        {

            maxNumChannels = (stereo) ? 2 : 1;

        }

    }

 

    /* During channel negotiation, the last ioctl() may have failed. This can

 

    /* douglas:

       we have to do this querying in a slightly different order. apparently

       e.g. a card might give you stereo at 22kHz but only mono at 44kHz.

       the correct order for OSS is: format, channels, sample rate

    */

    int tempDevHandle = -1;

    int flags;

    PaSampleFormat inputSampleFormat, outputSampleFormat;

    if( inputParameters )

    {

        inputChannelCount = inputParameters->channelCount;

    {

        outputChannelCount = outputParameters->channelCount;

        outputSampleFormat = outputParameters->sampleFormat;

        /* unless alternate device specification is supported, reject the use of

            paUseHostApiSpecificDeviceSpecification */

 

       return paInvalidChannelCount;

 

    /* open the device so we can do more tests */

    if( inputChannelCount > 0 )

    {

        result = PaUtil_DeviceIndexToHostApiDeviceIndex(&device, inputParameters->device, hostApi);

 

    deviceInfo = hostApi->deviceInfos[device];

    deviceName = (char *)deviceInfo->name;

    flags = O_NONBLOCK;

    if (inputChannelCount > 0 && outputChannelCount > 0)

       flags |= O_RDWR;

 

 error:

    if( tempDevHandle >= 0 )

 

    return result;

}

    {

        PaUtil_InitializeStreamRepresentation( &stream->streamRepresentation,

                                               &ossApi->blockingStreamInterface, callback, userData );

 

    ENSURE_( sem_init( &stream->semaphore, 0, 0 ), paInternalError );

 

        frmts |= paInt16;

    else

        result = paSampleFormatNotSupported;

    *availableFormats = frmts;

 

error:

    int frgmt;

    int numBufs;

    int bytesPerBuf;

    unsigned long fragSz;

    audio_buf_info bufInfo;

 

         * The hardware need not respect the requested fragment size, so we may have to adapt.

         */

        if( framesPerBuffer == paFramesPerBufferUnspecified )

            fragSz = bufSz / 4;

        }

        else

        {

            fragSz = framesPerBuffer;

        }

 

        PA_ENSURE( GetAvailableFormats( component, &availableFormats ) );

        hostFormat = PaUtil_SelectClosestAvailableFormat( availableFormats, component->userFormat );

 

        /* OSS demands at least 2 buffers, and 16 bytes per buffer */

        bytesPerBuf = PA_MAX( fragSz * Pa_GetSampleSize( hostFormat ) * chans, 16 );

 

        /* The fragment parameters are encoded like this:

        /* reject if there's no sample rate within 1% of the one requested */

        if( (fabs( sampleRate - sr ) / sampleRate) > 0.01 )

        {

            PA_ENSURE( paInvalidSampleRate );

        }

 

    if( stream->capture )

    {

        PaOssStreamComponent *component = stream->capture;

 

        assert( component->hostChannelCount > 0 );

        assert( component->hostFrames > 0 );

                return paInvalidChannelCount;

        }

    }

    /* allocate and do basic initialization of the stream structure */

    PA_UNLESS( stream = (PaOssStream*)PaUtil_AllocateMemory( sizeof(PaOssStream) ), paInsufficientMemory );

    PA_ENSURE( PaOssStream_Initialize( stream, inputParameters, outputParameters, streamCallback, userData, streamFlags, ossHostApi ) );

    PA_ENSURE( PaOssStream_Configure( stream, sampleRate, framesPerBuffer, &inLatency, &outLatency ) );

 

    PaUtil_InitializeCpuLoadMeasurer( &stream->cpuLoadMeasurer, sampleRate );

    if( inputParameters )

    {

        inputHostFormat = stream->capture->hostFormat;

                pollCapture = 0;

            }

            */

            {

                /*PA_DEBUG(( "%s: Trying to poll again for capture frames, pollTimeout: %d\n",

                            __FUNCTION__, stream->pollTimeout ));*/

 

    /* Ok, we have triggered the stream */

    stream->triggered = 1;

error:

    return result;

}

    PaUtil_ResetCpuLoadMeasurer( &stream->cpuLoadMeasurer );

 

    PaOssStream_Stop( stream, stream->callbackAbort );

    PA_DEBUG(( "OnExit: Stoppage\n" ));

 

    /* Eventually notify user all buffers have played */

    int initiateProcessing = triggered;    /* Already triggered? */

    PaStreamCallbackFlags cbFlags = 0;  /* We might want to keep state across iterations */

    PaStreamCallbackTimeInfo timeInfo = {0,0,0}; /* TODO: IMPLEMENT ME */

    /*

#if ( SOUND_VERSION > 0x030904 )

        audio_errinfo errinfo;

#endif

*/

    assert( stream );

 

    pthread_cleanup_push( &OnExit, stream );    /* Execute OnExit when exiting */

         */

        if( !initiateProcessing )

        {

            assert( framesAvail % stream->framesPerHostBuffer == 0 );

        }

        else

            if ( stream->capture )

            {

                PA_ENSURE( PaOssStreamComponent_Read( stream->capture, &frames ) );

            }

 

#if ( SOUND_VERSION >= 0x030904 )

                frames = framesAvail;

 

                PA_ENSURE( PaOssStreamComponent_Write( stream->playback, &frames ) );

            }

 

            framesAvail -= framesProcessed;

 

    if( ioctl( stream->playback->fd, SNDCTL_DSP_GETODELAY, &delay ) < 0 )

        return paUnanticipatedHostError;

    return (PaOssStreamComponent_BufferSize( stream->playback ) - delay) / PaOssStreamComponent_FrameSize( stream->playback );

}

 

{

    PaOssStream *stream = (PaOssStream*)s;

 

   return NULL;

}

 

{

    PaOssStream *stream = (PaOssStream*)s;