audite-lib 0.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 041f8e7065b49fc7d94f63647ac4c1f6d584f715
+  data.tar.gz: ccbf5a030a7523d61bf785ffa7387b9792dfcd0c
+SHA512:
+  metadata.gz: 8ed5cc854d9472737ed0e27ca389e8be9c194480ed44b2458b84ba1f612a1af832114e15d090044b1a3a3f04206c31f02f2b402259780b035f82fe9d04770f4d
+  data.tar.gz: 16c86468704fb1ee735c024e5884e9bf63d8c3e7b729cfb79674daf4af41704ca59f8fd6ba988601f62f937c7813c4e04fd2d550dd37ba25e0fe8a704f7718dc

data/.gitignore

@@ -0,0 +1,6 @@
+*~
+*.gem
+ext/*/Makefile
+ext/*/*.o
+ext/*/*.bundle
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in audite.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2013 Matthias Georgi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,71 @@
+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
+
+## Usage
+
+Audite ships an example player:
+
+```
+audite test.mp3
+```
+
+## API Example
+
+```
+require 'audite'
+
+player = Audite.new
+
+player.events.on(:complete) do
+  puts "COMPLETE"
+end
+
+player.events.on(:position_change) do |pos|
+  puts "POSITION: #{pos} seconds  level #{player.level}"
+end
+
+player.load('test.mp3')
+player.start_stream
+player.forward(20)
+player.thread.join
+
+```
+
+## Requirements
+
+* Portaudio >= 19
+* Mpg123 >= 1.14
+
+## OSX Install
+
+```
+brew install portaudio
+brew install mpg123
+
+gem install audite
+```
+
+
+## Debian / Ubuntu Install
+```
+apt-get install libjack0 libjack-dev
+apt-get install libportaudiocpp0 portaudio19-dev libmpg123-dev
+gem install audite
+```
+
+## Soundcloud2000
+
+Audite provides the audio engine for [Soundcloud2000][1]
+
+[1]: https://github.com/grobie/soundcloud2000

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/audite.gemspec

@@ -0,0 +1,23 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = "audite-lib"
+  s.version       = "0.4.1"
+  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.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "bundler", "~> 1.3"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+
+  s.extra_rdoc_files = ["README.md"]
+
+  s.extensions << 'ext/mpg123/extconf.rb'
+  s.extensions << 'ext/portaudio/extconf.rb'
+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,157 @@
+#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);
+
+  VALUE new_mpg123 = Data_Wrap_Struct(rb_cMpg123, 0, cleanup, mh);
+  rb_iv_set(new_mpg123, "@file", filename);
+  return new_mpg123;
+}
+
+static VALUE rb_mpg123_file(VALUE self, VALUE obj)
+{
+  return rb_iv_get(self, "@file");
+}
+
+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]));
+    }
+    free(buffer);
+    return result;
+  }
+  else {
+    free(buffer);
+    rb_raise(rb_eStandardError, "%s", mpg123_plain_strerror(err));
+  }
+}
+
+VALUE rb_mpg123_length(VALUE self)
+{
+  /*
+   * mpg123_length() only returns an estimated duration
+   * if the song hasn't previously been scanned.
+   * This can be incorrect if, for example, the song is corrupted
+   * and cannot be played after a certain point.
+   * Run mpg123_scan() first to get an accurate length reading.
+   */
+  mpg123_scan(DATA_PTR(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, "file", rb_mpg123_file, 0);
+
+  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,38 @@
+require 'mkmf'
+
+unless have_header('portaudio.h')
+  puts "portaudio.h not found"
+  puts "please brew install portaudio"
+  puts "or apt-get install portaudio19-dev"
+  exit
+end
+
+unless have_header('mpg123.h')
+  puts "mpg123.h not found"
+  puts "please brew install mpg123"
+  puts "or apt-get install libmpg123-dev"
+  exit
+end
+
+unless have_library('portaudio')
+  puts "lib portaudio not found"
+  puts "brew install portaudio"
+  puts "or apt-get install portaudio19-dev"
+  exit
+end
+
+unless have_library('mpg123')
+  puts "lib mpg123 not found"
+  puts "please brew install mpg123"
+  puts "or apt-get install libmpg123-0"
+  exit
+end
+
+unless have_type('PaStreamCallbackTimeInfo', 'portaudio.h')
+  puts "portaudio19 not found"
+  puts "brew install portaudio"
+  puts "or apt-get install portaudio19-dev"
+  exit
+end
+
+create_makefile('portaudio')

data/ext/portaudio/portaudio.c

@@ -0,0 +1,283 @@
+#include <ruby.h>
+#include <math.h>
+#include <pthread.h>
+#include <portaudio.h>
+#include <mpg123.h>
+#include <string.h>
+
+typedef struct {
+  PaStream *stream;
+  int size;
+  float *buffer;
+  float rms;
+  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);
+
+  memcpy(out, portaudio->buffer, sizeof(float) * portaudio->size);
+
+  pthread_cond_broadcast(&portaudio->cond);
+  pthread_mutex_unlock(&portaudio->mutex);
+
+  return 0;
+}
+
+VALUE rb_portaudio_new(VALUE klass, VALUE framesPerBuffer, VALUE deviceName)
+{
+  PaStreamParameters outputParameters;
+  const PaDeviceInfo *deviceInfo;
+  PaError err;
+  int device, numDevices, foundDevice = -1;
+  VALUE self;
+  Portaudio *portaudio = (Portaudio *) malloc(sizeof(Portaudio));
+
+  pthread_mutex_init(&portaudio->mutex, NULL);
+  pthread_cond_init(&portaudio->cond, NULL);
+
+  portaudio->size = FIX2INT(framesPerBuffer) * 2;
+  portaudio->buffer = (float *) malloc(sizeof(float) * portaudio->size);
+	numDevices = Pa_GetDeviceCount();
+	if( numDevices < 0 ) {
+		printf( "ERROR: Pa_CountDevices returned 0x%x\n", numDevices );
+		err = numDevices;
+	}
+
+	for ( device=0; device<numDevices; device++ ) {
+		deviceInfo = Pa_GetDeviceInfo( device );
+		if (strcmp(deviceInfo->name, StringValueCStr(deviceName)) == 0) {
+			foundDevice = device;
+			break;
+		}
+	}
+
+	if (foundDevice == -1) {
+		err = Pa_OpenDefaultStream(&portaudio->stream,
+				0,           /* no input channels */
+				2,           /* stereo output */
+				paFloat32,   /* 32 bit floating point output */
+				44100,       /* sample rate*/
+				FIX2INT(framesPerBuffer),
+				paCallback,
+				(void*) portaudio);
+	} else {
+		bzero( &outputParameters, sizeof( outputParameters ) );
+		outputParameters.device = foundDevice;
+		outputParameters.channelCount = 2;
+		outputParameters.sampleFormat = paFloat32;
+		outputParameters.suggestedLatency = Pa_GetDeviceInfo(foundDevice)->defaultLowOutputLatency ;
+
+		err = Pa_OpenStream(&portaudio->stream,
+				NULL,
+				&outputParameters,
+				44100,
+				FIX2INT(framesPerBuffer),
+				paNoFlag,
+				paCallback,
+				(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;
+}
+
+float rms(float *v, int n)
+{
+  int i;
+  float sum = 0.0;
+
+  for (i = 0; i < n; i++) {
+    sum += v[i] * v[i];
+  }
+
+  return sqrt(sum / n);
+}
+
+VALUE rb_portaudio_write_from_mpg(VALUE self, VALUE mpg)
+{
+  int err;
+  size_t done = 0;
+  Portaudio *portaudio;
+  mpg123_handle *mh = NULL;
+
+  Data_Get_Struct(self, Portaudio, portaudio);
+  Data_Get_Struct(mpg, mpg123_handle, mh);
+
+  err = mpg123_read(mh, (unsigned char *) portaudio->buffer, portaudio->size * sizeof(float), &done);
+
+  portaudio->rms = rms(portaudio->buffer, portaudio->size);
+
+  switch (err) {
+    case MPG123_OK: return ID2SYM(rb_intern("ok"));
+    case MPG123_DONE: return ID2SYM(rb_intern("done"));
+    case MPG123_NEED_MORE: return ID2SYM(rb_intern("need_more"));
+  }
+
+  rb_raise(rb_eStandardError, "%s", mpg123_plain_strerror(err));
+}
+
+VALUE rb_portaudio_wait(VALUE self)
+{
+  Portaudio *portaudio;
+  Data_Get_Struct(self, Portaudio, portaudio);
+
+#ifdef RUBY_UBF_IO
+  rb_thread_call_without_gvl(portaudio_wait, portaudio, RUBY_UBF_IO, NULL);
+#else
+  portaudio_wait(portaudio);
+#endif
+  return self;
+}
+
+VALUE rb_portaudio_write(VALUE self, VALUE buffer)
+{
+  int i, len;
+  Portaudio *portaudio;
+  Data_Get_Struct(self, Portaudio, portaudio);
+
+  Check_Type(buffer, T_ARRAY);
+
+  len = RARRAY_LEN(buffer);
+
+  if (len != portaudio->size) {
+    rb_raise(rb_eStandardError, "array length does not match buffer size: %d != %d", len, portaudio->size);
+  }
+
+  for (i = 0; i < len; i++) {
+    portaudio->buffer[i] = NUM2DBL(rb_ary_entry(buffer, i));
+  }
+
+  return self;
+}
+
+VALUE rb_portaudio_rms(VALUE self)
+{
+  Portaudio *portaudio;
+  Data_Get_Struct(self, Portaudio, portaudio);
+  return rb_float_new(portaudio->rms);
+}
+
+VALUE rb_portaudio_start(VALUE self)
+{
+  Portaudio *portaudio;
+  Data_Get_Struct(self, Portaudio, portaudio);
+  int err = Pa_StartStream(portaudio->stream);
+
+  pthread_cond_broadcast(&portaudio->cond);
+
+  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);
+
+  pthread_cond_broadcast(&portaudio->cond);
+
+  if (err != paNoError) {
+    rb_raise(rb_eStandardError, "%s", Pa_GetErrorText(err));
+  }
+
+  return self;
+}
+
+VALUE rb_portaudio_stream_stopped(VALUE self)
+{
+  Portaudio *portaudio;
+  Data_Get_Struct(self, Portaudio, portaudio);
+  int err = Pa_IsStreamStopped(portaudio->stream);
+
+  if (err == 1) {
+    return Qtrue;
+  } else if (err == 0) {
+    return Qfalse;
+  }
+
+  rb_raise(rb_eStandardError, "%s", Pa_GetErrorText(err));
+}
+
+VALUE rb_portaudio_close(VALUE self)
+{
+  Portaudio *portaudio;
+  Data_Get_Struct(self, Portaudio, portaudio);
+  int err = Pa_CloseStream(portaudio->stream);
+
+  pthread_cond_broadcast(&portaudio->cond);
+
+  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, 2);
+  rb_define_method(rb_cPortaudio, "wait", rb_portaudio_wait, 0);
+  rb_define_method(rb_cPortaudio, "stopped?", rb_portaudio_stream_stopped, 0);
+  rb_define_method(rb_cPortaudio, "close", rb_portaudio_close, 0);
+  rb_define_method(rb_cPortaudio, "rms", rb_portaudio_rms, 0);
+  rb_define_method(rb_cPortaudio, "write", rb_portaudio_write, 1);
+  rb_define_method(rb_cPortaudio, "write_from_mpg", rb_portaudio_write_from_mpg, 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,188 @@
+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, :active, :stream, :mp3, :thread, :file, :song_list
+
+  def initialize(buffer_size = 2**12, device_name = '')
+    @buffer_size = buffer_size
+    @device_name = device_name
+    @events = Events.new
+    @stream = Portaudio.new(@buffer_size, @device_name)
+    @song_list = []
+  end
+
+  def start_thread
+    @thread ||= Thread.start do
+      loop do
+        process @stream.write_from_mpg(@mp3)
+        @stream.wait
+      end
+    end
+  end
+
+  def level
+    @stream.rms
+  end
+
+  def process(status)
+    if [:done, :need_more].include? status
+      request_next_song
+      events.trigger(:complete)
+    else
+      events.trigger(:position_change, position)
+    end
+
+  rescue => e
+    $stderr.puts e.message
+    $stderr.puts e.backtrace
+  end
+
+  def current_song_name
+    File.basename mp3.file
+  end
+
+  def request_next_song
+    if songs_in_queue?
+      set_current_song
+      start_stream
+    else
+      stop_stream
+    end
+  end
+
+  def close
+    stream.close
+    exit
+  end
+
+  def start_stream
+    unless @active || !song_loaded?
+      @active = true
+      @stream.start
+      start_thread
+      events.trigger(:toggle, @active)
+    end
+  end
+
+  def stop_stream
+    if @active
+      @active = false
+      @thread = nil unless @thread.alive?
+      unless @stream.stopped?
+        @stream.stop
+        events.trigger(:toggle, @active)
+      end
+    end
+  end
+
+  def toggle
+    if @active
+      stop_stream
+    else
+      start_stream
+    end
+  end
+
+  def load(files)
+    files = [] << files unless Array === files
+    files.each {|file| queue file }
+    set_current_song
+  end
+
+  def song_loaded?
+    !@mp3.nil?
+  end
+
+  def set_current_song
+    @mp3 = song_list.shift
+    start_thread
+  end
+
+  def queue song
+    @song_list << Mpg123.new(song)
+  end
+
+  def queued_songs
+    @song_list.map {|s| File.basename s.file }
+  end
+
+  def songs_in_queue?
+    !@song_list.empty?
+  end
+
+  def time_per_frame
+    @mp3.tpf
+  end
+
+  def samples_per_frame
+    @mp3.spf
+  end
+
+  def tell
+    @mp3 ? @mp3.tell : 0
+  end
+
+  def length
+    @mp3 ? @mp3.length : 0
+  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)
+    if @mp3
+      samples = seconds_to_samples(seconds)
+
+      if (0..length).include?(samples)
+        @mp3.seek(samples)
+        events.trigger(:position_change, position)
+      end
+    end
+  end
+
+  def position
+    samples_to_seconds(tell)
+  end
+
+  def length_in_seconds
+    samples_to_seconds(length)
+  end
+
+  def rewind(seconds = 2)
+    seek(position - seconds)
+  end
+
+  def forward(seconds = 2)
+    seek(position + seconds)
+  end
+end

data/spec/audite_spec.rb

@@ -0,0 +1,14 @@
+require 'audite'
+
+describe Audite do
+  it "loads and reports on an mp3" do
+    player = Audite.new
+    player.load(File.dirname(__FILE__)+'/30sec.mp3')
+    player.length.should eq(1326351)
+    player.length_in_seconds.should eq(30.075986394557827)
+  end
+  it "generates an error on a non-existant mp3" do
+    player = Audite.new
+    expect {player.load('/tmp/file.mp3')}.to raise_error
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: audite-lib
+version: !ruby/object:Gem::Version
+  version: 0.4.1
+platform: ruby
+authors:
+- Matthias Georgi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Portable mp3 player built on mpg123 and portaudio
+email: matti.georgi@gmail.com
+executables: []
+extensions:
+- ext/mpg123/extconf.rb
+- ext/portaudio/extconf.rb
+extra_rdoc_files:
+- README.md
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- audite.gemspec
+- ext/mpg123/extconf.rb
+- ext/mpg123/mpg123.c
+- ext/portaudio/extconf.rb
+- ext/portaudio/portaudio.c
+- lib/audite.rb
+- spec/30sec.mp3
+- spec/audite_spec.rb
+homepage: http://georgi.github.com/audite
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Portable mp3 player
+test_files: []