WaveSwissKnife 0.0.1.20101110-x86-cygwin

data/ext/WSK/SilentUtils/SilentUtils.c

@@ -0,0 +1,431 @@
+/**
+ * Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+ * 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 eachRawBuffer 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(iValInputRawBuffer)->ptr;
+
+  // 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(iValRawBuffer)->ptr;
+  // 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/build.rb

@@ -0,0 +1,18 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+lAdditionalLocalLibs = [
+  'CommonUtils'
+]
+
+require 'mkmf'
+$CFLAGS += ' -Wall '
+lAdditionalLocalLibs.each do |iLibName|
+  lLibDir = File.expand_path("#{File.dirname(__FILE__)}/../../../external/#{iLibName}")
+  $CFLAGS += " -I#{lLibDir}/include "
+  $LDFLAGS += " -L#{lLibDir}/lib -l#{iLibName} "
+end
+create_makefile('SilentUtils')
+system('make')

data/ext/WSK/VolumeUtils/Makefile

@@ -0,0 +1,149 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /usr/lib/ruby/1.8/i386-cygwin
+hdrdir = $(topdir)
+VPATH = $(srcdir):$(topdir):$(hdrdir)
+prefix = $(DESTDIR)/usr
+exec_prefix = $(prefix)
+sitedir = $(prefix)/lib/ruby/site_ruby
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+docdir = $(datarootdir)/doc/$(PACKAGE)
+dvidir = $(docdir)
+datarootdir = $(prefix)/share
+archdir = $(rubylibdir)/$(arch)
+sbindir = $(exec_prefix)/sbin
+psdir = $(docdir)
+localedir = $(datarootdir)/locale
+htmldir = $(docdir)
+datadir = $(prefix)/share
+includedir = $(prefix)/include
+infodir = $(prefix)/share/info
+sysconfdir = $(DESTDIR)/etc
+mandir = $(prefix)/share/man
+libdir = $(exec_prefix)/lib
+sharedstatedir = $(prefix)/com
+oldincludedir = $(DESTDIR)/usr/include
+pdfdir = $(docdir)
+sitearchdir = $(sitelibdir)/$(sitearch)
+bindir = $(exec_prefix)/bin
+localstatedir = $(DESTDIR)/var
+sitelibdir = $(sitedir)/$(ruby_version)
+libexecdir = $(prefix)/sbin
+
+CC = gcc
+LIBRUBY = lib$(RUBY_SO_NAME).dll.a
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+
+RUBY_EXTCONF_H = 
+CFLAGS   =  -g -O2  -Wall  -I/cygdrive/f/RR/Source/waveswissknife/svn/waveswissknife/external/CommonUtils/include  
+INCFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir)
+CPPFLAGS =  
+CXXFLAGS = $(CFLAGS) 
+DLDFLAGS = -L.  -L/usr/local/lib -lgmp  -L/cygdrive/f/RR/Source/waveswissknife/svn/waveswissknife/external/CommonUtils/lib -lCommonUtils   -Wl,--enable-auto-image-base,--enable-auto-import,--export-all 
+LDSHARED = gcc -shared -s
+AR = ar
+EXEEXT = .exe
+
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby
+arch = i386-cygwin
+sitearch = i386-cygwin
+ruby_version = 1.8
+ruby = /usr/bin/ruby
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir)
+LIBPATH =  -L"." -L"$(libdir)"
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -ldl -lcrypt  
+SRCS = VolumeUtils.c
+OBJS = VolumeUtils.o
+TARGET = VolumeUtils
+DLLIB = $(TARGET).so
+EXTSTATIC = 
+STATIC_LIB = 
+
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).so $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.C.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $<
+
+$(DLLIB): $(OBJS)
+	@-$(RM) $@
+	$(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h