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

/*

 * PortAudio Portable Real-Time Audio Library

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

 * JACK Implementation by Joshua Haberman

 */

 

/*

 * 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 <string.h>

#include "pa_process.h"

#include "pa_allocation.h"

#include "pa_cpuload.h"

 

static int aErr_;

static PaError paErr_;     /* For use with ENSURE_PA */

static pthread_t mainThread_;

static char *jackErr_ = NULL;

 

#define STRINGIZE_HELPER(expr) #expr

#define STRINGIZE(expr) STRINGIZE_HELPER(expr)

        { \

            if( (paErr_) == paUnanticipatedHostError && pthread_self() == mainThread_ ) \

            { \

                PaUtil_SetLastHostErrorInfo( paJACK, -1, jackErr_ ); \

            } \

            PaUtil_DebugPrint(( "Expression '" #expr "' failed in '" __FILE__ "', line: " STRINGIZE( __LINE__ ) "\n" )); \

        { \

            if( (code) == paUnanticipatedHostError && pthread_self() == mainThread_ ) \

            { \

                PaUtil_SetLastHostErrorInfo( paJACK, -1, jackErr_ ); \

            } \

            PaUtil_DebugPrint(( "Expression '" #expr "' failed in '" __FILE__ "', line: " STRINGIZE( __LINE__ ) "\n" )); \

    /* These are useful for the blocking API */

 

    int                     isBlockingStream;

    volatile sig_atomic_t   data_available;

    sem_t                   data_semaphore;

    int                     bytesPerFrame;

/* ---- blocking emulation layer ---- */

 

/* Allocate buffer. */

{

    long numBytes = numFrames * bytesPerFrame;

    char *buffer = (char *) malloc( numBytes );

    if( buffer == NULL ) return paInsufficientMemory;

    memset( buffer, 0, numBytes );

}

 

/* Free buffer. */

{

    if( rbuf->buffer ) free( rbuf->buffer );

    rbuf->buffer = NULL;

    /* This may get called with NULL inputBuffer during initial setup. */

    if( inputBuffer != NULL )

    {

    }

    if( outputBuffer != NULL )

    {

        /* Zero out remainder of buffer if we run out of data. */

        memset( (char *)outputBuffer + numRead, 0, numBytes - numRead );

    }

        ENSURE_PA( BlockingInitFIFO( &stream->outFIFO, numFrames, stream->bytesPerFrame ) );

 

        /* Make Write FIFO appear full initially. */

    }

 

    stream->data_available = 0;

    long numBytes = stream->bytesPerFrame * numFrames;

    while( numBytes > 0 )

    {

        numBytes -= bytesRead;

        p += bytesRead;

        if( numBytes > 0 )

    long numBytes = stream->bytesPerFrame * numFrames;

    while( numBytes > 0 )

    {

        numBytes -= bytesWritten;

        p += bytesWritten;

        {

             *   (1) write data

             *   (2) if some data didn't fit into the ringbuffer, set data_available to 0

             *       to indicate to the audio that if space becomes available, we want to know

{

    PaJackStream *stream = (PaJackStream *)s;

 

    return bytesFull / stream->bytesPerFrame;

}

 

{

    PaJackStream *stream = (PaJackStream *)s;

 

    return bytesEmpty / stream->bytesPerFrame;

}

 

{

    PaJackStream *stream = (PaJackStream *)s;

 

    {

        stream->data_available = 0;

        sem_wait( &stream->data_semaphore );

{

    /* Utility macros for the repetitive process of allocating memory */

 

    /* JACK has no concept of a device.  To JACK, there are clients

     * which have an arbitrary number of ports.  To make this

     * intelligible to PortAudio clients, we will group each JACK client

     * associated with the previous list */

    PaUtil_FreeAllAllocations( jackApi->deviceInfoMemory );

 

 

    /* We can only retrieve the list of clients indirectly, by first

     * asking for a list of all ports, then parsing the port names

    while( jack_ports[numPorts] )

        ++numPorts;

    /* At least there will be one port per client :) */

 

    /* Build a list of clients from the list of ports */

    for( numClients = 0, port_index = 0; jack_ports[port_index] != NULL; port_index++ )

        if (client_seen)

            continue;   /* A: Nothing to see here, move along */

 

 

        /* The alsa_pcm client should go in spot 0.  If this

         * is the alsa_pcm client AND we are NOT about to put

    /* there is one global sample rate all clients must conform to */

 

    globalSampleRate = jack_get_sample_rate( jackApi->jack_client );

 

    assert( commonApi->info.deviceCount == 0 );

 

        PaDeviceInfo *curDevInfo;

        const char **clientPorts = NULL;

 

        strcpy( (char *)curDevInfo->name, client_names[client_index] );

 

        curDevInfo->structVersion = 2;

    free( jack_ports );

    return result;

}

 

static void UpdateSampleRate( PaJackStream *stream, double sampleRate )

{

    if( pthread_self() == mainThread_ )

    {

        assert( msg );

    }

}

 

    PaError result = paNoError;

    PaJackHostApiRepresentation *jackHostApi;

    int activated = 0;

    *hostApi = NULL;    /* Initialize to NULL */

 

    UNLESS( jackHostApi = (PaJackHostApiRepresentation*)

    /* Try to become a client of the JACK server.  If we cannot do

     * this, then this API cannot be used. */

 

    {

    }

 

    jackHostApi->hostApiIndex = hostApiIndex;

    jack_on_shutdown( jackHostApi->jack_client, JackOnShutdown, jackHostApi );

    jack_set_error_function( JackErrorCallback );

    jackHostApi->jack_buffer_size = jack_get_buffer_size ( jackHostApi->jack_client );

    UNLESS( !jack_set_xrun_callback( jackHostApi->jack_client, JackXRunCb, jackHostApi ), paUnanticipatedHostError );

    UNLESS( !jack_set_process_callback( jackHostApi->jack_client, JackCallback, jackHostApi ), paUnanticipatedHostError );

    UNLESS( !jack_activate( jackHostApi->jack_client ), paUnanticipatedHostError );

 

    /*

        The following check is not necessary for JACK.

            - if a full duplex stream is requested, check that the combination

                of input and output parameters is supported

 

        Because the buffer adapter handles conversion between all standard

        sample formats, the following checks are only required if paCustomFormat

        is implemented, or under some other unusual conditions.

            - check that input device can support inputSampleFormat, or that

                we have the capability to convert from outputSampleFormat to

                a native format

    */

 

    /* check that the device supports sampleRate */

#define ABS(x) ( (x) > 0 ? (x) : -(x) )

    if( ABS(sampleRate - jack_get_sample_rate(((PaJackHostApiRepresentation *) hostApi)->jack_client )) > 1 )

       return paInvalidSampleRate;

    return result;

}

 

static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,

                           PaStream** s,

                           const PaStreamParameters *inputParameters,

    if( inputChannelCount > 0 )

    {

        int err = 0;

        snprintf( regex_pattern, regexSz, "%s:.*", hostApi->deviceInfos[ inputParameters->device ]->name );

        UNLESS( jack_ports = jack_get_ports( jackHostApi->jack_client, regex_pattern,

                                     NULL, JackPortIsOutput ), paUnanticipatedHostError );

        for( i = 0; i < inputChannelCount && jack_ports[i]; i++ )

        {

            if( (stream->remote_output_ports[i] = jack_port_by_name(

            {

                err = 1;

                break;

    {

        int err = 0;

 

        snprintf( regex_pattern, regexSz, "%s:.*", hostApi->deviceInfos[ outputParameters->device ]->name );

        UNLESS( jack_ports = jack_get_ports( jackHostApi->jack_client, regex_pattern,

                                     NULL, JackPortIsInput ), paUnanticipatedHostError );

    stream->streamRepresentation.streamInfo.sampleRate = jackSr;

    stream->t0 = jack_frame_time( jackHostApi->jack_client );   /* A: Time should run from Pa_OpenStream */

 

    *s = (PaStream*)stream;

 

    return result;

    return result;

}

 

static PaError UpdateQueue( PaJackHostApiRepresentation *hostApi )

{

    PaError result = paNoError;

            node->next = hostApi->toAdd;

        }

        else

            hostApi->processQueue = (PaJackStream *)hostApi->toAdd;

 

        /* If necessary, update stream state */

        if( hostApi->toAdd->streamRepresentation.streamInfo.sampleRate != jackSr )

    return result;

}

 

static int JackCallback( jack_nframes_t frames, void *userData )

{

    PaError result = paNoError;

    /* Ready the processor */

    PaUtil_ResetBufferProcessor( &stream->bufferProcessor );

 

 

    if( stream->num_incoming_connections > 0 )

    {

        for( i = 0; i < stream->num_incoming_connections; i++ )

    }

 

    if( stream->num_outgoing_connections > 0 )

    {

        for( i = 0; i < stream->num_outgoing_connections; i++ )

    }

 

    stream->xrun = FALSE;

    ENSURE_PA( result );

 

    UNLESS( !stream->is_active, paInternalError );

    PA_DEBUG(( "%s: Stream stopped\n", __FUNCTION__ ));

 

error:

    {

        for( i = 0; i < stream->num_incoming_connections; i++ )

        {

            if( jack_port_connected( stream->local_input_ports[i] ) )

            {

                UNLESS( !jack_port_disconnect( stream->jack_client, stream->local_input_ports[i] ),

                        paUnanticipatedHostError );

            }

        }

        for( i = 0; i < stream->num_outgoing_connections; i++ )

        {

            if( jack_port_connected( stream->local_output_ports[i] ) )

            {

                UNLESS( !jack_port_disconnect( stream->jack_client, stream->local_output_ports[i] ),

                        paUnanticipatedHostError );

            }

        }

    }

 

    PaJackStream *stream = (PaJackStream*)s;

    return PaUtil_GetCpuLoad( &stream->cpuLoadMeasurer );

}