addons/PortAudio/source/IoAudioDevice.c

   1
   2 //metadoc AudioDevice copyright Steve Dekorte, 2004
   3 //metadoc AudioDevice license BSD revised
   4 //metadoc AudioDevice category Media")
   5 /*metadoc AudioDevice description
   6 The AudioDevice object can used to write audio data as if directly to the audio buffer.
   7 */
   8
   9 #include "IoAudioDevice.h"
  10 #include "List.h"
  11 #include "UArray.h"
  12 #include "IoState.h"
  13 #include "IoNumber.h"
  14 #include "IoSeq.h"
  15 #include "IoList.h"
  16 #include <math.h>
  17
  18 #define DATA(self) ((IoAudioDeviceData *)IoObject_dataPointer(self))
  19
  20 IoTag *IoAudioDevice_newTag(void *state)
  21 {
  22         IoTag *tag = IoTag_newWithName_("AudioDevice");
  23         IoTag_state_(tag, state);
  24         IoTag_cloneFunc_(tag, (IoTagCloneFunc *)IoAudioDevice_rawClone);
  25         IoTag_freeFunc_(tag, (IoTagFreeFunc *)IoAudioDevice_free);
  26         IoTag_markFunc_(tag, (IoTagMarkFunc *)IoAudioDevice_mark);
  27         return tag;
  28 }
  29
  30 IoAudioDevice *IoAudioDevice_proto(void *state)
  31 {
  32         IoObject *self = IoObject_new(state);
  33         IoObject_tag_(self, IoAudioDevice_newTag(state));
  34
  35         IoObject_setDataPointer_(self, calloc(1, sizeof(IoAudioDeviceData)));
  36
  37         DATA(self)->writeBuffer = IoSeq_new(state);
  38         DATA(self)->readBuffer = IoSeq_new(state);
  39         DATA(self)->audioDevice = AudioDevice_new();
  40         IoState_registerProtoWithFunc_(state, self, IoAudioDevice_proto);
  41
  42         {
  43         IoMethodTable methodTable[] = {
  44         {"open", IoAudioDevice_open},
  45         {"openForReadingAndWriting", IoAudioDevice_openForReadingAndWriting},
  46         {"close", IoAudioDevice_close},
  47         {"asyncWrite", IoAudioDevice_asyncWrite},
  48         {"asyncRead", IoAudioDevice_read},
  49         {"error", IoAudioDevice_error},
  50         {"isActive", IoAudioDevice_isActive},
  51         {"streamTime", IoAudioDevice_streamTime},
  52         {"needsData", IoAudioDevice_needsData},
  53         {"writeBufferIsEmpty", IoAudioDevice_writeBufferIsEmpty},
  54         {NULL, NULL},
  55         };
  56         IoObject_addMethodTable_(self, methodTable);
  57         }
  58         return self;
  59 }
  60
  61 IoAudioDevice *IoAudioDevice_rawClone(IoAudioDevice *proto)
  62 {
  63         IoObject *self = IoObject_rawClonePrimitive(proto);
  64         IoObject_setDataPointer_(self, calloc(1, sizeof(IoAudioDeviceData)));
  65         DATA(self)->writeBuffer = IOCLONE(DATA(proto)->writeBuffer);
  66         DATA(self)->readBuffer = IOCLONE(DATA(proto)->readBuffer);
  67         DATA(self)->audioDevice = AudioDevice_new();
  68         return self;
  69 }
  70
  71 IoAudioDevice *IoAudioDevice_new(void *state)
  72 {
  73         IoObject *proto = IoState_protoWithInitFunction_(state, IoAudioDevice_proto);
  74         return IOCLONE(proto);
  75 }
  76
  77 /* ----------------------------------------------------------- */
  78
  79 void IoAudioDevice_free(IoAudioDevice *self)
  80 {
  81         AudioDevice_free(DATA(self)->audioDevice);
  82         free(IoObject_dataPointer(self));
  83 }
  84
  85 void IoAudioDevice_mark(IoAudioDevice *self)
  86 {
  87         IoObject_shouldMark(DATA(self)->writeBuffer);
  88         IoObject_shouldMark(DATA(self)->readBuffer);
  89 }
  90
  91 AudioDevice *IoAudioDevice_rawAudioDevice(IoAudioDevice *self)
  92 {
  93         return DATA(self)->audioDevice;
  94 }
  95
  96 void IoAudioDevice_clearBuffers(IoAudioDevice *self)
  97 {
  98         AudioDevice_clearBuffers(DATA(self)->audioDevice);
  99 }
 100
 101 /* ----------------------------------------------------------- */
 102
 103 IoObject *IoAudioDevice_openForReadingAndWriting(IoAudioDevice *self, IoObject *locals, IoMessage *m)
 104 {
 105         /*doc AudioDevice openForReadingAndWriting
 106         Open audio output and input streams.
 107         */
 108
 109         AudioDevice_openForReadingAndWriting(DATA(self)->audioDevice);
 110         AudioDevice_start(DATA(self)->audioDevice);
 111         return self;
 112 }
 113
 114 IoObject *IoAudioDevice_open(IoAudioDevice *self, IoObject *locals, IoMessage *m)
 115 {
 116         /*doc AudioDevice open
 117         Open an audio output stream.
 118         */
 119
 120         AudioDevice_open(DATA(self)->audioDevice);
 121         AudioDevice_start(DATA(self)->audioDevice);
 122         return self;
 123 }
 124
 125 IoObject *IoAudioDevice_close(IoAudioDevice *self, IoObject *locals, IoMessage *m)
 126 {
 127         /*doc AudioDevice close
 128         Close the audio stream.
 129         */
 130
 131         AudioDevice_close(DATA(self)->audioDevice);
 132         return self;
 133 }
 134
 135 IoObject *IoAudioDevice_needsData(IoAudioDevice *self, IoObject *locals, IoMessage *m)
 136 {
 137         /*doc AudioDevice needsData
 138         Returns true if the receiver can read more data.
 139         */
 140
 141         return IOBOOL(self, DATA(self)->audioDevice->needsData == 1);
 142 }
 143
 144 IoObject *IoAudioDevice_asyncWrite(IoAudioDevice *self, IoObject *locals, IoMessage *m)
 145 {
 146         /*doc AudioDevice nonBlockingWrite(aBuffer)
 147         Writes aBuffer to the audio output buffer and returns immediately.
 148         */
 149
 150         IoSeq *buf = IoMessage_locals_seqArgAt_(m, locals, 0);
 151
 152         if (IoSeq_rawSize(buf) == 0)
 153         {
 154                 return self;
 155         }
 156
 157         AudioDevice_checkForError(DATA(self)->audioDevice);
 158         AudioDevice_write_(DATA(self)->audioDevice, IoSeq_rawUArray(buf));
 159         return self;
 160 }
 161
 162 IoObject *IoAudioDevice_read(IoAudioDevice *self, IoObject *locals, IoMessage *m)
 163 {
 164         /*doc AudioDevice read
 165         Returns the audio read buffer.
 166         */
 167
 168         AudioDevice *device = DATA(self)->audioDevice;
 169         UArray *rba = IoSeq_rawUArray(DATA(self)->readBuffer);
 170         UArray *ba;
 171
 172         while (device->locked)
 173         {
 174                 AudioDevice_nanoSleep(device);
 175         }
 176
 177         ba = AudioDevice_read(device);
 178         UArray_copy_(rba, ba);
 179
 180         return DATA(self)->readBuffer;
 181 }
 182
 183 IoObject *IoAudioDevice_error(IoAudioDevice *self, IoObject *locals, IoMessage *m)
 184 {
 185         /*doc AudioDevice error
 186         Returns an error string if an error has occured, Nil otherwise.
 187         */
 188
 189         const char *e = AudioDevice_error(DATA(self)->audioDevice);
 190         return e ? IOSYMBOL(e) : IONIL(self);
 191 }
 192
 193 IoObject *IoAudioDevice_isActive(IoAudioDevice *self, IoObject *locals, IoMessage *m)
 194 {
 195         /*doc AudioDevice isActive
 196         Returns self if the receiver is active, Nil otherwise.
 197         */
 198
 199         return AudioDevice_isActive(DATA(self)->audioDevice) ? self : IONIL(self);
 200 }
 201
 202 IoObject *IoAudioDevice_streamTime(IoAudioDevice *self, IoObject *locals, IoMessage *m)
 203 {
 204         /*doc AudioDevice streamTime
 205         Returns the audio stream time as a number.
 206         */
 207
 208         return IONUMBER(AudioDevice_streamTime(DATA(self)->audioDevice));
 209 }
 210
 211 IoObject *IoAudioDevice_writeBufferIsEmpty(IoAudioDevice *self, IoObject *locals, IoMessage *m)
 212 {
 213         /*doc AudioDevice writeBufferIsEmpty
 214         Returns the true if the audio buffer is empty, false otherwise.
 215         */
 216
 217         return IOBOOL(self, DATA(self)->audioDevice->writeBufferIsEmpty);
 218 }
 219