WaveSwissKnife 0.2.0.20120302

data/ext/WSK/FFTUtils/extconf.rb

@@ -0,0 +1,15 @@
+#--
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+require "#{File.dirname(__FILE__)}/../CommonBuild"
+# TODO (Cygwin): Adding -L/usr/local/lib is due to some Cygwin installs that do not include it with gcc
+$LDFLAGS += ' -L/usr/local/lib '
+begin
+  have_library('gmp')
+rescue Exception
+  puts "\n\n!!! Missing library gmp in this system. Please install it from http://gmplib.org/\n\n"
+  raise
+end
+create_makefile('FFTUtils')

data/ext/WSK/FunctionUtils/FunctionUtils.c

@@ -0,0 +1,182 @@
+/**
+ * Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+ * Licensed under the terms specified in LICENSE file. No warranty is provided.
+ **/
+
+#include "ruby.h"
+#include <math.h>
+#include <stdio.h>
+#include <CommonUtils.h>
+#include <gmp.h>
+
+/**
+ * Free a C function.
+ * This method is called by Ruby GC.
+ *
+ * Parameters::
+ * * *iPtrCFct* (<em>void*</em>): The C function to free (in fact a <em>tFunction*</em>)
+ */
+static void volumeutils_freeCFct(void* iPtrCFct) {
+  tFunction* lPtrCFct = (tFunction*)iPtrCFct;
+
+  if (lPtrCFct->freeFct != NULL) {
+    (lPtrCFct->freeFct)(lPtrCFct->fctData);
+  }
+  free(lPtrCFct->fctData);
+}
+
+/**
+ * Free a C function of type Piecewiese Linear.
+ *
+ * Parameters::
+ * * *iPtrCFct* (<em>void*</em>): The C function to free (in fact a <em>tFunction_PiecewiseLinear*</em>)
+ */
+static void functionutils_freeCFct_PiecewiseLinear(void* iPtrCFct) {
+  tFunction_PiecewiseLinear* lPtrCFct = (tFunction_PiecewiseLinear*)iPtrCFct;
+
+  free(lPtrCFct->pointsX);
+  free(lPtrCFct->pointsY);
+}
+
+static int gID_to_s;
+static int gID_numerator;
+static int gID_denominator;
+
+/**
+ * Convert a Ruby function value into a long double
+ *
+ * Parameters::
+ * * *iValBD* (_Rational_): The value to convert
+ * Return::
+ * * <em>long double</em>: The equivalent long double
+ */
+inline long double value2ld(
+  VALUE iValBD) {
+  long double rResult;
+
+  mpf_t lDenominator;
+  mpf_init_set_str(lDenominator, RSTRING_PTR(rb_funcall(rb_funcall(iValBD, gID_denominator, 0), gID_to_s, 0)), 10);
+  mpf_t lDivResult;
+  mpf_init_set_str(lDivResult, RSTRING_PTR(rb_funcall(rb_funcall(iValBD, gID_numerator, 0), gID_to_s, 0)), 10);
+  mpf_div(lDivResult, lDivResult, lDenominator);
+  // TODO: Find a way to round correctly lDivResult. It is currently truncated.
+  rResult = mpf_get_d(lDivResult);
+  mpf_clear(lDivResult);
+  mpf_clear(lDenominator);
+
+  return rResult;
+}
+
+/**
+ * Fill a C function with a given function of type Piecewise Linear
+ *
+ * Parameters::
+ * * *oPtrCFunction* (<em>tFunction*</em>): The C function to fill
+ * * *iValFunction* (<em>map<Symbol,Object></em>): The function to apply
+ * * *iIdxBeginSample* (<em>tSampleIndex</em>): First sample beginning the function
+ * * *iIdxEndSample* (<em>tSampleIndex</em>): Last sample ending the function
+ */
+static int functionutils_fillCFunction_PiecewiseLinear(
+  tFunction* oPtrCFunction,
+  VALUE iValFunction,
+  tSampleIndex iIdxBeginSample,
+  tSampleIndex iIdxEndSample) {
+  int rResultCode = 0;
+  
+  // Create the basic structure
+  tFunction_PiecewiseLinear* lPtrFctData = ALLOC(tFunction_PiecewiseLinear);
+  oPtrCFunction->fctData = (void*)lPtrFctData;
+  oPtrCFunction->freeFct = functionutils_freeCFct_PiecewiseLinear;
+  
+  // Fill it
+  // Read points in a sorted list of couples [x,y]
+  VALUE lValSortedPoints = rb_funcall(rb_funcall(rb_hash_aref(iValFunction, ID2SYM(rb_intern("Points"))), rb_intern("to_a"), 0), rb_intern("sort"), 0);
+  lPtrFctData->nbrPoints = RARRAY(lValSortedPoints)->len;
+  lPtrFctData->pointsX = ALLOC_N(tSampleIndex, lPtrFctData->nbrPoints);
+  lPtrFctData->pointsY = ALLOC_N(long double, lPtrFctData->nbrPoints);
+
+  // Get the X bounds
+  long double lMinX = value2ld(rb_ary_entry(rb_ary_entry(lValSortedPoints, 0), 0));
+  long double lDistX = value2ld(rb_ary_entry(rb_ary_entry(lValSortedPoints, lPtrFctData->nbrPoints-1), 0))-lMinX;
+  long double lDistSample = iIdxEndSample-iIdxBeginSample;
+
+  // Loop on each points pair
+  VALUE lValPoint;
+  tSampleIndex lPointX;
+  // Set the first point alone, as no check is performed about duplicates.
+  lValPoint = rb_ary_entry(lValSortedPoints, 0);
+  lPtrFctData->pointsX[0] = iIdxBeginSample+((tSampleIndex)((lDistSample*(value2ld(rb_ary_entry(lValPoint, 0))-lMinX))/lDistX));
+  lPtrFctData->pointsY[0] = value2ld(rb_ary_entry(lValPoint, 1));
+/*
+  printf("Function point n.0: %lld,%LF\n", lPtrFctData->pointsX[0], lPtrFctData->pointsY[0]);
+*/
+  // Loop on other points
+  int lIdxPoint;
+  int lIdxLastCPoint = 0;
+  for (lIdxPoint = 1; lIdxPoint < lPtrFctData->nbrPoints; ++lIdxPoint) {
+    lValPoint = rb_ary_entry(lValSortedPoints, lIdxPoint);
+    lPointX = iIdxBeginSample+((tSampleIndex)((lDistSample*(value2ld(rb_ary_entry(lValPoint, 0))-lMinX))/lDistX));
+    // If this abscisse is already set, change the already set one
+    if (lPtrFctData->pointsX[lIdxLastCPoint] != lPointX) {
+      ++lIdxLastCPoint;
+      lPtrFctData->pointsX[lIdxLastCPoint] = lPointX;
+    }
+    lPtrFctData->pointsY[lIdxLastCPoint] = value2ld(rb_ary_entry(lValPoint, 1));
+/*
+    printf("Function point n.%d: %lld,%LF\n", lIdxLastCPoint, lPtrFctData->pointsX[lIdxLastCPoint], lPtrFctData->pointsY[lIdxLastCPoint]);
+*/
+  }
+  // It is possible that the count differs
+  lPtrFctData->nbrPoints = lIdxLastCPoint + 1;
+
+  return rResultCode;
+}
+
+/**
+ * Create a C function based on a given function to be applied on a given discrete range.
+ *
+ * Parameters::
+ * * *iSelf* (_Object_): Calling object
+ * * *iValFunction* (<em>map<Symbol,Object></em>): The function
+ * * *iValIdxBeginSample* (<em>map<Symbol,Object></em>): The first sample for this function
+ * * *iValIdxEndSample* (<em>map<Symbol,Object></em>): The last sample for this function
+ * Return::
+ * * _Object_: The Ruby object containing the C function
+ */
+static VALUE functionutils_createCFunction(
+  VALUE iSelf,
+  VALUE iValFunction,
+  VALUE iValIdxBeginSample,
+  VALUE iValIdxEndSample) {
+  tSampleIndex iIdxBeginSample = FIX2LONG(iValIdxBeginSample);
+  tSampleIndex iIdxEndSample = FIX2LONG(iValIdxEndSample);
+
+  tFunction* lPtrCFunction = ALLOC(tFunction);
+  // Retrieve the function type
+  lPtrCFunction->fctType = FIX2INT(rb_hash_aref(iValFunction, ID2SYM(rb_intern("FunctionType"))));
+  // Call the relevant method based on the type
+  switch (lPtrCFunction->fctType) {
+    case FCTTYPE_PIECEWISE_LINEAR:
+      functionutils_fillCFunction_PiecewiseLinear(lPtrCFunction, iValFunction, iIdxBeginSample, iIdxEndSample);
+      break;
+    default: ; // The ; is here to make gcc compile: variables declarations are forbidden after a label.
+      char lLogMessage[256];
+      sprintf(lLogMessage, "Unknown function type %d", lPtrCFunction->fctType);
+      rb_funcall(iSelf, rb_intern("log_err"), 1, rb_str_new2(lLogMessage));
+      break;
+  }
+
+  return Data_Wrap_Struct(rb_cObject, NULL, volumeutils_freeCFct, lPtrCFunction);
+}
+
+// Initialize the module
+void Init_FunctionUtils() {
+  VALUE lWSKModule = rb_define_module("WSK");
+  VALUE lFunctionUtilsModule = rb_define_module_under(lWSKModule, "FunctionUtils");
+  VALUE lFunctionUtilsClass = rb_define_class_under(lFunctionUtilsModule, "FunctionUtils", rb_cObject);
+
+  rb_define_method(lFunctionUtilsClass, "createCFunction", functionutils_createCFunction, 3);
+  gID_to_s = rb_intern("to_s");
+  gID_numerator = rb_intern("numerator");
+  gID_denominator = rb_intern("denominator");
+}

data/ext/WSK/FunctionUtils/extconf.rb

@@ -0,0 +1,15 @@
+#--
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+require "#{File.dirname(__FILE__)}/../CommonBuild"
+# TODO (Cygwin): Adding -L/usr/local/lib is due to some Cygwin installs that do not include it with gcc
+$LDFLAGS += ' -L/usr/local/lib '
+begin
+  have_library('gmp')
+rescue Exception
+  puts "\n\n!!! Missing library gmp in this system. Please install it from http://gmplib.org/\n\n"
+  raise
+end
+create_makefile('FunctionUtils')

data/ext/WSK/SilentUtils/SilentUtils.c

@@ -0,0 +1,431 @@
+/**
+ * Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+ * Licensed under the terms specified in LICENSE file. No warranty is provided.
+ **/
+
+#include "ruby.h"
+#include <CommonUtils.h>
+
+// Struct used to convey data among iterators in the getNextSilentSample method
+typedef struct {
+  tSampleIndex* ptrIdxFirstSilentSample;
+  tThresholdInfo* ptrSilenceThresholds;
+  tSampleIndex* ptrIdxSilenceSample_Result;
+  tSampleIndex minSilenceSamples;
+  int nbrChannels;
+} tFindSilentStruct;
+
+// Struct used to convey data among iterators in the getFirstSampleBeyondThreshold method
+typedef struct {
+  tSampleIndex* ptrIdxSample_Result;
+  tThresholdInfo* ptrThresholds;
+  int nbrChannels;
+} tFirstSampleBeyondThresholdStruct;
+
+/**
+ * Process a value read from an input buffer for the NextSilentSample function.
+ *
+ * Parameters::
+ * * *iValue* (<em>const tSampleValue</em>): The value being read
+ * * *iIdxSample* (<em>const tSampleIndex</em>): Index of this sample
+ * * *iIdxChannel* (<em>const int</em>): Channel corresponding to the value being read
+ * * *iPtrArgs* (<em>void*</em>): additional arguments. In fact a <em>tFindSilentStruct*</em>.
+ * Return::
+ * * _int_: The return code:
+ * ** 0: Continue iteration
+ * ** 1: Break all iterations
+ * ** 2: Skip directly to the next sample (don't call us for other channels of this sample)
+ */
+int silentutils_processValue(
+  const tSampleValue iValue,
+  const tSampleIndex iIdxSample,
+  const int iIdxChannel,
+  void* iPtrArgs) {
+  int rResult = 0;
+
+  // Interpret parameters
+  tFindSilentStruct* lPtrVariables = (tFindSilentStruct*)iPtrArgs;
+
+  if ((iValue < (lPtrVariables->ptrSilenceThresholds)[iIdxChannel].min) ||
+      (iValue > (lPtrVariables->ptrSilenceThresholds)[iIdxChannel].max)) {
+    // This value is not silent
+    // If we were in silence that has not yet reached its minimal duration, cancel this last silence
+    *(lPtrVariables->ptrIdxFirstSilentSample) = -1;
+    // Don't even read other channels
+    rResult = 2;
+  } else {
+    // This value is silent
+    if ((*(lPtrVariables->ptrIdxFirstSilentSample)) == -1) {
+      // This is the first silent value we have
+      *(lPtrVariables->ptrIdxFirstSilentSample) = iIdxSample;
+    }
+    // Check if the minimal duration has been reached
+    if (iIdxSample - (*(lPtrVariables->ptrIdxFirstSilentSample)) + 1 >= lPtrVariables->minSilenceSamples) {
+      // We have found a silence according to thresholds.
+      *(lPtrVariables->ptrIdxSilenceSample_Result) = *(lPtrVariables->ptrIdxFirstSilentSample);
+      // Stop iterations
+      rResult = 1;
+    }
+  }
+
+  return rResult;
+}
+
+/**
+ * Process a value read from an input buffer for the NextSilentSample function.
+ * Do it in backwards search.
+ *
+ * Parameters::
+ * * *iValue* (<em>const tSampleValue</em>): The value being read
+ * * *iIdxSample* (<em>const tSampleIndex</em>): Index of this sample
+ * * *iIdxChannel* (<em>const int</em>): Channel corresponding to the value being read
+ * * *iPtrArgs* (<em>void*</em>): additional arguments. In fact a <em>tFindSilentStruct*</em>.
+ * Return::
+ * * _int_: The return code:
+ * ** 0: Continue iteration
+ * ** 1: Break all iterations
+ * ** 2: Skip directly to the next sample (don't call us for other channels of this sample)
+ */
+int silentutils_Reverse_processValue(
+  const tSampleValue iValue,
+  const tSampleIndex iIdxSample,
+  const int iIdxChannel,
+  void* iPtrArgs) {
+  int rResult = 0;
+
+  // Interpret parameters
+  tFindSilentStruct* lPtrVariables = (tFindSilentStruct*)iPtrArgs;
+
+  if ((iValue < (lPtrVariables->ptrSilenceThresholds)[iIdxChannel].min) ||
+      (iValue > (lPtrVariables->ptrSilenceThresholds)[iIdxChannel].max)) {
+    // This value is not silent
+    // If we were in silence that has not yet reached its minimal duration, cancel this last silence
+    *(lPtrVariables->ptrIdxFirstSilentSample) = -1;
+    // Don't even read other channels
+    rResult = 2;
+  } else {
+    // This value is silent
+    if ((*(lPtrVariables->ptrIdxFirstSilentSample)) == -1) {
+      // This is the first silent value we have
+      *(lPtrVariables->ptrIdxFirstSilentSample) = iIdxSample;
+    }
+    // Check if the minimal duration has been reached
+    if ((*(lPtrVariables->ptrIdxFirstSilentSample)) - iIdxSample + 1 >= lPtrVariables->minSilenceSamples) {
+      // We have found a silence according to thresholds.
+      *(lPtrVariables->ptrIdxSilenceSample_Result) = *(lPtrVariables->ptrIdxFirstSilentSample);
+      // Stop iterations
+      rResult = 1;
+    }
+  }
+
+  return rResult;
+}
+
+/**
+ * Code block called by getNextSilentSample in the each_raw_buffer loop.
+ * This is meant to be used with rb_iterate.
+ *
+ * Parameters::
+ * * *iValYieldArgs* (<em>list<Object></em>): The yield arguments:
+ * ** *iValInputRawBuffer* (_String_): The raw buffer
+ * ** *iValNbrSamples* (_Integer_): The number of samples in this buffer
+ * ** *iValNbrChannels* (_Integer_): The number of channels in this buffer
+ * * *iValIterateArgs* (<em>list<Object></em>): The iterate arguments:
+ * ** *iValNbrBitsPerSample* (_Integer_): Number of bits per sample
+ * ** *iValPtrIdxSample* (_Integer_): Address of the IdxSample variable
+ * ** *iValPtrIdxFirstSilentSample* (_Integer_): Address of the IdxFirstSilentSample variable
+ * ** *iValPtrSilenceThresholds* (_Integer_): Address of the SilenceThresholds variable
+ * ** *iValMinSilenceSamples* (_Integer_): Minimal silence samples
+ * ** *iValPtrIdxSilenceSample_Result* (_Integer_): Address of the IdxSilenceSample_Result variable
+ * ** *iValBackwardsSearch* (_Boolean_): Do we search backwards ?
+ */
+static VALUE silentutils_blockEachRawBuffer(
+  VALUE iValYieldArgs,
+  VALUE iValIterateArgs) {
+  // Read arguments
+  VALUE iValInputRawBuffer = rb_ary_entry(iValYieldArgs, 0);
+  VALUE iValNbrSamples = rb_ary_entry(iValYieldArgs, 1);
+  VALUE iValNbrChannels = rb_ary_entry(iValYieldArgs, 2);
+  VALUE iValNbrBitsPerSample = rb_ary_entry(iValIterateArgs, 0);
+  VALUE iValPtrIdxSample = rb_ary_entry(iValIterateArgs, 1);
+  VALUE iValPtrIdxFirstSilentSample = rb_ary_entry(iValIterateArgs, 2);
+  VALUE iValPtrSilenceThresholds = rb_ary_entry(iValIterateArgs, 3);
+  VALUE iValMinSilenceSamples = rb_ary_entry(iValIterateArgs, 4);
+  VALUE iValPtrIdxSilenceSample_Result = rb_ary_entry(iValIterateArgs, 5);
+  VALUE iValBackwardsSearch = rb_ary_entry(iValIterateArgs, 6);
+  // Translate parameters in C types
+  int iNbrBitsPerSample = FIX2INT(iValNbrBitsPerSample);
+  tSampleIndex iNbrSamples = FIX2LONG(iValNbrSamples);
+  int iNbrChannels = FIX2INT(iValNbrChannels);
+  tSampleIndex* lPtrIdxSample = (tSampleIndex*)FIX2INT(iValPtrIdxSample);
+  tSampleIndex* lPtrIdxFirstSilentSample = (tSampleIndex*)FIX2INT(iValPtrIdxFirstSilentSample);
+  tThresholdInfo* lPtrSilenceThresholds = (tThresholdInfo*)FIX2INT(iValPtrSilenceThresholds);
+  tSampleIndex iMinSilenceSamples = FIX2LONG(iValMinSilenceSamples);
+  tSampleIndex* lPtrIdxSilenceSample_Result = (tSampleIndex*)FIX2INT(iValPtrIdxSilenceSample_Result);
+
+  // Get the real underlying raw buffer
+  char* lPtrRawBuffer = RSTRING_PTR(iValInputRawBuffer);
+
+  // Set variables to give to the process
+  tFindSilentStruct lProcessVariables;
+  lProcessVariables.ptrIdxFirstSilentSample = lPtrIdxFirstSilentSample;
+  lProcessVariables.ptrSilenceThresholds = lPtrSilenceThresholds;
+  lProcessVariables.ptrIdxSilenceSample_Result = lPtrIdxSilenceSample_Result;
+  lProcessVariables.minSilenceSamples = iMinSilenceSamples;
+  lProcessVariables.nbrChannels = iNbrChannels;
+
+  // Iterate through the raw buffer
+  if (iValBackwardsSearch == Qtrue) {
+    commonutils_iterateReverseThroughRawBuffer(
+      lPtrRawBuffer,
+      iNbrBitsPerSample,
+      iNbrChannels,
+      iNbrSamples,
+      *lPtrIdxSample,
+      &silentutils_Reverse_processValue,
+      &lProcessVariables
+    );
+  } else {
+    commonutils_iterateThroughRawBuffer(
+      lPtrRawBuffer,
+      iNbrBitsPerSample,
+      iNbrChannels,
+      iNbrSamples,
+      *lPtrIdxSample,
+      &silentutils_processValue,
+      &lProcessVariables
+    );
+  }
+
+  // If the result was found in this raw buffer, stop parsing everything
+  if (*lPtrIdxSilenceSample_Result != -1) {
+    rb_iter_break();
+  }
+
+  // Modify the sample index
+  if (iValBackwardsSearch == Qtrue) {
+    (*lPtrIdxSample) -= iNbrSamples;
+  } else {
+    (*lPtrIdxSample) += iNbrSamples;
+  }
+
+  return Qnil;
+}
+
+/**
+ * Get the next silent sample from an input buffer
+ *
+ * Parameters::
+ * * *iSelf* (_FFTUtils_): Self
+ * * *iValInputData* (<em>WSK::Model::InputData</em>): The input data
+ * * *iValIdxStartSample* (_Integer_): Index of the first sample to search from
+ * * *iValSilenceThresholds* (<em>list< [Integer,Integer] ></em>): The silence thresholds specifications
+ * * *iValMinSilenceSamples* (_Integer_): Number of samples minimum to identify a silence
+ * * *iValBackwardsSearch* (_Boolean_): Do we search backwards ?
+ * Return::
+ * * _Integer_: Index of the next silent sample, or nil if none
+ **/
+static VALUE silentutils_getNextSilentInThresholds(
+  VALUE iSelf,
+  VALUE iValInputData,
+  VALUE iValIdxStartSample,
+  VALUE iValSilenceThresholds,
+  VALUE iValMinSilenceSamples,
+  VALUE iValBackwardsSearch) {
+  VALUE rValNextSilentSample = Qnil;
+
+  // Translate parameters in C types
+  tSampleIndex iIdxStartSample = FIX2LONG(iValIdxStartSample);
+
+  // The cursor of samples. Set it to the first sample we start from searching.
+  tSampleIndex lIdxSample = iIdxStartSample;
+  // Read some info from the Header
+  VALUE lValHeader = rb_funcall(iValInputData, rb_intern("Header"), 0);
+  VALUE lValNbrBitsPerSample = rb_funcall(lValHeader, rb_intern("NbrBitsPerSample"), 0);
+  VALUE lValNbrChannels = rb_funcall(lValHeader, rb_intern("NbrChannels"), 0);
+  // Decode the thresholds
+  int lNbrChannels = FIX2INT(lValNbrChannels);
+  tThresholdInfo lSilenceThresholds[lNbrChannels];
+  VALUE lTmpThresholds;
+  int lIdxChannel;
+  for(lIdxChannel = 0; lIdxChannel < lNbrChannels; ++lIdxChannel) {
+    lTmpThresholds = rb_ary_entry(iValSilenceThresholds, lIdxChannel);
+    lSilenceThresholds[lIdxChannel].min = FIX2INT(rb_ary_entry(lTmpThresholds, 0));
+    lSilenceThresholds[lIdxChannel].max = FIX2INT(rb_ary_entry(lTmpThresholds, 1));
+  }
+
+  // Index of the first silent sample encountered while parsing.
+  // Used to assert the minimal duration of the silence. -1 means we don't have one yet.
+  tSampleIndex lIdxFirstSilentSample;
+  // The result
+  tSampleIndex lIdxSilenceSample_Result;
+
+  // Encapsulate pointers to the data that will be used and modified by the iteration block
+  VALUE lValPtrIdxSample = INT2FIX(&lIdxSample);
+  VALUE lValPtrIdxFirstSilentSample = INT2FIX(&lIdxFirstSilentSample);
+  VALUE lValPtrSilenceThresholds = INT2FIX(&lSilenceThresholds);
+  VALUE lValPtrIdxSilenceSample_Result = INT2FIX(&lIdxSilenceSample_Result);
+
+  lIdxFirstSilentSample = -1;
+  lIdxSilenceSample_Result = -1;
+
+  // Parse the data, using thresholds matching only
+  if (iValBackwardsSearch == Qtrue) {
+    rb_iterate(
+      commonutils_callEachReverseRawBuffer,
+      rb_ary_new3(2,
+        iValInputData,
+        LONG2FIX(lIdxSample)),
+      silentutils_blockEachRawBuffer,
+      rb_ary_new3(7,
+        lValNbrBitsPerSample,
+        lValPtrIdxSample,
+        lValPtrIdxFirstSilentSample,
+        lValPtrSilenceThresholds,
+        iValMinSilenceSamples,
+        lValPtrIdxSilenceSample_Result,
+        iValBackwardsSearch)
+    );
+  } else {
+    rb_iterate(
+      commonutils_callEachRawBuffer,
+      rb_ary_new3(2,
+        iValInputData,
+        LONG2FIX(lIdxSample)),
+      silentutils_blockEachRawBuffer,
+      rb_ary_new3(7,
+        lValNbrBitsPerSample,
+        lValPtrIdxSample,
+        lValPtrIdxFirstSilentSample,
+        lValPtrSilenceThresholds,
+        iValMinSilenceSamples,
+        lValPtrIdxSilenceSample_Result,
+        iValBackwardsSearch)
+    );
+  }
+
+  if (lIdxSilenceSample_Result != -1) {
+    rValNextSilentSample = LONG2FIX(lIdxSilenceSample_Result);
+  }
+
+  return rValNextSilentSample;
+}
+
+/**
+ * Process a value read from an input buffer for the NextSilentSample function.
+ *
+ * Parameters::
+ * * *iValue* (<em>const tSampleValue</em>): The value being read
+ * * *iIdxSample* (<em>const tSampleIndex</em>): Index of this sample
+ * * *iIdxChannel* (<em>const int</em>): Channel corresponding to the value being read
+ * * *iPtrArgs* (<em>void*</em>): additional arguments. In fact an <em>tFirstSampleBeyondThresholdStruct*</em>.
+ * Return::
+ * * _int_: The return code:
+ * ** 0: Continue iteration
+ * ** 1: Break all iterations
+ * ** 2: Skip directly to the next sample (don't call us for other channels of this sample)
+ */
+int silentutils_sbt_processValue(
+  const tSampleValue iValue,
+  const tSampleIndex iIdxSample,
+  const int iIdxChannel,
+  void* iPtrArgs) {
+  int rResult = 0;
+
+  // Interpret parameters
+  tFirstSampleBeyondThresholdStruct* lPtrVariables = (tFirstSampleBeyondThresholdStruct*)iPtrArgs;
+
+  if ((iValue < (lPtrVariables->ptrThresholds)[iIdxChannel].min) ||
+      (iValue > (lPtrVariables->ptrThresholds)[iIdxChannel].max)) {
+    // This value is not silent
+    rResult = 1;
+    *(lPtrVariables->ptrIdxSample_Result) = iIdxSample;
+  }
+
+  return rResult;
+}
+
+/**
+ * Get the sample index that exceeds a threshold in a raw buffer.
+ *
+ * Parameters::
+ * * *iSelf* (_FFTUtils_): Self
+ * * *iValRawBuffer* (_String_): The raw buffer
+ * * *iValThresholds* (<em>list< [Integer,Integer] ></em>): The thresholds
+ * * *iValNbrBitsPerSample* (_Integer_): Number of bits per sample
+ * * *iValNbrChannels* (_Integer_): Number of channels
+ * * *iValNbrSamples* (_Integer_): Number of samples
+ * * *iValLastSample* (_Boolean_): Are we looking for the last sample beyond threshold ?
+ * Return::
+ * * _Integer_: Index of the first sample exceeding thresholds, or nil if none
+ */
+static VALUE silentutils_getSampleBeyondThresholds(
+  VALUE iSelf,
+  VALUE iValRawBuffer,
+  VALUE iValThresholds,
+  VALUE iValNbrBitsPerSample,
+  VALUE iValNbrChannels,
+  VALUE iValNbrSamples,
+  VALUE iValLastSample) {
+  VALUE rValIdxFirstSample = Qnil;
+
+  // Translate parameters in C types
+  tSampleIndex iNbrSamples = FIX2LONG(iValNbrSamples);
+  int iNbrChannels = FIX2INT(iValNbrChannels);
+  int iNbrBitsPerSample = FIX2INT(iValNbrBitsPerSample);
+  // Get the underlying char*
+  char* lPtrRawBuffer = RSTRING_PTR(iValRawBuffer);
+  // Decode the thresholds
+  tThresholdInfo lThresholds[iNbrChannels];
+  VALUE lTmpThresholds;
+  int lIdxChannel;
+  for(lIdxChannel = 0; lIdxChannel < iNbrChannels; ++lIdxChannel) {
+    lTmpThresholds = rb_ary_entry(iValThresholds, lIdxChannel);
+    lThresholds[lIdxChannel].min = FIX2INT(rb_ary_entry(lTmpThresholds, 0));
+    lThresholds[lIdxChannel].max = FIX2INT(rb_ary_entry(lTmpThresholds, 1));
+  }
+  // Set variables to give to the process
+  tSampleIndex lIdxSampleOut = -1;
+  tFirstSampleBeyondThresholdStruct lProcessVariables;
+  lProcessVariables.ptrThresholds = &lThresholds[0];
+  lProcessVariables.ptrIdxSample_Result = &lIdxSampleOut;
+  lProcessVariables.nbrChannels = iNbrChannels;
+
+  // Parse the buffer
+  if (iValLastSample == Qtrue) {
+    commonutils_iterateReverseThroughRawBuffer(
+      lPtrRawBuffer,
+      iNbrBitsPerSample,
+      iNbrChannels,
+      iNbrSamples,
+      iNbrSamples-1,
+      &silentutils_sbt_processValue,
+      &lProcessVariables
+    );
+  } else {
+    commonutils_iterateThroughRawBuffer(
+      lPtrRawBuffer,
+      iNbrBitsPerSample,
+      iNbrChannels,
+      iNbrSamples,
+      0,
+      &silentutils_sbt_processValue,
+      &lProcessVariables
+    );
+  }
+  if (lIdxSampleOut != -1) {
+    rValIdxFirstSample = LONG2FIX(lIdxSampleOut);
+  }
+
+  return rValIdxFirstSample;
+}
+
+// Initialize the module
+void Init_SilentUtils() {
+  VALUE lWSKModule = rb_define_module("WSK");
+  VALUE lSilentUtilsModule = rb_define_module_under(lWSKModule, "SilentUtils");
+  VALUE lSilentUtilsClass = rb_define_class_under(lSilentUtilsModule, "SilentUtils", rb_cObject);
+
+  rb_define_method(lSilentUtilsClass, "getNextSilentInThresholds", silentutils_getNextSilentInThresholds, 5);
+  rb_define_method(lSilentUtilsClass, "getSampleBeyondThresholds", silentutils_getSampleBeyondThresholds, 6);
+}

data/ext/WSK/SilentUtils/extconf.rb

@@ -0,0 +1,7 @@
+#--
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+require "#{File.dirname(__FILE__)}/../CommonBuild"
+create_makefile('SilentUtils')