noyes 0.8.0 → 0.9.0

data/VERSION

@@ -1 +1 @@
-0.8.0
+0.9.0

data/lib/c_impl/array_list.c

@@ -0,0 +1,64 @@
+#include "ruby.h"
+#include "noyes.h"
+#include "rnoyes.h"
+
+static int id_push;
+
+VALUE cArrayList;
+
+static void free_n_list(void *p) {
+  n_list_free(p);
+}
+
+static VALUE t_init(VALUE self) {
+  NList *st = n_list_new();
+  VALUE stv = Data_Wrap_Struct(cArrayList, 0, free_n_list, st);
+  rb_iv_set(self, "@n_list", stv);
+  return self;
+}
+
+static VALUE t_size(VALUE self) {
+  NList *array;
+  VALUE arrayv = rb_iv_get(self, "@n_list");
+  Data_Get_Struct(arrayv, NList, array);
+  return INT2FIX(n_list_size(array));
+}
+
+static VALUE t_add(VALUE self, VALUE obj) {
+  NList *array;
+  VALUE arrayv = rb_iv_get(self, "@n_list");
+  Data_Get_Struct(arrayv, NList, array);
+  n_list_add(array, (void*)obj);
+  return Qnil;
+}
+
+static VALUE t_get(VALUE self, VALUE obj) {
+  NList *array;
+  VALUE arrayv = rb_iv_get(self, "@n_list");
+  Data_Get_Struct(arrayv, NList, array);
+  return (VALUE)n_list_get(array, FIX2INT(obj));
+}
+
+static VALUE t_remove(VALUE self, VALUE start, VALUE finish) {
+  NList *array;
+  VALUE arrayv = rb_iv_get(self, "@n_list");
+  Data_Get_Struct(arrayv, NList, array);
+  int b = FIX2INT(start);
+  int e = FIX2INT(finish);
+  if (n_list_remove(array, b, e)) {
+    int s = n_list_size(array);
+    rb_raise(rb_eArgError, "start = %d, finish = %d with size =  %d", b, e, s);
+   }
+  return Qnil;
+}
+
+void Init_n_list() {
+  VALUE m_noyes_c = rb_define_module("NoyesC");
+  cArrayList = rb_define_class_under(m_noyes_c, "ArrayList", rb_cObject);
+  rb_define_method(cArrayList, "initialize", t_init, 0);
+  rb_define_method(cArrayList, "size", t_size, 0);
+  rb_define_method(cArrayList, "add", t_add, 1);
+  rb_define_method(cArrayList, "get", t_get, 1);
+  rb_define_method(cArrayList, "remove", t_remove, 2);
+  id_push = rb_intern("push");
+}

data/lib/c_impl/bent_cent_marker.c

@@ -0,0 +1,36 @@
+#include "ruby.h"
+#include "noyes.h"
+#include "rnoyes.h"
+
+static int id_push;
+
+VALUE cBentCentMarker;
+
+static void bent_cent_marker_free(void *p) {
+  free_bent_cent_marker(p);
+}
+
+static VALUE t_init(VALUE self) {
+  BentCentMarker *pre = new_bent_cent_marker();
+  VALUE prev = Data_Wrap_Struct(cBentCentMarker, 0, bent_cent_marker_free, pre);
+  rb_iv_set(self, "@bent_cent_marker", prev);
+  return self;
+}
+
+static VALUE t_left_shift(VALUE self, VALUE obj) {
+  NMatrix1 *M = v_2_nmatrix1(obj);
+  BentCentMarker *pre;
+  VALUE prev = rb_iv_get(self, "@bent_cent_marker");
+  Data_Get_Struct(prev, BentCentMarker, pre);
+  int res = bent_cent_marker_apply(pre, M);
+  free_nmatrix1(M);
+  return res ? Qtrue : Qfalse;
+}
+
+void Init_bent_cent_marker() {
+  VALUE m_noyes_c = rb_define_module("NoyesC");
+  cBentCentMarker = rb_define_class_under(m_noyes_c, "BentCentMarker", rb_cObject);
+  rb_define_method(cBentCentMarker, "initialize", t_init, 0);
+  rb_define_method(cBentCentMarker, "<<", t_left_shift, 1);
+  id_push = rb_intern("push");
+}

data/lib/c_impl/discrete_cosine_transform.c

@@ -49,6 +49,21 @@ static VALUE t_melcos(VALUE self) {
   return result;
 }
 
+static VALUE t_dft(VALUE classmod, VALUE data, VALUE size) {
+  NMatrix1 *M = v_2_nmatrix1(data);
+  NMatrix *R = dft(M->data, M->rows, FIX2INT(size));
+  VALUE result = rb_ary_new2(R->cols);
+  int i;
+  for (i=0;i<R->cols;++i) {
+    VALUE real = rb_float_new(R->data[0][i]);
+    VALUE imag = rb_float_new(R->data[1][i]);
+    rb_ary_store(result, i, rb_complex_new(real, imag));
+  }
+  free_nmatrix1(M);
+  free_nmatrix(R);
+  return result;
+}
+
 void Init_dct() {
   VALUE m_noyes_c = rb_define_module("NoyesC");
   cDiscreteCosineTransform = rb_define_class_under(m_noyes_c,
@@ -56,5 +71,6 @@ void Init_dct() {
   rb_define_method(cDiscreteCosineTransform, "initialize", t_init, -2);
   rb_define_method(cDiscreteCosineTransform, "<<", t_left_shift, 1);
   rb_define_method(cDiscreteCosineTransform, "melcos", t_melcos, 0);
+  rb_define_module_function(m_noyes_c, "dft", t_dft, 2);
   id_push = rb_intern("push");
 }

data/lib/c_impl/n_array_list.c

@@ -0,0 +1,72 @@
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "n_array_list.h"
+
+#define NLIST_INITIAL_CAPACITY 10
+#define NLIST_DELTA_CAPACITY 10
+#undef TRUE
+#define TRUE 1
+#undef FALSE
+#define FALSE 0
+
+NList * n_list_new() {
+  NList * self;
+  self = malloc(sizeof(NList));
+  self->capacity = NLIST_INITIAL_CAPACITY;
+  self->data = malloc(sizeof(void*) * self->capacity);
+  self->size = 0;
+  return self;
+}
+
+void n_list_free(NList * self) {
+  free(self->data);
+  free(self);
+}
+
+int n_list_add(NList * self, void * object) {
+  int old_size = n_list_size(self);
+  int new_capacity;
+  void ** new_data;
+
+  (self->size)++;
+  if (old_size == self->capacity) {
+    new_capacity = self->capacity + NLIST_DELTA_CAPACITY;
+    new_data = malloc(sizeof(void*) * new_capacity);
+    memcpy(new_data, self->data, sizeof(void*) * old_size);
+    free(self->data);
+    (self->data) = new_data;
+    self->capacity = new_capacity;
+  }
+  self->data[old_size] = object;
+  return TRUE;
+}
+
+int n_list_remove(NList * self, int start, int finish) {
+  if (start > finish || finish > self->size)
+    return 1;
+
+  memmove(self->data + start, self->data + finish,
+                              sizeof(void*) * (self->size - finish));
+  self->size = self->size - (finish - start);
+  if (self->size < self->capacity - 2 * NLIST_DELTA_CAPACITY) {
+    int new_capacity = self->size + NLIST_DELTA_CAPACITY;
+    self->data = realloc(self->data, sizeof(void*) * new_capacity);
+    self->capacity = new_capacity;
+  }
+  return 0;
+}
+
+void * n_list_get(const NList * self, const int index) {
+  if (index < 0 || index > self->size)
+    return NULL;
+  return self->data[index];
+}
+
+int n_list_is_empty(const NList * self) {
+  return 0 == n_list_size(self);
+}
+
+int n_list_size(const NList * self) {
+  return self->size;
+}

data/lib/c_impl/n_array_list.h

@@ -0,0 +1,18 @@
+#ifndef _N_ARRAY_LIST_H_
+#define _N_ARRAY_LIST_H_
+
+typedef struct {
+  int capacity;
+  void **data;
+  int size;
+} NList;
+
+NList * n_list_new();
+void n_list_free(NList * self);
+int n_list_size(const NList * self);
+int n_list_add(NList * self, void * object);
+int n_list_remove(NList * self, int start, int finish);
+void * n_list_get(const NList * self, const int index);
+int n_list_is_empty(const NList * self);
+
+#endif

data/lib/c_impl/n_bent_cent_marker.c

@@ -0,0 +1,48 @@
+#include "noyes.h"
+#include "math.h"
+#include "stdlib.h"
+
+BentCentMarker * new_bent_cent_marker() {
+  BentCentMarker *self = malloc(sizeof(BentCentMarker));
+  self->adjustment = 0.003;
+  self->average_number = 1.0;
+  self->background = 100.0;
+  self->level = 0.0;
+  self->min_signal = 0.0;
+  self->threshold = 10.0;
+  return self;
+}
+
+void free_bent_cent_marker(BentCentMarker *self) {
+  free(self);
+}
+
+double bent_cent_log_rms(BentCentMarker *self, NMatrix1 *pcm) {
+  double sum_of_squares = 0.0;
+  int i;
+  for (i=0;i<pcm->rows;++i) {
+    sum_of_squares += pcm->data[i] * pcm->data[i];
+  }
+  double rms = sqrt(sum_of_squares/pcm->rows);
+  rms = fmax(rms,1.0);
+  return log(rms) * 20;
+}
+
+int bent_cent_marker_apply(BentCentMarker *self, NMatrix1 *pcm) {
+  int is_speech = 0;
+  double current = bent_cent_log_rms(self, pcm);
+  if (current >= self->min_signal) {
+    self->level = ((self->level * self->average_number) + current) /
+                   (self->average_number + 1);
+    if (current < self->background) {
+      self->background = current;
+    } else {
+      self->background += (current - self->background) * self->adjustment;
+    }
+    if (self->level < self->background) {
+      self->level = self->background;
+    }
+    is_speech = self->level - self->background > self->threshold;
+  }
+  return is_speech;
+}

data/lib/c_impl/n_speech_trimmer.c

@@ -0,0 +1,67 @@
+#include "noyes.h"
+#undef TRUE
+#define TRUE 1
+#undef FALSE
+#define FALSE 0
+
+SpeechTrimmer * new_speech_trimmer() {
+  SpeechTrimmer *self = malloc(sizeof(SpeechTrimmer));
+  self->leader = 5;
+  self->trailer = 5;
+  self->speech_started = FALSE;
+  self->bcm = new_bent_cent_marker();
+  self->false_count = 0;
+  self->true_count = 0;
+  self->queue = n_list_new();
+  self->eos_reached = FALSE;
+  self->scs = 20;
+  self->ecs = 50;
+  return self;
+}
+
+void free_speech_trimmer(SpeechTrimmer *self) {
+  free_bent_cent_marker(self->bcm);
+  n_list_free(self->queue);
+  free(self);
+}
+
+void speech_trimmer_enqueue(SpeechTrimmer *self, NMatrix1* pcm) {
+  if (self->eos_reached)
+    return;
+  n_list_add(self->queue, pcm);
+  if (bent_cent_marker_apply(self->bcm, pcm)) {
+    self->false_count = 0;
+    self->true_count += 1;
+  } else {
+    self->false_count += 1;
+    self->true_count = 0;
+  }
+  if (self->speech_started) {
+    if (self->false_count == self->ecs) {
+      self->eos_reached = TRUE;
+      int new_size = n_list_size(self->queue) - self->ecs + self->trailer;
+      n_list_remove(self->queue, new_size, n_list_size(self->queue));
+    }
+  } else if (self->true_count > self->scs) {
+    if (self->leader + self->scs < n_list_size(self->queue)) {
+      int start = n_list_size(self->queue) - self->leader - self->scs - 1;
+      n_list_remove(self->queue, 0, start);
+    }
+    self->speech_started = TRUE;
+  }
+}
+
+NMatrix1 * speech_trimmer_dequeue(SpeechTrimmer *self) {
+  if (n_list_size(self->queue) == 0)
+    return NULL;
+  if (self->eos_reached || (self->speech_started &&
+      n_list_size(self->queue) > self->ecs)) {
+    NMatrix1 * N = n_list_get(self->queue, 0);
+    n_list_remove(self->queue, 0, 1);
+    return N;
+  }
+  return NULL;
+}
+int speech_trimmer_eos(SpeechTrimmer *self) {
+  return self->eos_reached;
+}

data/lib/c_impl/noyes.h

@@ -145,6 +145,42 @@ Fast8kMfcc* new_fast_8k_mfcc();
 void free_fast_8k_mfcc(Fast8kMfcc *self);
 NMatrix *fast_8k_mfcc_apply(Fast8kMfcc *self, NMatrix1 *data);
 
+// Silence removal with BentCentMarker and SpeechTrimmer
+typedef struct {
+  double adjustment;
+  double average_number;
+  double background;
+  double level;
+  double min_signal;
+  double threshold;
+} BentCentMarker;
+
+BentCentMarker * new_bent_cent_marker();
+void free_bent_cent_marker(BentCentMarker *self);
+double bent_cent_marker_log_rms(BentCentMarker *self, NMatrix1 *data);
+int bent_cent_marker_apply(BentCentMarker *self, NMatrix1 *data);
+
+#include "n_array_list.h"
+
+typedef struct {
+  int leader;
+  int trailer;
+  int speech_started;
+  int false_count;
+  int true_count;
+  int scs;
+  int ecs;
+  BentCentMarker *bcm;
+  NList *queue;
+  int eos_reached;
+} SpeechTrimmer;
+  
+SpeechTrimmer * new_speech_trimmer();
+void free_speech_trimmer(SpeechTrimmer *self);
+void speech_trimmer_enqueue(SpeechTrimmer *self, NMatrix1* pcm);
+NMatrix1 * speech_trimmer_dequeue(SpeechTrimmer *self);
+int speech_trimmer_eos(SpeechTrimmer *self);
+
 #ifdef __cplusplus
 }
 #endif

data/lib/c_impl/noyes_c.c

@@ -85,4 +85,7 @@ void Init_noyes_c() {
   Init_live_cmn();
   Init_fast_8k_mfcc();
   Init_dct();
+  Init_bent_cent_marker();
+  Init_speech_trimmer();
+  Init_n_list();
 }

data/lib/c_impl/rnoyes.h

@@ -9,6 +9,8 @@ void Init_log_compressor();
 void Init_live_cmn();
 void Init_fast_8k_mfcc();
 void Init_dct();
+void Init_bent_cent_marker();
+void Init_speech_trimmer();
 
 VALUE nmatrix_2_v(NMatrix *d);
 NMatrix * v_2_nmatrix(VALUE value);

data/lib/c_impl/speech_trimmer.c

@@ -0,0 +1,52 @@
+#include "ruby.h"
+#include "noyes.h"
+#include "rnoyes.h"
+
+static int id_push;
+
+VALUE cSpeechTrimmer;
+
+static void speech_trimmer_free(void *p) {
+  free_speech_trimmer(p);
+}
+
+static VALUE t_init(VALUE self) {
+  SpeechTrimmer *st = new_speech_trimmer();
+  VALUE stv = Data_Wrap_Struct(cSpeechTrimmer, 0, speech_trimmer_free, st);
+  rb_iv_set(self, "@speech_trimmer", stv);
+  return self;
+}
+
+static VALUE t_enqueue(VALUE self, VALUE obj) {
+  NMatrix1 *M = v_2_nmatrix1(obj);
+  SpeechTrimmer *st;
+  Data_Get_Struct(rb_iv_get(self, "@speech_trimmer"), SpeechTrimmer, st);
+  speech_trimmer_enqueue(st, M);
+  return Qnil;
+}
+
+static VALUE t_dequeue(VALUE self) {
+  SpeechTrimmer *st;
+  Data_Get_Struct(rb_iv_get(self, "@speech_trimmer"), SpeechTrimmer, st);
+  NMatrix1 *N =speech_trimmer_dequeue(st);
+  VALUE result = nmatrix1_2_v(N);
+  free_nmatrix1(N);
+  return result;
+}
+
+static VALUE t_eos(VALUE self) {
+  SpeechTrimmer *st;
+  VALUE stv = rb_iv_get(self, "@speech_trimmer");
+  Data_Get_Struct(stv, SpeechTrimmer, st);
+  return speech_trimmer_dequeue(st) ? Qtrue : Qfalse;
+}
+
+void Init_speech_trimmer() {
+  VALUE m_noyes_c = rb_define_module("NoyesC");
+  cSpeechTrimmer = rb_define_class_under(m_noyes_c, "SpeechTrimmer", rb_cObject);
+  rb_define_method(cSpeechTrimmer, "initialize", t_init, 0);
+  rb_define_method(cSpeechTrimmer, "enqueue", t_enqueue, 1);
+  rb_define_method(cSpeechTrimmer, "dequeue", t_dequeue, 0);
+  rb_define_method(cSpeechTrimmer, "eos?", t_eos, 0);
+  id_push = rb_intern("push");
+}

data/lib/common/ruby_ext.rb

@@ -0,0 +1,19 @@
+module Math
+  def self.max a, b
+    a > b ? a : b
+  end
+  def self.min a, b
+    a < b ? a : b
+  end
+end
+# I don't really undestand why Ruby 1.9 needs this.  It seems that Math gets
+# redefine to CMath at some point.  So calling Math.max will fail in 1.9 unless
+# I put these functions in CMath too.
+module CMath
+  def self.max a, b
+    a > b ? a : b
+  end
+  def self.min a, b
+    a < b ? a : b
+  end
+end

data/lib/common/send_incrementally.rb

@@ -1,6 +1,5 @@
 require 'noyes'
 require 'common/file2pcm'
-include Noyes
 
 # The following flags are in network byte order (big endian) and are 4 bytes
 # long. 

data/lib/common.rb

@@ -4,3 +4,4 @@ require 'common/noyes_dsl'
 require 'common/noyes_math'
 require 'common/noyes_protocol'
 require 'common/send_incrementally'
+require 'common/ruby_ext'

data/lib/java_impl/bent_cent_marker.rb

@@ -0,0 +1,13 @@
+module NoyesJava
+  class BentCentMarker
+    def initialize
+      @bcm = Java::talkhouse.BentCentMarker.new
+    end
+    def logrms pcm
+      @bcm.logRMS pcm.to_java(Java::double)
+    end
+    def << pcm
+      @bcm.apply pcm.to_java(Java::double)
+    end
+  end
+end

data/lib/java_impl/speech_trimmer.rb

@@ -0,0 +1,18 @@
+module NoyesJava
+  class SpeechTrimmer
+    def initialize
+      @st = Java::talkhouse.SpeechTrimmer.new
+    end
+    def enqueue pcm
+      @st.enqueue pcm.to_java(Java::double)
+    end
+    def dequeue
+      speech = @st.dequeue
+      speech.to_a if speech
+    end
+    def eos?
+      @st.eos
+    end
+  end
+end
+      

data/lib/noyes.rb

@@ -10,3 +10,5 @@ require 'ruby_impl/discrete_fourier_transform'
 require 'ruby_impl/power_spec'
 require 'ruby_impl/preemphasis'
 require 'ruby_impl/segment'
+require 'ruby_impl/bent_cent_marker'
+require 'ruby_impl/speech_trimmer'

data/lib/noyes_java.rb

@@ -11,4 +11,6 @@ require 'java_impl/discrete_fourier_transform'
 require 'java_impl/power_spec'
 require 'java_impl/preemphasis'
 require 'java_impl/segment'
+require 'java_impl/bent_cent_marker'
+require 'java_impl/speech_trimmer'
 require 'noyes.jar'

data/lib/ruby_impl/bent_cent_marker.rb

@@ -0,0 +1,40 @@
+module Noyes
+  # Determines whether a PCM frame is speech or not using Bent
+  # Schmidt-Nielsen's algorithm.  Basically, it's an energy-based detector
+  # where the background noise level is constantly estimated.
+  #
+  # The pcm data should be in 100 millisecond chunks.  For example,
+  # At 8000 Hz there should 80 frames of pcm.
+  class BentCentMarker
+    def initialize
+      @adjustment = 0.003
+      @average_number = 1.0
+      @background = 100.0
+      @level = 0.0
+      @min_signal = 0.0
+      @threshold = 10.0
+    end
+    def logrms pcm
+      sum_of_squares = 0.0
+      pcm.each {|sample| sum_of_squares += sample * sample}
+      rms = Math.sqrt sum_of_squares / pcm.size;
+      rms = Math.max rms, 1
+      Math.log(rms) * 20
+    end
+    def << pcm
+      is_speech = false
+      current = logrms pcm
+      if current >= @min_signal
+        @level = ((@level * @average_number) + current) / (@average_number + 1)
+        if current < @background 
+          @background = current
+        else
+          @background += (current - @background) * @adjustment
+        end
+        @level = @background if (@level < @background)
+        is_speech = @level - @background > @threshold
+      end
+      is_speech
+    end
+  end
+end

data/lib/ruby_impl/speech_trimmer.rb

@@ -0,0 +1,54 @@
+module Noyes
+  # SpeechTrimmer trims non-speech from both ends of an audio stream. Each time
+  # you enqueue audio into it you should dequeue audio out of it until dequeue
+  # returns nil.  Then check for eos.  If eos is true you are done.
+  # SpeechTrimmer is designed to work efficiently with live audio.
+  class SpeechTrimmer
+    def initialize
+      @leader = 5  # Cents of leading silence to retain.
+      @trailer = 5  # Cents of trailing silence to retain.
+      @speech_started = false
+      @cent_marker = BentCentMarker.new
+      @false_count=0
+      @true_count=0
+      @queue = []
+      @eos_reached = false
+      @scs = 20 # Centiseconds of speech before detection of utterance.
+      @ecs = 50 # Centiseconds of silence before end detection.
+    end
+
+    def enqueue pcm
+      return if @eos_reached
+      @queue << pcm
+      if @cent_marker << pcm
+        @false_count = 0
+        @true_count += 1
+      else
+        @false_count += 1
+        @true_count = 0
+      end
+      if @speech_started
+        if @false_count == @ecs
+          @eos_reached = true
+          # only keep trailer number of cents once eos is detected.
+          @queue = @queue[0, @queue.size - @ecs + @trailer]
+        end
+      elsif @true_count > @scs
+        # Discard most begining silence, keeping just a tad.
+        if @leader + @scs < @queue.size
+          start = @queue.size - @leader - 1 - @scs
+          @queue = @queue[start,@queue.size - start]
+        end
+        @speech_started = true
+      end
+    end
+    def dequeue
+      if @eos_reached || (@speech_started && @queue.size > @ecs)
+        @queue.shift
+      end
+    end
+    def eos?
+      @eos_reached
+    end
+  end    
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: noyes
 version: !ruby/object:Gem::Version 
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors: 
 - Joe Woelfel
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-28 00:00:00 -04:00
+date: 2010-06-22 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -37,6 +37,8 @@ extra_rdoc_files:
 - README
 files: 
 - VERSION
+- lib/c_impl/array_list.c
+- lib/c_impl/bent_cent_marker.c
 - lib/c_impl/discrete_cosine_transform.c
 - lib/c_impl/extconf.rb
 - lib/c_impl/fast_8k_mfcc.c
@@ -44,6 +46,9 @@ files:
 - lib/c_impl/live_cmn.c
 - lib/c_impl/log_compressor.c
 - lib/c_impl/mel_filter.c
+- lib/c_impl/n_array_list.c
+- lib/c_impl/n_array_list.h
+- lib/c_impl/n_bent_cent_marker.c
 - lib/c_impl/n_dft.c
 - lib/c_impl/n_discrete_cosine_transform.c
 - lib/c_impl/n_fast_8k_mfcc.c
@@ -55,12 +60,14 @@ files:
 - lib/c_impl/n_power_spec.c
 - lib/c_impl/n_preemphasis.c
 - lib/c_impl/n_segmenter.c
+- lib/c_impl/n_speech_trimmer.c
 - lib/c_impl/noyes.h
 - lib/c_impl/noyes_c.c
 - lib/c_impl/power_spectrum.c
 - lib/c_impl/preemphasis.c
 - lib/c_impl/rnoyes.h
 - lib/c_impl/segmenter.c
+- lib/c_impl/speech_trimmer.c
 - lib/common.rb
 - lib/common/file2pcm.rb
 - lib/common/mock_noyes_server.rb
@@ -68,8 +75,10 @@ files:
 - lib/common/noyes_math.rb
 - lib/common/noyes_protocol.rb
 - lib/common/parallel_filter.rb
+- lib/common/ruby_ext.rb
 - lib/common/send_incrementally.rb
 - lib/common/serial_filter.rb
+- lib/java_impl/bent_cent_marker.rb
 - lib/java_impl/dct.rb
 - lib/java_impl/delta.rb
 - lib/java_impl/discrete_fourier_transform.rb
@@ -82,9 +91,11 @@ files:
 - lib/java_impl/power_spec.rb
 - lib/java_impl/preemphasis.rb
 - lib/java_impl/segment.rb
+- lib/java_impl/speech_trimmer.rb
 - lib/noyes.rb
 - lib/noyes_c.rb
 - lib/noyes_java.rb
+- lib/ruby_impl/bent_cent_marker.rb
 - lib/ruby_impl/dct.rb
 - lib/ruby_impl/delta.rb
 - lib/ruby_impl/discrete_fourier_transform.rb
@@ -96,6 +107,7 @@ files:
 - lib/ruby_impl/power_spec.rb
 - lib/ruby_impl/preemphasis.rb
 - lib/ruby_impl/segment.rb
+- lib/ruby_impl/speech_trimmer.rb
 - ship/noyes.jar
 - COPYING
 - FAQ