coreaudio 0.0.1

data/ext/coreaudio.h

@@ -0,0 +1,14 @@
+#ifndef COREAUDIO_H
+#define COREAUDIO_H 1
+
+extern VALUE rb_mCoreAudio;
+extern VALUE rb_mAudioFile;
+
+extern void Init_coreaudio_audiofile(void);
+
+/*-- Utility Macros --*/
+#define CROPF(F) ((F) > 1.0 ? 1.0 : (((F) < -1.0) ? -1.0 : (F)))
+#define FLOAT2SHORT(F) ((short)(CROPF(F)*0x7FFF))
+#define SHORT2FLOAT(S) ((double)(S) / 32767.0)
+
+#endif

data/ext/coreaudio.m

@@ -0,0 +1,1054 @@
+#include <stdio.h>
+#include <unistd.h>
+
+#include <pthread.h>
+
+#include <Foundation/Foundation.h>
+#include <CoreAudio/CoreAudio.h>
+
+#include <ruby.h>
+
+#include "coreaudio.h"
+
+VALUE rb_mCoreAudio;
+
+static VALUE rb_cAudioDevice;
+static VALUE rb_cAudioStream;
+static VALUE rb_cOutLoop;
+static VALUE rb_cAudioBuffer;
+static VALUE rb_cOutputBuffer;
+static VALUE rb_cInputBuffer;
+static ID sym_iv_devid;
+static ID sym_iv_name;
+static ID sym_iv_available_sample_rate;
+static ID sym_iv_nominal_rate;
+static ID sym_iv_input_stream;
+static ID sym_iv_output_stream;
+static ID sym_iv_channels;
+static ID sym_iv_buffer_frame_size;
+
+/* utility macro */
+#define PropertyAddress { \
+  .mScope = kAudioObjectPropertyScopeGlobal,    \
+  .mElement = kAudioObjectPropertyElementMaster \
+}
+
+/*--- CoreAudio::AudioStream ---*/
+static VALUE
+ca_get_stream_channel_num(AudioDeviceID devID,
+                          AudioObjectPropertyScope scope)
+{
+    AudioObjectPropertyAddress address = PropertyAddress;
+    UInt32 size;
+    AudioChannelLayout *layout;
+    OSStatus status;
+    UInt32 ch_num;
+
+    address.mSelector = kAudioDevicePropertyPreferredChannelLayout;
+    address.mScope = scope;
+    if (!AudioObjectHasProperty(devID, &address))
+      return INT2NUM(0);
+
+    status = AudioObjectGetPropertyDataSize(devID, &address, 0, NULL, &size);
+
+    if (status != noErr) {
+      rb_raise(rb_eArgError,
+               "coreaudio: get preferred channel layout size failed: %d", status);
+    }
+
+    layout = alloca(size);
+
+    status = AudioObjectGetPropertyData(devID, &address, 0, NULL, &size, layout);
+    if (status != noErr) {
+      rb_raise(rb_eArgError,
+               "coreaudio: get preferred channel layout failed: %d", status);
+    }
+
+    if (layout->mChannelLayoutTag == kAudioChannelLayoutTag_UseChannelDescriptions) {
+      ch_num = layout->mNumberChannelDescriptions;
+    } else if (layout->mChannelLayoutTag == kAudioChannelLayoutTag_UseChannelBitmap) {
+      UInt32 i;
+      ch_num = 0;
+      for ( i = 0; i < sizeof(layout->mChannelBitmap)*8; i++ ) {
+        if ( (layout->mChannelBitmap >> i) & 0x01 )
+          ch_num++;
+      }
+    } else {
+      ch_num = AudioChannelLayoutTag_GetNumberOfChannels(layout->mChannelLayoutTag);
+    }
+    return UINT2NUM(ch_num);
+}
+
+static VALUE
+ca_get_stream_buffer_frame(AudioDeviceID devID, AudioObjectPropertyScope scope)
+{
+    AudioObjectPropertyAddress address = PropertyAddress;
+    UInt32 size, framesize;
+    OSStatus status;
+
+    address.mSelector = kAudioDevicePropertyBufferFrameSize;
+    address.mScope = scope;
+
+    if (!AudioObjectHasProperty(devID, &address))
+      return INT2NUM(0);
+
+    size = sizeof(framesize);
+    status = AudioObjectGetPropertyData(devID, &address, 0, NULL, &size, &framesize);
+    if (status != noErr) {
+      rb_raise(rb_eArgError,
+               "coreaudio: get buffer frame size failed: %d", status);
+    }
+    return UINT2NUM(framesize);
+}
+
+static VALUE
+ca_stream_initialize(VALUE self, VALUE devid_val, VALUE is_input)
+{
+    AudioDeviceID devID = (AudioDeviceID)NUM2UINT(devid_val);
+    AudioObjectPropertyScope scope;
+
+    if (RTEST(is_input))
+      scope = kAudioDevicePropertyScopeInput;
+    else
+      scope = kAudioDevicePropertyScopeOutput;
+    rb_ivar_set(self, sym_iv_channels, ca_get_stream_channel_num(devID, scope));
+    rb_ivar_set(self, sym_iv_buffer_frame_size, ca_get_stream_buffer_frame(devID, scope));
+
+    return self;
+}
+
+static VALUE
+ca_stream_new(VALUE devid, VALUE is_input)
+{
+    VALUE stream;
+    stream = rb_obj_alloc(rb_cAudioStream);
+    ca_stream_initialize(stream, devid, is_input);
+    return stream;
+}
+
+/*--- CoreAudio::AudioDevice ---*/
+static VALUE
+ca_get_device_name(AudioDeviceID devID)
+{
+    AudioObjectPropertyAddress address = PropertyAddress;
+    UInt32 size;
+    OSStatus status;
+    CFStringRef deviceName = NULL;
+    VALUE str;
+
+    address.mSelector = kAudioObjectPropertyName;
+    size = sizeof(deviceName);
+
+    status = AudioObjectGetPropertyData(devID, &address, 0, NULL, &size, &deviceName);
+    if ( status != noErr ) {
+      rb_raise(rb_eArgError, "coreaudio: get device name failed: %d", status);
+    }
+    str = rb_str_new2(CFStringGetCStringPtr(deviceName, kCFStringEncodingASCII));
+    CFRelease(deviceName);
+
+    return str;
+}
+
+static VALUE
+ca_get_device_available_sample_rate(AudioDeviceID devID)
+{
+    AudioObjectPropertyAddress address = PropertyAddress;
+    UInt32 size;
+    UInt32 n_rates;
+    AudioValueRange *sample_rates;
+    OSStatus status;
+    VALUE ary;
+    UInt32 i;
+
+    address.mSelector = kAudioDevicePropertyAvailableNominalSampleRates;
+    status = AudioObjectGetPropertyDataSize(devID, &address, 0, NULL, &size);
+
+    if (status != noErr) {
+      rb_raise(rb_eArgError,
+               "coreaudio: get available sample rates size failed: %d", status);
+    }
+
+    n_rates = size / (UInt32)sizeof(AudioValueRange);
+    sample_rates = ALLOCA_N(AudioValueRange, n_rates);
+
+    status = AudioObjectGetPropertyData(devID, &address, 0, NULL, &size, sample_rates);
+    if (status != noErr) {
+      rb_raise(rb_eArgError,
+               "coreaudio: get available sample rates failed: %d", status);
+    }
+
+    ary = rb_ary_new();
+    for ( i = 0; i < n_rates; i++ ) {
+      rb_ary_push(ary,
+                  rb_ary_new3(2,
+                              DBL2NUM((double)sample_rates[i].mMinimum),
+                              DBL2NUM((double)sample_rates[i].mMaximum)));
+    }
+
+    return ary;
+}
+
+static VALUE
+ca_get_device_nominal_sample_rate(AudioDeviceID devID)
+{
+    AudioObjectPropertyAddress address = PropertyAddress;
+    UInt32 size;
+    Float64 rate;
+    OSStatus status;
+
+    address.mSelector = kAudioDevicePropertyNominalSampleRate;
+    status = AudioObjectGetPropertyDataSize(devID, &address, 0, NULL, &size);
+
+    if (status != noErr) {
+      rb_raise(rb_eArgError,
+               "coreaudio: get nominal sample rates size failed: %d", status);
+    }
+
+    status = AudioObjectGetPropertyData(devID, &address, 0, NULL, &size, &rate);
+    if (status != noErr) {
+      rb_raise(rb_eArgError,
+               "coreaudio: get nominal sample rates failed: %d", status);
+    }
+    return DBL2NUM((double)rate);
+}
+
+static VALUE
+ca_get_device_actual_sample_rate(VALUE self)
+{
+    AudioDeviceID devID = NUM2UINT(rb_ivar_get(self, sym_iv_devid));
+    AudioObjectPropertyAddress address = PropertyAddress;
+    UInt32 size;
+    Float64 rate;
+    OSStatus status;
+
+    address.mSelector = kAudioDevicePropertyActualSampleRate;
+    status = AudioObjectGetPropertyDataSize(devID, &address, 0, NULL, &size);
+
+    size = sizeof(rate);
+    status = AudioObjectGetPropertyData(devID, &address, 0, NULL, &size, &rate);
+    if (status != noErr) {
+      rb_raise(rb_eArgError,
+               "coreaudio: get actual sample rates failed: %d", status);
+    }
+    return DBL2NUM((double)rate);
+}
+
+static VALUE
+ca_device_initialize(VALUE self, VALUE devIdVal)
+{
+    AudioDeviceID devID = (AudioDeviceID)NUM2LONG(devIdVal);
+    VALUE device_name;
+    VALUE available_sample_rate;
+    VALUE nominal_rate;
+    VALUE input_stream, output_stream;
+
+    device_name = ca_get_device_name(devID);
+    available_sample_rate = ca_get_device_available_sample_rate(devID);
+    rb_obj_freeze(available_sample_rate);
+    nominal_rate = ca_get_device_nominal_sample_rate(devID);
+    input_stream = ca_stream_new(devIdVal, Qtrue);
+    output_stream = ca_stream_new(devIdVal, Qfalse);
+
+    rb_ivar_set(self, sym_iv_devid, devIdVal);
+    rb_ivar_set(self, sym_iv_name, device_name);
+    rb_ivar_set(self, sym_iv_available_sample_rate, available_sample_rate);
+    rb_ivar_set(self, sym_iv_nominal_rate, nominal_rate);
+    rb_ivar_set(self, sym_iv_input_stream, input_stream);
+    rb_ivar_set(self, sym_iv_output_stream, output_stream);
+
+    return self;
+}
+
+static VALUE
+ca_device_new(AudioDeviceID devid)
+{
+    VALUE devIdVal = UINT2NUM(devid);
+    VALUE device;
+
+    device = rb_obj_alloc(rb_cAudioDevice);
+    ca_device_initialize(device, devIdVal);
+
+    return device;
+}
+
+/*
+ * Document-method: CoreAudio.devices
+ * call-seq:
+ *   CoreAudio.devices
+ *
+ * Get available all audio devices (CoreAudio::AudioDevice object).
+ */
+static VALUE
+ca_devices(VALUE mod)
+{
+    AudioObjectPropertyAddress address = PropertyAddress;
+    AudioDeviceID *devIDs = NULL;
+    UInt32 size = 0, devnum = 0;
+    OSStatus status = noErr;
+    VALUE ary;
+    UInt32 i;
+
+    address.mSelector = kAudioHardwarePropertyDevices;
+
+    status = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject,
+                                            &address, 0, NULL, &size);
+    if (status != noErr)
+      rb_raise(rb_eRuntimeError, "coreaudio: get devices size failed: %d", status);
+
+    devnum = size / (UInt32)sizeof(AudioDeviceID);
+    devIDs = ALLOCA_N(AudioDeviceID, devnum);
+
+    status = AudioObjectGetPropertyData(kAudioObjectSystemObject,
+                                        &address, 0, NULL, &size, devIDs);
+    if (status != noErr)
+      rb_raise(rb_eRuntimeError, "coreaudio: get devices failed: %d", status);
+
+    ary = rb_ary_new();
+    for (i = 0; i < devnum; i++) {
+      rb_ary_push(ary, ca_device_new(devIDs[i]));
+    }
+    return ary;
+}
+
+/*
+ * Document-method: CoreAudio.default_input_device
+ * call-seq:
+ *   CoreAudio.default_input_device
+ *
+ * Get system default audio input device as CoreAudio::AudioDevice object.
+ */
+static VALUE
+ca_default_input_device(VALUE mod)
+{
+    AudioDeviceID devID;
+    AudioObjectPropertyAddress address = PropertyAddress;
+    UInt32 size;
+    OSStatus status;
+
+    address.mSelector = kAudioHardwarePropertyDefaultInputDevice;
+    size = sizeof(devID);
+
+    status = AudioObjectGetPropertyData(kAudioObjectSystemObject,
+                                        &address, 0, NULL, &size, &devID);
+
+    if (status != noErr)
+      rb_raise(rb_eArgError, "coreaudio: get default input device failed: %d", status);
+
+    return ca_device_new(devID);
+}
+
+
+/*
+ * Document-method: CoreAudio.default_output_device
+ * call-seq:
+ *   CoreAudio.default_output_device
+ *
+ * Get system default audio output device as CoreAudio::AudioDevice object.
+ */
+static VALUE
+ca_default_output_device(VALUE mod)
+{
+    AudioDeviceID devID;
+    AudioObjectPropertyAddress address = PropertyAddress;
+    UInt32 size;
+    OSStatus status;
+
+    address.mSelector = kAudioHardwarePropertyDefaultOutputDevice;
+    size = sizeof(devID);
+
+    status = AudioObjectGetPropertyData(kAudioObjectSystemObject,
+                                        &address, 0, NULL, &size, &devID);
+
+    if (status != noErr)
+      rb_raise(rb_eArgError, "coreaudio: get default output device failed: %d", status);
+
+    return ca_device_new(devID);
+}
+
+/*
+ * Document-class: CoreAudio::OutLoop
+ *
+ * CoreAudio::OutLoop is an class for loop waveform to output audio stream.
+ */
+typedef struct {
+  AudioDeviceID       devID;
+  AudioDeviceIOProcID procID;
+  UInt32              frame;
+  UInt32              channel;
+  short               *buf;
+} ca_out_loop_data;
+
+static void
+ca_out_loop_data_free(void *ptr)
+{
+    if (ptr) {
+      ca_out_loop_data *data = ptr;
+      if (data->procID)
+        AudioDeviceDestroyIOProcID(data->devID, data->procID);
+      if (data->buf)
+        free(data->buf);
+      free(ptr);
+    }
+}
+
+static size_t
+ca_out_loop_data_memsize(const void *ptr)
+{
+    const ca_out_loop_data *data = ptr;
+    return sizeof(ca_out_loop_data) + data->channel * data->frame * sizeof(short);
+}
+
+static const rb_data_type_t ca_out_loop_data_type = {
+  "ca_out_loop_data",
+  {NULL, ca_out_loop_data_free, ca_out_loop_data_memsize},
+};
+
+static OSStatus
+ca_out_loop_proc(
+        AudioDeviceID           inDevice,
+        const AudioTimeStamp*   inNow,
+        const AudioBufferList*  inInputData,
+        const AudioTimeStamp*   inInputTime,
+        AudioBufferList*        outOutputData,
+        const AudioTimeStamp*   inOutputTime,
+        void*                   inClientData)
+{
+    NSUInteger i;
+    UInt32 buffers = outOutputData->mNumberBuffers;
+    ca_out_loop_data *loop_data = inClientData;
+    UInt32 channel = loop_data->channel;
+
+    for (i = 0; i < buffers; i++) {
+      float *ptr = outOutputData->mBuffers[i].mData;
+      UInt32 size = outOutputData->mBuffers[i].mDataByteSize / (UInt32)sizeof(float) / channel;
+      UInt32 offset = (UInt32)inOutputTime->mSampleTime % loop_data->frame;
+      UInt32 copied = 0;
+
+      if (outOutputData->mBuffers[i].mNumberChannels != channel) {
+        memset(ptr, 0, size * channel * sizeof(float));
+        continue;
+      }
+
+      while ( copied < size ) {
+        UInt32 len = loop_data->frame - offset;
+        UInt32 j;
+        if ( len > size - copied )
+          len = size - copied;
+        for (j = 0; j < len*channel; j++) {
+          ptr[copied*channel+j] = SHORT2FLOAT(loop_data->buf[offset*channel+j]);
+        }
+        offset = (offset + len) % loop_data->frame;
+        copied += len;
+      }
+    }
+
+    return 0;
+}
+
+static VALUE
+ca_out_loop_data_alloc(VALUE klass)
+{
+    VALUE obj;
+    ca_out_loop_data *ptr;
+
+    obj = TypedData_Make_Struct(klass, ca_out_loop_data, &ca_out_loop_data_type, ptr);
+    return obj;
+}
+
+static VALUE
+ca_out_loop_data_initialize(VALUE self, VALUE devID, VALUE frame, VALUE channel)
+{
+    ca_out_loop_data *data;
+    OSStatus status;
+
+    TypedData_Get_Struct(self, ca_out_loop_data, &ca_out_loop_data_type, data);
+    data->devID = NUM2UINT(devID);
+    status = AudioDeviceCreateIOProcID(data->devID, ca_out_loop_proc, data, &data->procID);
+    if ( status != noErr )
+    {
+      rb_raise(rb_eRuntimeError, "coreaudio: create proc ID fail: %d", status);
+    }
+    data->frame = NUM2UINT(frame);
+    data->channel = NUM2UINT(channel);
+    data->buf = malloc(sizeof(short)*data->frame*data->channel);
+    if (data->buf == NULL)
+      rb_raise(rb_eNoMemError, "coreaudio: fail to alloc out loop data buffer");
+    return self;
+}
+
+/*
+ * Document-method: CoreAudio::AudioDevice#out_loop
+ * call-seq:
+ *   device.out_loop(frame)
+ *
+ * Create output audio loop buffer.
+ *
+ * == Parameters
+ * * +frame+ is an integer value indicate loop buffer size in number of
+ *   sample/frame. The number of channel is considered automatically.
+ */
+static VALUE
+ca_device_create_out_loop_proc(VALUE self, VALUE frame)
+{
+    VALUE proc;
+    VALUE out_stream = rb_ivar_get(self, sym_iv_output_stream);
+
+    proc = ca_out_loop_data_alloc(rb_cOutLoop);
+    ca_out_loop_data_initialize(proc, rb_ivar_get(self, sym_iv_devid), frame,
+                                rb_ivar_get(out_stream, sym_iv_channels));
+    return proc;
+}
+
+/*
+ * call-seq:
+ *   outloop.start
+ *
+ * Start play of output audio loop.
+ */
+static VALUE
+ca_out_loop_data_start(VALUE self)
+{
+    ca_out_loop_data *data;
+    OSStatus status;
+
+    TypedData_Get_Struct(self, ca_out_loop_data, &ca_out_loop_data_type, data);
+
+    status = AudioDeviceStart(data->devID, data->procID);
+    if ( status != noErr )
+    {
+      rb_raise(rb_eRuntimeError, "coreaudio: audio device start fail: %d", status);
+    }
+    return self;
+}
+
+/*
+ * call-seq:
+ *   outloop.stop
+ *
+ * Stop play of output audio loop.
+ */
+static VALUE
+ca_out_loop_data_stop(VALUE self)
+{
+    ca_out_loop_data *data;
+    OSStatus status;
+
+    TypedData_Get_Struct(self, ca_out_loop_data, &ca_out_loop_data_type, data);
+
+    status = AudioDeviceStop(data->devID, data->procID);
+    if ( status != noErr )
+    {
+      rb_raise(rb_eRuntimeError, "coreaudio: audio device stop fail: %d", status);
+    }
+    return self;
+}
+
+/*
+ * call-seq:
+ *   outloop[frame] = sample
+ *   outloop[frame] = [sample1, sample2]
+ *
+ * Assign audio loop buffer frame value.
+ * If assigned value is an Fixnum (-32767..32767, signed 16bit),
+ * the value is stored to all channel.
+ * The +sample+ should be normalize to -32767 <= sample <= 32767 range.
+ * If assigned value is an Array of Fixnum, each value is stored to each
+ * correponding channel. If size of array is not equal to the AudioDevice's
+ * output stream channel number, raise ArgumentError.
+ */
+static VALUE
+ca_out_loop_data_assign(VALUE self, VALUE index, VALUE val)
+{
+    ca_out_loop_data *data;
+    size_t idx;
+    UInt32 i;
+
+    TypedData_Get_Struct(self, ca_out_loop_data, &ca_out_loop_data_type, data);
+
+    idx = NUM2UINT(index) % data->frame;
+    if (TYPE(val) == T_ARRAY) {
+      if (RARRAY_LEN(val) != data->channel) {
+        rb_raise(rb_eArgError, "size of array and channel size mismatch");
+      }
+      for (i = 0; i < data->channel; i++) {
+        data->buf[idx*data->channel+i] = (short)NUM2INT(RARRAY_PTR(val)[i]);
+      }
+    } else {
+      for (i = 0; i < data->channel; i++) {
+        data->buf[idx*data->channel+i] = (short)NUM2INT(val);
+      }
+    }
+    return val;
+}
+
+typedef struct {
+  AudioDeviceID       devID;
+  AudioDeviceIOProcID procID;
+  UInt32              frame;
+  UInt32              channel;
+  short               *buf;
+  UInt32              start;
+  UInt32              end;
+  long                dropped_frame;
+  pthread_mutex_t     mutex;
+  pthread_cond_t      cond;
+} ca_buffer_data;
+
+static void
+ca_buffer_data_free(void *ptr)
+{
+    if (ptr) {
+      ca_buffer_data *data = ptr;
+      if (data->procID)
+        AudioDeviceDestroyIOProcID(data->devID, data->procID);
+      pthread_cond_destroy(&data->cond);
+      pthread_mutex_destroy(&data->mutex);
+      if (data->buf)
+        free(data->buf);
+      free(ptr);
+    }
+}
+
+static size_t
+ca_buffer_data_memsize(const void *ptr)
+{
+    const ca_buffer_data *data = ptr;
+    return sizeof(ca_buffer_data) + data->channel * data->frame * sizeof(short);
+}
+
+static const rb_data_type_t ca_buffer_data_type = {
+  "ca_buffer_data",
+  {NULL, ca_buffer_data_free, ca_buffer_data_memsize},
+};
+
+static VALUE
+ca_buffer_data_alloc(VALUE klass)
+{
+    VALUE obj;
+    ca_buffer_data *ptr;
+
+    obj = TypedData_Make_Struct(klass, ca_buffer_data, &ca_buffer_data_type, ptr);
+    pthread_mutex_init(&ptr->mutex, NULL);
+    pthread_cond_init(&ptr->cond, NULL);
+    return obj;
+}
+
+static VALUE
+ca_buffer_data_start(VALUE self)
+{
+    ca_buffer_data *data;
+    OSStatus status;
+
+    TypedData_Get_Struct(self, ca_buffer_data, &ca_buffer_data_type, data);
+
+    data->dropped_frame = 0;
+    status = AudioDeviceStart(data->devID, data->procID);
+    if ( status != noErr )
+    {
+      rb_raise(rb_eRuntimeError, "coreaudio: audio device start fail: %d", status);
+    }
+    return self;
+}
+
+static VALUE
+ca_buffer_data_stop(VALUE self)
+{
+    ca_buffer_data *data;
+    OSStatus status;
+
+    TypedData_Get_Struct(self, ca_buffer_data, &ca_buffer_data_type, data);
+
+    status = AudioDeviceStop(data->devID, data->procID);
+    if ( status != noErr )
+    {
+      rb_raise(rb_eRuntimeError, "coreaudio: audio device stop fail: %d", status);
+    }
+    return self;
+}
+
+static VALUE
+ca_buffer_wait(void *ptr)
+{
+    ca_buffer_data *data = ptr;
+    int ret;
+
+    ret = pthread_cond_wait(&data->cond, &data->mutex);
+
+    return (VALUE)ret;
+}
+
+#if 0
+/* use pthread_mutex_lock in unblocking function cause deadlock.
+ * because calling thread have GVL lock and interrupted thread could
+ * be waiting mutex lock for GVL.
+ * So use RUBY_UBF_IO for unblocking function.
+ * Although pthread_cond_wait() shouldn't return EINTR acoording to POSIX,
+ * on Mac OS X pthread_cond_wait() actually returns when received signals. */
+static void
+ca_buffer_unblocking_func(void *ptr)
+{
+    ca_buffer_data *data = ptr;
+
+    pthread_mutex_lock(&data->mutex);
+    pthread_cond_broadcast(&data->cond);
+    pthread_mutex_unlock(&data->mutex);
+}
+#endif
+
+static VALUE
+ca_buffer_wait_blocking(VALUE value)
+{
+    void *ptr = (void *)value;
+#if 0
+    return rb_thread_blocking_region(ca_buffer_wait, ptr,
+                                     ca_buffer_unblocking_func, ptr);
+#endif
+    return rb_thread_blocking_region(ca_buffer_wait, ptr,
+                                     RUBY_UBF_IO, NULL);
+}
+
+static VALUE
+ca_buffer_dropped_frame(VALUE self)
+{
+    ca_buffer_data *data;
+    long dropped;
+
+    TypedData_Get_Struct(self, ca_buffer_data, &ca_buffer_data_type, data);
+
+    pthread_mutex_lock(&data->mutex);
+    dropped = data->dropped_frame;
+    pthread_mutex_unlock(&data->mutex);
+    return LONG2NUM(dropped);
+}
+
+static VALUE
+ca_buffer_reset_dropped_frame(VALUE self)
+{
+    ca_buffer_data *data;
+    long dropped;
+
+    TypedData_Get_Struct(self, ca_buffer_data, &ca_buffer_data_type, data);
+
+    pthread_mutex_lock(&data->mutex);
+    dropped = data->dropped_frame;
+    data->dropped_frame = 0;
+    pthread_mutex_unlock(&data->mutex);
+    return LONG2NUM(dropped);
+}
+
+/*
+ * Document-class: CoreAudio::OutputBuffer
+ *
+ * CoreAudio::OutputBuffer is a class for stream waveform to output audio stream.
+ */
+static OSStatus
+ca_out_buffer_proc(
+        AudioDeviceID           inDevice,
+        const AudioTimeStamp*   inNow,
+        const AudioBufferList*  inInputData,
+        const AudioTimeStamp*   inInputTime,
+        AudioBufferList*        outOutputData,
+        const AudioTimeStamp*   inOutputTime,
+        void*                   inClientData)
+{
+    NSUInteger n_buf;
+    UInt32 buffers = outOutputData->mNumberBuffers;
+    ca_buffer_data *buffer_data = inClientData;
+    UInt32 channel = buffer_data->channel;
+
+    for (n_buf = 0; n_buf < buffers; n_buf++) {
+      float *ptr = outOutputData->mBuffers[n_buf].mData;
+      UInt32 size = outOutputData->mBuffers[n_buf].mDataByteSize / (UInt32)sizeof(float) / channel;
+      UInt32 copied = 0;
+      UInt32 i;
+
+      if (outOutputData->mBuffers[n_buf].mNumberChannels != channel) {
+        memset(ptr, 0, size * channel * sizeof(float));
+        continue;
+      }
+
+      pthread_mutex_lock(&buffer_data->mutex);
+      for ( copied = 0, i = buffer_data->start; copied < size && i != buffer_data->end; copied++, i = (i+1) % buffer_data->frame ) {
+        UInt32 ch;
+        for (ch = 0; ch < channel; ch++) {
+          ptr[copied*channel+ch] = SHORT2FLOAT(buffer_data->buf[i*channel+ch]);
+        }
+      }
+      buffer_data->start = i;
+      pthread_cond_broadcast(&buffer_data->cond);
+      pthread_mutex_unlock(&buffer_data->mutex);
+      if ( copied < size ) {
+        memset(ptr+(copied*channel), 0, sizeof(float)*channel*(size-copied));
+        buffer_data->dropped_frame += size - copied;
+      }
+    }
+
+    return 0;
+}
+
+static VALUE
+ca_out_buffer_data_initialize(VALUE self, VALUE devID, VALUE frame, VALUE channel)
+{
+    ca_buffer_data *data;
+    OSStatus status;
+
+    TypedData_Get_Struct(self, ca_buffer_data, &ca_buffer_data_type, data);
+    data->devID = NUM2UINT(devID);
+    status = AudioDeviceCreateIOProcID(data->devID, ca_out_buffer_proc, data, &data->procID);
+    if ( status != noErr )
+    {
+      rb_raise(rb_eRuntimeError, "coreaudio: create proc ID fail: %d", status);
+    }
+    data->frame = NUM2UINT(frame);
+    data->channel = NUM2UINT(channel);
+    data->buf = malloc(sizeof(short)*data->frame*data->channel);
+    if (data->buf == NULL)
+      rb_raise(rb_eNoMemError, "coreaudio: fail to alloc out buffer data buffer");
+    return self;
+}
+
+static VALUE
+ca_device_create_out_buffer_proc(VALUE self, VALUE frame)
+{
+    VALUE proc;
+    VALUE out_stream = rb_ivar_get(self, sym_iv_output_stream);
+
+    proc = ca_buffer_data_alloc(rb_cOutputBuffer);
+    ca_out_buffer_data_initialize(proc, rb_ivar_get(self, sym_iv_devid), frame,
+                                  rb_ivar_get(out_stream, sym_iv_channels));
+    return proc;
+}
+
+static VALUE
+ca_out_buffer_data_append(VALUE self, VALUE ary)
+{
+    ca_buffer_data *data;
+    UInt32 idx;
+    VALUE val;
+    long i;
+    UInt32 j;
+
+    TypedData_Get_Struct(self, ca_buffer_data, &ca_buffer_data_type, data);
+
+    pthread_mutex_lock(&data->mutex);
+    idx = data->end;
+    for ( i = 0; i < RARRAY_LEN(ary); i++, idx = (idx+1)%data->frame) {
+      while ( (idx+1) % data->frame == data->start ) {
+        int ret, state;
+        data->end = idx;
+        ret = (int)rb_protect(ca_buffer_wait_blocking, (VALUE)data, &state);
+        if (state) {
+          pthread_mutex_unlock(&data->mutex);
+          rb_jump_tag(state);
+        }
+        switch(ret) {
+          case 0:
+          case EINTR:
+          case EAGAIN:
+            break;
+          default:
+            pthread_mutex_unlock(&data->mutex);
+            rb_sys_fail("pthread_cond_wait");
+            break;
+        }
+      }
+      val = RARRAY_PTR(ary)[i];
+
+      if (TYPE(val) == T_ARRAY) {
+        if (RARRAY_LEN(val) != data->channel) {
+          pthread_mutex_unlock(&data->mutex);
+          rb_raise(rb_eArgError, "size of array and channel size mismatch");
+        }
+        for (j = 0; j < data->channel; j++) {
+          data->buf[idx*data->channel+j] = (short)NUM2INT(RARRAY_PTR(val)[j]);
+        }
+      } else {
+        for (j = 0; j < data->channel; j++) {
+          data->buf[idx*data->channel+j] = (short)NUM2INT(val);
+        }
+      }
+      data->end = idx;
+    }
+    pthread_mutex_unlock(&data->mutex);
+    return self;
+}
+
+/*
+ * Document-class: CoreAudio::InputBuffer
+ *
+ * CoreAudio::InputBuffer is a class for stream waveform to input audio stream.
+ */
+static OSStatus
+ca_in_buffer_proc(
+        AudioDeviceID           inDevice,
+        const AudioTimeStamp*   inNow,
+        const AudioBufferList*  inInputData,
+        const AudioTimeStamp*   inInputTime,
+        AudioBufferList*        outOutputData,
+        const AudioTimeStamp*   inOutputTime,
+        void*                   inClientData)
+{
+    NSUInteger n_buf;
+    UInt32 buffers = inInputData->mNumberBuffers;
+    ca_buffer_data *buffer_data = inClientData;
+    UInt32 channel = buffer_data->channel;
+
+    for (n_buf = 0; n_buf < buffers; n_buf++) {
+      float *ptr = inInputData->mBuffers[n_buf].mData;
+      UInt32 size = inInputData->mBuffers[n_buf].mDataByteSize / (UInt32)sizeof(float) / channel;
+      UInt32 copied, idx;
+
+      if (inInputData->mBuffers[n_buf].mNumberChannels != channel) {
+        continue;
+      }
+
+      pthread_mutex_lock(&buffer_data->mutex);
+
+      copied = 0;
+      for (idx = buffer_data->end;
+           copied < size && (idx+1) % buffer_data->frame != buffer_data->start;
+           copied++, idx = (idx+1) % buffer_data->frame) {
+        UInt32 ch;
+        for (ch = 0; ch < channel; ch++) {
+          buffer_data->buf[idx*channel+ch] = FLOAT2SHORT(ptr[copied*channel+ch]);
+        }
+      }
+      buffer_data->end = idx;
+      buffer_data->dropped_frame += size - copied;
+
+      pthread_cond_broadcast(&buffer_data->cond);
+      pthread_mutex_unlock(&buffer_data->mutex);
+    }
+
+    return 0;
+}
+
+static VALUE
+ca_in_buffer_data_initialize(VALUE self, VALUE devID, VALUE frame, VALUE channel)
+{
+    ca_buffer_data *data;
+    OSStatus status;
+
+    TypedData_Get_Struct(self, ca_buffer_data, &ca_buffer_data_type, data);
+    data->devID = NUM2UINT(devID);
+    status = AudioDeviceCreateIOProcID(data->devID, ca_in_buffer_proc, data, &data->procID);
+    if ( status != noErr )
+    {
+      rb_raise(rb_eRuntimeError, "coreaudio: create proc ID fail: %d", status);
+    }
+    data->frame = NUM2UINT(frame);
+    data->channel = NUM2UINT(channel);
+    data->buf = malloc(sizeof(short)*data->frame*data->channel);
+    if (data->buf == NULL)
+      rb_raise(rb_eNoMemError, "coreaudio: fail to alloc input buffer data buffer");
+    return self;
+}
+
+static VALUE
+ca_device_create_in_buffer_proc(VALUE self, VALUE frame)
+{
+    VALUE proc;
+    VALUE in_stream = rb_ivar_get(self, sym_iv_input_stream);
+
+    proc = ca_buffer_data_alloc(rb_cInputBuffer);
+    ca_in_buffer_data_initialize(proc, rb_ivar_get(self, sym_iv_devid), frame,
+                                 rb_ivar_get(in_stream, sym_iv_channels));
+    return proc;
+}
+
+static VALUE
+ca_in_buffer_data_read(VALUE self, VALUE num)
+{
+    ca_buffer_data *data;
+    UInt32 frame = NUM2UINT(num);
+    VALUE val;
+    UInt32 i;
+    UInt32 j;
+
+    TypedData_Get_Struct(self, ca_buffer_data, &ca_buffer_data_type, data);
+
+    val = rb_ary_new2(frame * data->channel);
+
+    pthread_mutex_lock(&data->mutex);
+    for ( i = 0; i < frame; i++, data->start = (data->start+1)%data->frame) {
+      while (data->start == data->end) {
+        int ret, state;
+        ret = (int)rb_protect(ca_buffer_wait_blocking, (VALUE)data, &state);
+        if (state) {
+          pthread_mutex_unlock(&data->mutex);
+          rb_jump_tag(state);
+        }
+        switch(ret) {
+          case 0:
+          case EINTR:
+          case EAGAIN:
+            break;
+          default:
+            pthread_mutex_unlock(&data->mutex);
+            rb_sys_fail("pthread_cond_wait");
+            break;
+        }
+      }
+      for ( j = 0; j < data->channel; j++ ) {
+        rb_ary_push(val, INT2NUM((double)data->buf[data->start*data->channel+j]));
+      }
+    }
+    pthread_mutex_unlock(&data->mutex);
+    return val;
+}
+
+void
+Init_coreaudio_ext(void)
+{
+    sym_iv_devid = rb_intern("@devid");
+    sym_iv_name = rb_intern("@name");
+    sym_iv_available_sample_rate = rb_intern("@available_sample_rate");
+    sym_iv_nominal_rate = rb_intern("@nominal_rate");
+    sym_iv_input_stream = rb_intern("@input_stream");
+    sym_iv_output_stream = rb_intern("@output_stream");
+    sym_iv_channels = rb_intern("@channels");
+    sym_iv_buffer_frame_size = rb_intern("@buffer_frame_size");
+
+    rb_mCoreAudio = rb_define_module("CoreAudio");
+    rb_cAudioDevice = rb_define_class_under(rb_mCoreAudio, "AudioDevice", rb_cObject);
+    rb_cAudioStream = rb_define_class_under(rb_mCoreAudio, "AudioStream", rb_cObject);
+    rb_cOutLoop = rb_define_class_under(rb_mCoreAudio, "OutLoop", rb_cObject);
+    rb_cAudioBuffer = rb_define_class_under(rb_mCoreAudio, "AudioBuffer", rb_cObject);
+    rb_cOutputBuffer = rb_define_class_under(rb_mCoreAudio, "OutputBuffer", rb_cAudioBuffer);
+    rb_cInputBuffer = rb_define_class_under(rb_mCoreAudio, "InputBuffer", rb_cAudioBuffer);
+
+    rb_define_method(rb_cAudioDevice, "initialize", ca_device_initialize, 1);
+    rb_define_method(rb_cAudioDevice, "actual_rate", ca_get_device_actual_sample_rate, 0);
+    rb_define_method(rb_cAudioDevice, "output_loop", ca_device_create_out_loop_proc, 1);
+    rb_define_method(rb_cAudioDevice, "output_buffer", ca_device_create_out_buffer_proc, 1);
+    rb_define_method(rb_cAudioDevice, "input_buffer", ca_device_create_in_buffer_proc, 1);
+    rb_define_attr(rb_cAudioDevice, "devid", 1, 0);
+    rb_define_attr(rb_cAudioDevice, "name", 1, 0);
+    rb_define_attr(rb_cAudioDevice, "available_sample_rate", 1, 0);
+    rb_define_attr(rb_cAudioDevice, "nominal_rate", 1, 0);
+    rb_define_attr(rb_cAudioDevice, "input_stream", 1, 0);
+    rb_define_attr(rb_cAudioDevice, "output_stream", 1, 0);
+
+    rb_define_method(rb_cAudioStream, "initialize", ca_stream_initialize, 2);
+    rb_define_attr(rb_cAudioStream, "channels", 1, 0);
+    rb_define_attr(rb_cAudioStream, "buffer_frame_size", 1, 0);
+
+    rb_define_singleton_method(rb_mCoreAudio, "devices", ca_devices, 0);
+    rb_define_singleton_method(rb_mCoreAudio, "default_input_device", ca_default_input_device, 0);
+    rb_define_singleton_method(rb_mCoreAudio, "default_output_device", ca_default_output_device, 0);
+
+    rb_define_method(rb_cOutLoop, "[]=", ca_out_loop_data_assign, 2);
+    rb_define_method(rb_cOutLoop, "start", ca_out_loop_data_start, 0);
+    rb_define_method(rb_cOutLoop, "stop", ca_out_loop_data_stop, 0);
+
+    rb_define_method(rb_cAudioBuffer, "start", ca_buffer_data_start, 0);
+    rb_define_method(rb_cAudioBuffer, "stop", ca_buffer_data_stop, 0);
+    rb_define_method(rb_cAudioBuffer, "dropped_frame", ca_buffer_dropped_frame, 0);
+    rb_define_method(rb_cAudioBuffer, "reset_dropped_frame", ca_buffer_reset_dropped_frame, 0);
+
+    rb_define_method(rb_cOutputBuffer, "<<", ca_out_buffer_data_append, 1);
+
+    rb_define_method(rb_cInputBuffer, "read", ca_in_buffer_data_read, 1);
+
+    Init_coreaudio_audiofile();
+}