~ubuntu-branches/ubuntu/wily/sflphone/wily

/*

 * $Id: pa_linux_alsa.c 1415 2009-06-03 18:57:56Z aknudsen $

 * PortAudio Portable Real-Time Audio Library

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

 * ALSA implementation by Joshua Haberman and Arve Knudsen

 *

 * Copyright (c) 2002 Joshua Haberman <joshua@haberman.com>

 * Copyright (c) 2005-2009 Arve Knudsen <arve.knudsen@gmail.com>

 * Copyright (c) 2008 Kevin Kofler <kevin.kofler@chello.at>

 *

 * Based on the Open Source API proposed by Ross Bencina

 * Copyright (c) 1999-2002 Ross Bencina, Phil Burk

 *

 * Permission is hereby granted, free of charge, to any person obtaining

 * a copy of this software and associated documentation files

 * (the "Software"), to deal in the Software without restriction,

 * including without limitation the rights to use, copy, modify, merge,

 * publish, distribute, sublicense, and/or sell copies of the Software,

 * and to permit persons to whom the Software is furnished to do so,

 * subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR

 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 */

/*

 * The text above constitutes the entire PortAudio license; however, 

 * 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

 * they can be incorporated into the canonical version. It is also 

 * requested that these non-binding requests be included along with the 

 * license above.

 */

/**

 @file

 @ingroup hostapi_src

*/

#define ALSA_PCM_NEW_HW_PARAMS_API

#define ALSA_PCM_NEW_SW_PARAMS_API

#include <alsa/asoundlib.h>

#undef ALSA_PCM_NEW_HW_PARAMS_API

#undef ALSA_PCM_NEW_SW_PARAMS_API

#include <sys/poll.h>

#include <string.h> /* strlen() */

#include <limits.h>

#include <math.h>

#include <pthread.h>

#include <signal.h>

#include <time.h>

#include <sys/mman.h>

#include <signal.h> /* For sig_atomic_t */

#include "portaudio.h"

#include "pa_util.h"

#include "pa_unix_util.h"

#include "pa_allocation.h"

#include "pa_hostapi.h"

#include "pa_stream.h"

#include "pa_cpuload.h"

#include "pa_process.h"

#include "pa_endianness.h"

#include "pa_debugprint.h"

#include "pa_linux_alsa.h"

/* Check return value of ALSA function, and map it to PaError */

#define ENSURE_(expr, code) \

    do { \

        if( UNLIKELY( (aErr_ = (expr)) < 0 ) ) \

        { \

            /* PaUtil_SetLastHostErrorInfo should only be used in the main thread */ \

            if( (code) == paUnanticipatedHostError && pthread_equal( pthread_self(), paUnixMainThread) ) \

            { \

                PaUtil_SetLastHostErrorInfo( paALSA, aErr_, snd_strerror( aErr_ ) ); \

            } \

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

            if( (code) == paUnanticipatedHostError ) \

                PA_DEBUG(( "Host error description: %s\n", snd_strerror( aErr_ ) )); \

            result = (code); \

            goto error; \

        } \

    } while( 0 );

#define ASSERT_CALL_(expr, success) \

    aErr_ = (expr); \

    assert( success == aErr_ );

static int aErr_;               /* Used with ENSURE_ */

static int numPeriods_ = 4;

static int busyRetries_ = 100;

int PaAlsa_SetNumPeriods( int numPeriods )

{

    numPeriods_ = numPeriods;

    return paNoError;

}

typedef enum

{

    StreamDirection_In,

    StreamDirection_Out

} StreamDirection;

typedef struct

{

    PaSampleFormat hostSampleFormat;

    unsigned long framesPerBuffer;

    int numUserChannels, numHostChannels;

    int userInterleaved, hostInterleaved;

    int canMmap;

    void *nonMmapBuffer;

    PaDeviceIndex device;     /* Keep the device index */

    snd_pcm_t *pcm;

    snd_pcm_uframes_t bufferSize;

    snd_pcm_format_t nativeFormat;

    unsigned int nfds;

    int ready;  /* Marked ready from poll */

    void **userBuffers;

    snd_pcm_uframes_t offset;

    StreamDirection streamDir;

    snd_pcm_channel_area_t *channelAreas;  /* Needed for channel adaption */

} PaAlsaStreamComponent;

/* Implementation specific stream structure */

typedef struct PaAlsaStream

{

    PaUtilStreamRepresentation streamRepresentation;

    PaUtilCpuLoadMeasurer cpuLoadMeasurer;

    PaUtilBufferProcessor bufferProcessor;

    PaUnixThread thread;

    unsigned long framesPerUserBuffer, maxFramesPerHostBuffer;

    int primeBuffers;

    int callbackMode;              /* bool: are we running in callback mode? */

    int pcmsSynced;	            /* Have we successfully synced pcms */

    int rtSched;

    /* the callback thread uses these to poll the sound device(s), waiting

     * for data to be ready/available */

    struct pollfd* pfds;

    int pollTimeout;

    /* Used in communication between threads */

    volatile sig_atomic_t callback_finished; /* bool: are we in the "callback finished" state? */

    volatile sig_atomic_t callbackAbort;    /* Drop frames? */

    volatile sig_atomic_t isActive;         /* Is stream in active state? (Between StartStream and StopStream || !paContinue) */

    PaUnixMutex stateMtx;                   /* Used to synchronize access to stream state */

    int neverDropInput;

    PaTime underrun;

    PaTime overrun;

    PaAlsaStreamComponent capture, playback;

}

PaAlsaStream;

/* PaAlsaHostApiRepresentation - host api datastructure specific to this implementation */

typedef struct PaAlsaHostApiRepresentation

{

    PaUtilHostApiRepresentation baseHostApiRep;

    PaUtilStreamInterface callbackStreamInterface;

    PaUtilStreamInterface blockingStreamInterface;

    PaUtilAllocationGroup *allocations;

    PaHostApiIndex hostApiIndex;

}

PaAlsaHostApiRepresentation;

typedef struct PaAlsaDeviceInfo

{

    PaDeviceInfo baseDeviceInfo;

    char *alsaName;

    int isPlug;

    int minInputChannels;

    int minOutputChannels;

}

PaAlsaDeviceInfo;

/* prototypes for functions declared in this file */

static void Terminate( struct PaUtilHostApiRepresentation *hostApi );

static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi,

                                  const PaStreamParameters *inputParameters,

                                  const PaStreamParameters *outputParameters,

                                  double sampleRate );

static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,

                           PaStream** s,

                           const PaStreamParameters *inputParameters,

                           const PaStreamParameters *outputParameters,

                           double sampleRate,

                           unsigned long framesPerBuffer,

                           PaStreamFlags streamFlags,

                           PaStreamCallback *callback,

                           void *userData );

static PaError CloseStream( PaStream* stream );

static PaError StartStream( PaStream *stream );

static PaError StopStream( PaStream *stream );

static PaError AbortStream( PaStream *stream );

static PaError IsStreamStopped( PaStream *s );

static PaError IsStreamActive( PaStream *stream );

static PaTime GetStreamTime( PaStream *stream );

static double GetStreamCpuLoad( PaStream* stream );

static PaError BuildDeviceList( PaAlsaHostApiRepresentation *hostApi );

static int SetApproximateSampleRate( snd_pcm_t *pcm, snd_pcm_hw_params_t *hwParams, double sampleRate );

static int GetExactSampleRate( snd_pcm_hw_params_t *hwParams, double *sampleRate );

/* Callback prototypes */

static void *CallbackThreadFunc( void *userData );

/* Blocking prototypes */

static signed long GetStreamReadAvailable( PaStream* s );

static signed long GetStreamWriteAvailable( PaStream* s );

static PaError ReadStream( PaStream* stream, void *buffer, unsigned long frames );

static PaError WriteStream( PaStream* stream, const void *buffer, unsigned long frames );

static const PaAlsaDeviceInfo *GetDeviceInfo( const PaUtilHostApiRepresentation *hostApi, int device )

{

    return (const PaAlsaDeviceInfo *)hostApi->deviceInfos[device];

}

static void AlsaErrorHandler(const char *file, int line, const char *function, int err, const char *fmt, ...)

{

}

PaError PaAlsa_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex hostApiIndex )

{

    PaError result = paNoError;

    PaAlsaHostApiRepresentation *alsaHostApi = NULL;

    PA_UNLESS( alsaHostApi = (PaAlsaHostApiRepresentation*) PaUtil_AllocateMemory(

                sizeof(PaAlsaHostApiRepresentation) ), paInsufficientMemory );

    PA_UNLESS( alsaHostApi->allocations = PaUtil_CreateAllocationGroup(), paInsufficientMemory );

    alsaHostApi->hostApiIndex = hostApiIndex;

    *hostApi = (PaUtilHostApiRepresentation*)alsaHostApi;

    (*hostApi)->info.structVersion = 1;

    (*hostApi)->info.type = paALSA;

    (*hostApi)->info.name = "ALSA";

    (*hostApi)->Terminate = Terminate;

    (*hostApi)->OpenStream = OpenStream;

    (*hostApi)->IsFormatSupported = IsFormatSupported;

    ENSURE_( snd_lib_error_set_handler(AlsaErrorHandler), paUnanticipatedHostError );

    PA_ENSURE( BuildDeviceList( alsaHostApi ) );

    PaUtil_InitializeStreamInterface( &alsaHostApi->callbackStreamInterface,

                                      CloseStream, StartStream,

                                      StopStream, AbortStream,

                                      IsStreamStopped, IsStreamActive,

                                      GetStreamTime, GetStreamCpuLoad,

                                      PaUtil_DummyRead, PaUtil_DummyWrite,

                                      PaUtil_DummyGetReadAvailable,

                                      PaUtil_DummyGetWriteAvailable );

    PaUtil_InitializeStreamInterface( &alsaHostApi->blockingStreamInterface,

                                      CloseStream, StartStream,

                                      StopStream, AbortStream,

                                      IsStreamStopped, IsStreamActive,

                                      GetStreamTime, PaUtil_DummyGetCpuLoad,

                                      ReadStream, WriteStream,

                                      GetStreamReadAvailable,

                                      GetStreamWriteAvailable );

    PA_ENSURE( PaUnixThreading_Initialize() );

    return result;

error:

    if( alsaHostApi )

    {

        if( alsaHostApi->allocations )

        {

            PaUtil_FreeAllAllocations( alsaHostApi->allocations );

            PaUtil_DestroyAllocationGroup( alsaHostApi->allocations );

        }

        PaUtil_FreeMemory( alsaHostApi );

    }

    return result;

}

static void Terminate( struct PaUtilHostApiRepresentation *hostApi )

{

    PaAlsaHostApiRepresentation *alsaHostApi = (PaAlsaHostApiRepresentation*)hostApi;

    assert( hostApi );

    if( alsaHostApi->allocations )

    {

        PaUtil_FreeAllAllocations( alsaHostApi->allocations );

        PaUtil_DestroyAllocationGroup( alsaHostApi->allocations );

    }

    PaUtil_FreeMemory( alsaHostApi );

    snd_config_update_free_global();

}

/** Determine max channels and default latencies.

 *

 * This function provides functionality to grope an opened (might be opened for capture or playback) pcm device for 

 * traits like max channels, suitable default latencies and default sample rate. Upon error, max channels is set to zero,

 * and a suitable result returned. The device is closed before returning.

 */

static PaError GropeDevice( snd_pcm_t* pcm, int isPlug, StreamDirection mode, int openBlocking,

        PaAlsaDeviceInfo* devInfo )

{

    PaError result = paNoError;

    snd_pcm_hw_params_t *hwParams;

    snd_pcm_uframes_t lowLatency = 512, highLatency = 2048;

    unsigned int minChans, maxChans;

    int* minChannels, * maxChannels;

    double * defaultLowLatency, * defaultHighLatency, * defaultSampleRate =

        &devInfo->baseDeviceInfo.defaultSampleRate;

    double defaultSr = *defaultSampleRate;

    assert( pcm );

    if( StreamDirection_In == mode )

    {

        minChannels = &devInfo->minInputChannels;

        maxChannels = &devInfo->baseDeviceInfo.maxInputChannels;

        defaultLowLatency = &devInfo->baseDeviceInfo.defaultLowInputLatency;

        defaultHighLatency = &devInfo->baseDeviceInfo.defaultHighInputLatency;

    }

    else

    {

        minChannels = &devInfo->minOutputChannels;

        maxChannels = &devInfo->baseDeviceInfo.maxOutputChannels;

        defaultLowLatency = &devInfo->baseDeviceInfo.defaultLowOutputLatency;

        defaultHighLatency = &devInfo->baseDeviceInfo.defaultHighOutputLatency;

    }

    ENSURE_( snd_pcm_nonblock( pcm, 0 ), paUnanticipatedHostError );

    snd_pcm_hw_params_alloca( &hwParams );

    snd_pcm_hw_params_any( pcm, hwParams );

    if( defaultSr >= 0 )

    {

        /* Could be that the device opened in one mode supports samplerates that the other mode wont have,

         * so try again .. */

        if( SetApproximateSampleRate( pcm, hwParams, defaultSr ) < 0 )

        {

            defaultSr = -1.;

            PA_DEBUG(( "%s: Original default samplerate failed, trying again ..\n", __FUNCTION__ ));

        }

    }

    if( defaultSr < 0. )           /* Default sample rate not set */

    {

        unsigned int sampleRate = 44100;        /* Will contain approximate rate returned by alsa-lib */

        if( snd_pcm_hw_params_set_rate_near( pcm, hwParams, &sampleRate, NULL ) < 0)

        {

            result = paUnanticipatedHostError;

            goto error;

        }

        ENSURE_( GetExactSampleRate( hwParams, &defaultSr ), paUnanticipatedHostError );

    }

    ENSURE_( snd_pcm_hw_params_get_channels_min( hwParams, &minChans ), paUnanticipatedHostError );

    ENSURE_( snd_pcm_hw_params_get_channels_max( hwParams, &maxChans ), paUnanticipatedHostError );

    assert( maxChans <= INT_MAX );

    assert( maxChans > 0 );    /* Weird linking issue could cause wrong version of ALSA symbols to be called,

                                   resulting in zeroed values */

    /* XXX: Limit to sensible number (ALSA plugins accept a crazy amount of channels)? */

    if( isPlug && maxChans > 128 )

    {

        maxChans = 128;

        PA_DEBUG(( "%s: Limiting number of plugin channels to %u\n", __FUNCTION__, maxChans ));

    }

    /* TWEAKME:

     *

     * Giving values for default min and max latency is not

     * straightforward.  Here are our objectives:

     *

     *         * for low latency, we want to give the lowest value

     *         that will work reliably.  This varies based on the

     *         sound card, kernel, CPU, etc.  I think it is better

     *         to give sub-optimal latency than to give a number

     *         too low and cause dropouts.  My conservative

     *         estimate at this point is to base it on 4096-sample

     *         latency at 44.1 kHz, which gives a latency of 23ms.

     *         * for high latency we want to give a large enough

     *         value that dropouts are basically impossible.  This

     *         doesn't really require as much tweaking, since

     *         providing too large a number will just cause us to

     *         select the nearest setting that will work at stream

     *         config time.

     */

    ENSURE_( snd_pcm_hw_params_set_buffer_size_near( pcm, hwParams, &lowLatency ), paUnanticipatedHostError );

    /* Have to reset hwParams, to set new buffer size */

    ENSURE_( snd_pcm_hw_params_any( pcm, hwParams ), paUnanticipatedHostError ); 

    ENSURE_( snd_pcm_hw_params_set_buffer_size_near( pcm, hwParams, &highLatency ), paUnanticipatedHostError );

    *minChannels = (int)minChans;

    *maxChannels = (int)maxChans;

    *defaultSampleRate = defaultSr;

    *defaultLowLatency = (double) lowLatency / *defaultSampleRate;

    *defaultHighLatency = (double) highLatency / *defaultSampleRate;

end:

    snd_pcm_close( pcm );

    return result;

error:

    goto end;

}

/* Initialize device info with invalid values (maxInputChannels and maxOutputChannels are set to zero since these indicate

 * wether input/output is available) */

static void InitializeDeviceInfo( PaDeviceInfo *deviceInfo )

{

    deviceInfo->structVersion = -1;

    deviceInfo->name = NULL;

    deviceInfo->hostApi = -1;

    deviceInfo->maxInputChannels = 0;

    deviceInfo->maxOutputChannels = 0;

    deviceInfo->defaultLowInputLatency = -1.;

    deviceInfo->defaultLowOutputLatency = -1.;

    deviceInfo->defaultHighInputLatency = -1.;

    deviceInfo->defaultHighOutputLatency = -1.;

    deviceInfo->defaultSampleRate = -1.;

}

/* Helper struct */

typedef struct

{

    char *alsaName;

    char *name;

    int isPlug;

    int hasPlayback;

    int hasCapture;

} HwDevInfo;

HwDevInfo predefinedNames[] = {

    { "center_lfe", NULL, 0, 1, 0 },

/* { "default", NULL, 0, 1, 0 }, */

/* { "dmix", NULL, 0, 1, 0 }, */

/* { "dpl", NULL, 0, 1, 0 }, */

/* { "dsnoop", NULL, 0, 1, 0 }, */

    { "front", NULL, 0, 1, 0 },

    { "iec958", NULL, 0, 1, 0 },

/* { "modem", NULL, 0, 1, 0 }, */

    { "rear", NULL, 0, 1, 0 },

    { "side", NULL, 0, 1, 0 },

/*     { "spdif", NULL, 0, 0, 0 }, */

    { "surround40", NULL, 0, 1, 0 },

    { "surround41", NULL, 0, 1, 0 },

    { "surround50", NULL, 0, 1, 0 },

    { "surround51", NULL, 0, 1, 0 },

    { "surround71", NULL, 0, 1, 0 },

    { NULL, NULL, 0, 1, 0 }

};

static const HwDevInfo *FindDeviceName( const char *name )

{

    int i;

    for( i = 0; predefinedNames[i].alsaName; i++ )

    {

	if( strcmp( name, predefinedNames[i].alsaName ) == 0 )

	{

	    return &predefinedNames[i];

	}

    }

    return NULL;

}

static PaError PaAlsa_StrDup( PaAlsaHostApiRepresentation *alsaApi,

        char **dst,

        const char *src)

{

    PaError result = paNoError;

    int len = strlen( src ) + 1;

    /* PA_DEBUG(("PaStrDup %s %d\n", src, len)); */

    PA_UNLESS( *dst = (char *)PaUtil_GroupAllocateMemory( alsaApi->allocations, len ),

            paInsufficientMemory );

    strncpy( *dst, src, len );

error:

    return result;

}

/* Disregard some standard plugins

 */

static int IgnorePlugin( const char *pluginId )

{

    static const char *ignoredPlugins[] = {"hw", "plughw", "plug", "dsnoop", "tee",

        "file", "null", "shm", "cards", "rate_convert", NULL};

    int i = 0;

    while( ignoredPlugins[i] )

    {

        if( !strcmp( pluginId, ignoredPlugins[i] ) )

        {

            return 1;

        }

        ++i;

    }

    return 0;

}

/** Open PCM device.

 *

 * Wrapper around snd_pcm_open which may repeatedly retry opening a device if it is busy, for

 * a certain time. This is because dmix may temporarily hold on to a device after it (dmix)

 * has been opened and closed.

 * @param mode: Open mode (e.g., SND_PCM_BLOCKING).

 * @param waitOnBusy: Retry opening busy device for up to one second?

 **/

static int OpenPcm( snd_pcm_t **pcmp, const char *name, snd_pcm_stream_t stream, int mode, int waitOnBusy )

{

    int tries = 0, maxTries = waitOnBusy ? busyRetries_ : 0;

    int ret = snd_pcm_open( pcmp, name, stream, mode );

    for( tries = 0; tries < maxTries && -EBUSY == ret; ++tries )

    {

        Pa_Sleep( 10 );

        ret = snd_pcm_open( pcmp, name, stream, mode );

        if( -EBUSY != ret )

        {

            PA_DEBUG(( "%s: Successfully opened initially busy device after %d tries\n",

                        __FUNCTION__, tries ));

        }

    }

    if( -EBUSY == ret )

    {

        PA_DEBUG(( "%s: Failed to open busy device '%s'\n",

                    __FUNCTION__, name ));

    }

    return ret;

}

static PaError FillInDevInfo( PaAlsaHostApiRepresentation *alsaApi, HwDevInfo* deviceName, int blocking,

        PaAlsaDeviceInfo* devInfo, int* devIdx )

{

    PaError result = 0;

    PaDeviceInfo *baseDeviceInfo = &devInfo->baseDeviceInfo;

    snd_pcm_t *pcm;

    PaUtilHostApiRepresentation *baseApi = &alsaApi->baseHostApiRep;

    /* Zero fields */

    InitializeDeviceInfo( baseDeviceInfo );

    /* to determine device capabilities, we must open the device and query the

     * hardware parameter configuration space */

    /* Query capture */

    if( deviceName->hasCapture &&

            OpenPcm( &pcm, deviceName->alsaName, SND_PCM_STREAM_CAPTURE, blocking, 0 )

            >= 0 )

    {

        if( GropeDevice( pcm, deviceName->isPlug, StreamDirection_In, blocking, devInfo ) != paNoError )

        {

            /* Error */

            PA_DEBUG(("%s: Failed groping %s for capture\n", __FUNCTION__, deviceName->alsaName));

            goto end;

        }

    }

    /* Query playback */

    if( deviceName->hasPlayback &&

            OpenPcm( &pcm, deviceName->alsaName, SND_PCM_STREAM_PLAYBACK, blocking, 0 )

            >= 0 )

    {

        if( GropeDevice( pcm, deviceName->isPlug, StreamDirection_Out, blocking, devInfo ) != paNoError )

        {

            /* Error */

            PA_DEBUG(("%s: Failed groping %s for playback\n", __FUNCTION__, deviceName->alsaName));

            goto end;

        }

    }

    baseDeviceInfo->structVersion = 2;

    baseDeviceInfo->hostApi = alsaApi->hostApiIndex;

    baseDeviceInfo->name = deviceName->name;

    devInfo->alsaName = deviceName->alsaName;

    devInfo->isPlug = deviceName->isPlug;

    /* A: Storing pointer to PaAlsaDeviceInfo object as pointer to PaDeviceInfo object.

     * Should now be safe to add device info, unless the device supports neither capture nor playback

     */

    if( baseDeviceInfo->maxInputChannels > 0 || baseDeviceInfo->maxOutputChannels > 0 )

    {

        /* Make device default if there isn't already one or it is the ALSA "default" device */

        if( (baseApi->info.defaultInputDevice == paNoDevice || !strcmp(deviceName->alsaName,

                        "default" )) && baseDeviceInfo->maxInputChannels > 0 )

        {

            baseApi->info.defaultInputDevice = *devIdx;

            PA_DEBUG(("Default input device: %s\n", deviceName->name));

        }

        if( (baseApi->info.defaultOutputDevice == paNoDevice || !strcmp(deviceName->alsaName,

                        "default" )) && baseDeviceInfo->maxOutputChannels > 0 )

        {

            baseApi->info.defaultOutputDevice = *devIdx;

            PA_DEBUG(("Default output device: %s\n", deviceName->name));

        }

        PA_DEBUG(("%s: Adding device %s: %d\n", __FUNCTION__, deviceName->name, *devIdx));

        baseApi->deviceInfos[*devIdx] = (PaDeviceInfo *) devInfo;

        (*devIdx) += 1;

    }

end:

    return result;

}

/* Build PaDeviceInfo list, ignore devices for which we cannot determine capabilities (possibly busy, sigh) */

static PaError BuildDeviceList( PaAlsaHostApiRepresentation *alsaApi )

{

    PaUtilHostApiRepresentation *baseApi = &alsaApi->baseHostApiRep;

    PaAlsaDeviceInfo *deviceInfoArray;

    int cardIdx = -1, devIdx = 0;

    snd_ctl_card_info_t *cardInfo;

    PaError result = paNoError;

    size_t numDeviceNames = 0, maxDeviceNames = 1, i;

    HwDevInfo *hwDevInfos = NULL;

    snd_config_t *topNode = NULL;

    snd_pcm_info_t *pcmInfo;

    int res;

    int blocking = SND_PCM_NONBLOCK;

    char alsaCardName[50];

#ifdef PA_ENABLE_DEBUG_OUTPUT

    PaTime startTime = PaUtil_GetTime();

#endif

    if( getenv( "PA_ALSA_INITIALIZE_BLOCK" ) && atoi( getenv( "PA_ALSA_INITIALIZE_BLOCK" ) ) )

        blocking = 0;

    /* These two will be set to the first working input and output device, respectively */

    baseApi->info.defaultInputDevice = paNoDevice;

    baseApi->info.defaultOutputDevice = paNoDevice;

    /* Gather info about hw devices

     * snd_card_next() modifies the integer passed to it to be:

     *      the index of the first card if the parameter is -1

     *      the index of the next card if the parameter is the index of a card

     *      -1 if there are no more cards

     *

     * The function itself returns 0 if it succeeded. */

    cardIdx = -1;

    snd_ctl_card_info_alloca( &cardInfo );

    snd_pcm_info_alloca( &pcmInfo );

    while( snd_card_next( &cardIdx ) == 0 && cardIdx >= 0 )

    {

        char *cardName;

        int devIdx = -1;

        snd_ctl_t *ctl;

        char buf[50];

        snprintf( alsaCardName, sizeof (alsaCardName), "hw:%d", cardIdx );

        /* Acquire name of card */

        if( snd_ctl_open( &ctl, alsaCardName, 0 ) < 0 )

        {

            /* Unable to open card :( */

            PA_DEBUG(( "%s: Unable to open device %s\n", __FUNCTION__, alsaCardName ));

            continue;

        }

        snd_ctl_card_info( ctl, cardInfo );

        PA_ENSURE( PaAlsa_StrDup( alsaApi, &cardName, snd_ctl_card_info_get_name( cardInfo )) );

        while( snd_ctl_pcm_next_device( ctl, &devIdx ) == 0 && devIdx >= 0 )

        {

            char *alsaDeviceName, *deviceName;

            size_t len;

            int hasPlayback = 0, hasCapture = 0;

            snprintf( buf, sizeof (buf), "hw:%d,%d", cardIdx, devIdx );

            /* Obtain info about this particular device */

            snd_pcm_info_set_device( pcmInfo, devIdx );

            snd_pcm_info_set_subdevice( pcmInfo, 0 );

            snd_pcm_info_set_stream( pcmInfo, SND_PCM_STREAM_CAPTURE );

            if( snd_ctl_pcm_info( ctl, pcmInfo ) >= 0 )

            {

                hasCapture = 1;

            }

            snd_pcm_info_set_stream( pcmInfo, SND_PCM_STREAM_PLAYBACK );

            if( snd_ctl_pcm_info( ctl, pcmInfo ) >= 0 )

            {

                hasPlayback = 1;

            }

            if( !hasPlayback && !hasCapture )

            {

                /* Error */

                continue;

            }

            /* The length of the string written by snprintf plus terminating 0 */

            len = snprintf( NULL, 0, "%s: %s (%s)", cardName, snd_pcm_info_get_name( pcmInfo ), buf ) + 1;

            PA_UNLESS( deviceName = (char *)PaUtil_GroupAllocateMemory( alsaApi->allocations, len ),

                    paInsufficientMemory );

            snprintf( deviceName, len, "%s: %s (%s)", cardName,

                    snd_pcm_info_get_name( pcmInfo ), buf );

            ++numDeviceNames;

            if( !hwDevInfos || numDeviceNames > maxDeviceNames )

            {

                maxDeviceNames *= 2;

                PA_UNLESS( hwDevInfos = (HwDevInfo *) realloc( hwDevInfos, maxDeviceNames * sizeof (HwDevInfo) ),

                        paInsufficientMemory );

            }

            PA_ENSURE( PaAlsa_StrDup( alsaApi, &alsaDeviceName, buf ) );

            hwDevInfos[ numDeviceNames - 1 ].alsaName = alsaDeviceName;

            hwDevInfos[ numDeviceNames - 1 ].name = deviceName;

            hwDevInfos[ numDeviceNames - 1 ].isPlug = 0;

            hwDevInfos[ numDeviceNames - 1 ].hasPlayback = hasPlayback;

            hwDevInfos[ numDeviceNames - 1 ].hasCapture = hasCapture;

        }

        snd_ctl_close( ctl );

    }

    /* Iterate over plugin devices */

    if( NULL == snd_config )

    {

        /* snd_config_update is called implicitly by some functions, if this hasn't happened snd_config will be NULL (bleh) */

        ENSURE_( snd_config_update(), paUnanticipatedHostError );

        PA_DEBUG(( "Updating snd_config\n" ));

    }

    assert( snd_config );

    if( (res = snd_config_search( snd_config, "pcm", &topNode )) >= 0 )

    {

        snd_config_iterator_t i, next;

        snd_config_for_each( i, next, topNode )

        {

            const char *tpStr = "unknown", *idStr = NULL;

            int err = 0;

            char *alsaDeviceName, *deviceName;

	    const HwDevInfo *predefined = NULL;

            snd_config_t *n = snd_config_iterator_entry( i ), * tp = NULL;;

            if( (err = snd_config_search( n, "type", &tp )) < 0 )

            {

                if( -ENOENT != err )

                {

                    ENSURE_(err, paUnanticipatedHostError);

                }

            }

            else 

            {

                ENSURE_( snd_config_get_string( tp, &tpStr ), paUnanticipatedHostError );

            }

            ENSURE_( snd_config_get_id( n, &idStr ), paUnanticipatedHostError );

            if( IgnorePlugin( idStr ) )

            {

                PA_DEBUG(( "%s: Ignoring ALSA plugin device %s of type %s\n", __FUNCTION__, idStr, tpStr ));

                continue;

            }

            PA_DEBUG(( "%s: Found plugin %s of type %s\n", __FUNCTION__, idStr, tpStr ));

            PA_UNLESS( alsaDeviceName = (char*)PaUtil_GroupAllocateMemory( alsaApi->allocations,

                                                            strlen(idStr) + 6 ), paInsufficientMemory );

            strcpy( alsaDeviceName, idStr );

            PA_UNLESS( deviceName = (char*)PaUtil_GroupAllocateMemory( alsaApi->allocations,

                                                            strlen(idStr) + 1 ), paInsufficientMemory );

            strcpy( deviceName, idStr );

            ++numDeviceNames;

            if( !hwDevInfos || numDeviceNames > maxDeviceNames )

            {

                maxDeviceNames *= 2;