coreaudio 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+end

data/Gemfile.lock

@@ -0,0 +1,16 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 2011 Tomoyuki Chikanaga. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/README.rdoc

@@ -0,0 +1,32 @@
+= coreaudio
+
+CoreAudio (Audio Framework of Mac OS X) wrapper library for ruby 1.9
+
+== Features
+* HAL (Hardware Abstraction Layer) wrapper
+* Detect audio devices
+* Get/Set device properties (numbers of channels, sample rate, frame size...)
+* Output audio data (Loop buffer, Stream buffer)
+* Input audio data (Stream buffer)
+* Save audio data to WAV/M4A file (wrapper for ExtAudioFile)
+
+== ToDo
+* Switch input/output audio sample type (signed 16bit integer, Float)
+* Read audio file (wrapper for ExtAudioFile)
+* Wrapper for AudioUnit/AudioGraph
+
+== Contributing to coreaudio
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 CHIKANAGA Tomoyuki. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "coreaudio"
+  gem.homepage = "http://github.com/nagachika/coreaudio"
+  gem.license = "BSDL"
+  gem.summary = %Q{Mac OS X CoreAudio wrapper library}
+  gem.description = %Q{Mac OS X CoreAudio wrapper library}
+  gem.email = "nagachika00@gmail.com"
+  gem.authors = ["CHIKANAGA Tomoyuki"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "coreaudio #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include('ext/**/*.m')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/examples/outbuffer_sine.rb

@@ -0,0 +1,22 @@
+require "coreaudio"
+
+dev = CoreAudio.default_output_device
+buf = dev.output_buffer(1024)
+
+phase = Math::PI * 2.0 * 440.0 / dev.nominal_rate
+th = Thread.start do
+  i = 0
+  loop do
+    wav = Array.new(1024){|j| (0.4 * Math.sin(phase*(i+j)) * 0x7FFF).round }
+    i += 1024
+    buf << wav
+  end
+end
+
+buf.start
+sleep 2
+buf.stop
+
+puts "#{buf.dropped_frame} frame dropped."
+
+th.kill

data/examples/outloop_sine.rb

@@ -0,0 +1,14 @@
+require "coreaudio"
+
+dev = CoreAudio.default_output_device
+buf = dev.output_loop(44000)
+
+phase = Math::PI * 2.0 * 440.0 / 44000.0
+44000.times do |i|
+  buf[i] = ((0.4 * Math.sin(phase*i)) * 0x7FFF).round
+end
+
+buf.start
+sleep 2
+buf.stop
+

data/examples/record_to_wave.rb

@@ -0,0 +1,31 @@
+
+require "coreaudio"
+
+dev = CoreAudio.default_input_device
+buf = dev.input_buffer(1024)
+
+wav = CoreAudio::AudioFile.new("sample.wav", :write, :format => :wav,
+                               :rate => dev.nominal_rate,
+                               :channel => dev.input_stream.channels)
+
+samples = 0
+th = Thread.start do
+  loop do
+    w = buf.read(4096)
+    samples += w.size / dev.input_stream.channels
+    wav.write(w)
+  end
+end
+
+buf.start;
+$stdout.print "RECORDING..."
+$stdout.flush
+sleep 5;
+buf.stop
+$stdout.puts "done."
+th.kill.join
+
+wav.close
+
+puts "#{samples} samples read."
+puts "#{buf.dropped_frame} frame dropped."

data/ext/audiofile.m

@@ -0,0 +1,276 @@
+#include <stdio.h>
+#include <unistd.h>
+
+#include <Foundation/Foundation.h>
+#include <CoreAudio/CoreAudio.h>
+
+#include <ruby.h>
+
+#include <AudioToolbox/AudioToolbox.h>
+
+#include "coreaudio.h"
+
+
+VALUE rb_cAudioFile;
+
+static VALUE sym_read, sym_write, sym_format;
+static VALUE sym_rate, sym_file_rate, sym_channel, sym_file_channel;
+static VALUE sym_wav, sym_m4a;
+
+static void
+setASBD(AudioStreamBasicDescription *asbd,
+        Float64 rate,
+        UInt32 format,
+        UInt32 flags,
+        UInt32 channel,
+        UInt32 bitsPerChannel,
+        UInt32 framePerPacket)
+{
+    asbd->mSampleRate = rate;
+    asbd->mFormatID = format;
+    asbd->mFormatFlags = flags;
+    asbd->mBitsPerChannel = bitsPerChannel;
+    asbd->mChannelsPerFrame = channel;
+    asbd->mFramesPerPacket = framePerPacket;
+    asbd->mBytesPerFrame = bitsPerChannel/8*channel;
+    asbd->mBytesPerPacket = bitsPerChannel/8*channel*framePerPacket;
+}
+
+typedef struct {
+  AudioStreamBasicDescription file_desc;
+  AudioStreamBasicDescription inner_desc;
+  Boolean                     for_write;
+  ExtAudioFileRef             file;
+} ca_audio_file_t;
+
+static void
+ca_audio_file_free(void *ptr)
+{
+    ca_audio_file_t *data = ptr;
+
+    if ( data->file ) {
+      CFRelease(data->file);
+      data->file = NULL;
+    }
+}
+
+static size_t
+ca_audio_file_memsize(const void *ptr)
+{
+    (void)ptr;
+    return sizeof(ca_audio_file_t);
+}
+
+static const rb_data_type_t ca_audio_file_type = {
+  "ca_audio_file",
+  {NULL, ca_audio_file_free, ca_audio_file_memsize},
+};
+
+static VALUE
+ca_audio_file_alloc(VALUE klass)
+{
+    VALUE obj;
+    ca_audio_file_t *ptr;
+
+    obj = TypedData_Make_Struct(klass, ca_audio_file_t, &ca_audio_file_type, ptr);
+
+    return obj;
+}
+
+/*
+ * call-seq:
+ *   AudioFile.new(filepath, mode, opt)
+ *
+ * open audio file at +filepath+. +mode+ should be :read or :write
+ * corresponding to file mode argument of Kernel#open.
+ * +opt+ must contain :format key.
+ *
+ * 'client data' means audio data pass to AudioFile#write or from
+ * AudioFile#read method.
+ *
+ * :format :: audio file format. currently audio file format and 
+ *            codec type is hardcoded. (:wav, :m4a)
+ * :rate :: sample rate of data pass from AudioFile#read or to AudioFile#write
+ *          If not specified, :file_rate value is used. (Float)
+ * :channel :: number of channels 
+ * :file_rate :: file data sample rate. only work when open for output. (Float)
+ * :file_channel :: file data number of channels. only work when open for
+ *                  output.
+ */
+static VALUE
+ca_audio_file_initialize(int argc, VALUE *argv, VALUE self)
+{
+    ca_audio_file_t *data;
+    VALUE path, mode, opt, format;
+    Float64 rate, file_rate;
+    UInt32 channel, file_channel;
+    CFURLRef outUrl = NULL;
+    AudioFileTypeID filetype;
+    ExtAudioFileRef audioFileRef = NULL;
+    UInt32 flags = kAudioFileFlags_EraseFile;
+    OSStatus err = noErr;
+
+    TypedData_Get_Struct(self, ca_audio_file_t, &ca_audio_file_type, data);
+
+    rb_scan_args(argc, argv, "11:", &path, &mode, &opt);
+
+    /* check mode */
+    if (NIL_P(mode) || mode == sym_read)
+      data->for_write = FALSE;
+    else if (mode == sym_write)
+        data->for_write = TRUE;
+    else
+      rb_raise(rb_eArgError, "coreaudio: mode should be :read or :write");
+
+    /* parse options */
+    if (NIL_P(rb_hash_aref(opt, sym_rate))) {
+      rate = 44100.0;
+    } else {
+      rate = NUM2DBL(rb_hash_aref(opt, sym_rate));
+    }
+    if (NIL_P(rb_hash_aref(opt, sym_file_rate))) {
+      file_rate = rate;
+    } else {
+      file_rate = NUM2DBL(rb_hash_aref(opt, sym_file_rate));
+    }
+    if (NIL_P(rb_hash_aref(opt, sym_channel))) {
+      channel = 2;
+    } else {
+      channel = NUM2UINT(rb_hash_aref(opt, sym_channel));
+    }
+    if (NIL_P(rb_hash_aref(opt, sym_file_channel))) {
+      file_channel = channel;
+    } else {
+      file_channel = NUM2UINT(rb_hash_aref(opt, sym_file_channel));
+    }
+
+    format = rb_hash_aref(opt, sym_format);
+    if (NIL_P(format))
+      rb_raise(rb_eArgError, "coreaudio: :format option must be specified");
+
+    if (format == sym_wav) {
+      filetype = kAudioFileWAVEType;
+      setASBD(&data->file_desc, file_rate, kAudioFormatLinearPCM,
+              kLinearPCMFormatFlagIsSignedInteger |
+              kAudioFormatFlagIsPacked,
+              file_channel, 16, 1);
+    } else if (format == sym_m4a) {
+      filetype = kAudioFileM4AType;
+      setASBD(&data->file_desc, file_rate, kAudioFormatMPEG4AAC,
+              0, file_channel, 0, 0);
+    } else {
+      volatile VALUE str = rb_inspect(format);
+      RB_GC_GUARD(str);
+      rb_raise(rb_eArgError, "coreaudio: unsupported format (%s)",
+               RSTRING_PTR(str));
+    }
+
+    /* create URL represent the target filepath */
+    outUrl = CFURLCreateFromFileSystemRepresentation(
+                NULL, StringValueCStr(path), (CFIndex)RSTRING_LEN(path), FALSE);
+
+    /* open ExtAudioFile */
+    err = ExtAudioFileCreateWithURL(outUrl, filetype, &data->file_desc,
+                                    NULL, flags, &data->file);
+    CFRelease(outUrl);
+    outUrl = NULL;
+    if (err != noErr) {
+      rb_raise(rb_eArgError,
+               "coreaudio: file to open ExtAudioFile: %d", (int)err);
+    }
+
+    setASBD(&data->inner_desc, rate, kAudioFormatLinearPCM,
+            kLinearPCMFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked,
+            channel, 16, 1);
+
+    err = ExtAudioFileSetProperty(
+            data->file, kExtAudioFileProperty_ClientDataFormat,
+            sizeof(data->inner_desc), &data->inner_desc);
+    if (err != noErr) {
+      ExtAudioFileDispose(data->file);
+      data->file = NULL;
+      rb_raise(rb_eArgError, "coreaudio: fail to set client data format: %d",
+               (int)err);
+    }
+
+    return self;
+}
+
+static VALUE
+ca_audio_file_close(VALUE self)
+{
+    ca_audio_file_t *data;
+
+    TypedData_Get_Struct(self, ca_audio_file_t, &ca_audio_file_type, data);
+    if (data->file) {
+      ExtAudioFileDispose(data->file);
+      data->file = NULL;
+    }
+
+    return self;
+}
+
+static VALUE
+ca_audio_file_write(VALUE self, VALUE data)
+{
+    ca_audio_file_t *file;
+    short *buf;
+    AudioBufferList buf_list;
+    UInt32 frames;
+    size_t alloc_size;
+    OSStatus err = noErr;
+    int i;
+
+    if (!RB_TYPE_P(data, T_ARRAY))
+      rb_raise(rb_eArgError, "coreaudio: audio buffer must be an array");
+
+    TypedData_Get_Struct(self, ca_audio_file_t, &ca_audio_file_type, file);
+
+    frames = RARRAY_LEN(data) / file->inner_desc.mChannelsPerFrame;
+    alloc_size = (file->inner_desc.mBitsPerChannel/8) * RARRAY_LEN(data);
+
+    /* prepare interleaved audio buffer */
+    buf_list.mNumberBuffers = 1;
+    buf_list.mBuffers[0].mNumberChannels = file->inner_desc.mChannelsPerFrame;
+    buf_list.mBuffers[0].mDataByteSize = alloc_size;
+    buf_list.mBuffers[0].mData = xmalloc(alloc_size);
+    buf = buf_list.mBuffers[0].mData;
+
+    for (i = 0; i < RARRAY_LEN(data); i++) {
+      buf[i] = (short)NUM2INT(RARRAY_PTR(data)[i]);
+    }
+
+    err = ExtAudioFileWrite(file->file, frames, &buf_list);
+
+    xfree(buf);
+
+    if (err != noErr) {
+      rb_raise(rb_eRuntimeError,
+               "coreaudio: ExtAudioFileWrite() fails: %d", (int)err);
+    }
+
+    return self;
+}
+
+void
+Init_coreaudio_audiofile(void)
+{
+    sym_read = ID2SYM(rb_intern("read"));
+    sym_write = ID2SYM(rb_intern("write"));
+    sym_format = ID2SYM(rb_intern("format"));
+    sym_rate = ID2SYM(rb_intern("rate"));
+    sym_file_rate = ID2SYM(rb_intern("file_rate"));
+    sym_channel = ID2SYM(rb_intern("channel"));
+    sym_file_channel = ID2SYM(rb_intern("file_channel"));
+    sym_wav = ID2SYM(rb_intern("wav"));
+    sym_m4a = ID2SYM(rb_intern("m4a"));
+
+    rb_cAudioFile = rb_define_class_under(rb_mCoreAudio, "AudioFile",
+                                          rb_cObject);
+    rb_global_variable(&rb_cAudioFile);
+
+    rb_define_alloc_func(rb_cAudioFile, ca_audio_file_alloc);
+    rb_define_method(rb_cAudioFile, "initialize", ca_audio_file_initialize, -1);
+    rb_define_method(rb_cAudioFile, "close", ca_audio_file_close, 0);
+    rb_define_method(rb_cAudioFile, "write", ca_audio_file_write, 1);
+}