pocketsphinx-ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b67faaa7d60b0ff377d160f8fd88a28ebcc1eaa4
+  data.tar.gz: 163809adeed0af96f876f10bb2b2e93b4ebc8ba6
+SHA512:
+  metadata.gz: f7e109bae75aadd7a1ea053fb21cfd099e95c8e7476c08ea0d45d01991d84a93713e346e63d415e14981353f557d6c78fd11177cac726f1145ecbd1b80567f9f
+  data.tar.gz: a5b0af62adb929f617239f651d6929eb88b55861e5318970f14e46eaf81b49433fb1492bcfe2d176ea53f982843c3cd674d5cd7e63155ebe788618c0cbaa397b

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.DS_Store
+log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,25 @@
+language: ruby
+rvm:
+  - 2.1.2
+  - 2.0.0
+  - 1.9.3
+  - rbx-2.2.9
+  - jruby-1.7.16
+before_install:
+  - sudo apt-get update -qq
+  - sudo apt-get install -y swig
+  - git clone https://github.com/cmusphinx/sphinxbase.git
+  - cd sphinxbase
+  - ./autogen.sh
+  - ./configure
+  - make
+  - sudo make install
+  - cd ..
+  - git clone https://github.com/cmusphinx/pocketsphinx.git
+  - cd pocketsphinx
+  - ./autogen.sh
+  - ./configure
+  - make
+  - sudo make install
+  - cd ..
+  - sudo ldconfig

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Howard Wilson
+
+MIT License
+
+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,96 @@
+# pocketsphinx-ruby
+
+[![Build Status](http://img.shields.io/travis/watsonbox/pocketsphinx-ruby.svg?style=flat)](https://travis-ci.org/watsonbox/pocketsphinx-ruby)
+[![Code Climate](http://img.shields.io/codeclimate/github/watsonbox/pocketsphinx-ruby/badges/gpa.svg?style=flat)](https://codeclimate.com/github/watsonbox/pocketsphinx-ruby)
+[![Coverage Status](https://img.shields.io/coveralls/watsonbox/pocketsphinx-ruby.svg?style=flat)](https://coveralls.io/r/watsonbox/pocketsphinx-ruby)
+
+This gem provides Ruby [FFI](https://github.com/ffi/ffi) bindings for [Pocketsphinx](https://github.com/cmusphinx/pocketsphinx), a lightweight speech recognition engine, specifically tuned for handheld and mobile devices, though it works equally well on the desktop. Pocketsphinx is part of the [CMU Sphinx](http://cmusphinx.sourceforge.net/) Open Source Toolkit For Speech Recognition.
+
+I had initially looked at using Pocketsphinx's [SWIG](http://www.swig.org/) interface for this gem, but decided in favor of FFI for many of the reasons outlined [here](https://github.com/ffi/ffi/wiki/Why-use-FFI), but most importantly ease of maintenance and JRuby support.
+
+The goal of this project is to make it as easy as possible for the Ruby community to experiment with speech recognition. Please do contribute fixes and enhancements.
+
+
+## Installation
+
+This gem depends on [Pocketsphinx](https://github.com/cmusphinx/pocketsphinx) (libpocketsphinx), and [Sphinxbase](https://github.com/cmusphinx/sphinxbase) (libsphinxbase and libsphinxad). The current stable versions (0.8) are from late 2012 and are now outdated. Build them manually from source, or on OSX the latest development (potentially unstable) versions can be installed using [Homebrew](http://brew.sh/) as follows ([more information here](https://github.com/watsonbox/homebrew-cmu-sphinx)).
+
+Add the Homebrew tap:
+
+```bash
+$ brew tap watsonbox/cmu-sphinx
+```
+
+You'll see some warnings as these formulae conflict with those in the main reponitory, but that's fine.
+
+Install the libraries:
+
+```bash
+$ brew install --HEAD watsonbox/cmu-sphinx/cmu-sphinxbase
+$ brew install --HEAD watsonbox/cmu-sphinx/cmu-sphinxtrain # optional
+$ brew install --HEAD watsonbox/cmu-sphinx/cmu-pocketsphinx
+```
+
+You can test continuous recognition as follows:
+
+```bash
+$ pocketsphinx_continuous -inmic yes
+```
+
+Then add this line to your application's Gemfile:
+
+    gem 'pocketsphinx-ruby'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pocketsphinx-ruby
+
+
+## Basic Usage
+
+The `LiveSpeechRecognizer` is modeled on the same class in [Sphinx4](http://cmusphinx.sourceforge.net/wiki/tutorialsphinx4). It uses the `Microphone` and `Decoder` classes internally to provide a simple, high-level recognition interface:
+
+```ruby
+require 'pocketsphinx-ruby'
+
+Pocketsphinx::LiveSpeechRecognizer.new.recognize do |speech|
+  puts speech
+end
+```
+
+
+## Microphone
+
+The `Microphone` class uses Pocketsphinx's libsphinxad to record audio for speech recognition. For desktop applications this should normally be 16bit/16kHz raw PCM audio, so these are the default settings. The exact audio backend depends on [what was selected](https://github.com/cmusphinx/sphinxbase/blob/master/configure.in#L138) when libsphinxad was built. On OSX, OpenAL is [now supported](https://github.com/cmusphinx/sphinxbase/commit/5cc55c4721273681200e1f754ff0798ac073b950) and should work just fine.
+
+For example, to record and save a 5 second raw audio file:
+
+```ruby
+microphone = Microphone.new
+
+File.open("test.raw", "wb") do |file|
+  microphone.record do
+    FFI::MemoryPointer.new(:int16, 4096) do |buffer|
+      50.times do
+        sample_count = microphone.read_audio(buffer, 4096)
+        file.write buffer.get_bytes(0, sample_count * 2)
+
+        sleep 0.1
+      end
+    end
+  end
+end
+```
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/pocketsphinx-ruby/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/clean'
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+  task :default => [:spec]
+rescue LoadError
+end

data/examples/pocketsphinx_continuous.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pocketsphinx-ruby"
+
+include Pocketsphinx
+
+configuration = Configuration.default
+recognizer = LiveSpeechRecognizer.new(configuration)
+
+recognizer.recognize do |speech|
+  puts speech
+end

data/examples/record_audio_file.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pocketsphinx-ruby"
+
+include Pocketsphinx
+
+MAX_SAMPLES = 4096
+RECORDING_INTERVAL = 0.1
+RECORDING_LENGTH = 5
+
+puts "Recording #{RECORDING_LENGTH} seconds of audio..."
+
+microphone = Microphone.new
+
+File.open("test_write.raw", "wb") do |file|
+  microphone.record do
+    FFI::MemoryPointer.new(:int16, MAX_SAMPLES) do |buffer|
+      (RECORDING_LENGTH / RECORDING_INTERVAL).times do
+        sample_count = microphone.read_audio(buffer, MAX_SAMPLES)
+
+        # sample_count * 2 since this is length in bytes
+        file.write buffer.get_bytes(0, sample_count * 2)
+
+        sleep RECORDING_INTERVAL
+      end
+    end
+  end
+end

data/lib/pocketsphinx-ruby.rb

@@ -0,0 +1 @@
+require 'pocketsphinx'

data/lib/pocketsphinx.rb

@@ -0,0 +1,16 @@
+require 'ffi'
+
+require "pocketsphinx/version"
+require "pocketsphinx/api/sphinxbase"
+require "pocketsphinx/api/sphinxad"
+require "pocketsphinx/api/pocketsphinx"
+
+require "pocketsphinx/configuration"
+require "pocketsphinx/microphone"
+require "pocketsphinx/decoder"
+require "pocketsphinx/speech_recognizer"
+require "pocketsphinx/live_speech_recognizer"
+
+module Pocketsphinx
+
+end

data/lib/pocketsphinx/api/pocketsphinx.rb

@@ -0,0 +1,17 @@
+module Pocketsphinx
+  module API
+    module Pocketsphinx
+      extend FFI::Library
+      ffi_lib "libpocketsphinx"
+
+      attach_function :ps_init, [:pointer], :pointer
+      attach_function :ps_default_search_args, [:pointer], :void
+      attach_function :ps_args, [], :pointer
+      attach_function :ps_process_raw, [:pointer, :pointer, :size_t, :int, :int], :int
+      attach_function :ps_start_utt, [:pointer, :string], :int
+      attach_function :ps_end_utt, [:pointer], :int
+      attach_function :ps_get_in_speech, [:pointer], :uint8
+      attach_function :ps_get_hyp, [:pointer, :pointer, :pointer], :string
+    end
+  end
+end

data/lib/pocketsphinx/api/sphinxad.rb

@@ -0,0 +1,14 @@
+module Pocketsphinx
+  module API
+    module SphinxAD
+      extend FFI::Library
+      ffi_lib "libsphinxad"
+
+      attach_function :ad_open_dev, [:string, :int], :pointer
+      attach_function :ad_start_rec, [:pointer], :int32
+      attach_function :ad_stop_rec, [:pointer], :int32
+      attach_function :ad_read, [:pointer, :pointer, :int], :int
+      attach_function :ad_close, [:pointer], :void
+    end
+  end
+end

data/lib/pocketsphinx/api/sphinxbase.rb

@@ -0,0 +1,26 @@
+module Pocketsphinx
+  module API
+    module Sphinxbase
+      extend FFI::Library
+      ffi_lib "libsphinxbase"
+
+      class Argument < FFI::Struct
+        layout :name, :string,
+          :type, :int,
+          :deflt, :string,
+          :doc, :string
+      end
+
+      # TODO: Document on ruby side?
+      attach_function :cmd_ln_parse_r, [:pointer, :pointer, :int32, :pointer, :int], :pointer
+      attach_function :cmd_ln_float_r, [:pointer, :string], :double
+      attach_function :cmd_ln_set_float_r, [:pointer, :string, :double], :void
+      attach_function :cmd_ln_int_r, [:pointer, :string], :int
+      attach_function :cmd_ln_set_int_r, [:pointer, :string, :int], :void
+      attach_function :cmd_ln_str_r, [:pointer, :string], :string
+      attach_function :cmd_ln_set_str_r, [:pointer, :string, :string], :void
+      attach_function :err_set_debug_level, [:int], :int
+      attach_function :err_set_logfile, [:string], :int
+    end
+  end
+end

data/lib/pocketsphinx/configuration.rb

@@ -0,0 +1,65 @@
+require 'pocketsphinx/configuration/setting_definition'
+
+module Pocketsphinx
+  class Configuration
+    attr_reader :ps_config
+
+    private_class_method :new
+
+    def initialize(ps_arg_defs)
+      @ps_arg_defs = ps_arg_defs
+      @setting_definitions = SettingDefinition.from_arg_defs(ps_arg_defs)
+
+      # Sets default settings based on definitions
+      @ps_config = API::Sphinxbase.cmd_ln_parse_r(nil, ps_arg_defs, 0, nil, 1)
+
+      # Sets default grammar and language model if they are not set explicitly and
+      # are present in the default search path.
+      API::Pocketsphinx.ps_default_search_args(@ps_config)
+    end
+
+    def self.default
+      new(API::Pocketsphinx.ps_args)
+    end
+
+    def [](name)
+      unless definition = @setting_definitions[name]
+        raise "Configuration setting '#{name}' does not exist"
+      end
+
+      case definition.type
+      when :integer
+        API::Sphinxbase.cmd_ln_int_r(@ps_config, "-#{name}")
+      when :float
+        API::Sphinxbase.cmd_ln_float_r(@ps_config, "-#{name}")
+      when :string
+        API::Sphinxbase.cmd_ln_str_r(@ps_config, "-#{name}")
+      when :boolean
+        API::Sphinxbase.cmd_ln_int_r(@ps_config, "-#{name}") != 0
+      when :string_list
+        raise NotImplementedException
+      end
+    end
+
+    def []=(name, value)
+      unless definition = @setting_definitions[name]
+        raise "Configuration setting '#{name}' does not exist"
+      end
+
+      case definition.type
+      when :integer
+        raise "Configuration setting '#{name}' must be a Fixnum" unless value.respond_to?(:to_i)
+        API::Sphinxbase.cmd_ln_set_int_r(@ps_config, "-#{name}", value.to_i)
+      when :float
+        raise "Configuration setting '#{name}' must be a Float" unless value.respond_to?(:to_i)
+        API::Sphinxbase.cmd_ln_set_float_r(@ps_config, "-#{name}", value.to_f)
+      when :string
+        API::Sphinxbase.cmd_ln_set_str_r(@ps_config, "-#{name}", value.to_s)
+      when :boolean
+        API::Sphinxbase.cmd_ln_set_int_r(@ps_config, "-#{name}", value ? 1 : 0)
+      when :string_list
+        raise NotImplementedException
+      end
+    end
+  end
+end

data/lib/pocketsphinx/configuration/setting_definition.rb

@@ -0,0 +1,40 @@
+module Pocketsphinx
+  class Configuration
+    class SettingDefinition
+      TYPES = [:integer, :float, :string, :boolean, :string_list]
+
+      def initialize(name, type_code, default, doc)
+        @name, @type_code, @default, @doc = name, type_code, default, doc
+      end
+
+      def type
+        # Remove the required bit if it exists and find type from log2 of code
+        TYPES[Math.log2(@type_code - @type_code%2) - 1]
+      end
+
+      def required?
+        @type_code % 2 == 1
+      end
+
+      # Build setting definitions from pocketsphinx argument definitions
+      #
+      # @param [FFI::Pointer] ps_arg_defs A pointer to the Pocketsphinx argument definitions
+      #
+      # @return [Hash] A hash of setting definitions (name -> definition)
+      def self.from_arg_defs(ps_arg_defs)
+        {}.tap do |setting_defs|
+          arg_array = FFI::Pointer.new(API::Sphinxbase::Argument, ps_arg_defs)
+
+          0.upto(Float::INFINITY) do |i|
+            arg = API::Sphinxbase::Argument.new(arg_array[i])
+            break if arg[:name].nil?
+
+            # Remove '-' from argument name
+            name = arg[:name][1..-1]
+            setting_defs[name] = new(name, arg[:type], arg[:deflt], arg[:doc])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pocketsphinx/decoder.rb

@@ -0,0 +1,64 @@
+module Pocketsphinx
+  class Decoder
+    Error = Class.new(StandardError)
+
+    attr_reader :ps_decoder
+    attr_writer :ps_api
+
+    def initialize(configuration)
+      @configuration = configuration
+      @ps_decoder = ps_api.ps_init(configuration.ps_config)
+    end
+
+    # Decode raw audio data.
+    #
+    # @param [Boolean] no_search If non-zero, perform feature extraction but don't do any
+    #   recognition yet.  This may be necessary if your processor has trouble doing recognition in
+    #   real-time.
+    # @param [Boolean] full_utt If non-zero, this block of data is a full utterance
+    #   worth of data.  This may allow the recognizer to produce more accurate results.
+    # @return Number of frames of data searched
+    def process_raw(buffer, size, no_search = false, full_utt = false)
+      ps_api.ps_process_raw(@ps_decoder, buffer, size, no_search ? 1 : 0, full_utt ? 1 : 0).tap do |result|
+        raise Error, "Decoder#process_raw failed with error code #{result}" if result < 0
+      end
+    end
+
+    # Start utterance processing.
+    #
+    # This function should be called before any utterance data is passed
+    # to the decoder.  It marks the start of a new utterance and
+    # reinitializes internal data structures.
+    #
+    # @param [String] name String uniquely identifying this utterance. If nil, one will be created.
+    def start_utterance(name = nil)
+      ps_api.ps_start_utt(@ps_decoder, name).tap do |result|
+        raise Error, "Decoder#start_utterance failed with error code #{result}" if result < 0
+      end
+    end
+
+    # End utterance processing
+    def end_utterance
+      ps_api.ps_end_utt(@ps_decoder).tap do |result|
+        raise Error, "Decoder#end_utterance failed with error code #{result}" if result < 0
+      end
+    end
+
+    # Checks if the last feed audio buffer contained speech
+    def in_speech?
+      ps_api.ps_get_in_speech(@ps_decoder) != 0
+    end
+
+    # Get hypothesis string and path score.
+    #
+    # @return [String] Hypothesis string
+    # @todo Expand to return path score and utterance ID
+    def hypothesis
+      ps_api.ps_get_hyp(@ps_decoder, nil, nil)
+    end
+
+    def ps_api
+      @ps_api || API::Pocketsphinx
+    end
+  end
+end

data/lib/pocketsphinx/live_speech_recognizer.rb

@@ -0,0 +1,48 @@
+module Pocketsphinx
+  # High-level class for live speech recognition.
+  #
+  # Modeled on the LiveSpeechRecognizer from Sphinx4.
+  class LiveSpeechRecognizer < SpeechRecognizer
+    attr_writer :microphone
+
+    def microphone
+      @microphone ||= Microphone.new
+    end
+
+    # Recognize utterances and yield hypotheses in infinite loop
+    #
+    # @param [Float]
+    def recognize(recording_interval = 0.1, max_samples = 4096)
+      decoder.start_utterance
+
+      microphone.record do
+        FFI::MemoryPointer.new(:int16, max_samples) do |buffer|
+          loop do
+            if decoder.in_speech?
+              process_audio(buffer, max_samples, recording_interval) while decoder.in_speech?
+              yield get_hypothesis
+            else
+              process_audio(buffer, max_samples, recording_interval)
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def process_audio(buffer, max_samples, delay)
+      sample_count = microphone.read_audio(buffer, max_samples)
+      decoder.process_raw(buffer, sample_count)
+      sleep delay
+    end
+
+    # Called on speech -> silence transition
+    def get_hypothesis
+      decoder.end_utterance
+      decoder.hypothesis.tap do
+        decoder.start_utterance
+      end
+    end
+  end
+end

data/lib/pocketsphinx/microphone.rb

@@ -0,0 +1,65 @@
+module Pocketsphinx
+  # Provides non-blocking audio recording using libsphinxad
+  class Microphone
+    Error = Class.new(StandardError)
+
+    attr_reader :ps_audio_device
+    attr_writer :ps_api
+
+    # Opens an audio device for recording
+    #
+    # The device is opened in non-blocking mode and placed in idle state.
+    #
+    # @param [Fixnum] sample_rate Samples per second for recording, e.g. 16000 for 16kHz
+    # @param [String] default_device The device name
+    # @param [Object] ps_api A SphinxAD API implementation to use, API::SphinxAD if not provided
+    def initialize(sample_rate = 16000, default_device = nil, ps_api = nil)
+      @ps_api = ps_api
+      @ps_audio_device = ps_api.ad_open_dev(default_device, sample_rate)
+
+      # Ensure that audio device is closed when object is garbage collected
+      ObjectSpace.define_finalizer(self, self.class.finalize(ps_api, @ps_audio_device))
+    end
+
+    def self.finalize(ps_api, ps_audio_device)
+      proc { ps_api.ad_close(ps_audio_device) }
+    end
+
+    def record
+      start_recording
+      yield
+      stop_recording
+    end
+
+    def start_recording
+      ps_api.ad_start_rec(@ps_audio_device).tap do |result|
+        raise Error, "Microphone#start_recording failed with error code #{result}" if result < 0
+      end
+    end
+
+    def stop_recording
+      ps_api.ad_stop_rec(@ps_audio_device).tap do |result|
+        raise Error, "Microphone#stop_recording failed with error code #{result}" if result < 0
+      end
+    end
+
+    # Read next block of audio samples while recording; read upto max samples into buf.
+    #
+    # @param [FFI::Pointer] buffer 16bit buffer of at least max_samples in size
+    # @return [Fixnum] Samples actually read (could be 0 since non-blocking); -1 if not
+    #   recording and no more samples remaining to be read from most recent recording.
+    def read_audio(buffer, max_samples = 4096)
+      ps_api.ad_read(@ps_audio_device, buffer, max_samples)
+    end
+
+    def close_device
+      ps_api.ad_close(@ps_audio_device).tap do |result|
+        raise Error, "Microphone#close_device failed with error code #{result}" if result < 0
+      end
+    end
+
+    def ps_api
+      @ps_api || API::SphinxAD
+    end
+  end
+end

data/lib/pocketsphinx/speech_recognizer.rb

@@ -0,0 +1,9 @@
+module Pocketsphinx
+  class SpeechRecognizer
+    attr_reader :decoder
+
+    def initialize(configuration= nil)
+      @decoder = Decoder.new(configuration || Configuration.default)
+    end
+  end
+end

data/lib/pocketsphinx/version.rb

@@ -0,0 +1,3 @@
+module Pocketsphinx
+  VERSION = "0.0.1"
+end

data/pocketsphinx-ruby.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pocketsphinx/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pocketsphinx-ruby"
+  spec.version       = Pocketsphinx::VERSION
+  spec.authors       = ["Howard Wilson"]
+  spec.email         = ["howard@watsonbox.net"]
+  spec.summary       = %q{Ruby FFI pocketsphinx bindings}
+  spec.description   = %q{Ruby FFI pocketsphinx bindings}
+  spec.homepage      = "https://github.com/watsonbox/pocketsphinx-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "ffi", ">= 1.9"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.1.0"
+  spec.add_development_dependency "coveralls"
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Configuration do
+  subject { Pocketsphinx::Configuration.default }
+
+  it "provides a default pocketsphinx configuration" do
+    expect(subject).to be_a(Pocketsphinx::Configuration)
+  end
+
+  it "supports integer settings" do
+    expect(subject['frate']).to eq(100)
+    expect(subject['frate']).to be_a(Fixnum)
+
+    subject['frate'] = 50
+    expect(subject['frate']).to eq(50)
+  end
+
+  it "supports float settings" do
+    expect(subject['samprate']).to eq(16000)
+    expect(subject['samprate']).to be_a(Float)
+
+    subject['samprate'] = 8000
+    expect(subject['samprate']).to eq(8000)
+  end
+
+  it "supports getting strings" do
+    expect(subject['warp_type']).to eq('inverse_linear')
+
+    subject['warp_type'] = 'different_type'
+    expect(subject['warp_type']).to eq('different_type')
+  end
+
+  it "supports getting booleans" do
+    expect(subject['smoothspec']).to eq(false)
+
+    subject['smoothspec'] = true
+    expect(subject['smoothspec']).to eq(true)
+  end
+
+  it 'raises exceptions when setting with incorrectly typed values' do
+    expect { subject['frate'] = true }.to raise_exception "Configuration setting 'frate' must be a Fixnum"
+  end
+
+  it 'raises exceptions when a setting is unknown' do
+    expect { subject['unknown'] = true }.to raise_exception "Configuration setting 'unknown' does not exist"
+  end
+end

data/spec/decoder_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Decoder do
+  subject { @decoder }
+  let(:ps_api) { @decoder.ps_api = double }
+
+  # Share decoder across all examples for speed
+  before :all do
+    @decoder = Decoder.new(Configuration.default)
+  end
+
+  describe '#process_raw' do
+    it 'calls libpocketsphinx' do
+      FFI::MemoryPointer.new(:int16, 4096) do |buffer|
+        expect(ps_api)
+          .to receive(:ps_process_raw)
+          .with(subject.ps_decoder, buffer, 4096, 0, 0)
+          .and_return(0)
+
+        subject.process_raw(buffer, 4096, false, false)
+      end
+    end
+
+    it 'raises an exception on error' do
+      FFI::MemoryPointer.new(:int16, 4096) do |buffer|
+        expect(ps_api)
+          .to receive(:ps_process_raw)
+          .with(subject.ps_decoder, buffer, 4096, 0, 0)
+          .and_return(-1)
+
+        expect { subject.process_raw(buffer, 4096, false, false) }
+          .to raise_exception "Decoder#process_raw failed with error code -1"
+      end
+    end
+  end
+
+  describe '#start_utterance' do
+    it 'calls libpocketsphinx' do
+      expect(ps_api)
+        .to receive(:ps_start_utt)
+        .with(subject.ps_decoder, "Utterance Name")
+        .and_return(0)
+
+      subject.start_utterance("Utterance Name")
+    end
+
+    it 'raises an exception on error' do
+      expect(ps_api)
+        .to receive(:ps_start_utt)
+        .with(subject.ps_decoder, "Utterance Name")
+        .and_return(-1)
+
+      expect { subject.start_utterance("Utterance Name") }
+        .to raise_exception "Decoder#start_utterance failed with error code -1"
+    end
+  end
+
+  describe '#end_utterance' do
+    it 'calls libpocketsphinx' do
+      expect(ps_api)
+        .to receive(:ps_end_utt)
+        .with(subject.ps_decoder)
+        .and_return(0)
+
+      subject.end_utterance
+    end
+
+    it 'raises an exception on error' do
+      expect(ps_api)
+        .to receive(:ps_end_utt)
+        .with(subject.ps_decoder)
+        .and_return(-1)
+
+      expect { subject.end_utterance }
+        .to raise_exception "Decoder#end_utterance failed with error code -1"
+    end
+  end
+
+  describe '#in_speech' do
+    it 'calls libpocketsphinx' do
+      expect(ps_api)
+        .to receive(:ps_get_in_speech)
+        .with(subject.ps_decoder)
+        .and_return(0)
+
+      expect(subject.in_speech?).to eq(false)
+    end
+  end
+
+  describe '#hypothesis' do
+    it 'calls libpocketsphinx' do
+      expect(ps_api)
+        .to receive(:ps_get_hyp)
+        .with(subject.ps_decoder, nil, nil)
+        .and_return("Hypothesis")
+
+      expect(subject.hypothesis).to eq("Hypothesis")
+    end
+  end
+end

data/spec/microphone_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Microphone do
+  module DummyAPI
+    def self.ad_open_dev(default_device, sample_rate)
+      :audio_device
+    end
+  end
+
+  subject { @microphone }
+  let!(:ps_api) { @microphone.ps_api = double }
+
+  # Share microphone across all examples for speed
+  before :all do
+    # Don't open an audio device as there isn't one on Travis CI
+    @microphone = Microphone.new(16000, nil, DummyAPI)
+  end
+
+  describe '#start_recording' do
+    it 'calls libsphinxad' do
+      expect(ps_api)
+        .to receive(:ad_start_rec)
+        .with(subject.ps_audio_device)
+        .and_return(0)
+
+      subject.start_recording
+    end
+
+    it 'raises an exception on error' do
+      expect(ps_api)
+        .to receive(:ad_start_rec)
+        .with(subject.ps_audio_device)
+        .and_return(-1)
+
+      expect { subject.start_recording }
+        .to raise_exception "Microphone#start_recording failed with error code -1"
+    end
+  end
+
+  describe '#stop_recording' do
+    it 'calls libsphinxad' do
+      expect(ps_api)
+        .to receive(:ad_stop_rec)
+        .with(subject.ps_audio_device)
+        .and_return(0)
+
+      subject.stop_recording
+    end
+
+    it 'raises an exception on error' do
+      expect(ps_api)
+        .to receive(:ad_stop_rec)
+        .with(subject.ps_audio_device)
+        .and_return(-1)
+
+      expect { subject.stop_recording }
+        .to raise_exception "Microphone#stop_recording failed with error code -1"
+    end
+  end
+
+  describe '#record' do
+    it 'starts and stops recording, yielding control' do
+      expect(subject).to receive(:start_recording).ordered
+
+      subject.record do
+        expect(subject).to receive(:stop_recording).ordered
+      end
+    end
+  end
+
+  describe '#read_audio' do
+    it 'calls libsphinxad' do
+      expect(ps_api)
+        .to receive(:ad_read)
+        .with(subject.ps_audio_device, :buffer, 4096)
+        .and_return(0)
+
+      subject.read_audio(:buffer, 4096)
+    end
+  end
+
+  describe '#close_device' do
+    it 'calls libsphinxad' do
+      expect(ps_api)
+        .to receive(:ad_close)
+        .with(subject.ps_audio_device)
+        .and_return(0)
+
+      subject.close_device
+    end
+
+    it 'raises an exception on error' do
+      expect(ps_api)
+        .to receive(:ad_close)
+        .with(subject.ps_audio_device)
+        .and_return(-1)
+
+      expect { subject.close_device }
+        .to raise_exception "Microphone#close_device failed with error code -1"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'pocketsphinx'
+
+POCKETSPHINX_LOG_FILE = "./log/pocketsphinx_test.log"
+
+# Set up pocketsphinx logging to a file rather than stdout
+FileUtils.makedirs File.dirname(POCKETSPHINX_LOG_FILE)
+FileUtils.touch POCKETSPHINX_LOG_FILE
+Pocketsphinx::API::Sphinxbase.err_set_logfile POCKETSPHINX_LOG_FILE
+
+RSpec.configure do |config|
+  include Pocketsphinx
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: pocketsphinx-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Howard Wilson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  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: Ruby FFI pocketsphinx bindings
+email:
+- howard@watsonbox.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/pocketsphinx_continuous.rb
+- examples/record_audio_file.rb
+- lib/pocketsphinx-ruby.rb
+- lib/pocketsphinx.rb
+- lib/pocketsphinx/api/pocketsphinx.rb
+- lib/pocketsphinx/api/sphinxad.rb
+- lib/pocketsphinx/api/sphinxbase.rb
+- lib/pocketsphinx/configuration.rb
+- lib/pocketsphinx/configuration/setting_definition.rb
+- lib/pocketsphinx/decoder.rb
+- lib/pocketsphinx/live_speech_recognizer.rb
+- lib/pocketsphinx/microphone.rb
+- lib/pocketsphinx/speech_recognizer.rb
+- lib/pocketsphinx/version.rb
+- pocketsphinx-ruby.gemspec
+- spec/configuration_spec.rb
+- spec/decoder_spec.rb
+- spec/microphone_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/watsonbox/pocketsphinx-ruby
+licenses:
+- MIT
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby FFI pocketsphinx bindings
+test_files:
+- spec/configuration_spec.rb
+- spec/decoder_spec.rb
+- spec/microphone_spec.rb
+- spec/spec_helper.rb