audite 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*~
+ext/*/Makefile
+ext/*/*.o
+ext/*/*.bundle

data/README.md

@@ -0,0 +1,51 @@
+Audite - a portable mp3 player in Ruby
+======================================
+
+Audite is a portable ruby library for playing mp3 files built on
+libmp123 and portaudio.
+
+## Features
+
+* Nonblocking playback using native threads
+* Realtime seeking
+* Realtime events
+* Progress information
+* Simple level meter
+
+## Player
+
+Audite ships an example player, just try `audite test.mp3`.
+
+## Example
+
+```
+require 'audite'
+
+player = Audite.new
+
+player.events.on(:complete) do
+  exit
+end
+
+player.events.on(:level) do |level|
+  puts level
+end
+
+player.events.on(:position_change) do |pos|
+  puts pos
+end
+
+player.load('test.mp3')
+player.start_stream
+player.forward(20) 
+
+```
+
+## OSX Install
+
+```
+brew install portaudio
+brew install mpg123
+
+gem install audite
+```

data/audite.gemspec

@@ -0,0 +1,21 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = "audite"
+  s.version       = "0.1.0"
+  s.author        = "Matthias Georgi"
+  s.email         = "matti.georgi@gmail.com"
+  s.homepage      = "http://georgi.github.com/audite"
+  s.summary       = "Portable mp3 player"
+  s.description   = "Portable mp3 player built on mpg123 and portaudio"
+
+  s.bindir        = 'bin'
+  s.files         = `git ls-files`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.extra_rdoc_files = ["README.md"]
+
+  s.extensions << 'ext/mpg123/extconf.rb'
+  s.extensions << 'ext/portaudio/extconf.rb'
+end

data/bin/audite

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require 'audite'
+require 'curses'
+
+player = Audite.new
+player.load(ARGV[0])
+player.start_stream
+
+player.events.on(:complete) do
+  exit
+end
+
+player.events.on(:level) do |level|
+  p = (level * Curses.cols).ceil
+  Curses.setpos(2, 0)
+  Curses.addstr(">" * p + " " * (Curses.cols - p))
+  Curses.refresh
+end
+
+player.events.on(:position_change) do |pos|
+  p = ((pos / player.length_in_seconds) * Curses.cols).ceil
+  Curses.setpos(0, 0)
+  Curses.addstr("playing #{ARGV[0]}    #{player.position.ceil} seconds of #{player.length_in_seconds.ceil} total")
+  Curses.setpos(1, 0)
+  Curses.addstr("#" * p + " " * (Curses.cols - p))
+  Curses.refresh
+end
+
+Curses.init_screen
+Curses.noecho
+Curses.stdscr.keypad(true)
+Curses.clear
+
+while c = Curses.getch
+  case c
+  when Curses::KEY_LEFT
+    player.rewind
+  when Curses::KEY_RIGHT
+    player.forward
+  when ' '
+    player.toggle
+  end
+end

data/ext/mpg123/extconf.rb

@@ -0,0 +1,13 @@
+require 'mkmf'
+
+unless have_header('mpg123.h')
+  puts "please install mpg123 headers"
+  exit
+end
+
+unless have_library('mpg123')
+  puts "please install mpg123 lib"
+  exit
+end
+
+create_makefile('mpg123')

data/ext/mpg123/mpg123.c

@@ -0,0 +1,139 @@
+#include <ruby.h>
+
+#include <stdio.h>
+#include <strings.h>
+#include <mpg123.h>
+
+void cleanup(mpg123_handle *mh)
+{
+  mpg123_close(mh);
+  mpg123_delete(mh);
+}
+
+static VALUE rb_cMpg123;
+
+VALUE rb_mpg123_new(VALUE klass, VALUE filename) {
+  int err = MPG123_OK;
+  mpg123_handle *mh;
+  VALUE mpg123;
+  long rate;
+  int channels, encoding;
+
+  Check_Type(filename, T_STRING);
+
+  if ((mh = mpg123_new(NULL, &err)) == NULL) {
+    rb_raise(rb_eStandardError, "%s", mpg123_plain_strerror(err));
+  }
+
+  mpg123_param(mh, MPG123_ADD_FLAGS, MPG123_FORCE_FLOAT, 0.);
+
+  if (mpg123_open(mh, (char*) RSTRING_PTR(filename)) != MPG123_OK ||
+      mpg123_getformat(mh, &rate, &channels, &encoding) != MPG123_OK) {
+    rb_raise(rb_eStandardError, "%s", mpg123_strerror(mh));
+  }
+
+  if (encoding != MPG123_ENC_FLOAT_32) {
+    rb_raise(rb_eStandardError, "bad encoding");
+  }
+
+  mpg123_format_none(mh);
+  mpg123_format(mh, rate, channels, encoding);
+
+  return Data_Wrap_Struct(rb_cMpg123, 0, cleanup, mh);
+}
+
+VALUE rb_mpg123_close(VALUE self)
+{
+  mpg123_close(DATA_PTR(self));
+  return self;
+}
+
+
+VALUE rb_mpg123_read(VALUE self, VALUE _size)
+{
+  int size = FIX2INT(_size);
+  float *buffer = malloc(size * sizeof(float));
+  VALUE result = rb_ary_new2(size);
+  mpg123_handle *mh = NULL;
+  size_t done = 0;
+  int i;
+  int err = MPG123_OK;
+
+  Data_Get_Struct(self, mpg123_handle, mh);
+  err = mpg123_read(mh, (unsigned char *) buffer, size * sizeof(float), &done);
+
+  if (err == MPG123_OK || err == MPG123_DONE) {
+    for (i = 0; i < size; i++) {
+      rb_ary_store(result, i, rb_float_new(buffer[i]));
+    }
+    return result;
+  }
+  else {
+    rb_raise(rb_eStandardError, "%s", mpg123_plain_strerror(err));
+  }
+}
+
+VALUE rb_mpg123_length(VALUE self)
+{
+  return INT2FIX(mpg123_length(DATA_PTR(self)));
+}
+
+VALUE rb_mpg123_spf(VALUE self)
+{
+  return rb_float_new(mpg123_spf(DATA_PTR(self)));
+}
+
+VALUE rb_mpg123_tpf(VALUE self)
+{
+  return rb_float_new(mpg123_tpf(DATA_PTR(self)));
+}
+
+VALUE rb_mpg123_tell(VALUE self)
+{
+  return INT2FIX(mpg123_tell(DATA_PTR(self)));
+}
+
+VALUE rb_mpg123_tellframe(VALUE self)
+{
+  return INT2FIX(mpg123_tellframe(DATA_PTR(self)));
+}
+
+VALUE rb_mpg123_seek(VALUE self, VALUE offset)
+{
+  return INT2FIX(mpg123_seek(DATA_PTR(self), FIX2INT(offset), SEEK_SET));
+}
+
+VALUE rb_mpg123_seek_frame(VALUE self, VALUE offset)
+{
+  return INT2FIX(mpg123_seek_frame(DATA_PTR(self), FIX2INT(offset), SEEK_SET));
+}
+
+VALUE rb_mpg123_timeframe(VALUE self, VALUE seconds)
+{
+  return INT2FIX(mpg123_timeframe(DATA_PTR(self), NUM2DBL(seconds)));
+}
+
+void Init_mpg123(void) {
+  int err = MPG123_OK;
+
+  err = mpg123_init();
+
+  if (err != MPG123_OK) {
+    rb_raise(rb_eStandardError, "%s", mpg123_plain_strerror(err));
+  }
+
+  rb_cMpg123 = rb_define_class("Mpg123", rb_cObject);
+
+  rb_define_singleton_method(rb_cMpg123, "new", rb_mpg123_new, 1);
+
+  rb_define_method(rb_cMpg123, "close", rb_mpg123_close, 0);
+  rb_define_method(rb_cMpg123, "read", rb_mpg123_read, 1);
+  rb_define_method(rb_cMpg123, "length", rb_mpg123_length, 0);
+  rb_define_method(rb_cMpg123, "spf", rb_mpg123_spf, 0);
+  rb_define_method(rb_cMpg123, "tpf", rb_mpg123_tpf, 0);
+  rb_define_method(rb_cMpg123, "tell", rb_mpg123_tell, 0);
+  rb_define_method(rb_cMpg123, "tellframe", rb_mpg123_tellframe, 0);
+  rb_define_method(rb_cMpg123, "seek", rb_mpg123_seek, 1);
+  rb_define_method(rb_cMpg123, "seek_frame", rb_mpg123_seek_frame, 1);
+  rb_define_method(rb_cMpg123, "timeframe", rb_mpg123_timeframe, 1);
+}

data/ext/portaudio/extconf.rb

@@ -0,0 +1,13 @@
+require 'mkmf'
+
+unless have_header('portaudio.h')
+  puts "please install portaudio headers"
+  exit
+end
+
+unless have_library('portaudio')
+  puts "please install portaudio lib"
+  exit
+end
+
+create_makefile('portaudio')

data/ext/portaudio/portaudio.c

@@ -0,0 +1,151 @@
+#include <ruby.h>
+#include <pthread.h>
+#include <portaudio.h>
+
+typedef struct {
+  PaStream *stream;
+  int size;
+  float *buffer;
+  pthread_mutex_t mutex;
+  pthread_cond_t cond;
+} Portaudio;
+
+static VALUE rb_cPortaudio;
+
+void free_portaudio(void *ptr)
+{
+  Portaudio *portaudio = (Portaudio *) ptr;
+
+  if (portaudio) {
+    pthread_cond_destroy(&portaudio->cond);
+    pthread_mutex_destroy(&portaudio->mutex);
+
+    if (portaudio->buffer) {
+      free(portaudio->buffer);
+    }
+
+    Pa_CloseStream(portaudio->stream);
+  }
+}
+
+
+static int paCallback(const void *inputBuffer,
+                      void *outputBuffer,
+                      unsigned long framesPerBuffer,
+                      const PaStreamCallbackTimeInfo* timeInfo,
+                      PaStreamCallbackFlags statusFlags,
+                      void *userData )
+{
+  Portaudio *portaudio = (Portaudio *) userData;
+  float *out = (float*) outputBuffer;
+  unsigned int i;
+
+  pthread_mutex_lock(&portaudio->mutex);
+
+  for (i = 0; i < framesPerBuffer * 2; i++) {
+    *out++ = portaudio->buffer[i];
+  }
+
+  pthread_mutex_unlock(&portaudio->mutex);
+  pthread_cond_signal(&portaudio->cond);
+
+  return 0;
+}
+
+VALUE rb_portaudio_new(VALUE klass)
+{
+  PaError err;
+  VALUE self;
+  Portaudio *portaudio = (Portaudio *) malloc(sizeof(Portaudio));
+
+  pthread_mutex_init(&portaudio->mutex, NULL);
+  pthread_cond_init(&portaudio->cond, NULL);
+
+  portaudio->size = 4096 * 2;
+  portaudio->buffer = (float *) malloc(sizeof(float) * portaudio->size);
+
+  err = Pa_OpenDefaultStream(&portaudio->stream,
+                             0,           /* no input channels */
+                             2,           /* stereo output */
+                             paFloat32,   /* 32 bit floating point output */
+                             44100,       /* 44100 sample rate*/
+                             4096,        /* frames per buffer */
+                             paCallback,  /* this is your callback function */
+                             (void*) portaudio);
+
+  if (err != paNoError) {
+    rb_raise(rb_eStandardError, "%s", Pa_GetErrorText(err));
+  }
+
+  self = Data_Wrap_Struct(rb_cPortaudio, 0, free_portaudio, portaudio);
+
+  return self;
+}
+
+
+VALUE portaudio_wait(void *ptr)
+{
+  Portaudio *portaudio = (Portaudio *) ptr;
+
+  pthread_cond_wait(&portaudio->cond, &portaudio->mutex);
+
+  return Qnil;
+}
+
+VALUE rb_portaudio_write(VALUE self, VALUE buffer)
+{
+  int i;
+  Portaudio *portaudio;
+  Data_Get_Struct(self, Portaudio, portaudio);
+
+  Check_Type(buffer, T_ARRAY);
+
+  for (i = 0; i < portaudio->size; i++) {
+    portaudio->buffer[i] = NUM2DBL(rb_ary_entry(buffer, i));
+  }
+
+  rb_thread_blocking_region(portaudio_wait, portaudio, RUBY_UBF_IO, NULL);
+
+  return self;
+}
+
+VALUE rb_portaudio_start(VALUE self)
+{
+  Portaudio *portaudio;
+  Data_Get_Struct(self, Portaudio, portaudio);
+  int err = Pa_StartStream(portaudio->stream);
+
+  if (err != paNoError) {
+    rb_raise(rb_eStandardError, "%s", Pa_GetErrorText(err));
+  }
+
+  return self;
+}
+
+VALUE rb_portaudio_stop(VALUE self)
+{
+  Portaudio *portaudio;
+  Data_Get_Struct(self, Portaudio, portaudio);
+  int err = Pa_StopStream(portaudio->stream);
+
+  if (err != paNoError) {
+    rb_raise(rb_eStandardError, "%s", Pa_GetErrorText(err));
+  }
+
+  return self;
+}
+
+void Init_portaudio(void) {
+  int err = Pa_Initialize();
+
+  if (err != paNoError) {
+    rb_raise(rb_eStandardError, "%s", Pa_GetErrorText(err));
+  }
+
+  rb_cPortaudio = rb_define_class("Portaudio", rb_cObject);
+
+  rb_define_singleton_method(rb_cPortaudio, "new", rb_portaudio_new, 0);
+  rb_define_method(rb_cPortaudio, "write", rb_portaudio_write, 1);
+  rb_define_method(rb_cPortaudio, "start", rb_portaudio_start, 0);
+  rb_define_method(rb_cPortaudio, "stop", rb_portaudio_stop, 0);
+}

data/lib/audite.rb

@@ -0,0 +1,153 @@
+require 'portaudio'
+require 'mpg123'
+
+class Audite
+  class Events
+    def initialize
+      @handlers = Hash.new {|h,k| h[k] = [] }
+    end
+
+    def on(event, &block)
+      @handlers[event] << block
+    end
+
+    def trigger(event, *args)
+      @handlers[event].each do |handler|
+        handler.call(*args)
+      end
+    end
+  end
+
+  attr_reader :events
+
+  def initialize
+    @events = Events.new
+    @stream = Portaudio.new
+    @thread = start_thread
+  end
+
+  def start_thread
+    Thread.start do
+      loop do
+        @stream.write(process(4096))
+      end
+    end
+  end
+
+  def process(samples)
+    if tell >= length
+      events.trigger(:complete)
+      stop_stream
+      (0..samples).map { 0 }
+
+    elsif slice = read(samples * 2)
+      events.trigger(:level, level(slice))
+      events.trigger(:position_change, position)
+
+      slice
+    else
+      (0..samples).map { 0 }
+    end
+
+  rescue => e
+    puts e.message
+    puts e.backtrace
+  end
+
+  def start_stream
+    unless @active
+      @active = true
+      @stream.start
+    end
+  end
+
+  def stop_stream
+    if @active
+      @active = false
+      @stream.stop
+    end
+  end
+
+  def toggle
+    if @active
+      stop_stream
+    else
+      start_stream
+    end
+  end
+
+  def load(file)
+    @mp3 = Mpg123.new(file)
+  end
+
+  def time_per_frame
+    @mp3.tpf
+  end
+
+  def samples_per_frame
+    @mp3.spf
+  end
+
+  def tell
+    @mp3.tell
+  end
+
+  def length
+    @mp3.length
+  end
+
+  def read(samples)
+    @mp3.read(samples)
+  end
+
+  def seconds_to_frames(seconds)
+    seconds / time_per_frame
+  end
+
+  def seconds_to_samples(seconds)
+    seconds_to_frames(seconds) * samples_per_frame
+  end
+
+  def samples_to_seconds(samples)
+    samples_to_frames(samples) * time_per_frame
+  end
+
+  def samples_to_frames(samples)
+    samples / samples_per_frame
+  end
+
+  def seek(seconds)
+    samples = seconds_to_samples(seconds)
+
+    if (0..length).include?(samples)
+      @mp3.seek(samples)
+      events.trigger(:position_change, position)
+    end
+  end
+
+  def position
+    samples_to_seconds(tell)
+  end
+
+  def length_in_seconds
+    samples_to_seconds(length)
+  end
+
+  def level(slice)
+    slice.inject(0) {|s, i| s + i.abs } / slice.size
+  end
+
+  def rewind(seconds = 1)
+    if @mp3
+      start_stream
+      seek(position - seconds)
+    end
+  end
+
+  def forward(seconds = 1)
+    if @mp3
+      start_stream
+      seek(position + seconds)
+    end
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: audite
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Matthias Georgi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-26 00:00:00.000000000 Z
+dependencies: []
+description: Portable mp3 player built on mpg123 and portaudio
+email: matti.georgi@gmail.com
+executables:
+- audite
+extensions:
+- ext/mpg123/extconf.rb
+- ext/portaudio/extconf.rb
+extra_rdoc_files:
+- README.md
+files:
+- .gitignore
+- README.md
+- audite.gemspec
+- bin/audite
+- ext/mpg123/extconf.rb
+- ext/mpg123/mpg123.c
+- ext/portaudio/extconf.rb
+- ext/portaudio/portaudio.c
+- lib/audite.rb
+homepage: http://georgi.github.com/audite
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Portable mp3 player
+test_files: []
+has_rdoc: