Mercurial > audio-send

     1 /**

     2  * OpenAL cross platform audio library

     3  * Copyright (C) 1999-2007 by authors.

     4  * This library is free software; you can redistribute it and/or

     5  *  modify it under the terms of the GNU Library General Public

     6  *  License as published by the Free Software Foundation; either

     7  *  version 2 of the License, or (at your option) any later version.

     8  *

     9  * This library is distributed in the hope that it will be useful,

    10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    12  *  Library General Public License for more details.

    13  *

    14  * You should have received a copy of the GNU Library General Public

    15  *  License along with this library; if not, write to the

    16  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    17  *  Boston, MA  02111-1307, USA.

    18  * Or go to http://www.gnu.org/copyleft/lgpl.html

    19  */

    20 

    21 #include "config.h"

    22 

    23 #include <stdio.h>

    24 #include <stdlib.h>

    25 #include <string.h>

    26 #include "alMain.h"

    27 #include "AL/al.h"

    28 #include "AL/alc.h"

    29 

    30 #include <portaudio.h>

    31 

    32 

    33 static const ALCchar pa_device[] = "PortAudio Default";

    34 

    35 

    36 static void *pa_handle;

    37 #ifdef HAVE_DYNLOAD

    38 #define MAKE_FUNC(x) static typeof(x) * p##x

    39 MAKE_FUNC(Pa_Initialize);

    40 MAKE_FUNC(Pa_Terminate);

    41 MAKE_FUNC(Pa_GetErrorText);

    42 MAKE_FUNC(Pa_StartStream);

    43 MAKE_FUNC(Pa_StopStream);

    44 MAKE_FUNC(Pa_OpenStream);

    45 MAKE_FUNC(Pa_CloseStream);

    46 MAKE_FUNC(Pa_GetDefaultOutputDevice);

    47 MAKE_FUNC(Pa_GetStreamInfo);

    48 #undef MAKE_FUNC

    49 

    50 #define Pa_Initialize                  pPa_Initialize

    51 #define Pa_Terminate                   pPa_Terminate

    52 #define Pa_GetErrorText                pPa_GetErrorText

    53 #define Pa_StartStream                 pPa_StartStream

    54 #define Pa_StopStream                  pPa_StopStream

    55 #define Pa_OpenStream                  pPa_OpenStream

    56 #define Pa_CloseStream                 pPa_CloseStream

    57 #define Pa_GetDefaultOutputDevice      pPa_GetDefaultOutputDevice

    58 #define Pa_GetStreamInfo               pPa_GetStreamInfo

    59 #endif

    60 

    61 static ALCboolean pa_load(void)

    62 {

    63     if(!pa_handle)

    64     {

    65         PaError err;

    66 

    67 #ifdef HAVE_DYNLOAD

    68 #ifdef _WIN32

    69 # define PALIB "portaudio.dll"

    70 #elif defined(__APPLE__) && defined(__MACH__)

    71 # define PALIB "libportaudio.2.dylib"

    72 #elif defined(__OpenBSD__)

    73 # define PALIB "libportaudio.so"

    74 #else

    75 # define PALIB "libportaudio.so.2"

    76 #endif

    77 

    78         pa_handle = LoadLib(PALIB);

    79         if(!pa_handle)

    80             return ALC_FALSE;

    81 

    82 #define LOAD_FUNC(f) do {                                                     \

    83     p##f = GetSymbol(pa_handle, #f);                                          \

    84     if(p##f == NULL)                                                          \

    85     {                                                                         \

    86         CloseLib(pa_handle);                                                  \

    87         pa_handle = NULL;                                                     \

    88         return ALC_FALSE;                                                     \

    89     }                                                                         \

    90 } while(0)

    91         LOAD_FUNC(Pa_Initialize);

    92         LOAD_FUNC(Pa_Terminate);

    93         LOAD_FUNC(Pa_GetErrorText);

    94         LOAD_FUNC(Pa_StartStream);

    95         LOAD_FUNC(Pa_StopStream);

    96         LOAD_FUNC(Pa_OpenStream);

    97         LOAD_FUNC(Pa_CloseStream);

    98         LOAD_FUNC(Pa_GetDefaultOutputDevice);

    99         LOAD_FUNC(Pa_GetStreamInfo);

   100 #undef LOAD_FUNC

   101 #else

   102         pa_handle = (void*)0xDEADBEEF;

   103 #endif

   104 

   105         if((err=Pa_Initialize()) != paNoError)

   106         {

   107             ERR("Pa_Initialize() returned an error: %s\n", Pa_GetErrorText(err));

   108             CloseLib(pa_handle);

   109             pa_handle = NULL;

   110             return ALC_FALSE;

   111         }

   112     }

   113     return ALC_TRUE;

   114 }

   115 

   116 

   117 typedef struct {

   118     PaStream *stream;

   119     ALuint update_size;

   120 

   121     RingBuffer *ring;

   122 } pa_data;

   123 

   124 

   125 static int pa_callback(const void *inputBuffer, void *outputBuffer,

   126                        unsigned long framesPerBuffer, const PaStreamCallbackTimeInfo *timeInfo,

   127                        const PaStreamCallbackFlags statusFlags, void *userData)

   128 {

   129     ALCdevice *device = (ALCdevice*)userData;

   130 

   131     (void)inputBuffer;

   132     (void)timeInfo;

   133     (void)statusFlags;

   134 

   135     aluMixData(device, outputBuffer, framesPerBuffer);

   136     return 0;

   137 }

   138 

   139 static int pa_capture_cb(const void *inputBuffer, void *outputBuffer,

   140                          unsigned long framesPerBuffer, const PaStreamCallbackTimeInfo *timeInfo,

   141                          const PaStreamCallbackFlags statusFlags, void *userData)

   142 {

   143     ALCdevice *device = (ALCdevice*)userData;

   144     pa_data *data = (pa_data*)device->ExtraData;

   145 

   146     (void)outputBuffer;

   147     (void)timeInfo;

   148     (void)statusFlags;

   149 

   150     WriteRingBuffer(data->ring, inputBuffer, framesPerBuffer);

   151     return 0;

   152 }

   153 

   154 

   155 static ALCboolean pa_open_playback(ALCdevice *device, const ALCchar *deviceName)

   156 {

   157     PaStreamParameters outParams;

   158     pa_data *data;

   159     PaError err;

   160 

   161     if(!deviceName)

   162         deviceName = pa_device;

   163     else if(strcmp(deviceName, pa_device) != 0)

   164         return ALC_FALSE;

   165 

   166     data = (pa_data*)calloc(1, sizeof(pa_data));

   167     data->update_size = device->UpdateSize;

   168 

   169     device->ExtraData = data;

   170 

   171     outParams.device = GetConfigValueInt("port", "device", -1);

   172     if(outParams.device < 0)

   173         outParams.device = Pa_GetDefaultOutputDevice();

   174     outParams.suggestedLatency = (device->UpdateSize*device->NumUpdates) /

   175                                  (float)device->Frequency;

   176     outParams.hostApiSpecificStreamInfo = NULL;

   177 

   178     switch(device->FmtType)

   179     {

   180         case DevFmtByte:

   181             outParams.sampleFormat = paInt8;

   182             break;

   183         case DevFmtUByte:

   184             outParams.sampleFormat = paUInt8;

   185             break;

   186         case DevFmtUShort:

   187             device->FmtType = DevFmtShort;

   188             /* fall-through */

   189         case DevFmtShort:

   190             outParams.sampleFormat = paInt16;

   191             break;

   192         case DevFmtFloat:

   193             outParams.sampleFormat = paFloat32;

   194             break;

   195     }

   196     outParams.channelCount = ((device->FmtChans == DevFmtMono) ? 1 : 2);

   197 

   198     SetDefaultChannelOrder(device);

   199 

   200     err = Pa_OpenStream(&data->stream, NULL, &outParams, device->Frequency,

   201                         device->UpdateSize, paNoFlag, pa_callback, device);

   202     if(err != paNoError)

   203     {

   204         ERR("Pa_OpenStream() returned an error: %s\n", Pa_GetErrorText(err));

   205         device->ExtraData = NULL;

   206         free(data);

   207         return ALC_FALSE;

   208     }

   209 

   210     device->szDeviceName = strdup(deviceName);

   211 

   212     if((ALuint)outParams.channelCount != ChannelsFromDevFmt(device->FmtChans))

   213     {

   214         if(outParams.channelCount != 1 && outParams.channelCount != 2)

   215         {

   216             ERR("Unhandled channel count: %u\n", outParams.channelCount);

   217             Pa_CloseStream(data->stream);

   218             device->ExtraData = NULL;

   219             free(data);

   220             return ALC_FALSE;

   221         }

   222         if((device->Flags&DEVICE_CHANNELS_REQUEST))

   223             ERR("Failed to set %s, got %u channels instead\n", DevFmtChannelsString(device->FmtChans), outParams.channelCount);

   224         device->Flags &= ~DEVICE_CHANNELS_REQUEST;

   225         device->FmtChans = ((outParams.channelCount==1) ? DevFmtMono : DevFmtStereo);

   226     }

   227 

   228     return ALC_TRUE;

   229 }

   230 

   231 static void pa_close_playback(ALCdevice *device)

   232 {

   233     pa_data *data = (pa_data*)device->ExtraData;

   234     PaError err;

   235 

   236     err = Pa_CloseStream(data->stream);

   237     if(err != paNoError)

   238         ERR("Error closing stream: %s\n", Pa_GetErrorText(err));

   239 

   240     free(data);

   241     device->ExtraData = NULL;

   242 }

   243 

   244 static ALCboolean pa_reset_playback(ALCdevice *device)

   245 {

   246     pa_data *data = (pa_data*)device->ExtraData;

   247     const PaStreamInfo *streamInfo;

   248     PaError err;

   249 

   250     streamInfo = Pa_GetStreamInfo(data->stream);

   251     if(device->Frequency != streamInfo->sampleRate)

   252     {

   253         if((device->Flags&DEVICE_FREQUENCY_REQUEST))

   254             ERR("PortAudio does not support changing sample rates (wanted %dhz, got %.1fhz)\n", device->Frequency, streamInfo->sampleRate);

   255         device->Flags &= ~DEVICE_FREQUENCY_REQUEST;

   256         device->Frequency = streamInfo->sampleRate;

   257     }

   258     device->UpdateSize = data->update_size;

   259 

   260     err = Pa_StartStream(data->stream);

   261     if(err != paNoError)

   262     {

   263         ERR("Pa_StartStream() returned an error: %s\n", Pa_GetErrorText(err));

   264         return ALC_FALSE;

   265     }

   266 

   267     return ALC_TRUE;

   268 }

   269 

   270 static void pa_stop_playback(ALCdevice *device)

   271 {

   272     pa_data *data = (pa_data*)device->ExtraData;

   273     PaError err;

   274 

   275     err = Pa_StopStream(data->stream);

   276     if(err != paNoError)

   277         ERR("Error stopping stream: %s\n", Pa_GetErrorText(err));

   278 }

   279 

   280 

   281 static ALCboolean pa_open_capture(ALCdevice *device, const ALCchar *deviceName)

   282 {

   283     PaStreamParameters inParams;

   284     ALuint frame_size;

   285     pa_data *data;

   286     PaError err;

   287 

   288     if(!deviceName)

   289         deviceName = pa_device;

   290     else if(strcmp(deviceName, pa_device) != 0)

   291         return ALC_FALSE;

   292 

   293     data = (pa_data*)calloc(1, sizeof(pa_data));

   294     if(data == NULL)

   295     {

   296         alcSetError(device, ALC_OUT_OF_MEMORY);

   297         return ALC_FALSE;

   298     }

   299 

   300     frame_size = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);

   301     data->ring = CreateRingBuffer(frame_size, device->UpdateSize*device->NumUpdates);

   302     if(data->ring == NULL)

   303     {

   304         alcSetError(device, ALC_OUT_OF_MEMORY);

   305         goto error;

   306     }

   307 

   308     inParams.device = GetConfigValueInt("port", "capture", -1);

   309     if(inParams.device < 0)

   310         inParams.device = Pa_GetDefaultOutputDevice();

   311     inParams.suggestedLatency = 0.0f;

   312     inParams.hostApiSpecificStreamInfo = NULL;

   313 

   314     switch(device->FmtType)

   315     {

   316         case DevFmtByte:

   317             inParams.sampleFormat = paInt8;

   318             break;

   319         case DevFmtUByte:

   320             inParams.sampleFormat = paUInt8;

   321             break;

   322         case DevFmtShort:

   323             inParams.sampleFormat = paInt16;

   324             break;

   325         case DevFmtFloat:

   326             inParams.sampleFormat = paFloat32;

   327             break;

   328         case DevFmtUShort:

   329             ERR("Unsigned short samples not supported\n");

   330             goto error;

   331     }

   332     inParams.channelCount = ChannelsFromDevFmt(device->FmtChans);

   333 

   334     err = Pa_OpenStream(&data->stream, &inParams, NULL, device->Frequency,

   335                         paFramesPerBufferUnspecified, paNoFlag, pa_capture_cb, device);

   336     if(err != paNoError)

   337     {

   338         ERR("Pa_OpenStream() returned an error: %s\n", Pa_GetErrorText(err));

   339         goto error;

   340     }

   341 

   342     device->szDeviceName = strdup(deviceName);

   343 

   344     device->ExtraData = data;

   345     return ALC_TRUE;

   346 

   347 error:

   348     DestroyRingBuffer(data->ring);

   349     free(data);

   350     return ALC_FALSE;

   351 }

   352 

   353 static void pa_close_capture(ALCdevice *device)

   354 {

   355     pa_data *data = (pa_data*)device->ExtraData;

   356     PaError err;

   357 

   358     err = Pa_CloseStream(data->stream);

   359     if(err != paNoError)

   360         ERR("Error closing stream: %s\n", Pa_GetErrorText(err));

   361 

   362     free(data);

   363     device->ExtraData = NULL;

   364 }

   365 

   366 static void pa_start_capture(ALCdevice *device)

   367 {

   368     pa_data *data = device->ExtraData;

   369     PaError err;

   370 

   371     err = Pa_StartStream(data->stream);

   372     if(err != paNoError)

   373         ERR("Error starting stream: %s\n", Pa_GetErrorText(err));

   374 }

   375 

   376 static void pa_stop_capture(ALCdevice *device)

   377 {

   378     pa_data *data = (pa_data*)device->ExtraData;

   379     PaError err;

   380 

   381     err = Pa_StopStream(data->stream);

   382     if(err != paNoError)

   383         ERR("Error stopping stream: %s\n", Pa_GetErrorText(err));

   384 }

   385 

   386 static void pa_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples)

   387 {

   388     pa_data *data = device->ExtraData;

   389     if(samples <= (ALCuint)RingBufferSize(data->ring))

   390         ReadRingBuffer(data->ring, buffer, samples);

   391     else

   392         alcSetError(device, ALC_INVALID_VALUE);

   393 }

   394 

   395 static ALCuint pa_available_samples(ALCdevice *device)

   396 {

   397     pa_data *data = device->ExtraData;

   398     return RingBufferSize(data->ring);

   399 }

   400 

   401 

   402 static const BackendFuncs pa_funcs = {

   403     pa_open_playback,

   404     pa_close_playback,

   405     pa_reset_playback,

   406     pa_stop_playback,

   407     pa_open_capture,

   408     pa_close_capture,

   409     pa_start_capture,

   410     pa_stop_capture,

   411     pa_capture_samples,

   412     pa_available_samples

   413 };

   414 

   415 ALCboolean alc_pa_init(BackendFuncs *func_list)

   416 {

   417     if(!pa_load())

   418         return ALC_FALSE;

   419     *func_list = pa_funcs;

   420     return ALC_TRUE;

   421 }

   422 

   423 void alc_pa_deinit(void)

   424 {

   425     if(pa_handle)

   426     {

   427         Pa_Terminate();

   428 #ifdef HAVE_DYNLOAD

   429         CloseLib(pa_handle);

   430 #endif

   431         pa_handle = NULL;

   432     }

   433 }

   434 

   435 void alc_pa_probe(enum DevProbe type)

   436 {

   437     switch(type)

   438     {

   439         case DEVICE_PROBE:

   440             AppendDeviceList(pa_device);

   441             break;

   442         case ALL_DEVICE_PROBE:

   443             AppendAllDeviceList(pa_device);

   444             break;

   445         case CAPTURE_DEVICE_PROBE:

   446             AppendCaptureDeviceList(pa_device);

   447             break;

   448     }

   449 }
author	Robert McIntyre <rlm@mit.edu>
date	Tue, 25 Oct 2011 13:02:31 -0700
parents
children