fileshunter 0.1.0.20130725

data/AUTHORS

@@ -0,0 +1,3 @@
+= Muriel Salvan (muriel@x-aeon.com)
+
+* 1.0.0.20130611

data/ChangeLog

@@ -0,0 +1,5 @@
+= FilesHunter Release History
+
+== 0.1.0.20130725 (Beta)
+
+* Initial public release.

data/Credits

@@ -0,0 +1,21 @@
+= Projects used by FilesHunter
+
+== bindata
+* Dion Mendel (https://github.com/dmendel)
+* https://github.com/dmendel/bindata
+* Used to parse binary data efficiently.
+
+== IOBlockReader
+* Muriel Salvan (http://murielsalvan.users.sourceforge.net)
+* http://ioblockreader.sourceforge.net
+* Used to read files efficiently.
+
+== Ruby
+* Yukihiro « matz » Matsumoto (http://www.rubyist.net/~matz/)
+* http://www.ruby-lang.org/
+* Thanks a lot Matz for this truly wonderful language!
+
+== rUtilAnts
+* Muriel Salvan (http://murielsalvan.users.sourceforge.net)
+* http://rutilants.sourceforge.net
+* Used for plugins and logging handling.

data/LICENSE

@@ -0,0 +1,31 @@
+
+The license stated herein is a copy of the BSD License (modified on July 1999).
+The AUTHOR mentionned below refers to the list of people involved in the
+creation and modification of any file included in the delivered package.
+This list is found in the file named AUTHORS.
+The AUTHORS and LICENSE files have to be included in any release of software
+embedding source code of this package, or using it as a derivative software.
+
+Copyright (c) 2010 - 2013 Muriel Salvan (muriel@x-aeon.com)
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+   2. Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+   3. The name of the author may not be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+OF SUCH DAMAGE.

data/README

@@ -0,0 +1,15 @@
+= Files Hunter
+
+Analyze files to get their real format. Ideal to retrieve hidden and corrupted files.
+
+== Where is the documentation ?
+
+Check the website at https://github.com/Muriel-Salvan/files-hunter
+
+== Who wrote it ?
+
+Check the AUTHORS[link:AUTHORS.html] file.
+
+== What is the license ?
+
+You can find out in the LICENSE[link:LICENSE.html] file.

data/README.md

@@ -0,0 +1,11 @@
+FilesHunter
+=============
+
+Analyze files to get their real format. Ideal to retrieve hidden and corrupted files.
+
+Analyze files and guess their true content\'s format.
+Extract hidden files from corrupted ones.
+Easily extensible by adding new plug-ins for new formats.
+Handles documents, videos, images, music, executables...
+
+[See its documentation here.](http://fileshunter.sourceforge.net)

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+
+task :test do |t|
+  load("#{File.dirname(__FILE__)}/test/run.rb")
+end
+
+task :default => :test

data/ReleaseInfo

@@ -0,0 +1,8 @@
+
+# This file has been generated by RubyPackager during a delivery.
+# More info about RubyPackager: http://rubypackager.sourceforge.net
+{
+  :version => '0.1.0.20130725',
+  :tags => [ 'Beta' ],
+  :dev_status => 'Beta'
+}

data/bin/fileshunt

@@ -0,0 +1,216 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'fileshunter'
+require 'fileutils'
+
+module FilesHunter
+
+  class Extractor
+
+    # Constructor
+    def initialize
+      # Default options
+      @extract = false
+      @display_help = false
+      @debug = false
+      @log = false
+      @block_size = 134217728
+      @extract_dir = nil
+      # The command line parser
+      @options = OptionParser.new
+      @options.banner = 'fileshunt [--help] [--debug] [--extract] [--extractdir <DirectoryName>] [--log] [--blocksize <BlockSizeInBytes>] <FileName1> <FileName2> ...'
+      @options.on( '--extract',
+        'Extract found segments as extra files next to the analyzed ones (named from the original file name and __EXTRACT__ suffixes).') do
+        @extract = true
+      end
+      @options.on( '--log',
+        'Log found segments in various log files (named fileshunt*.log).') do
+        @log = true
+      end
+      @options.on( '--extractdir <DirectoryName>', String,
+        '<DirectoryName>: Directory name to extract to.',
+        'Specify the directory where extracted files are written. If none specified, they will be written next to original files.') do |arg|
+        @extract_dir = arg
+      end
+      @options.on( '--blocksize <BlockSizeInBytes>', Integer,
+        "<BlockSizeInBytes>: Size of blocks to read at once from disk. Default = #{@block_size}.",
+        'Specify the block size when reading from files') do |arg|
+        @block_size = arg
+      end
+      @options.on( '--help',
+        'Display help') do
+        @display_help = true
+      end
+      @options.on( '--debug',
+        'Activate debug logs') do
+        @debug = true
+      end
+    end
+
+    # Executes the extractor
+    #
+    # Parameters::
+    # * *args* (<em>list<String></em>): Arguments given to the extractor
+    def execute(args)
+      # Analyze arguments
+      remaining_args = @options.parse(args)
+
+      if @display_help
+        puts @options
+      else
+        activate_log_debug(true) if @debug
+        if @log
+          # Clean log files
+          File.unlink(EXTRACTOR_LOG) if (File.exist?(EXTRACTOR_LOG))
+          File.unlink(EXTRACTOR_1_LOG) if (File.exist?(EXTRACTOR_1_LOG))
+          File.unlink(EXTRACTOR_2_20_LOG) if (File.exist?(EXTRACTOR_2_20_LOG))
+          File.unlink(EXTRACTOR_20_LOG) if (File.exist?(EXTRACTOR_20_LOG))
+        end
+
+        # Compute the list of files
+        files = []
+        if (remaining_args.empty?)
+          # Put current directory
+          log_debug 'Adding current directory to inspect'
+          files = Dir.glob("#{Dir.getwd}/**/*")
+        else
+          remaining_args.each do |file_name|
+            if (File.exists?(file_name))
+              if (File.directory?(file_name))
+                log_debug "Adding directory #{file_name} to inspect"
+                files.concat(Dir.glob("#{file_name}/**/*"))
+              else
+                log_debug "Adding file #{file_name} to inspect"
+                files << file_name
+              end
+            else
+              # Might have wildcards in it
+              log_debug "Adding filter #{file_name} to inspect"
+              lst_files = Dir.glob(file_name)
+              if (lst_files.empty?)
+                log_warn "Unable to find file: #{file_name}"
+              else
+                files.concat(lst_files)
+              end
+            end
+          end
+        end
+        # Remove already extracted files from the list
+        files.select! { |file_name| ((file_name =~ /\.__EXTRACT__\./) == nil) }
+
+        # Analyze them
+        analyze_files(files)
+      end
+    end
+
+    private
+
+    EXTRACTOR_LOG = 'fileshunt.log'
+    EXTRACTOR_1_LOG = 'fileshunt_1_segment.log'
+    EXTRACTOR_2_20_LOG = 'fileshunt_2-20_segments.log'
+    EXTRACTOR_20_LOG = 'fileshunt_20_segments.log'
+
+    # Analyze a list of files
+    #
+    # Parameters::
+    # * *files* (<em>list<String></em>): List of file names to analyze
+    def analyze_files(files)
+      nbr_files = files.size
+      if (nbr_files == 0)
+        log_info 'No file found to be analyzed.'
+      else
+        segments_analyzer = FilesHunter::get_segments_analyzer(:block_Size => @block_size)
+        start_time = Time.now
+        files.each_with_index do |file_name, idx|
+          log_debug "Handle file #{file_name}"
+          # List of segments identified in this file
+          segments = segments_analyzer.get_segments(file_name)
+
+          report_line = "[#{file_name}] - Found #{segments.size} segments: #{segments.map { |segment| "#{segment.extensions.join(',')}#{segment.truncated ? ' (truncated)' : ''}#{segment.missing_previous_data ? ' (missing previous data)' : ''}[#{segment.begin_offset}-#{segment.end_offset}]" }}"
+          log_info report_line
+          if debug_activated?
+            segments.each_with_index do |segment, idx_segment|
+              log_debug "+ ##{idx_segment} [#{segment.begin_offset}-#{segment.end_offset}]: #{segment.extensions.join(', ')}#{segment.truncated ? ' (truncated)' : ''}#{segment.missing_previous_data ? ' (missing previous data)' : ''}"
+              segment.metadata.each do |key, value|
+                log_debug "  - #{key} => #{value.inspect}"
+              end
+            end
+          end
+
+          if @log
+            log_files = [EXTRACTOR_LOG]
+            if (segments.size == 1)
+              log_files << EXTRACTOR_1_LOG
+            elsif (segments.size <= 20)
+              log_files << EXTRACTOR_2_20_LOG
+            else
+              log_files << EXTRACTOR_20_LOG
+            end
+            log_files.each do |log_file|
+              File.open(log_file, 'a') do |file|
+                file.puts report_line
+              end
+            end
+          end
+
+          # Write them on disk
+          if (@extract and
+              (segments.size > 1))
+            File.open(file_name, 'rb') do |file|
+              content = IOBlockReader.init(file, :block_size => 64*1048576)
+              segments.each_with_index do |segment, segment_idx|
+                write_segment(content, segment_idx, segment, file_name)
+              end
+            end
+          end
+
+          elapsed_time = Time.now-start_time
+          total_time = (elapsed_time*nbr_files)/(idx+1)
+          $stdout.write "[#{((idx*100)/nbr_files).to_i}%] - [ #{print_time(total_time-elapsed_time)} / #{print_time(total_time)} ] - #{file_name}     \r"
+        end
+      end
+    end
+
+    # Write a segment to disk
+    #
+    # Parameters::
+    # * *data* (_IOBlockReader_): The data containing the segment to be written
+    # * *index* (_Fixnum_): Index of the segment
+    # * *segment* (_Segment_): Segment to be written
+    # * *file_name* (_String_): File name containing the original data
+    def write_segment(data, index, segment, file_name)
+      file_name_suffix = ".__EXTRACT__.#{sprintf('%.4d', index)}.#{segment.truncated ? 'truncated.' : ''}#{segment.missing_previous_data ? 'missing_previous_data.' : ''}#{segment.extensions[0].to_s}"
+      extracted_file_name = nil
+      if (@extract_dir == nil)
+        extracted_file_name = "#{file_name}#{file_name_suffix}"
+      else
+        extracted_file_name = "#{@extract_dir}/#{file_name}#{file_name_suffix}"
+        FileUtils::mkdir_p(File.dirname(extracted_file_name))
+      end
+      log_info "Write extracted segment in #{extracted_file_name}"
+      File.open(extracted_file_name, 'wb') do |file|
+        data.each_block(segment.begin_offset..segment.end_offset-1) do |block_data|
+          file.write(block_data)
+        end
+      end
+    end
+
+    # Get a number of seconds in a nice way
+    #
+    # Parameters::
+    # * *nbr_secs* (_Fixnum_): Number of seconds
+    # Result::
+    # * _String_: Formatted way
+    def print_time(nbr_secs)
+      secs  = nbr_secs.to_i
+      mins  = secs / 60
+      hours = mins / 60
+      return "#{hours}:#{sprintf('%.2d',mins % 60)}:#{sprintf('%.2d',secs % 60)}"
+    end
+
+  end
+
+end
+
+FilesHunter::Extractor.new.execute(ARGV)

data/ext/fileshunter/Decoders/_FLAC.c

@@ -0,0 +1,233 @@
+#include "ruby.h"
+
+//#define DEBUG
+
+/** Load the data block containing a given offset and update variables pointing to the underlying data.
+ *
+ * Parameters::
+ * * *rb_self* (_FLAC_): Self
+ * * *rb_data* (_IOBlockReader_): Data
+ * * *offset* (_int_): Offset indicating the block to be loaded
+ * * *ptr_str_cursor* (uint8_t**_): [Result] C-String that points on the offset
+ * * *ptr_str_cursor_start* (uint8_t**_): [Result] C-String that points on the offset too
+ * * *ptr_str_cursor_end* (uint8_t**_): [Result] C-String that points on the end of the block
+ * * *ptr_last_data_block* (_int*_): [Result] Boolean indicating if the data block is the last one. The bool has to be previsouly set to the value of the previous block.
+ **/
+void load_next_block(
+  VALUE rb_self,
+  VALUE rb_data,
+  int offset,
+  uint8_t** ptr_str_cursor,
+  uint8_t** ptr_str_cursor_start,
+  uint8_t** ptr_str_cursor_end,
+  int* ptr_last_data_block) {
+  // Check that there is data to read
+  if (*ptr_last_data_block) {
+    rb_funcall(rb_self, rb_intern("truncated_data"), 2, rb_str_new2("Unable to get next block to read"), rb_ivar_get(rb_self, rb_intern("@end_offset")));
+  }
+  // Load the block in memory and get it
+  VALUE rb_result = rb_funcall(rb_data, rb_intern("get_block_containing_offset"), 1, INT2FIX(offset));
+  VALUE rb_str_data_block = rb_ary_entry(rb_result, 0);
+  uint32_t size_data_block = RSTRING_LEN(rb_str_data_block);
+  uint32_t offset_data_block = FIX2INT(rb_ary_entry(rb_result, 1));
+  *ptr_last_data_block = (rb_ary_entry(rb_result, 2) == Qtrue);
+  *ptr_str_cursor_start = RSTRING_PTR(rb_str_data_block) + offset - offset_data_block;
+  *ptr_str_cursor = (*ptr_str_cursor_start);
+  *ptr_str_cursor_end = RSTRING_PTR(rb_str_data_block) + size_data_block;
+  //printf("Next block loaded correctly: @%u (size=%u) &start=%u &end=%u\n", offset, size_data_block, *ptr_str_cursor_start, *ptr_str_cursor_end);
+}
+
+/** Decode data at a given cursor and cursor_bits position as a given number of samples encoded in a Rice partition
+ *
+ * Parameters::
+ * * *rb_self* (_FLAC_): Self
+ * * *rb_cursor* (_Fixnum_): Current cursor
+ * * *rb_cursor_bits* (_Fixnum_): Current cursor_bits
+ * * *rb_nbr_samples* (_Fixnum_): Number of samples to decode
+ * * *rb_rice_parameter* (_Fixnum_): Rice parameter
+ * Return::
+ * * _Fixnum_: New cursor
+ * * _Fixnum_: New cursor_bits
+ **/
+static VALUE flac_decode_rice(
+  VALUE rb_self,
+  VALUE rb_cursor,
+  VALUE rb_cursor_bits,
+  VALUE rb_nbr_samples,
+  VALUE rb_rice_parameter) {
+  // Translate Ruby objects
+  uint32_t cursor = FIX2INT(rb_cursor);
+  uint32_t cursor_bits = FIX2INT(rb_cursor_bits);
+  uint32_t nbr_samples = FIX2INT(rb_nbr_samples);
+  uint32_t rice_parameter = FIX2INT(rb_rice_parameter);
+  VALUE rb_data = rb_ivar_get(rb_self, rb_intern("@data"));
+  // Initialize the data stream
+  int last_data_block = 0;
+  uint8_t* str_cursor;
+  uint8_t* str_cursor_start;
+  uint8_t* str_cursor_end;
+  load_next_block(rb_self, rb_data, cursor, &str_cursor, &str_cursor_start, &str_cursor_end, &last_data_block);
+  // Temporary variables
+  uint8_t current_byte;
+  int found;
+  uint32_t bits_count;
+  uint32_t idx_sample;
+#ifdef DEBUG
+  uint32_t high_part;
+  uint32_t low_part;
+  uint32_t remaining_bits_to_decode;
+  int32_t value;
+  uint32_t temp;
+#endif
+
+  // Loop on samples
+  for (idx_sample = 0; idx_sample < nbr_samples; ++idx_sample) {
+
+    // cursor is the offset of str_cursor_start in the data stream.
+    // str_cursor, cursor_bits point to the data being decoded.
+    // str_cursor_start points to the beginning of the current data block
+    // str_cursor_end points to the end of the current data block
+    // last_data_block indicates if this is the last block
+
+    // 1. Decode next bits as a unary encoded number: this will be the high bits of the value
+    //printf("@%u,%u - 0 cursor=%u str_cursor=%u str_cursor_end=%u\n", cursor+str_cursor-str_cursor_start, cursor_bits, cursor, str_cursor-str_cursor_start, str_cursor_end-str_cursor_start);
+#ifdef DEBUG
+    printf("@%u,%u - Reading %u\n", cursor+str_cursor-str_cursor_start, cursor_bits, *str_cursor);
+    high_part = 0;
+#endif
+    found = 0;
+    if (cursor_bits > 0) {
+      // Consider ending bits of current byte
+      current_byte = *str_cursor;
+      while ((cursor_bits < 8) &&
+             ((current_byte & (1 << (7-cursor_bits))) == 0)) {
+        ++cursor_bits;
+#ifdef DEBUG
+        ++high_part;
+#endif
+      }
+      if (cursor_bits == 8) {
+        // Not found in the current byte
+        ++str_cursor;
+      } else {
+        // Found it
+        found = 1;
+      }
+    }
+    //printf("@%u,%u - 0.5 cursor=%u str_cursor=%u str_cursor_end=%u\n", cursor+str_cursor-str_cursor_start, cursor_bits, cursor, str_cursor-str_cursor_start, str_cursor_end-str_cursor_start);
+    if (!found) {
+      // Here we are byte-aligned
+      // str_cursor points on the byte we are starting to search from (can be at the end of our current block)
+      // cursor_bits has no significant value
+      // First check if we need to read an extra block
+      if (str_cursor == str_cursor_end) {
+        cursor += str_cursor - str_cursor_start;
+        load_next_block(rb_self, rb_data, cursor, &str_cursor, &str_cursor_start, &str_cursor_end, &last_data_block);
+      }
+      // Now we can continue our inspection
+      // Loop until we find a non-null byte
+      while (!found) {
+        while ((str_cursor != str_cursor_end) &&
+               ((*str_cursor) == 0)) {
+          ++str_cursor;
+#ifdef DEBUG
+          high_part += 8;
+#endif
+        }
+        if (str_cursor == str_cursor_end) {
+          cursor += str_cursor - str_cursor_start;
+          load_next_block(rb_self, rb_data, cursor, &str_cursor, &str_cursor_start, &str_cursor_end, &last_data_block);
+        } else {
+          found = 1;
+        }
+      }
+      //printf("@%u,%u - 0.8 cursor=%u str_cursor=%u str_cursor_end=%u\n", cursor+str_cursor-str_cursor_start, cursor_bits, cursor, str_cursor-str_cursor_start, str_cursor_end-str_cursor_start);
+      // Here, str_cursor points on the first non-null byte
+      current_byte = *str_cursor;
+      cursor_bits = 0;
+      while ((cursor_bits < 8) &&
+             ((current_byte & (1 << (7-cursor_bits))) == 0)) {
+        ++cursor_bits;
+#ifdef DEBUG
+        ++high_part;
+#endif
+      }
+    }
+    // Here, str_cursor and cursor_bits point on the first bit set to 1
+    //printf("@%u,%u - 1 cursor=%u str_cursor=%u str_cursor_end=%u\n", cursor+str_cursor-str_cursor_start, cursor_bits, cursor, str_cursor-str_cursor_start, str_cursor_end-str_cursor_start);
+
+    // 2. Read the next rice_parameter bits: this will be the low bits of the value
+#ifdef DEBUG
+    printf("@%u,%u - Got high part (%u). Now decode low value (%u bits)\n", cursor+str_cursor-str_cursor_start, cursor_bits, high_part, rice_parameter);
+    ++cursor_bits;
+    if (cursor_bits == 8) {
+      cursor_bits = 0;
+      ++str_cursor;
+      if (str_cursor == str_cursor_end) {
+        cursor += str_cursor - str_cursor_start;
+        load_next_block(rb_self, rb_data, cursor, &str_cursor, &str_cursor_start, &str_cursor_end, &last_data_block);
+      }
+    }
+    if (cursor_bits + rice_parameter <= 8) {
+      // The value can be decoded using current byte only
+      low_part = ((*str_cursor) & ((1 << (8-cursor_bits)) - 1)) >> (8-cursor_bits-rice_parameter);
+      cursor_bits += rice_parameter;
+    } else {
+      // Decode current byte and go on next ones
+      low_part = (*str_cursor) & ((1 << (8-cursor_bits)) - 1);
+      printf("@%u,%u - A - low_part=%u\n", cursor+str_cursor-str_cursor_start, cursor_bits, low_part);
+      ++str_cursor;
+      remaining_bits_to_decode = rice_parameter - 8 + cursor_bits;
+      cursor_bits = 0;
+      while (remaining_bits_to_decode > 0) {
+        // Here we are byte aligned
+        if (str_cursor == str_cursor_end) {
+          cursor += str_cursor - str_cursor_start;
+          load_next_block(rb_self, rb_data, cursor, &str_cursor, &str_cursor_start, &str_cursor_end, &last_data_block);
+        }
+        if (remaining_bits_to_decode >= 8) {
+          low_part = (low_part << 8) + (*str_cursor);
+          printf("@%u,%u - B (%u) - low_part=%u\n", cursor+str_cursor-str_cursor_start, cursor_bits, remaining_bits_to_decode, low_part);
+          ++str_cursor;
+          remaining_bits_to_decode -= 8;
+        } else {
+          // This byte is the last one to decode
+          temp = low_part;
+          low_part = (low_part << remaining_bits_to_decode) + ((*str_cursor) >> (8-remaining_bits_to_decode));
+          printf("@%u,%u - C (%u) - low_part=%u (%u + %u)\n", cursor+str_cursor-str_cursor_start, cursor_bits, remaining_bits_to_decode, low_part, (temp << remaining_bits_to_decode), (current_byte >> (8-remaining_bits_to_decode)));
+          cursor_bits = remaining_bits_to_decode;
+          remaining_bits_to_decode = 0;
+        }
+      }
+    }
+    // Here we have high_part and low_part
+    value = (high_part << (rice_parameter-1)) + (low_part >> 1);
+    if ((low_part & 1) == 1) {
+      value = -value-1;
+    }
+    printf("@%u,%u - Residual[%u]=%d (%u and %u)\n", cursor+str_cursor-str_cursor_start, cursor_bits, idx_sample, value, high_part, low_part);
+#else
+    bits_count = cursor_bits + 1 + rice_parameter;
+    cursor_bits = (bits_count & 7);
+    str_cursor += (bits_count >> 3);
+    if (str_cursor >= str_cursor_end) {
+      cursor += str_cursor - str_cursor_start;
+      load_next_block(rb_self, rb_data, cursor, &str_cursor, &str_cursor_start, &str_cursor_end, &last_data_block);
+    }
+    //printf("@%u,%u - 2 cursor=%u str_cursor=%u str_cursor_end=%u\n", cursor+str_cursor-str_cursor_start, cursor_bits, cursor, str_cursor-str_cursor_start, str_cursor_end-str_cursor_start);
+#endif
+
+  }
+
+  return rb_ary_new3(2, INT2FIX(cursor+str_cursor-str_cursor_start), INT2FIX(cursor_bits));
+}
+
+// Initialize the module
+void Init__FLAC() {
+  VALUE rb_mFilesHunter = rb_define_module("FilesHunter");
+  VALUE rb_mDecoders = rb_define_module_under(rb_mFilesHunter, "Decoders");
+  VALUE rb_cDecoder = rb_define_class_under(rb_mFilesHunter, "Decoder", rb_cObject);
+  VALUE rb_cBeginPatternDecoder = rb_define_class_under(rb_mFilesHunter, "BeginPatternDecoder", rb_cDecoder);
+  VALUE rb_cFLAC = rb_define_class_under(rb_mDecoders, "FLAC", rb_cBeginPatternDecoder);
+  rb_define_method(rb_cFLAC, "decode_rice", flac_decode_rice, 4);
+}

data/ext/fileshunter/Decoders/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('_FLAC')