ao 0.0.4 → 0.1.0

data/ext/audio/live.c

@@ -0,0 +1,114 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include "cao.h"
+#include "thread.h"
+
+ao_device *
+rao_open_live_dev(int driver_id,
+		  ao_sample_format *format,
+		  ao_option *option){
+  ao_device *dev;
+
+  dev = ao_open_live(driver_id, format, option);
+  if (dev == NULL){
+    free_format(format);
+    ao_free_options(option);
+    switch(errno){
+    case AO_ENODRIVER:
+      rb_raise(cAO_eNoDriver,
+	       "No driver corresponds - %s",
+	       strerror(errno));
+      break;
+    case AO_ENOTLIVE:
+      rb_raise(cAO_eNotLive,
+	       "This driver is not a live output device - %s",
+	       strerror(errno));
+      break;
+    case AO_EBADOPTION:
+      rb_raise(cAO_eBadOption,
+	       "A valid option key has an invalid value - %s",
+	       strerror(errno));
+      break;
+    case AO_EOPENDEVICE:
+      rb_raise(cAO_eDeviceError,
+	       "Cannot open the device - %s",
+	       strerror(errno));
+      break;
+    case AO_EFAIL:
+      rb_raise(cAO_eUnknownError,
+	       "Any other cause of failure - %s",
+	       strerror(errno));
+      break;
+    default:
+      rb_raise(cAO_eUnknownError,
+	       "Unknown error - %s",
+	       strerror(errno));
+    }
+  }
+  return dev;
+}
+
+/*
+ * call-seq: Audio::LiveOutput.new(driver_id, bits, rate, channels, byte_format, matrix, options)
+ *
+ * オーディオ出力デバイスを開く。
+ * 引数に指定するmatrixとoptionについては以下を参照。
+ * [matrix] http://xiph.org/ao/doc/ao_sample_format.html
+ * [option] http://xiph.org/ao/doc/drivers.html
+ * optionはKey-Valueを要素に含む2次元配列を設定する。
+ * 特に設定が必要なければnilで構わない。
+ * ex) ALSAドライバのデバイスをhw:1に設定する場合は [["dev", "hw:1"]] を渡す。
+ *
+ * [arg1] DriverID
+ * [arg2] bits(Fixnum)
+ * [arg3] rate(Fixnum)
+ * [arg4] channels(fixnum)
+ * [arg5] byte_format(fixnum)
+ * [arg6] matrix(String or nil)
+ * [arg7] options(Array or nil)
+ * [arg8] thread(true or false)
+ * [return] self
+ */
+VALUE
+rao_open_live(VALUE obj,      VALUE driver_id,
+	      VALUE bits, VALUE rate, VALUE channels,
+	      VALUE byte_format, VALUE matrix,
+	      VALUE a_options, VALUE thread)
+{
+  ao_struct        *aos;
+  ao_device        *dev;
+  ao_sample_format *format;
+  ao_option        *option;
+  VALUE             rdev;
+
+  if (rb_iv_get(obj, "@device") != Qnil){
+    Data_Get_Struct(rb_iv_get(obj, "@device"),
+		    ao_struct, aos);
+    rb_raise(cAO_eDeviceError,
+	     "Device is already open.\n");
+  }
+  Check_Type(driver_id,   T_FIXNUM);
+  format = set_format(bits, rate, channels, byte_format, matrix);
+  option = set_option(a_options);
+
+  dev = rao_open_live_dev(FIX2INT(driver_id), format, option);
+  if ((aos = init_aos(dev, format, option)) == NULL){
+    rb_raise(cAO_eUnknownError,
+	     "memory allocation failure - %s",
+	     strerror(errno));
+  }
+  if (TYPE(thread) == T_TRUE){
+    if ((aos = create_thread(aos)) == NULL){
+      rb_raise(cAO_eUnknownError,
+	       "memory allocation failure - %s",
+	       strerror(errno));
+    }
+  }
+  rdev = Data_Wrap_Struct(cAO_DeviceData, 0,
+			  remove_device, aos);
+  rb_iv_set(obj, "@device", rdev);  
+  rb_ary_push(rb_cv_get(cAO_Live, "@@devices"), rdev);
+  return obj;
+}

data/ext/audio/mixer.c

@@ -0,0 +1,128 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <errno.h>
+#include "cao.h"
+
+int
+mix_sample_8(sample_t **samples,  sample_t *ret, int chs){
+  int32_t sum;
+  int ch;
+  int pos;
+  int8_t *buffer;
+  int8_t *src;
+
+  buffer = (int8_t *)ret->buffer;
+  for (pos=0; pos<ret->bytes; pos++){
+    sum = 0;
+    for (ch=0; ch<chs; ch++){
+      if (pos < samples[ch]->bytes){
+	src = (int8_t *)samples[ch]->buffer;
+	sum += src[pos];
+      }
+    }
+    buffer[pos] = (int8_t)(sum / chs);
+  }
+  return 1;
+}
+
+int
+mix_sample_16(sample_t **samples, sample_t *ret, int chs){
+  int32_t sum;
+  int ch;
+  int pos;
+  int16_t *buffer;
+  int16_t *src;
+
+  buffer = (int16_t *)ret->buffer;
+  for (pos=0; pos< ret->bytes / 2; pos++){
+    sum = 0;
+    for (ch=0; ch<chs; ch++){
+      if (pos < samples[ch]->bytes / 2){
+	src = (int16_t *)samples[ch]->buffer;
+	sum += src[pos];
+      }
+    }
+    buffer[pos] = (int16_t)(sum / chs);
+  }
+
+  return 1;
+}
+
+int
+mix_sample(int bits, sample_t **samples,
+	   sample_t *ret, int chs){
+  if (bits == 8){
+    return mix_sample_8(samples, ret, chs);
+  } else if(bits == 16){
+    return mix_sample_16(samples, ret, chs);
+  } else {
+    return -1;
+  }
+}
+
+/*
+ * call-seq: Audio::Mixer.mix(samples)
+ *
+ * 複数のオーディオサンプルをMixする。
+ * samplesには、Mix対象のデータ(String)の配列を入れる。
+ * 8bitまたは16bitのみ対応
+ *
+ * [arg1] bits(8 or 16)
+ * [arg2] samples([sample1, sample2, ...])
+ * [return] Mixed string
+ */
+VALUE
+rao_mix_samples(VALUE obj, VALUE bits, VALUE rsamples){
+  VALUE rsample;
+  sample_t **samples;
+  sample_t ret;
+  int stat;
+  int chs = 0;
+  int maxlen = 0;
+
+  Check_Type(bits, T_FIXNUM);
+  Check_Type(rsamples, T_ARRAY);
+  samples = malloc(sizeof(sample_t *) * 1);
+  while(1){
+    rsample = rb_ary_entry(rsamples, chs);
+    if (TYPE(rsample) == T_NIL){
+      break;
+    }
+    Check_Type(rsample, T_STRING);
+    samples[chs] = malloc(sizeof(sample_t));
+    samples[chs]->buffer = StringValuePtr(rsample);
+    samples[chs]->bytes  = RSTRING_LEN(rsample);
+    if (samples[chs]->bytes > maxlen){
+      maxlen = samples[chs]->bytes;
+    }
+    chs++;
+    samples = realloc(samples, sizeof(sample_t *) * chs);
+  }
+
+  ret.bytes  = sizeof(char) * maxlen;
+  ret.buffer = malloc(ret.bytes);
+  stat = mix_sample(FIX2INT(bits), samples, &ret, chs);
+  free(samples);
+  if (stat == -1){
+    rb_raise(cAO_eAOError, "Unsupported format.");
+    return Qnil;
+  }
+  rsample = rb_str_new(ret.buffer, ret.bytes);
+  free(ret.buffer);
+  return rsample;
+}
+
+void
+init_mixer(void)
+{
+  /*
+   * Document-class: Audio::Mixer
+   *
+   * オーディオデータをシンプルにミックスするモジュール。
+   */
+  cAO_Mixer = rb_define_module_under(cAudio, "Mixer");
+
+  rb_define_module_function(cAO_Mixer, "mix", rao_mix_samples, 2);
+}

data/ext/{option.c → audio/option.c}

@@ -18,7 +18,7 @@ set_format(VALUE bits, VALUE rate, VALUE channels,
 {
   ao_sample_format *format;
   size_t len;
-  
+
   if ((format = malloc(sizeof(ao_sample_format))) == NULL){
     rb_raise(cAO_eUnknownError, "memory allocation failure.");
   }
@@ -70,7 +70,7 @@ set_option(VALUE a_options)
   ao_option *option = NULL;
   int   pos, result;
   VALUE element, key, value;
-  
+
   switch(TYPE(a_options)){
   case T_ARRAY:
     for (pos=0; pos<RARRAY_LEN(a_options); pos++){

data/ext/audio/output.c

@@ -0,0 +1,113 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include "cao.h"
+
+VALUE cAudio;
+VALUE cAO_Live;
+VALUE cAO_File;
+VALUE cAO_Info;
+VALUE cAO_Mixer;
+VALUE cAO_DeviceData;
+VALUE cAO_eAOError;
+VALUE cAO_eDeviceError;
+VALUE cAO_eUnknownError;
+
+VALUE cAO_eNoDriver;
+VALUE cAO_eNotFile;
+VALUE cAO_eNotLive;
+VALUE cAO_eBadOption;
+VALUE cAO_eDriverError;
+
+VALUE
+rao_close(VALUE obj)
+{
+  ao_struct *aos;
+
+  if (rb_iv_get(obj, "@device") == Qnil){
+    return Qfalse;
+  }
+
+  Data_Get_Struct(rb_iv_get(obj, "@device"),
+		  ao_struct, aos);
+  close_device(aos);
+  rb_ary_delete(rb_cv_get(cAO_Live, "@@devices"), rb_intern("@device"));
+  /*rb_iv_set(obj, "@device", Qnil);*/
+  return Qtrue;
+}
+
+/*
+ * libaoを終了する。shutdownの前に開いている全てのデバイスを
+ * closeしておかなければならない。
+ *
+ * [return] nil
+ */
+void
+rao_shutdown(VALUE obj){
+  VALUE rdev;
+  ao_struct *aos;
+
+  rb_gc_start();
+  while ((rdev = rb_ary_pop(rb_cv_get(cAO_Live, "@@devices"))) != Qnil){
+    Data_Get_Struct(rdev, ao_struct, aos);
+    close_device(aos);
+  }
+  ao_shutdown();
+  return;
+}
+
+void
+Init_outputc(void)
+{
+  ao_initialize();
+  /*
+   * Document-class: Audio
+   *
+   * Ruby-AOの基礎となるクラス。
+   */
+  cAudio = rb_define_class("Audio", rb_cObject);
+
+  /*
+   * Document-class: Audio::LiveOutput
+   *
+   * オーディオデバイス出力機能をサポートするクラス。
+   */
+  cAO_Live = rb_define_class_under(cAudio, "LiveOutputC", rb_cObject);
+  rb_cv_set(cAO_Live, "@@devices", rb_ary_new());
+
+  /*
+   * Document-class: Audio::BasicOutput::DeviceData
+   *
+   * 開いたデバイスに関する基本的な情報を保持するクラス。
+   * ruby側から操作はしない。
+   */
+  cAO_DeviceData = rb_define_class_under(cAO_Live, "DeviceData", rb_cData);
+
+  /* library initialize & shutdown */
+  rb_define_private_method(cAO_Live, "initialize", rao_open_live, 7);
+
+  /* device setup */
+  rb_define_method(cAO_Live, "close",   rao_close,     0);
+  rb_define_method(cAO_Live, "play",    raodev_play,   1);
+  rb_define_method(cAO_Live, "closed?", raodev_closed, 0);
+  rb_define_method(cAO_Live, "playing?", raodev_playing, 0);
+  rb_define_method(cAO_Live, "waiting", raodev_waiting, 0);
+
+  /*
+   * Document-class: Audio::FileOutput
+   *
+   * オーディオファイル出力機能をサポートするクラス。
+   */
+  cAO_File = rb_define_class_under(cAudio, "FileOutputC", cAO_Live);
+  rb_define_private_method(cAO_File, "initialize", rao_open_file, 9);
+
+  init_exception();
+  init_info();
+  init_mixer();
+  init_constant();
+  init_option();
+
+  /* Shutdown */
+  rb_set_end_proc(rao_shutdown, (VALUE)NULL);
+}

data/ext/audio/queue.c

@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <assert.h>
+#include "cao.h"
+
+int
+enqueue(ao_struct *aos, void *value){
+  queue *last;
+
+  assert(pthread_mutex_lock(&aos->mutex) == 0);
+  if (aos->queue == NULL){
+    aos->queue = malloc(sizeof(queue));
+    aos->queue->data = value;
+    aos->queue->next = NULL;
+    aos->qsize++;
+    assert(pthread_cond_signal(&aos->cond) == 0);
+    assert(pthread_mutex_unlock(&aos->mutex) == 0);
+    return aos->qsize;
+  }
+
+  last = aos->queue;
+  while (last->next != NULL){
+    last = last->next;
+  }
+  last->next = malloc(sizeof(queue));
+  last->next->data = value;
+  last->next->next = NULL;
+  aos->qsize++;
+  assert(pthread_cond_signal(&aos->cond) == 0);
+  assert(pthread_mutex_unlock(&aos->mutex) == 0);
+  return aos->qsize;
+}
+
+void *
+dequeue(ao_struct *aos){
+  void *res;
+  queue *trash;
+
+  if (aos->queue == NULL){
+    return NULL;
+  }
+  assert(pthread_mutex_lock(&aos->mutex) == 0);
+  trash = aos->queue;
+  res = aos->queue->data;
+  aos->queue = aos->queue->next;
+  aos->qsize--;
+  free(trash);
+  assert(pthread_mutex_unlock(&aos->mutex) == 0);
+  return res;
+}

data/ext/audio/queue.h

@@ -0,0 +1,6 @@
+#ifndef QUEUE_H
+#define QUEUE_H
+
+int enqueue(ao_struct *aos, void *value);
+void *dequeue(ao_struct *aos);
+#endif

data/ext/audio/thread.c

@@ -0,0 +1,88 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <pthread.h>
+#include <time.h>
+#include <signal.h>
+#include "cao.h"
+#include "queue.h"
+#include "thread.h"
+
+void *
+thread_player(void *val){
+  queue res;
+  ao_struct *aos = val;
+  sample_t *sample;
+  struct timespec tout = {0, 1000000};
+
+  pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+  /*assert(pthread_detach(pthread_self()) == 0);*/
+
+  while (1){
+    assert(pthread_mutex_lock(&aos->mutex) == 0);
+    while (aos->status == 1 && aos->queue == NULL){
+      pthread_cond_timedwait(&aos->cond, &aos->mutex, &tout);
+    }
+    if (aos->status != 1){
+      assert(pthread_mutex_unlock(&aos->mutex) == 0);
+      break;
+    }
+    aos->status = 2;
+    assert(pthread_mutex_unlock(&aos->mutex) == 0);
+
+    while ((sample = dequeue(aos)) != NULL){
+      ao_play(aos->device, sample->buffer,
+	      sample->bytes);
+      free(sample->buffer);
+      free(sample);
+      assert(pthread_mutex_lock(&aos->mutex) == 0);
+      if (aos->status == 1){
+	assert(pthread_mutex_unlock(&aos->mutex) == 0);
+	break;
+      }
+      assert(pthread_mutex_unlock(&aos->mutex) == 0);
+    }
+
+    assert(pthread_mutex_lock(&aos->mutex) == 0);
+    if (aos->status == 2){
+      aos->status = 1;
+      assert(pthread_mutex_unlock(&aos->mutex) == 0);
+      break;
+    }
+    assert(pthread_mutex_unlock(&aos->mutex) == 0);
+  }
+
+  while ((sample = dequeue(aos)) != NULL){
+    free(sample->buffer);
+    free(sample);
+  }
+  if (aos->device != NULL){
+    ao_close(aos->device);
+  }
+  if (aos->option != NULL){
+    ao_free_options(aos->option);
+  }
+  if (aos->format != NULL){
+    free_format(aos->format);
+  }
+  aos->device = NULL;
+  aos->option = NULL;
+  aos->format = NULL;
+  aos->queue  = NULL;
+  assert(pthread_mutex_lock(&aos->mutex) == 0);
+  aos->status = -1;
+  assert(pthread_mutex_unlock(&aos->mutex) == 0);
+  pthread_exit(NULL);
+}
+
+ao_struct *
+create_thread(ao_struct *aos){
+  aos->thread = 1;
+  assert(pthread_mutex_init(&aos->mutex, NULL) == 0);
+  assert(pthread_cond_init(&aos->cond, NULL) == 0);
+  assert(pthread_create(&aos->thread, NULL,
+			thread_player, aos) == 0);
+  return aos;
+}