addons/PortAudio/source/new/IoAudioMixer.c

   1 /*   copyright: Steve Dekorte, 2002
   2 *   All rights reserved. See _BSDLicense.txt.
   3 */
   4
   5 #include "IoAudioMixer.h"
   6 #include "IoAudioDevice.h"
   7 #include "IoObject_actor.h"
   8 #include "base/List.h"
   9 #include "base/UArray.h"
  10 #include "IoState.h"
  11 #include "IoNumber.h"
  12 #include "IoSeq.h"
  13 #include "IoNil.h"
  14 #include "IoSound.h"
  15 #include "IoList.h"
  16 #include <math.h>
  17
  18 #include "SoundTouch_wrapper.h"
  19
  20 /* 1/N of a second worth of frames/samples */
  21 #define FRAMES_PER_BUFFER (44100/32)
  22
  23 /*#define DEBUG*/
  24
  25 AudioEvent *AudioEvent_new(void)
  26 {
  27         AudioEvent *self = calloc(1, sizeof(AudioEvent));
  28         return self;
  29 }
  30
  31 AudioEvent *AudioEvent_newWithSound_onSample_of_type_(IoSound *playSound, long sample, IoSound *ioTriggerSound, char etype)
  32 {
  33         AudioEvent *self = AudioEvent_new();
  34         self->ioPlaySound = playSound;
  35         self->sample = sample - 1;
  36         self->etype = etype;
  37         if (self->sample < 0) self->sample = 0;
  38         self->ioTriggerSound = ioTriggerSound;
  39         return self;
  40 }
  41
  42 void AudioEvent_free(AudioEvent *self)
  43 {
  44         free(self);
  45 }
  46
  47 void AudioEvent_mark(AudioEvent *self)
  48 {
  49         if (self->ioTriggerSound) IoObject_makeGrayIfWhite(self->ioTriggerSound);
  50         if (self->ioPlaySound) IoObject_makeGrayIfWhite(self->ioPlaySound);
  51 }
  52
  53 inline long AudioEvent_samplesUntilTrigger(AudioEvent *self)
  54 {
  55         if (!self->ioTriggerSound) return 0;
  56         return self->sample - Sound_position(IoSound_rawSound(self->ioTriggerSound));
  57 }
  58
  59 long AudioEvent_compare(AudioEvent **self, AudioEvent **event)
  60 {
  61         int diff = AudioEvent_samplesUntilTrigger(*event) - AudioEvent_samplesUntilTrigger(*self);
  62         if (diff) return diff;
  63         return ((*self)->etype) == AUDIOEVENT_ADD ? 0 : 1;
  64 }
  65
  66 void AudioEvent_show(AudioEvent *self)
  67 {
  68         char *type = self->etype == AUDIOEVENT_ADD ? "add" : "remove";
  69         /*
  70          printf("AudioEvent %p %s sound %p at sample %i\n",
  71                    (void *)self, type, self->ioPlaySound, (int)self->sample);
  72          */
  73         printf("event %s sound %p\n", type, self->ioPlaySound);
  74 }
  75
  76
  77 /* ---------------------------------------------------------- */
  78
  79 #define DATA(self) ((IoAudioMixerData *)self->data)
  80
  81 IoTag *IoAudioMixer_newTag(void *state)
  82 {
  83         IoTag *tag = IoTag_newWithName_("AudioMixer");
  84         IoTag_state_(tag, state);
  85         IoTag_cloneFunc_(tag, (IoTagCloneFunc *)IoAudioMixer_rawClone);
  86         IoTag_freeFunc_(tag, (IoTagFreeFunc *)IoAudioMixer_free);
  87         IoTag_markFunc_(tag, (IoTagMarkFunc *)IoAudioMixer_mark);
  88         return tag;
  89 }
  90
  91 IoAudioMixer *IoAudioMixer_proto(void *state)
  92 {
  93         IoObject *self = IoObject_new(state);
  94         IoObject_tag_(self, IoAudioMixer_newTag(state));
  95
  96         self->data = calloc(1, sizeof(IoAudioMixerData));
  97         DATA(self)->sounds = List_new();
  98         DATA(self)->soundsToRemove = List_new();
  99         DATA(self)->events = List_new();
 100         DATA(self)->activeEvents = List_new();
 101         DATA(self)->samplesPerBuffer = FRAMES_PER_BUFFER;
 102         DATA(self)->volume = 1.0;
 103
 104         DATA(self)->ioBuffer = IoSeq_new(IOSTATE);
 105         DATA(self)->buffer = IoSeq_rawUArray(DATA(self)->ioBuffer);
 106         DATA(self)->mixBuffer = UArray_new();
 107         DATA(self)->writeMessage =
 108                 IoMessage_newWithName_label_(IOSTATE,
 109                                                             IOSYMBOL("write"),
 110                                                             IOSYMBOL("AudioMixer"));
 111         IoMessage_setCachedArg_to_(DATA(self)->writeMessage, 0, DATA(self)->ioBuffer);
 112
 113         DATA(self)->nonBlockingWriteMessage =
 114                 IoMessage_newWithName_label_(IOSTATE,
 115                                                             IOSYMBOL("nonBlockingWrite"),
 116                                                             IOSYMBOL("AudioMixer"));
 117         IoMessage_setCachedArg_to_(DATA(self)->nonBlockingWriteMessage, 0, DATA(self)->ioBuffer);
 118
 119         DATA(self)->soundTouch = SoundTouch_init();
 120         SoundTouch_setSampleRate(DATA(self)->soundTouch, 44100);
 121         SoundTouch_setChannels(DATA(self)->soundTouch, 2);
 122         DATA(self)->tempo = 1.0;
 123
 124         IoState_registerProtoWithFunc_(state, self, IoAudioMixer_proto);
 125
 126         {
 127                 IoMethodTable methodTable[] = {
 128                 {"start", IoAudioMixer_start},
 129                 {"stop", IoAudioMixer_stop},
 130                 {"sounds", IoAudioMixer_sounds},
 131                 {"addSound", IoAudioMixer_addSound_},
 132                 {"addSoundOnSampleOfSound",
 133                         IoAudioMixer_addSound_onSample_ofSound_},
 134                 {"removeSound", IoAudioMixer_removeSound_},
 135                 {"removeAllSounds", IoAudioMixer_removeAllSounds},
 136                 {"removeSoundOnSampleOfSound", IoAudioMixer_removeSound_onSample_ofSound_},
 137                 {"setSamplesPerBuffer", IoAudioMixer_setSamplesPerBuffer},
 138                 {"setVolume", IoAudioMixer_setVolume},
 139                 {"setTempo", IoAudioMixer_setTempo},
 140                 {"setSampleRate", IoAudioMixer_setSampleRate},
 141                 {"setPitchSemiTones", IoAudioMixer_setPitchSemiTones},
 142                 {"setAudioDevice", IoAudioMixer_setAudioDevice},
 143                 {NULL, NULL},
 144                 };
 145                 IoObject_addMethodTable_(self, methodTable);
 146         }
 147
 148         DATA(self)->ioAudioDevice = IoObject_rawGetSlot_(self, IOSYMBOL("AudioDevice"));
 149         {
 150                 IoMessage *m = 0x0;
 151                 IOASSERT(DATA(self)->ioAudioDevice, "unable to find AudioDevice");
 152         }
 153         return self;
 154 }
 155
 156 IoAudioMixer *IoAudioMixer_rawClone(IoAudioMixer *proto)
 157 {
 158         IoObject *self = IoObject_rawClonePrimitive(proto);
 159         self->data = cpalloc(proto->data, sizeof(IoAudioMixerData));
 160
 161         DATA(self)->ioBuffer = IoSeq_new(IOSTATE);
 162         DATA(self)->buffer = IoSeq_rawUArray(DATA(self)->ioBuffer);
 163         DATA(proto)->mixBuffer = UArray_new();
 164         DATA(self)->writeMessage =
 165                 IoMessage_newWithName_label_(IOSTATE,
 166                                                             IOSYMBOL("write"),
 167                                                             IOSYMBOL("AudioMixer"));
 168         IoMessage_setCachedArg_to_(DATA(self)->writeMessage, 0, DATA(self)->ioBuffer);
 169
 170         DATA(self)->nonBlockingWriteMessage =
 171                 IoMessage_newWithName_label_(IOSTATE,
 172                                                             IOSYMBOL("nonBlockingWrite"),
 173                                                             IOSYMBOL("AudioMixer"));
 174         IoMessage_setCachedArg_to_(DATA(self)->nonBlockingWriteMessage, 0, DATA(self)->ioBuffer);
 175
 176         DATA(self)->sounds = List_new();
 177         DATA(self)->soundsToRemove = List_new();
 178         DATA(self)->events = List_new();
 179         DATA(self)->activeEvents = List_new();
 180         DATA(self)->volume = DATA(self)->volume;
 181
 182         DATA(self)->soundTouch = SoundTouch_init();
 183         SoundTouch_setSampleRate(DATA(self)->soundTouch, 44100);
 184         SoundTouch_setChannels(DATA(self)->soundTouch, 2);
 185         DATA(self)->tempo = 1.0;
 186         IoState_addValue_(IOSTATE, self);
 187         return self;
 188 }
 189
 190 IoAudioMixer *IoAudioMixer_new(void *state)
 191 {
 192         IoObject *proto = IoState_protoWithInitFunction_(state, IoAudioMixer_proto);
 193         return IOCLONE(proto);
 194 }
 195
 196 /* ----------------------------------------------------------- */
 197
 198 void IoAudioMixer_free(IoAudioMixer *self)
 199 {
 200         List_free(DATA(self)->sounds);
 201         List_free(DATA(self)->soundsToRemove);
 202         List_free(DATA(self)->events);
 203         List_free(DATA(self)->activeEvents);
 204         UArray_free(DATA(self)->mixBuffer);
 205         SoundTouch_free(DATA(self)->soundTouch);
 206         free(self->data);
 207 }
 208
 209 void IoAudioMixer_mark(IoAudioMixer *self)
 210 {
 211         /* buffer is a UArray */
 212         List_do_(DATA(self)->sounds, (ListDoCallback *)IoObject_makeGrayIfWhite);
 213         List_do_(DATA(self)->events, (ListDoCallback *)AudioEvent_mark);
 214         List_do_(DATA(self)->activeEvents, (ListDoCallback *)AudioEvent_mark);
 215         List_do_(DATA(self)->soundsToRemove, (ListDoCallback *)IoObject_makeGrayIfWhite);
 216         IoObject_makeGrayIfWhite(DATA(self)->ioAudioDevice);
 217         IoObject_makeGrayIfWhite(DATA(self)->writeMessage);
 218         IoObject_makeGrayIfWhite(DATA(self)->nonBlockingWriteMessage);
 219         IoObject_makeGrayIfWhite(DATA(self)->ioBuffer);
 220 }
 221
 222 /* ----------------------------------------------------------- */
 223
 224 void IoAudioMixer_updateBufferSize(IoAudioMixer *self)
 225 {
 226         int numBytes = DATA(self)->samplesPerBuffer * sizeof(float) * 2;
 227         UArray_setSize_(DATA(self)->mixBuffer, numBytes * DATA(self)->tempo);
 228         UArray_setSize_(DATA(self)->buffer, 10000*8);
 229 }
 230
 231 IoObject *IoAudioMixer_setAudioDevice(IoAudioMixer *self, IoObject *locals, IoMessage *m)
 232 {
 233         DATA(self)->ioAudioDevice = IOREF(IoMessage_locals_valueArgAt_(m, locals, 0));
 234         return self;
 235 }
 236
 237 IoObject *IoAudioMixer_setSamplesPerBuffer(IoAudioMixer *self, IoObject *locals, IoMessage *m)
 238 {
 239         int s = IoMessage_locals_intArgAt_(m, locals, 0);
 240         DATA(self)->samplesPerBuffer = s;
 241 #ifdef DEBUG
 242         printf("IoAudioMixer_setSamplesPerBuffer(%i)\n", s);
 243 #endif
 244         IoAudioMixer_updateBufferSize(self);
 245         return self;
 246 }
 247
 248 void IoAudioMixer_updateScale(IoAudioMixer *self)
 249 {
 250         DATA(self)->scale = DATA(self)->volume * (float)(0.9 / sqrt((double)List_size(DATA(self)->sounds)));
 251 }
 252
 253 IoObject *IoAudioMixer_setVolume(IoAudioMixer *self, IoObject *locals, IoMessage *m)
 254 {
 255         DATA(self)->volume = IoMessage_locals_doubleArgAt_(m, locals, 0);
 256         IoAudioMixer_updateScale(self);
 257         return self;
 258 }
 259
 260 IoObject *IoAudioMixer_sounds(IoAudioMixer *self, IoObject *locals, IoMessage *m)
 261 {
 262         IoList *ioList = IoList_new(IOSTATE);
 263         List_copy_(IoList_rawList(ioList), DATA(self)->sounds);
 264         return ioList;
 265 }
 266
 267 void IoAudioMixer_showEvents(IoAudioMixer *self)
 268 {
 269         List *events = DATA(self)->events;
 270         int i;
 271         for (i=0; i<List_size(events); i++)
 272         {
 273                 printf("%i: ", i);
 274                 AudioEvent_show(List_at_(events, i));
 275         }
 276         /*List_do_(events, (ListDoCallback *)AudioEvent_show);*/
 277         printf("\n");
 278 }
 279
 280 void IoAudioMixer_addEvent_(IoAudioMixer *self, AudioEvent *event)
 281 {
 282         List *events = DATA(self)->events;
 283         List_append_(events, event);
 284         List_qsort(events, (void *)AudioEvent_compare);
 285 #ifdef DEBUG
 286         IoAudioMixer_showEvents(self);
 287 #endif
 288 }
 289
 290 IoObject *IoAudioMixer_addSound_(IoAudioMixer *self, IoObject *locals, IoMessage *m)
 291 {
 292         IoSound *ioSound    = IoMessage_locals_soundArgAt_(m, locals, 0);
 293         AudioEvent *event = AudioEvent_newWithSound_onSample_of_type_(ioSound, 0, 0x0, AUDIOEVENT_ADD);
 294         IoAudioMixer_addEvent_(self, event);
 295         return self;
 296 }
 297
 298 IoObject *IoAudioMixer_addSound_onSample_ofSound_(IoAudioMixer *self, IoObject *locals, IoMessage *m)
 299 {
 300         IoSound *ioSound        = IoMessage_locals_soundArgAt_(m, locals, 0);
 301         long sample             = IoMessage_locals_longArgAt_(m, locals, 1);
 302         IoSound *ioTriggerSound = IoMessage_locals_soundArgAt_(m, locals, 2);
 303         AudioEvent *event       = AudioEvent_newWithSound_onSample_of_type_(
 304                                                                                                                    ioSound, sample, ioTriggerSound, AUDIOEVENT_ADD);
 305         IoAudioMixer_addEvent_(self, event);
 306         return self;
 307 }
 308
 309 void IoAudioMixer_justAddSound_(IoAudioMixer *self, IoSound *ioSound)
 310 {
 311         /*printf("add sound %p\n", (void *)ioSound);*/
 312         List_append_(DATA(self)->sounds, ioSound);
 313         Sound_setIsPlaying_(IoSound_rawSound(ioSound), 1);
 314 }
 315
 316 void IoAudioMixer_justRemoveSound_(IoAudioMixer *self, IoSound *ioSound)
 317 {
 318         /*printf("remove sound %p\n", (void *)ioSound);*/
 319         List_remove_(DATA(self)->sounds, ioSound);
 320         Sound_setIsPlaying_(IoSound_rawSound(ioSound), 0);
 321 }
 322
 323 IoObject *IoAudioMixer_removeSound_(IoAudioMixer *self, IoObject *locals, IoMessage *m)
 324 {
 325         IoSound *ioSound = IoMessage_locals_soundArgAt_(m, locals, 0);
 326         /*List_append_(DATA(self)->soundsToRemove, ioSound);*/
 327         AudioEvent *event = AudioEvent_newWithSound_onSample_of_type_(ioSound, 0, 0x0, AUDIOEVENT_REMOVE);
 328         IoAudioMixer_addEvent_(self, event);
 329         /*IoAudioMixer_justRemoveSound_(self, ioSound);*/
 330         return self;
 331 }
 332
 333 IoObject *IoAudioMixer_removeAllSounds(IoAudioMixer *self, IoObject *locals, IoMessage *m)
 334 {
 335         List *sounds = DATA(self)->sounds;
 336         while (List_size(sounds))
 337         {
 338                 IoAudioMixer_justRemoveSound_(self, List_at_(sounds, 0));
 339         }
 340         return self;
 341 }
 342
 343
 344 IoObject *IoAudioMixer_removeSound_onSample_ofSound_(IoAudioMixer *self, IoObject *locals, IoMessage *m)
 345 {
 346         IoSound *ioSound        = IoMessage_locals_soundArgAt_(m, locals, 0);
 347         long sample             = IoMessage_locals_longArgAt_(m, locals, 1);
 348         IoSound *ioTriggerSound = IoMessage_locals_soundArgAt_(m, locals, 2);
 349         AudioEvent *event       =
 350                 AudioEvent_newWithSound_onSample_of_type_(ioSound, sample, ioTriggerSound, AUDIOEVENT_REMOVE);
 351         IoAudioMixer_addEvent_(self, event);
 352         return self;
 353 }
 354
 355 /* ----------------------------------------------------------- */
 356
 357 int IoAudioMixer_isActive(IoAudioMixer *self)
 358 {
 359         return List_size(DATA(self)->sounds) ||
 360         List_size(DATA(self)->soundsToRemove) ||
 361         List_size(DATA(self)->events) ||
 362         List_size(DATA(self)->activeEvents);
 363 }
 364
 365 IoObject *IoAudioMixer_start(IoAudioMixer *self, IoObject *locals, IoMessage *m)
 366 {
 367         IoAudioMixer_updateBufferSize(self);
 368
 369         DATA(self)->isRunning = 1;
 370         while (DATA(self)->isRunning)
 371         {
 372                 if (IoAudioMixer_isActive(self))
 373                 {
 374                         int outSamples = IoAudioMixer_mixOneChunk(self, locals, m);
 375                         if (outSamples < 5000)
 376                         {
 377 #ifdef DEBUG
 378                                 printf("< 5000 out - mix another chunk\n");
 379 #endif
 380                                 IoAudioMixer_mixOneChunk(self, locals, m);
 381                         }
 382                 }
 383                 //IoState_yield(IOSTATE);
 384         }
 385         return self;
 386 }
 387
 388 IoObject *IoAudioMixer_stop(IoAudioMixer *self, IoObject *locals, IoMessage *m)
 389 {
 390         DATA(self)->isRunning = 0;
 391         /*IoAudioDevice_clearBuffers(DATA(self)->ioAudioDevice);*/
 392         return self;
 393 }
 394
 395 void IoAudioMixer_processSoundRemovals(IoAudioMixer *self)
 396 {
 397         IoSound *s;
 398         List *soundsToRemove = DATA(self)->soundsToRemove;
 399         List *sounds = DATA(self)->sounds;
 400         int removeCount = List_size(soundsToRemove);
 401
 402         if (removeCount)
 403         {
 404                 printf("removeCount = %i\n", removeCount);
 405                 printf("soundsCount = %i\n", List_size(sounds));
 406         }
 407
 408         while ( (s = List_pop(soundsToRemove)) )
 409         { IoAudioMixer_justRemoveSound_(self, s); }
 410
 411         if (removeCount)
 412         {
 413                 printf("remaining sounds = %i\n", List_size(sounds));
 414                 printf("remaining removeCount = %i\n\n", List_size(soundsToRemove));
 415         }
 416
 417         IoAudioMixer_updateScale(self);
 418 }
 419
 420 void IoAudioMixer_processActiveEvents(IoAudioMixer *self)
 421 {
 422         AudioEvent *e;
 423         while ( (e = List_pop(DATA(self)->activeEvents)) )
 424         {
 425 #ifdef DEBUG
 426                 printf("processing: ");
 427                 AudioEvent_show(e);
 428 #endif
 429                 switch (e->etype)
 430                 {
 431                         case AUDIOEVENT_ADD:
 432                                 IoAudioMixer_justAddSound_(self, e->ioPlaySound);
 433                                 break;
 434                         case AUDIOEVENT_REMOVE:
 435                                 IoAudioMixer_justRemoveSound_(self, e->ioPlaySound);
 436                                 break;
 437                 }
 438         }
 439         IoAudioMixer_updateScale(self);
 440 }
 441
 442 int IoAudioMixer_mixOneChunk(IoAudioMixer *self, IoObject *locals, IoMessage *m)
 443 {
 444         UArray *mixBuffer = DATA(self)->mixBuffer;
 445         List *sounds = DATA(self)->sounds;
 446         List *soundsToRemove = DATA(self)->soundsToRemove;
 447         AudioEvent *e = List_top(DATA(self)->events);
 448         List *activeEvents = DATA(self)->activeEvents;
 449         int frame;
 450         /*int samplesPerBuffer = DATA(self)->samplesPerBuffer;*/
 451         int samplesPerBuffer = UArray_size(DATA(self)->mixBuffer) / (sizeof(float) * 2);
 452
 453         UArray_setAllBytesTo_(mixBuffer, 0);
 454
 455         while ( e && (!e->ioTriggerSound))
 456         {
 457                 List_append_(DATA(self)->activeEvents, List_pop(DATA(self)->events));
 458                 e = List_top(DATA(self)->events);
 459         }
 460
 461         if (List_size(activeEvents))   IoAudioMixer_processActiveEvents(self);
 462         if (List_size(soundsToRemove)) IoAudioMixer_processSoundRemovals(self);
 463
 464         for (frame = 0; frame < samplesPerBuffer; frame ++)
 465         {
 466                 int index = frame * 2;
 467                 int i;
 468                 float *ol = UArray_floatPointerAt_(mixBuffer, index);
 469                 float *or = UArray_floatPointerAt_(mixBuffer, index+1);
 470
 471                 for (i = 0; i < List_size(sounds); i++)
 472                 {
 473                         IoSound *ioSound = List_at_(sounds, i);
 474                         Sound *sound = IoSound_rawSound(ioSound);
 475                         float left, right;
 476                         char done = Sound_nextFloat(sound, &left, &right);
 477
 478                         if (done && !Sound_isLooping(sound))
 479                         {
 480                                 List_append_(soundsToRemove, ioSound);
 481                                 continue;
 482                         }
 483
 484                         (*ol) += left;
 485                         (*or) += right;
 486
 487                         while (e &&
 488                                   ((!e->ioTriggerSound) ||
 489                                    ((e->ioTriggerSound == ioSound) &&
 490                                     (e->sample == Sound_position(sound))))
 491                                   )
 492                         {
 493                                 List_append_(DATA(self)->activeEvents, List_pop(DATA(self)->events));
 494                                 e = List_top(DATA(self)->events);
 495                         }
 496                 }
 497
 498                 (*ol) *= DATA(self)->scale;
 499                 (*or) *= DATA(self)->scale;
 500
 501                 if (List_size(activeEvents))   IoAudioMixer_processActiveEvents(self);
 502                 if (List_size(soundsToRemove)) IoAudioMixer_processSoundRemovals(self);
 503         }
 504
 505         /* adjust pitch and tempo */
 506         {
 507                 //double t1 = ((double)clock())/((double)CLOCKS_PER_SEC);
 508                 //double t2;
 509                 int receivedSamples = 1;
 510
 511                 SoundTouch_putSamples(DATA(self)->soundTouch, (float *)UArray_bytes(mixBuffer), samplesPerBuffer);
 512                 //printf("put %i\n", samplesPerBuffer);
 513                 //while (receivedSamples)
 514                 {
 515                         UArray_setSize_(DATA(self)->buffer, 10000*8);
 516                         receivedSamples = SoundTouch_receiveSamples(DATA(self)->soundTouch,
 517                                                                                             (float *)UArray_bytes(DATA(self)->buffer),
 518                                                                                             UArray_size(DATA(self)->buffer) / (sizeof(float) * 2));
 519                         UArray_setSize_(DATA(self)->buffer, receivedSamples * (sizeof(float) * 2));
 520
 521                         //printf("received %i\n", receivedSamples);
 522                         if (receivedSamples)
 523                         {
 524                                 if (receivedSamples < 5000)
 525                                 {
 526 #ifdef DEBUG
 527                                         printf("non-blocking write\n");
 528 #endif
 529
 530                                         IoMessage_locals_performOn_(DATA(self)->nonBlockingWriteMessage,
 531                                                                                    self, DATA(self)->ioAudioDevice);
 532                                 }
 533                                 else
 534                                 {
 535                                         IoMessage_locals_performOn_(DATA(self)->writeMessage,
 536                                                                                    self, DATA(self)->ioAudioDevice);
 537                                 }
 538                         }
 539 #ifdef DEBUG
 540                         t2 = ((double)clock())/((double)CLOCKS_PER_SEC);
 541                         printf("tempo: %1.1f  %i -> %i in %0.2f sec\n",
 542                                   DATA(self)->tempo,
 543                                   samplesPerBuffer,
 544                                   receivedSamples,
 545                                   (float)(t2 - t1));
 546 #endif
 547                 }
 548
 549                 //printf("\n");
 550                 return receivedSamples;
 551         }
 552         /* need to change this to be dynamic, so we can easily record the output */
 553         /*IoAudioDevice_justWrite(DATA(self)->ioAudioDevice, locals, m, buffer);*/
 554         return UArray_size(DATA(self)->buffer) / 8;
 555 }
 556
 557 IoObject *IoAudioMixer_setTempo(IoAudioMixer *self, IoObject *locals, IoMessage *m)
 558 {
 559         DATA(self)->tempo = IoMessage_locals_floatArgAt_(m, locals, 0);
 560         SoundTouch_setTempo(DATA(self)->soundTouch, DATA(self)->tempo);
 561         printf("IoAudioMixer_setTempo(%f)\n", DATA(self)->tempo);
 562         IoAudioMixer_updateBufferSize(self);
 563         return self;
 564 }
 565
 566 IoObject *IoAudioMixer_setSampleRate(IoAudioMixer *self, IoObject *locals, IoMessage *m)
 567 {
 568         DATA(self)->sampleRate = IoMessage_locals_intArgAt_(m, locals, 0);
 569         SoundTouch_setSampleRate(DATA(self)->soundTouch, (unsigned int)DATA(self)->sampleRate);
 570         printf("IoAudioMixer_setSampleRate(%i)\n", DATA(self)->sampleRate);
 571         IoAudioMixer_updateBufferSize(self);
 572         return self;
 573 }
 574
 575 IoObject *IoAudioMixer_setPitchSemiTones(IoAudioMixer *self, IoObject *locals, IoMessage *m)
 576 {
 577         DATA(self)->pitch = IoMessage_locals_floatArgAt_(m, locals, 0);
 578         SoundTouch_setPitchSemiTones(DATA(self)->soundTouch, DATA(self)->pitch);
 579         printf("IoAudioMixer_setPitchSemiTones(%f)\n", DATA(self)->pitch);
 580         IoAudioMixer_updateBufferSize(self);
 581         return self;
 582 }
 583