addons/PortAudio/source/AudioDevice.c

   1
   2 #include "AudioDevice.h"
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <math.h>
   6 #include <limits.h>
   7 #include <time.h>
   8 #include <unistd.h>
   9
  10 #define FRAMES_PER_BUFFER 256
  11 #define INPUT_CHANNELS 1
  12
  13 void AudioDevice_nanoSleep(AudioDevice *self)
  14 {
  15         /*
  16          struct timespec rqtp;
  17          struct timespec extra;
  18          rqtp.tv_sec = 0;
  19          rqtp.tv_nsec = 10;
  20          nanosleep(&rqtp, &extra);
  21          */
  22         usleep(self->lockSleepMicroSeconds);
  23         //printf("AudioDevice usleep(%i)\n", self->lockSleepMicroSeconds);
  24 }
  25
  26 AudioDevice *AudioDevice_new(void)
  27 {
  28         AudioDevice *self = calloc(1, sizeof(AudioDevice));
  29
  30         self->writeBuffer = UArray_new();
  31         self->nextWriteBuffer = UArray_new();
  32
  33         self->readBuffer = UArray_new();
  34         self->nextReadBuffer = UArray_new();
  35         self->maxReadFrame = 4096 * 100;
  36         self->lockSleepMicroSeconds = 10;
  37         self->needsData = 1;
  38
  39         AudioDevice_init(self);
  40         return self;
  41 }
  42
  43 inline void AudioDevice_lock(AudioDevice *self)
  44 {
  45         while (self->locked) { AudioDevice_nanoSleep(self); }
  46         self->locked = 1;
  47 }
  48
  49 inline void AudioDevice_unlock(AudioDevice *self)
  50 {
  51         self->locked = 0;
  52 }
  53
  54 int AudioDevice_isLocked(AudioDevice *self)
  55 {
  56         return self->locked;
  57 }
  58
  59 void AudioDevice_free(AudioDevice *self)
  60 {
  61         self->isFreed = 1;
  62         AudioDevice_lock(self);
  63         /*
  64          while (self->locked)
  65          { printf("AudioDevice_free waiting on lock %i\n", self->locked); }
  66          */
  67         AudioDevice_terminate(self);
  68
  69         UArray_free(self->writeBuffer);
  70         UArray_free(self->nextWriteBuffer);
  71
  72         UArray_free(self->readBuffer);
  73         UArray_free(self->nextReadBuffer);
  74
  75         free(self);
  76 }
  77
  78 void AudioDevice_init(AudioDevice *self)
  79 {
  80         self->locked = 0;
  81         /*printf("AudioDevice_init\n");*/
  82         self->err = Pa_Initialize();
  83         AudioDevice_checkForError(self);
  84 }
  85
  86 int AudioDevice_framesPerBuffer(AudioDevice *self)
  87 {
  88         return FRAMES_PER_BUFFER;
  89 }
  90
  91 void AudioDevice_terminate(AudioDevice *self)
  92 {
  93         Pa_Terminate();
  94 }
  95
  96 void AudioDevice_isListening_(AudioDevice *self, int v)
  97 {
  98         self->isListening = v;
  99 }
 100
 101 int AudioDevice_isListening(AudioDevice *self)
 102 {
 103         return self->isListening;
 104 }
 105
 106 void AudioDevice_openForReadingAndWriting(AudioDevice *self)
 107 {
 108         AudioDevice_isListening_(self, 1);
 109         AudioDevice_open(self);
 110 }
 111
 112 void AudioDevice_open(AudioDevice *self)
 113 {
 114         if (!self->stream)
 115         {
 116                 self->err = Pa_OpenDefaultStream(
 117                                                                    &(self->stream),
 118                                                                    self->isListening ? INPUT_CHANNELS : 0, /* input channels */
 119                                                                    2, /* stereo output */
 120                                                                    paFloat32,
 121                                                                    44100, /* sample rate */
 122                                                                    FRAMES_PER_BUFFER, /* frames per buffer */
 123                                                                    //0, /* number of buffers, if zero then use default minimum */
 124                                                                    /*AudioDevice_callbackInputTest, */
 125                                                                    AudioDevice_callback,
 126                                                                    (void *)self
 127                                                                    ); /* pass our data through to callback */
 128                 AudioDevice_checkForError(self);
 129                 //printf("opening self->needsData = 1\n");
 130                 self->needsData = 1;
 131         }
 132 }
 133
 134 inline int AudioDevice_isOpen(AudioDevice *self)
 135 {
 136         return (self->stream != NULL);
 137 }
 138
 139 void AudioDevice_close(AudioDevice *self)
 140 {
 141         if (AudioDevice_isOpen(self))
 142         {
 143                 self->err = Pa_CloseStream( self->stream );
 144                 self->stream = NULL;
 145                 AudioDevice_checkForError(self);
 146         }
 147 }
 148
 149 void AudioDevice_checkForError(AudioDevice *self)
 150 {
 151         if (self->err != paNoError)
 152         {
 153                 AudioDevice_printError(self);
 154         }
 155 }
 156
 157 const char *AudioDevice_error(AudioDevice *self)
 158 {
 159         return self->err ? Pa_GetErrorText(self->err) : NULL;
 160 }
 161
 162 void AudioDevice_printError(AudioDevice *self)
 163 {
 164         printf("AudioDevice error: %s\n", AudioDevice_error(self));
 165 }
 166
 167 void AudioDevice_start(AudioDevice *self)
 168 {
 169         if (!AudioDevice_isOpen(self))
 170         {
 171                 AudioDevice_open(self);
 172         }
 173
 174         if (AudioDevice_isOpen(self) && !AudioDevice_isActive(self))
 175         {
 176                 self->err = Pa_StartStream( self->stream );
 177                 AudioDevice_checkForError(self);
 178         }
 179 }
 180
 181 void AudioDevice_stop(AudioDevice *self)
 182 {
 183         if (AudioDevice_isOpen(self) && AudioDevice_isActive(self))
 184         {
 185                 self->err = Pa_StopStream( self->stream );
 186                 AudioDevice_checkForError(self);
 187         }
 188 }
 189
 190 int AudioDevice_isActive(AudioDevice *self)
 191 {
 192         return AudioDevice_isOpen(self) ? Pa_IsStreamActive( self->stream ) : 0;
 193 }
 194
 195 int AudioDevice_streamTime(AudioDevice *self)
 196 {
 197         return AudioDevice_isOpen(self) ? Pa_GetStreamTime( self->stream ) : 0;
 198 }
 199
 200 double AudioDevice_cpuLoad(AudioDevice *self)
 201 {
 202         return AudioDevice_isOpen(self) ? Pa_GetStreamCpuLoad( self->stream ) : 0;
 203 }
 204
 205 int AudioDevice_callbackTest(
 206                                             void *inputBuffer,
 207                                             void *outputBuffer,
 208                                             unsigned long framesPerBuffer,
 209                                             PaTimestamp outTime,
 210                                             void *userData)
 211 {
 212         unsigned long frame;
 213         float *out = (float *)outputBuffer;
 214
 215         for (frame = 0; frame < framesPerBuffer; frame++)
 216         {
 217                 double k = frame + outTime;
 218                 float a = sin((k * 4 * 261.6) / 44100.0);
 219                 out[frame*2+0] = a;
 220                 out[frame*2+1] = 0.0;
 221         }
 222
 223         return 0;
 224 }
 225
 226 int AudioDevice_callbackInputTest(
 227                                                     void *inputBuffer,
 228                                                     void *outputBuffer,
 229                                                     unsigned long framesPerBuffer,
 230                                                     PaTimestamp outTime,
 231                                                     void *userData)
 232 {
 233         unsigned long frame;
 234         float *in  = (float *)inputBuffer;
 235         float *out = (float *)outputBuffer;
 236
 237         for (frame = 0; frame < framesPerBuffer; frame++)
 238         {
 239                 out[frame*2+0] = in[frame];
 240                 out[frame*2+1] = in[frame];
 241         }
 242
 243         return 0;
 244 }
 245
 246 unsigned long AudioDevice_bytesPerFrame(AudioDevice *self)
 247 {
 248         return sizeof(float)*2;
 249 }
 250
 251 unsigned long AudioDevice_framesInWriteBuffer(AudioDevice *self)
 252 {
 253         return UArray_size(self->writeBuffer)/AudioDevice_bytesPerFrame(self);
 254 }
 255
 256 int AudioDevice_callback(
 257                                         void *inputBuffer,
 258                                         void *outputBuffer,
 259                                         unsigned long framesPerBuffer,
 260                                         PaTimestamp outTime,
 261                                         void *userData)
 262 {
 263         AudioDevice *self = (AudioDevice *)userData;
 264         self->writeBufferIsEmpty = 0;
 265
 266         //printf("AudioDevice_callback\n");
 267
 268         if (self->isFreed)
 269         {
 270                 printf("AudioDevice: auto stop portaudio stream\n");
 271                 return -1;
 272         } /* return non zero to stop stream */
 273
 274     memset(outputBuffer, 0, framesPerBuffer*2*4);
 275
 276     AudioDevice_lock(self);
 277
 278     /* --- speaker output ----------------------- */
 279
 280     if (UArray_size(self->writeBuffer) == 0)
 281     {
 282             AudioDevice_swapWriteBuffers(self);
 283     }
 284
 285     if (UArray_size(self->writeBuffer))
 286     {
 287             float *out = (float *)outputBuffer;
 288             /*int writeFrames = AudioDevice_framesInWriteBuffer(self);*/
 289             float *buf  = (float *)UArray_bytes(self->writeBuffer);
 290             int outFrame = 0;
 291
 292             for (;;)
 293             {
 294                     int outFramesLeft = framesPerBuffer - outFrame;
 295                     int writeFramesLeft = AudioDevice_framesInWriteBuffer(self) - self->writeFrame;
 296                     //printf("outFramesLeft = %i\n", outFramesLeft);
 297
 298                     if (writeFramesLeft < outFramesLeft) /* out > in */
 299                     {
 300                             memcpy(out + (outFrame*2), buf + (self->writeFrame*2), writeFramesLeft*2*4);
 301
 302                             AudioDevice_swapWriteBuffers(self);
 303                             buf = (float *)UArray_bytes(self->writeBuffer);
 304                             outFrame += writeFramesLeft;
 305
 306                             if (AudioDevice_framesInWriteBuffer(self) == 0)
 307                             {
 308                                     //memset(out + (outFrame*2), 0, outFramesLeft*2*4);
 309                                     //printf("AudioDevice warning: empty buffer ---------------------------------------\n");
 310                                     self->writeBufferIsEmpty = 1;
 311                                     break;
 312                             }
 313                     }
 314                     else /* in > out */
 315                     {
 316                             memcpy(out + (outFrame*2), buf + (self->writeFrame*2), outFramesLeft*2*4);
 317                             self->writeFrame += outFramesLeft;
 318                             break;
 319                     }
 320             }
 321     }
 322     else
 323     {
 324             self->writeBufferIsEmpty = 1;
 325     }
 326
 327
 328     /* --- mic input ----------------------- */
 329
 330     if (inputBuffer && self->isListening)
 331     {
 332             unsigned long frame = framesPerBuffer;
 333             float *input = inputBuffer;
 334             float *buf;
 335
 336             if (self->readFrame > self->maxReadFrame)
 337             {
 338                     self->readFrame = 0;
 339             }
 340
 341             UArray_setSize_(self->readBuffer,
 342                                            (self->readFrame + framesPerBuffer) * sizeof(float) /*bytes */ * 2 /* channels */);
 343
 344             buf  = (float *)UArray_bytes(self->readBuffer);
 345
 346             buf += self->readFrame * 2;
 347
 348             // map mono mic input to stereo output
 349
 350             while (frame)
 351             {
 352                     *buf = *input; buf++;
 353                     *buf = *input; buf++;
 354                     input++;
 355                     frame--;
 356             }
 357             self->readFrame += framesPerBuffer;
 358
 359     }
 360
 361     AudioDevice_unlock(self);
 362     return 0;
 363 }
 364
 365 int AudioDevice_swapWriteBuffers(AudioDevice *self)
 366 {
 367         /* clear the current buffer */
 368         UArray_setSize_(self->writeBuffer, 0);
 369         self->writeFrame = 0;
 370
 371         /* swap if the next one has data */
 372         if (UArray_size(self->nextWriteBuffer))
 373         {
 374                 void *b = self->writeBuffer;
 375                 self->writeBuffer = self->nextWriteBuffer;
 376                 self->nextWriteBuffer = b;
 377                 //printf("swapping buffers self->needsData = 1\n");
 378                 self->needsData = 1;
 379         }
 380
 381         return 0;
 382 }
 383
 384 int AudioDevice_swapReadBuffers(AudioDevice *self)
 385 {
 386         int didSwap = 0;
 387
 388         if (UArray_size(self->readBuffer))
 389         {
 390                 /* clear the next buffer */
 391                 UArray_setSize_(self->nextReadBuffer, 0);
 392                 self->readFrame = 0;
 393
 394                 /* swap */
 395                 {
 396                         void *b = self->readBuffer;
 397                         self->readBuffer = self->nextReadBuffer;
 398                         self->nextReadBuffer = b;
 399                 }
 400                 didSwap = 1;
 401         }
 402
 403         return didSwap;
 404 }
 405
 406 void AudioDevice_clearBuffers(AudioDevice *self)
 407 {
 408         AudioDevice_lock(self);
 409         UArray_setSize_(self->readBuffer, 0);
 410         UArray_setSize_(self->nextReadBuffer, 0);
 411         AudioDevice_unlock(self);
 412 }
 413
 414 /* --- called from the outside --- */
 415
 416 void AudioDevice_writeData_length_(AudioDevice *self, uint8_t *data, size_t numBytes)
 417 {
 418         self->writeBufferIsEmpty = 0;
 419         AudioDevice_lock(self);
 420         UArray_appendBytes_size_(self->nextWriteBuffer, data, numBytes);
 421         self->needsData = 0;
 422         //printf("writting self->needsData = 0\n");
 423         AudioDevice_unlock(self);
 424         AudioDevice_start(self);
 425 }
 426
 427 void AudioDevice_write_(AudioDevice *self, UArray *buf)
 428 {
 429         AudioDevice_writeData_length_(self, UArray_bytes(buf), UArray_size(buf));
 430 }
 431
 432 UArray *AudioDevice_read(AudioDevice *self)
 433 {
 434         AudioDevice_start(self);
 435         AudioDevice_lock(self);
 436         AudioDevice_swapReadBuffers(self);
 437         AudioDevice_unlock(self);
 438         return self->nextReadBuffer;
 439 }