ruby-alsa 0.0.5 → 0.7

data/refs/alsa_player.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+# A Minimal Capture Program
+# using alsa via ruby-ffi
+#
+# This program opens an audio interface for capture, configures it for
+# stereo, 16 bit, 44.1kHz, interleaved conventional read/write
+# access. Then its reads a chunk of random data from it, and exits. It
+# isn't meant to be a real program.
+#
+# Based on C example of Paul David's tutorial : http://equalarea.com/paul/alsa-audio.html
+
+require 'rubygems'
+
+$: << File.expand_path("#{File.dirname(__FILE__)}/../lib")
+require 'alsa'
+
+include FFI
+include ALSA::PCM::Native
+
+ALSA.logger.level = Logger::DEBUG
+
+alsa_device = (ARGV.first or "default")
+capture_handle = MemoryPointer.new :pointer
+format = Format::S16_LE
+
+ALSA::try_to "open audio device #{alsa_device}" do
+  open capture_handle, alsa_device, Stream::PLAYBACK, BLOCK
+end
+
+capture_handle = capture_handle.read_pointer
+
+MemoryPointer.new(:pointer) do |hw_params|
+  ALSA::try_to "allocate hardware parameter structure" do
+    hw_params_malloc hw_params
+  end
+  hw_params = hw_params.read_pointer
+
+  ALSA::try_to "initialize hardware parameter structure" do
+    hw_params_any capture_handle, hw_params
+  end
+
+  ALSA::try_to "set access type" do
+    hw_params_set_access capture_handle, hw_params, Access::RW_INTERLEAVED
+  end
+
+  ALSA::try_to "set sample format" do
+    hw_params_set_format capture_handle, hw_params, format
+  end
+
+  ALSA::try_to "set sample rate" do
+    [44100, 0].to_pointers do |rate, direction|
+      hw_params_set_rate_near capture_handle, hw_params, rate, direction
+    end
+  end
+
+  ALSA::try_to "set channel count" do
+    hw_params_set_channels capture_handle, hw_params, 2
+  end
+
+  ALSA::try_to "set hw parameters" do
+    hw_params capture_handle, hw_params
+  end
+
+  ALSA::try_to "unallocate hw_params" do
+    hw_params_free hw_params
+  end
+end
+
+ALSA::try_to "prepare audio interface to use" do
+  prepare capture_handle
+end
+
+frame_count = 44100
+MemoryPointer.new(format_size(format, frame_count) * 2) do |buffer|
+  3.times do
+    ALSA::try_to "write in audio interface" do
+      writei(capture_handle, buffer, frame_count)
+    end
+  end
+end
+
+ALSA::try_to "close audio device" do
+  close capture_handle
+end

data/refs/alsa_player_async.c

@@ -0,0 +1,113 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <alsa/asoundlib.h>
+#include <unistd.h>
+
+static void playback_callback(snd_async_handler_t *callback)
+{
+  snd_pcm_t *playback_handle = snd_async_handler_get_pcm(callback);
+  void *buf = snd_async_handler_get_callback_private(callback);
+
+  snd_pcm_sframes_t avail;
+  int err;
+
+  avail = snd_pcm_avail_update(playback_handle);
+  while (avail >= 1024) {
+    if ((err = snd_pcm_writei(playback_handle, buf, 1024)) != 1024) {
+      fprintf (stderr, "write to audio interface failed (%s)\n",
+               snd_strerror (err));
+      exit (1);
+    }
+    avail = snd_pcm_avail_update(playback_handle);
+  }
+}
+	      
+main (int argc, char *argv[])
+{
+  int i;
+  int err;
+  short buf[1024];
+  snd_pcm_t *playback_handle;
+  snd_pcm_hw_params_t *hw_params;
+	
+  if ((err = snd_pcm_open (&playback_handle, argv[1], SND_PCM_STREAM_PLAYBACK, 0)) < 0) {
+    fprintf (stderr, "cannot open audio device %s (%s)\n", 
+             argv[1],
+             snd_strerror (err));
+    exit (1);
+  }
+		   
+  if ((err = snd_pcm_hw_params_malloc (&hw_params)) < 0) {
+    fprintf (stderr, "cannot allocate hardware parameter structure (%s)\n",
+             snd_strerror (err));
+    exit (1);
+  }
+				 
+  if ((err = snd_pcm_hw_params_any (playback_handle, hw_params)) < 0) {
+    fprintf (stderr, "cannot initialize hardware parameter structure (%s)\n",
+             snd_strerror (err));
+    exit (1);
+  }
+	
+  if ((err = snd_pcm_hw_params_set_access (playback_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
+    fprintf (stderr, "cannot set access type (%s)\n",
+             snd_strerror (err));
+    exit (1);
+  }
+	
+  if ((err = snd_pcm_hw_params_set_format (playback_handle, hw_params, SND_PCM_FORMAT_S16_LE)) < 0) {
+    fprintf (stderr, "cannot set sample format (%s)\n",
+             snd_strerror (err));
+    exit (1);
+  }
+	
+  if ((err = snd_pcm_hw_params_set_rate (playback_handle, hw_params, 44100, 0)) < 0) {
+    fprintf (stderr, "cannot set sample rate (%s)\n",
+             snd_strerror (err));
+    exit (1);
+  }
+	
+  if ((err = snd_pcm_hw_params_set_channels (playback_handle, hw_params, 2)) < 0) {
+    fprintf (stderr, "cannot set channel count (%s)\n",
+             snd_strerror (err));
+    exit (1);
+  }
+	
+  if ((err = snd_pcm_hw_params (playback_handle, hw_params)) < 0) {
+    fprintf (stderr, "cannot set parameters (%s)\n",
+             snd_strerror (err));
+    exit (1);
+  }
+	
+  snd_pcm_hw_params_free (hw_params);
+
+  if ((err = snd_pcm_prepare (playback_handle)) < 0) {
+    fprintf (stderr, "cannot prepare audio interface for use (%s)\n",
+             snd_strerror (err));
+    exit (1);
+  }
+
+  snd_async_handler_t *async_handler;
+
+  if ((err = snd_async_add_pcm_handler(&async_handler, playback_handle, playback_callback, buf)) < 0) {
+    fprintf (stderr, "cannot add async handler (%s)\n",
+             snd_strerror (err));
+    exit (1);
+  }
+
+  if ((err = snd_pcm_start (playback_handle)) < 0) {
+    fprintf (stderr, "cannot start audio interface for use (%s)\n",
+             snd_strerror (err));
+    exit (1);
+  }
+
+  if ((err = snd_pcm_writei (playback_handle, buf, 1024)) != 1024) {
+    fprintf (stderr, "write to audio interface failed (%s)\n",
+             snd_strerror (err));
+    exit (1);
+  }
+
+	while (1) {
+		sleep(1);
+	}
+}

data/refs/alsa_player_async.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+
+# A Minimal Capture Program
+# using alsa via ruby-ffi
+#
+# This program opens an audio interface for capture, configures it for
+# stereo, 16 bit, 44.1kHz, interleaved conventional read/write
+# access. Then its reads a chunk of random data from it, and exits. It
+# isn't meant to be a real program.
+#
+# Based on C example of Paul David's tutorial : http://equalarea.com/paul/alsa-audio.html
+
+require 'rubygems'
+
+$: << File.expand_path("#{File.dirname(__FILE__)}/../lib")
+require 'alsa'
+
+include FFI
+include ALSA::Native
+include ALSA::PCM::Native
+
+ALSA.logger.level = Logger::DEBUG
+
+alsa_device = (ARGV.first or "default")
+capture_handle = MemoryPointer.new :pointer
+format = Format::S16_LE
+
+ALSA::try_to "open audio device #{alsa_device}" do
+  open capture_handle, alsa_device, Stream::PLAYBACK, BLOCK
+end
+
+capture_handle = capture_handle.read_pointer
+
+MemoryPointer.new(:pointer) do |hw_params|
+  ALSA::try_to "allocate hardware parameter structure" do
+    hw_params_malloc hw_params
+  end
+  hw_params = hw_params.read_pointer
+
+  ALSA::try_to "initialize hardware parameter structure" do
+    hw_params_any capture_handle, hw_params
+  end
+
+  ALSA::try_to "set access type" do
+    hw_params_set_access capture_handle, hw_params, Access::RW_INTERLEAVED
+  end
+
+  ALSA::try_to "set sample format" do
+    hw_params_set_format capture_handle, hw_params, format
+  end
+
+  ALSA::try_to "set sample rate" do
+    [44100, 0].to_pointers do |rate, direction|
+      hw_params_set_rate_near capture_handle, hw_params, rate, direction
+    end
+  end
+
+  ALSA::try_to "set channel count" do
+    hw_params_set_channels capture_handle, hw_params, 2
+  end
+
+  ALSA::try_to "set hw parameters" do
+    hw_params capture_handle, hw_params
+  end
+
+  ALSA::try_to "unallocate hw_params" do
+    hw_params_free hw_params
+  end
+end
+
+ALSA::try_to "prepare audio interface to use" do
+  prepare capture_handle
+end
+
+async_handler = MemoryPointer.new(:pointer)
+
+frame_count = 44100
+
+playback_callback = Proc.new do |async_handler|
+  capture_handle = async_handler_get_pcm(async_handler)
+  buffer = async_handler_get_callback_private(async_handler)
+
+  ALSA::try_to "write in audio interface" do
+    writei(capture_handle, buffer, frame_count)
+  end
+end
+
+buffer = MemoryPointer.new(format_size(format, frame_count) * 2)
+
+ALSA::try_to "add async handler" do
+  async_add_pcm_handler(async_handler, capture_handle, playback_callback, buffer)
+end
+
+ALSA::try_to "write in audio interface" do
+  writei(capture_handle, buffer, frame_count)
+end
+
+loop { sleep 10 }

data/refs/alsa_recorder.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+# A Minimal Capture Program
+# using alsa via ruby-ffi
+#
+# This program opens an audio interface for capture, configures it for
+# stereo, 16 bit, 44.1kHz, interleaved conventional read/write
+# access. Then its reads a chunk of random data from it, and exits. It
+# isn't meant to be a real program.
+#
+# Based on C example of Paul David's tutorial : http://equalarea.com/paul/alsa-audio.html
+
+require 'rubygems'
+
+$: << File.expand_path("#{File.dirname(__FILE__)}/../lib")
+require 'alsa'
+
+include FFI
+include ALSA::PCM::Native
+
+ALSA.logger.level = Logger::DEBUG
+
+alsa_device = (ARGV.first or "default")
+capture_handle = MemoryPointer.new :pointer
+format = Format::S16_LE
+
+ALSA::try_to "open audio device #{alsa_device}" do
+  open capture_handle, alsa_device, Stream::CAPTURE, BLOCK
+end
+
+capture_handle = capture_handle.read_pointer
+
+MemoryPointer.new(:pointer) do |hw_params|
+  ALSA::try_to "allocate hardware parameter structure" do
+    hw_params_malloc hw_params
+  end
+  hw_params = hw_params.read_pointer
+
+  ALSA::try_to "initialize hardware parameter structure" do
+    hw_params_any capture_handle, hw_params
+  end
+
+  ALSA::try_to "set access type" do
+    hw_params_set_access capture_handle, hw_params, Access::RW_INTERLEAVED
+  end
+
+  ALSA::try_to "set sample format" do
+    hw_params_set_format capture_handle, hw_params, format
+  end
+
+  ALSA::try_to "set sample rate" do
+    [44100, 0].to_pointers do |rate, direction|
+      hw_params_set_rate_near capture_handle, hw_params, rate, direction
+    end
+  end
+
+  ALSA::try_to "set channel count" do
+    hw_params_set_channels capture_handle, hw_params, 2
+  end
+
+  ALSA::try_to "set hw parameters" do
+    hw_params capture_handle, hw_params
+  end
+
+  ALSA::try_to "unallocate hw_params" do
+    hw_params_free hw_params
+  end
+end
+
+ALSA::try_to "prepare audio interface to use" do
+  prepare capture_handle
+end
+
+frame_count = 44100
+MemoryPointer.new(format_size(format, frame_count) * 2) do |buffer|
+  3.times do 
+    ALSA::try_to "read from audio interface" do
+      readi(capture_handle, buffer, frame_count)
+    end
+  end
+end
+
+ALSA::try_to "close audio device" do
+  close capture_handle
+end

data/refs/alsa_recorder_async.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+
+# A Minimal Capture Program
+# using alsa via ruby-ffi
+#
+# This program opens an audio interface for capture, configures it for
+# stereo, 16 bit, 44.1kHz, interleaved conventional read/write
+# access. Then its reads a chunk of random data from it, and exits. It
+# isn't meant to be a real program.
+#
+# Based on C example of Paul David's tutorial : http://equalarea.com/paul/alsa-audio.html
+
+require 'rubygems'
+
+$: << File.expand_path("#{File.dirname(__FILE__)}/../lib")
+require 'alsa'
+
+include FFI
+include ALSA::Native
+include ALSA::PCM::Native
+
+ALSA.logger.level = Logger::DEBUG
+
+alsa_device = (ARGV.first or "default")
+capture_handle = MemoryPointer.new :pointer
+format = Format::S16_LE
+
+ALSA::try_to "open audio device #{alsa_device}" do
+  open capture_handle, alsa_device, Stream::CAPTURE, BLOCK
+end
+
+capture_handle = capture_handle.read_pointer
+
+MemoryPointer.new(:pointer) do |hw_params|
+  ALSA::try_to "allocate hardware parameter structure" do
+    hw_params_malloc hw_params
+  end
+  hw_params = hw_params.read_pointer
+
+  ALSA::try_to "initialize hardware parameter structure" do
+    hw_params_any capture_handle, hw_params
+  end
+
+  ALSA::try_to "set access type" do
+    hw_params_set_access capture_handle, hw_params, Access::RW_INTERLEAVED
+  end
+
+  ALSA::try_to "set sample format" do
+    hw_params_set_format capture_handle, hw_params, format
+  end
+
+  ALSA::try_to "set sample rate" do
+    [44100, 0].to_pointers do |rate, direction|
+      hw_params_set_rate_near capture_handle, hw_params, rate, direction
+    end
+  end
+
+  ALSA::try_to "set channel count" do
+    hw_params_set_channels capture_handle, hw_params, 2
+  end
+
+  ALSA::try_to "set hw parameters" do
+    hw_params capture_handle, hw_params
+  end
+
+  ALSA::try_to "unallocate hw_params" do
+    hw_params_free hw_params
+  end
+end
+
+ALSA::try_to "prepare audio interface to use" do
+  prepare capture_handle
+end
+
+async_handler = MemoryPointer.new(:pointer)
+
+frame_count = 44100
+
+capture_callback = Proc.new do |async_handler|
+  capture_handle = async_handler_get_pcm(async_handler)
+  buffer = async_handler_get_callback_private(async_handler)
+
+  ALSA::try_to "read in audio interface" do
+    readi(capture_handle, buffer, frame_count)
+  end
+end
+
+buffer = MemoryPointer.new(format_size(format, frame_count) * 2)
+
+ALSA::try_to "add async handler" do
+  async_add_pcm_handler(async_handler, capture_handle, capture_callback, buffer)
+end
+
+ALSA::try_to "read from audio interface" do
+  readi(capture_handle, buffer, frame_count)
+end
+
+loop { sleep 10 }