pocketsphinx-ruby 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b67faaa7d60b0ff377d160f8fd88a28ebcc1eaa4
-  data.tar.gz: 163809adeed0af96f876f10bb2b2e93b4ebc8ba6
+  metadata.gz: 440699d34e0585b3670bd4bfa91e6e9a87b2331f
+  data.tar.gz: 8a697fa2d7e491e4eccfb47fe678a6acfcf695a7
 SHA512:
-  metadata.gz: f7e109bae75aadd7a1ea053fb21cfd099e95c8e7476c08ea0d45d01991d84a93713e346e63d415e14981353f557d6c78fd11177cac726f1145ecbd1b80567f9f
-  data.tar.gz: a5b0af62adb929f617239f651d6929eb88b55861e5318970f14e46eaf81b49433fb1492bcfe2d176ea53f982843c3cd674d5cd7e63155ebe788618c0cbaa397b
+  metadata.gz: 7d913ab82f397056b9b90bb5f7d4fb6609a618a367a361c3936afd4e850caf908614bb16a174cae26160241cc8424eb7abae4404595b1d27e6a90bc0e431f2cf
+  data.tar.gz: ab6b8b36f3b9ef07f0086cca1e28b49b146116b15a3acf7e06f0fc80d50fc133a2653e05f437344c2f8532284c4e8fa8205151bca3de379f4a4f354048accdf5

data/README.md

@@ -6,7 +6,7 @@
 
 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.
+Pocketsphinx's [SWIG](http://www.swig.org/) interface was initially considered for this gem, but dropped in favor of FFI for many of the reasons outlined [here](https://github.com/ffi/ffi/wiki/Why-use-FFI); 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.
 
@@ -62,6 +62,41 @@ Pocketsphinx::LiveSpeechRecognizer.new.recognize do |speech|
 end
 ```
 
+The `AudioFileSpeechRecognizer` decodes directly from an audio file by coordinating interactions between an `AudioFile` and `Decoder`.
+
+```ruby
+recognizer = Pocketsphinx::AudioFileSpeechRecognizer.new
+
+recognizer.recognize('spec/assets/audio/goforward.raw') do |speech|
+  puts speech # => "go forward ten years"
+end
+```
+
+These two classes split speech into utterances by detecting silence between them. By default this uses Pocketsphinx's internal Voice Activity Detection (VAD) which can be configured by adjusting the `vad_postspeech`, `vad_prespeech`, and `vad_threshold` configuration settings.
+
+
+## Configuration
+
+All of Pocketsphinx's decoding settings are managed by the `Configuration` class, which can be passed into the high-level speech recognizers:
+
+```ruby
+configuration = Pocketsphinx::Configuration.default
+configuration.details('vad_threshold')
+# => {
+#   :name => "vad_threshold",
+#   :type => :float,
+#   :default => 2.0,
+#   :value => 2.0,
+#   :info => "Threshold for decision between noise and silence frames. Log-ratio between signal level and noise level."
+# }
+
+configuration['vad_threshold'] = 4
+
+Pocketsphinx::LiveSpeechRecognizer.new(configuration)
+```
+
+You can find the output of `configuration.details` [here](https://github.com/watsonbox/pocketsphinx-ruby/wiki/Default-Pocketsphinx-Configuration) for more information on the various different settings.
+
 
 ## Microphone
 
@@ -86,6 +121,20 @@ File.open("test.raw", "wb") do |file|
 end
 ```
 
+To open this audio file take a look at [this wiki page](https://github.com/watsonbox/pocketsphinx-ruby/wiki/Importing-raw-PCM-audio-with-Audacity).
+
+
+## Decoder
+
+The `Decoder` class uses Pocketsphinx's libpocketsphinx to decode audio data into text. For example to decode a single utterance:
+
+```ruby
+decoder = Decoder.new(Configuration.default)
+decoder.decode 'spec/assets/audio/goforward.raw'
+
+puts decoder.hypothesis # => "go forward ten years"
+```
+
 
 ## Contributing
 

data/examples/decode_audio_file.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pocketsphinx-ruby"
+
+include Pocketsphinx
+
+decoder = Decoder.new(Configuration.default)
+decoder.decode 'spec/assets/audio/goforward.raw'
+
+puts decoder.hypothesis # => "go forward ten years"

data/examples/record_audio_file.rb

@@ -16,7 +16,7 @@ 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
+      (RECORDING_LENGTH / RECORDING_INTERVAL).to_i.times do
         sample_count = microphone.read_audio(buffer, MAX_SAMPLES)
 
         # sample_count * 2 since this is length in bytes

data/lib/pocketsphinx.rb

@@ -6,10 +6,12 @@ require "pocketsphinx/api/sphinxad"
 require "pocketsphinx/api/pocketsphinx"
 
 require "pocketsphinx/configuration"
+require "pocketsphinx/audio_file"
 require "pocketsphinx/microphone"
 require "pocketsphinx/decoder"
 require "pocketsphinx/speech_recognizer"
 require "pocketsphinx/live_speech_recognizer"
+require "pocketsphinx/audio_file_speech_recognizer"
 
 module Pocketsphinx
 

data/lib/pocketsphinx/api/pocketsphinx.rb

@@ -4,14 +4,18 @@ module Pocketsphinx
       extend FFI::Library
       ffi_lib "libpocketsphinx"
 
-      attach_function :ps_init, [:pointer], :pointer
+      typedef :pointer, :decoder
+      typedef :pointer, :configuration
+
+      attach_function :ps_init, [:configuration], :decoder
       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
+      attach_function :ps_decode_raw, [:decoder, :pointer, :string, :long], :int
+      attach_function :ps_process_raw, [:decoder, :pointer, :size_t, :int, :int], :int
+      attach_function :ps_start_utt, [:decoder, :string], :int
+      attach_function :ps_end_utt, [:decoder], :int
+      attach_function :ps_get_in_speech, [:decoder], :uint8
+      attach_function :ps_get_hyp, [:decoder, :pointer, :pointer], :string
     end
   end
 end

data/lib/pocketsphinx/audio_file.rb

@@ -0,0 +1,32 @@
+module Pocketsphinx
+  # Implements Recordable interface (#record and #read_audio)
+  class AudioFile < Struct.new(:file_path)
+    def record
+      File.open(file_path, 'rb') do |file|
+        self.file = file
+        yield
+        self.file = nil
+      end
+    end
+
+    # Read next block of audio samples from file; up to max samples into buffer.
+    #
+    # @param [FFI::Pointer] buffer 16bit buffer of at least max_samples in size
+    # @params [Fixnum] max_samples The maximum number of samples to read from the audio file
+    # @return [Fixnum] Samples actually read; nil if EOF
+    def read_audio(buffer, max_samples = 4096)
+      if file.nil?
+        raise "Can't read audio: use AudioFile#record to open the file first"
+      end
+
+      if data = file.read(max_samples * 2)
+        buffer.write_string(data)
+        data.length / 2
+      end
+    end
+
+    private
+
+    attr_accessor :file
+  end
+end

data/lib/pocketsphinx/audio_file_speech_recognizer.rb

@@ -0,0 +1,12 @@
+module Pocketsphinx
+  # High-level class for live speech recognition from a raw audio file.
+  class AudioFileSpeechRecognizer < SpeechRecognizer
+    def recognize(file_path, max_samples = 4096)
+      self.recordable = AudioFile.new(file_path)
+
+      super(max_samples) do |speech|
+        yield speech if block_given?
+      end
+    end
+  end
+end

data/lib/pocketsphinx/configuration.rb

@@ -3,6 +3,7 @@ require 'pocketsphinx/configuration/setting_definition'
 module Pocketsphinx
   class Configuration
     attr_reader :ps_config
+    attr_reader :setting_definitions
 
     private_class_method :new
 
@@ -22,12 +23,33 @@ module Pocketsphinx
       new(API::Pocketsphinx.ps_args)
     end
 
-    def [](name)
-      unless definition = @setting_definitions[name]
-        raise "Configuration setting '#{name}' does not exist"
+    def setting_names
+      setting_definitions.keys.sort
+    end
+
+    # Get details for one or all configuration settings
+    #
+    # @param [String] name Name of setting to get details for. Gets details for all settings if nil.
+    def details(name = nil)
+      details = [name || setting_names].flatten.map do |name|
+        definition = find_definition(name)
+
+        {
+          name: name,
+          type: definition.type,
+          default: definition.default,
+          required: definition.required?,
+          value: self[name],
+          info: definition.doc
+        }
       end
 
-      case definition.type
+      name ? details.first : details
+    end
+
+    # Get a configuration setting
+    def [](name)
+      case find_definition(name).type
       when :integer
         API::Sphinxbase.cmd_ln_int_r(@ps_config, "-#{name}")
       when :float
@@ -41,12 +63,9 @@ module Pocketsphinx
       end
     end
 
+    # Set a configuration setting with type checking
     def []=(name, value)
-      unless definition = @setting_definitions[name]
-        raise "Configuration setting '#{name}' does not exist"
-      end
-
-      case definition.type
+      case find_definition(name).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)
@@ -61,5 +80,11 @@ module Pocketsphinx
         raise NotImplementedException
       end
     end
+
+    private
+
+    def find_definition(name)
+      setting_definitions[name] or raise "Configuration setting '#{name}' does not exist"
+    end
   end
 end

data/lib/pocketsphinx/configuration/setting_definition.rb

@@ -1,19 +1,25 @@
 module Pocketsphinx
   class Configuration
-    class SettingDefinition
+    class SettingDefinition < Struct.new(:name, :type_code, :deflt, :doc)
       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]
+        TYPES[Math.log2(type_code - type_code%2) - 1]
+      end
+
+      # Convert string defaults from pocketsphinx to Ruby types
+      def default
+        case type
+          when :integer then deflt.to_i
+          when :float then deflt.to_f
+          when :boolean then deflt == 'yes'
+          else deflt
+        end
       end
 
       def required?
-        @type_code % 2 == 1
+        type_code % 2 == 1
       end
 
       # Build setting definitions from pocketsphinx argument definitions

data/lib/pocketsphinx/decoder.rb

@@ -10,6 +10,42 @@ module Pocketsphinx
       @ps_decoder = ps_api.ps_init(configuration.ps_config)
     end
 
+    # Decode a raw audio stream as a single utterance, opening a file if path given
+    #
+    # See #decode_raw
+    #
+    # @param [IO] audio_path_or_file The raw audio stream or file path to decode as a single utterance
+    # @param [Fixnum] max_samples The maximum samples to process from the stream on each iteration
+    def decode(audio_path_or_file, max_samples = 2048)
+      case audio_path_or_file
+      when String
+        File.open(audio_path_or_file, 'rb') { |f| decode_raw(f, max_samples) }
+      else
+        decode_raw(audio_path_or_file, max_samples)
+      end
+    end
+
+    # Decode a raw audio stream as a single utterance.
+    #
+    # No headers are recognized in this files.  The configuration parameters samprate
+    # and input_endian are used to determine the sampling rate and endianness of the stream,
+    # respectively.  Audio is always assumed to be 16-bit signed PCM.
+    #
+    # @param [IO] audio_file The raw audio stream to decode as a single utterance
+    # @param [Fixnum] max_samples The maximum samples to process from the stream on each iteration
+    def decode_raw(audio_file, max_samples = 2048)
+      start_utterance
+
+      FFI::MemoryPointer.new(:int16, max_samples) do |buffer|
+        while data = audio_file.read(max_samples * 2)
+          buffer.write_string(data)
+          process_raw(buffer, data.length / 2)
+        end
+      end
+
+      end_utterance
+    end
+
     # Decode raw audio data.
     #
     # @param [Boolean] no_search If non-zero, perform feature extraction but don't do any

data/lib/pocketsphinx/live_speech_recognizer.rb

@@ -3,46 +3,8 @@ module Pocketsphinx
   #
   # 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
+    def recordable
+      @recordable ||= Microphone.new
     end
   end
 end

data/lib/pocketsphinx/microphone.rb

@@ -1,10 +1,13 @@
 module Pocketsphinx
-  # Provides non-blocking audio recording using libsphinxad
+  # Provides non-blocking live audio recording using libsphinxad
+  #
+  # Implements Recordable interface (#record and #read_audio)
   class Microphone
     Error = Class.new(StandardError)
 
     attr_reader :ps_audio_device
     attr_writer :ps_api
+    attr_reader :sample_rate
 
     # Opens an audio device for recording
     #
@@ -14,8 +17,9 @@ module Pocketsphinx
     # @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)
+      @sample_rate = sample_rate
       @ps_api = ps_api
-      @ps_audio_device = ps_api.ad_open_dev(default_device, sample_rate)
+      @ps_audio_device = self.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))
@@ -46,10 +50,22 @@ module Pocketsphinx
     # 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
+    # @params [Fixnum] max_samples The maximum number of samples to read from the audio device
+    # @return [Fixnum] Samples actually read (could be 0 since non-blocking); nil 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)
+      samples = ps_api.ad_read(@ps_audio_device, buffer, max_samples)
+      samples if samples >= 0
+    end
+
+    # A Recordable may specify an audio reading delay
+    #
+    # In the case of the Microphone, because we are doing non-blocking reads,
+    # we specify a delay which should fill half of the max buffer size
+    #
+    # @param [Fixnum] max_samples The maximum samples we tried to read from the audio device
+    def read_audio_delay(max_samples = 4096)
+      max_samples / (2 * sample_rate)
     end
 
     def close_device

data/lib/pocketsphinx/speech_recognizer.rb

@@ -1,9 +1,83 @@
 module Pocketsphinx
+  # Reads audio data from a recordable interface and decodes it into utterances
+  #
+  # Essentially orchestrates interaction between Recordable and Decoder, and detects new utterances.
   class SpeechRecognizer
-    attr_reader :decoder
+    # Recordable interface must implement #record and #read_audio
+    attr_writer :recordable
+    attr_writer :decoder
 
-    def initialize(configuration= nil)
-      @decoder = Decoder.new(configuration || Configuration.default)
+    def initialize(configuration = nil)
+      @configuration = configuration
+    end
+
+    def recordable
+      @recordable or raise "A SpeechRecognizer must have a recordable interface"
+    end
+
+    def decoder
+      @decoder ||= Decoder.new(configuration)
+    end
+
+    def configuration
+      @configuration ||= Configuration.default
+    end
+
+    # Recognize utterances and yield hypotheses in infinite loop
+    #
+    # Splits speech into utterances by detecting silence between them.
+    # By default this uses Pocketsphinx's internal Voice Activity Detection (VAD) which can be
+    # configured by adjusting the `vad_postspeech`, `vad_prespeech`, and `vad_threshold` settings.
+    #
+    # @param [Fixnum] max_samples Number of samples to process at a time
+    def recognize(max_samples = 4096)
+      decoder.start_utterance
+
+      recordable.record do
+        FFI::MemoryPointer.new(:int16, max_samples) do |buffer|
+          loop do
+            if in_speech?
+              while decoder.in_speech?
+                process_audio(buffer, max_samples) or break
+              end
+
+              yield get_hypothesis
+            else
+              process_audio(buffer, max_samples) or break
+            end
+          end
+        end
+      end
+    end
+
+    def in_speech?
+      # Use Pocketsphinx's implementation by default
+      decoder.in_speech?
+    end
+
+    private
+
+    def process_audio(buffer, max_samples)
+      sample_count = recordable.read_audio(buffer, max_samples)
+
+      if sample_count
+        decoder.process_raw(buffer, sample_count)
+
+        # Check for a delay for example in case of non-blocking live audio
+        if recordable.respond_to?(:read_audio_delay)
+          sleep recordable.read_audio_delay(max_samples)
+        end
+      end
+
+      sample_count
+    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/version.rb

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

data/spec/configuration_spec.rb

@@ -44,4 +44,37 @@ describe Configuration do
   it 'raises exceptions when a setting is unknown' do
     expect { subject['unknown'] = true }.to raise_exception "Configuration setting 'unknown' does not exist"
   end
+
+  describe '#setting_names' do
+    it 'contains the names of all possible system settings' do
+      expect(subject.setting_names.count).to eq(117)
+    end
+  end
+
+  describe '#details' do
+    it 'gives details for a single setting' do
+      expect(subject.details 'vad_threshold').to eq({
+        name: "vad_threshold",
+        type: :float,
+        default: 2.0,
+        required: false,
+        value: 2.0,
+        info: "Threshold for decision between noise and silence frames. Log-ratio between signal level and noise level."
+      })
+    end
+
+    it 'gives details for all settings when no name is specified' do
+      details = subject.details
+
+      expect(details.count).to eq(117)
+      expect(details.first).to eq({
+        name: "agc",
+        type: :string,
+        default: "none",
+        required: false,
+        value: "none",
+        info: "Automatic gain control for c0 ('max', 'emax', 'noise', or 'none')"
+      })
+    end
+  end
 end

data/spec/decoder_spec.rb

@@ -9,6 +9,22 @@ describe Decoder do
     @decoder = Decoder.new(Configuration.default)
   end
 
+  # Full integration test
+  describe '#decode' do
+    it 'correctly decodes the speech in goforward.raw' do
+      subject.decode File.open('spec/assets/audio/goforward.raw', 'rb')
+
+      # With the default configuration (no specific grammar), pocketsphinx doesn't actually
+      # get this quite right, but nonetheless this is the expected output
+      expect(subject.hypothesis).to eq("go forward ten years")
+    end
+
+    it 'accepts a file path as well as a stream' do
+      subject.decode 'spec/assets/audio/goforward.raw'
+      expect(subject.hypothesis).to eq("go forward ten years")
+    end
+  end
+
   describe '#process_raw' do
     it 'calls libpocketsphinx' do
       FFI::MemoryPointer.new(:int16, 4096) do |buffer|

data/spec/speech_recognizer_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe SpeechRecognizer do
+  let(:recordable) { AudioFile.new('spec/assets/audio/goforward.raw') }
+
+  subject do
+    SpeechRecognizer.new.tap do |speech_recognizer|
+      speech_recognizer.recordable = recordable
+      speech_recognizer.decoder = @decoder
+    end
+  end
+
+  # Share decoder across all examples for speed
+  before :all do
+    @decoder = Decoder.new(Configuration.default)
+  end
+
+  describe '#recognize' do
+    it 'should decode speech in raw audio' do
+      expect { |b| subject.recognize(4096, &b) }.to yield_with_args("go forward ten years")
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pocketsphinx-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Howard Wilson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-19 00:00:00.000000000 Z
+date: 2014-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -94,6 +94,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/decode_audio_file.rb
 - examples/pocketsphinx_continuous.rb
 - examples/record_audio_file.rb
 - lib/pocketsphinx-ruby.rb
@@ -101,6 +102,8 @@ files:
 - lib/pocketsphinx/api/pocketsphinx.rb
 - lib/pocketsphinx/api/sphinxad.rb
 - lib/pocketsphinx/api/sphinxbase.rb
+- lib/pocketsphinx/audio_file.rb
+- lib/pocketsphinx/audio_file_speech_recognizer.rb
 - lib/pocketsphinx/configuration.rb
 - lib/pocketsphinx/configuration/setting_definition.rb
 - lib/pocketsphinx/decoder.rb
@@ -109,10 +112,12 @@ files:
 - lib/pocketsphinx/speech_recognizer.rb
 - lib/pocketsphinx/version.rb
 - pocketsphinx-ruby.gemspec
+- spec/assets/audio/goforward.raw
 - spec/configuration_spec.rb
 - spec/decoder_spec.rb
 - spec/microphone_spec.rb
 - spec/spec_helper.rb
+- spec/speech_recognizer_spec.rb
 homepage: https://github.com/watsonbox/pocketsphinx-ruby
 licenses:
 - MIT
@@ -138,7 +143,9 @@ signing_key:
 specification_version: 4
 summary: Ruby FFI pocketsphinx bindings
 test_files:
+- spec/assets/audio/goforward.raw
 - spec/configuration_spec.rb
 - spec/decoder_spec.rb
 - spec/microphone_spec.rb
 - spec/spec_helper.rb
+- spec/speech_recognizer_spec.rb