libsamplerate 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ee15d47be4e3b7cc4d7ed3e0655c1b7ca2fdcb6e48d93dd3ed80ad7778924595
+  data.tar.gz: '04119ee09a4fe0fbeb01cd67c311c88361973c4db495303b821c42020d948139'
+SHA512:
+  metadata.gz: e7bb7f868cf5c609d79fa4a63e68611256cc636f9ae52ca2da7ddb99d771b338d120b84b34ea6bcfcab0c4845bf1954f2de454e00d8376c9283e131f4acb3ae8
+  data.tar.gz: '0940cac612bec8ed28aa55a0516af6ec42d8eeda90599f2075ade3cfdffb926fe032dd3fdaf8af2316ab3896529fd87129a2ca853a927d94eb61e726d789b72a'

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'libc', git: 'https://github.com/shamangeorge/libc.git', branch: 'master'
+gemspec

data/LICENSE.md

@@ -0,0 +1,177 @@
+Copyright (C) 2016 shamangeorge
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.md

@@ -0,0 +1,4 @@
+# libsamplerate
+
+[![pipeline status](https://damos.fruitopology.net/gems/libsamplerate/badges/master/pipeline.svg)](https://damos.fruitopology.net/gems/libsamplerate/commits/master)
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "libsamplerate"
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+bundle install

data/exe/ffi_gen_libsamplerate

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "ffi_gen"
+
+# Install libsamplerate from meganerd.com
+# and add it to you LD_LIBRARY_PATH
+
+FFIGen.generate(
+  module_name: "Libsamplerate::FFI",
+  ffi_lib:     "libsamplerate",
+  headers:     ["samplerate.h"],
+  cflags:      [],
+  prefixes:    [],
+  output:      "lib/libsamplerate/ffi.rb"
+)

data/exe/resample-stream.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+require "ruby-audio"
+require "libsamplerate"
+
+puts "================================="
+puts "Version:"
+puts Libsamplerate::FFI.src_get_version
+puts "================================="
+puts "Available Converters"
+(0..4).each do |i|
+  puts "=-=-=-=-=-=-=-="
+  puts Libsamplerate::FFI.src_get_name(i)
+  puts Libsamplerate::FFI.src_get_description(i)
+end
+puts "================================="
+
+out_dir = "."
+out_dir = "/home/pikos/Dropbox"
+file_name = "vagelis.wav"
+file_path = "#{out_dir}/#{file_name}"
+buffer = []
+RubyAudio::Sound.open(file_path) do |snd|
+  snd.read(:float, snd.info.frames).each do |sample|
+    buffer.push((sample[0] + sample[1]) / 2)
+  end
+end
+
+error_ptr = FFI::MemoryPointer.new :int
+converter = 0
+channels = 1
+src_state = Libsamplerate::FFI.src_new(
+  converter,
+  channels,
+  error_ptr
+)
+
+slice = 4096
+all_data = []
+buffer.each_slice(slice) do |input|
+  num_samples = input.size
+  in_ptr = FFI::MemoryPointer.new :float, input.size
+  in_ptr.write_array_of_float input
+  outbuffer = FFI::MemoryPointer.new :float, num_samples
+
+  src_data = Libsamplerate::FFI::SRCDATA.new
+  src_data[:data_in] = in_ptr
+  src_data[:input_frames] = num_samples
+  src_data[:data_out] = outbuffer
+  src_data[:output_frames] = num_samples / 2
+  src_data[:src_ratio] = 16000.0 / 44100.0
+
+  puts "State Error: #{Libsamplerate::FFI.src_strerror error_ptr.read_int}"
+  resampled = Libsamplerate::FFI.src_process(src_state, src_data)
+  #resampled = Libsamplerate::FFI.src_simple(src_data, converter, channels)
+  puts "resampled: #{Libsamplerate::FFI.src_strerror resampled}"
+  num_samples_out = src_data[:output_frames_gen]
+  num_samples_in = src_data[:input_frames_used]
+  puts "Number of used input frames: #{num_samples_in}"
+  puts "Number of generated output frames: #{num_samples_out}"
+  samples = src_data[:data_out].read_array_of_float(num_samples_out * channels)
+  all_data.concat(samples)
+  puts "done"
+end
+Libsamplerate::FFI.src_delete src_state
+file_out = "#{out_dir}/vagelis-16k-out.mono.stream.wav"
+channels = 1
+samplerate = 16000
+info = RubyAudio::SoundInfo.new(
+  :channels => channels,
+  :samplerate => samplerate,
+  :format => RubyAudio::FORMAT_WAV|RubyAudio::FORMAT_PCM_16
+)
+sound = RubyAudio::Sound.open(file_out, 'w', info)
+buffer = RubyAudio::Buffer.float(all_data.length, channels)
+all_data.each_with_index { |sample, index|
+  puts sample if index == 100
+  buffer[index] = sample
+}
+sound.write(buffer)
+sound.close

data/exe/resample.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require "libsamplerate"
+
+out_dir = "/home/pikos/Dropbox/Public"
+file_name = "vagelis.wav"
+file_path = "#{out_dir}/#{file_name}"
+resampler = Libsamplerate::StaticResampler.new file_path
+puts resampler

data/lib/libsamplerate.rb

@@ -0,0 +1,7 @@
+require "libsamplerate/version"
+require "libsamplerate/ffi"
+require "utils"
+require "libsamplerate/static_resampler"
+
+module Libsamplerate
+end

data/lib/libsamplerate/ffi.rb

@@ -0,0 +1,266 @@
+# Generated by ffi_gen. Please do not change this file by hand.
+
+require 'ffi'
+
+module Libsamplerate::FFI
+  extend FFI::Library
+  ffi_lib "libsamplerate"
+
+  def self.attach_function(name, *_)
+    begin; super; rescue FFI::NotFoundError => e
+      (class << self; self; end).class_eval { define_method(name) { |*_| raise e } }
+    end
+  end
+
+  # Opaque data type SRC_STATE.
+  class SRCSTATETag < FFI::Struct
+    layout :dummy, :char
+  end
+
+  # SRC_DATA is used to pass data to src_simple() and src_process().
+  #
+  # = Fields:
+  # :data_in ::
+  #   (FFI::Pointer(*Float))
+  # :data_out ::
+  #   (FFI::Pointer(*Float))
+  # :input_frames ::
+  #   (Integer)
+  # :output_frames ::
+  #   (Integer)
+  # :input_frames_used ::
+  #   (Integer)
+  # :output_frames_gen ::
+  #   (Integer)
+  # :end_of_input ::
+  #   (Integer)
+  # :src_ratio ::
+  #   (Float)
+  class SRCDATA < FFI::Struct
+    layout :data_in, :pointer,
+           :data_out, :pointer,
+           :input_frames, :long,
+           :output_frames, :long,
+           :input_frames_used, :long,
+           :output_frames_gen, :long,
+           :end_of_input, :int,
+           :src_ratio, :double
+  end
+
+  # SRC_CB_DATA is used with callback based API.
+  #
+  # = Fields:
+  # :frames ::
+  #   (Integer)
+  # :data_in ::
+  #   (FFI::Pointer(*Float))
+  class SRCCBDATA < FFI::Struct
+    layout :frames, :long,
+           :data_in, :pointer
+  end
+
+  # User supplied callback function type for use with src_callback_new()
+  # and src_callback_read(). First parameter is the same pointer that was
+  # passed into src_callback_new(). Second parameter is pointer to a
+  # pointer. The user supplied callback function must modify *data to
+  # point to the start of the user supplied float array. The user supplied
+  # function must return the number of frames that **data points to.
+  #
+  # <em>This entry is only for documentation and no real method.</em>
+  #
+  # @method _callback_src_callback_t_(cb_data, data)
+  # @param [FFI::Pointer(*Void)] cb_data
+  # @param [FFI::Pointer(**Float)] data
+  # @return [FFI::Pointer(*Void)]
+  # @scope class
+  callback :src_callback_t, [:pointer, :pointer], :pointer
+
+  # Standard initialisation function : return an anonymous pointer to the
+  # internal state of the converter. Choose a converter from the enums below.
+  # Error returned in *error.
+  #
+  # @method src_new(converter_type, channels, error)
+  # @param [Integer] converter_type
+  # @param [Integer] channels
+  # @param [FFI::Pointer(*Int)] error
+  # @return [SRCSTATETag]
+  # @scope class
+  attach_function :src_new, :src_new, [:int, :int, :pointer], SRCSTATETag
+
+  # Initilisation for callback based API : return an anonymous pointer to the
+  # internal state of the converter. Choose a converter from the enums below.
+  # The cb_data pointer can point to any data or be set to NULL. Whatever the
+  # value, when processing, user supplied function "func" gets called with
+  # cb_data as first parameter.
+  #
+  # @method src_callback_new(func, converter_type, channels, error, cb_data)
+  # @param [Proc(_callback_src_callback_t_)] func
+  # @param [Integer] converter_type
+  # @param [Integer] channels
+  # @param [FFI::Pointer(*Int)] error
+  # @param [FFI::Pointer(*Void)] cb_data
+  # @return [SRCSTATETag]
+  # @scope class
+  attach_function :src_callback_new, :src_callback_new, [:src_callback_t, :int, :int, :pointer, :pointer], SRCSTATETag
+
+  # Cleanup all internal allocations.
+  # Always returns NULL.
+  #
+  # @method src_delete(state)
+  # @param [SRCSTATETag] state
+  # @return [SRCSTATETag]
+  # @scope class
+  attach_function :src_delete, :src_delete, [SRCSTATETag], SRCSTATETag
+
+  # Standard processing function.
+  # Returns non zero on error.
+  #
+  # @method src_process(state, data)
+  # @param [SRCSTATETag] state
+  # @param [SRCDATA] data
+  # @return [Integer]
+  # @scope class
+  attach_function :src_process, :src_process, [SRCSTATETag, SRCDATA], :int
+
+  # Callback based processing function. Read up to frames worth of data from
+  # the converter int *data and return frames read or -1 on error.
+  #
+  # @method src_callback_read(state, src_ratio, frames, data)
+  # @param [SRCSTATETag] state
+  # @param [Float] src_ratio
+  # @param [Integer] frames
+  # @param [FFI::Pointer(*Float)] data
+  # @return [Integer]
+  # @scope class
+  attach_function :src_callback_read, :src_callback_read, [SRCSTATETag, :double, :long, :pointer], :long
+
+  # Simple interface for performing a single conversion from input buffer to
+  # output buffer at a fixed conversion ratio.
+  # Simple interface does not require initialisation as it can only operate on
+  # a single buffer worth of audio.
+  #
+  # @method src_simple(data, converter_type, channels)
+  # @param [SRCDATA] data
+  # @param [Integer] converter_type
+  # @param [Integer] channels
+  # @return [Integer]
+  # @scope class
+  attach_function :src_simple, :src_simple, [SRCDATA, :int, :int], :int
+
+  # This library contains a number of different sample rate converters,
+  # numbered 0 through N.
+  #
+  # Return a string giving either a name or a more full description of each
+  # sample rate converter or NULL if no sample rate converter exists for
+  # the given value. The converters are sequentially numbered from 0 to N.
+  #
+  # @method src_get_name(converter_type)
+  # @param [Integer] converter_type
+  # @return [String]
+  # @scope class
+  attach_function :src_get_name, :src_get_name, [:int], :string
+
+  # (Not documented)
+  #
+  # @method src_get_description(converter_type)
+  # @param [Integer] converter_type
+  # @return [String]
+  # @scope class
+  attach_function :src_get_description, :src_get_description, [:int], :string
+
+  # (Not documented)
+  #
+  # @method src_get_version()
+  # @return [String]
+  # @scope class
+  attach_function :src_get_version, :src_get_version, [], :string
+
+  # Set a new SRC ratio. This allows step responses
+  # in the conversion ratio.
+  # Returns non zero on error.
+  #
+  # @method src_set_ratio(state, new_ratio)
+  # @param [SRCSTATETag] state
+  # @param [Float] new_ratio
+  # @return [Integer]
+  # @scope class
+  attach_function :src_set_ratio, :src_set_ratio, [SRCSTATETag, :double], :int
+
+  # Reset the internal SRC state.
+  # Does not modify the quality settings.
+  # Does not free any memory allocations.
+  # Returns non zero on error.
+  #
+  # @method src_reset(state)
+  # @param [SRCSTATETag] state
+  # @return [Integer]
+  # @scope class
+  attach_function :src_reset, :src_reset, [SRCSTATETag], :int
+
+  # Return TRUE if ratio is a valid conversion ratio, FALSE
+  # otherwise.
+  #
+  # @method src_is_valid_ratio(ratio)
+  # @param [Float] ratio
+  # @return [Integer]
+  # @scope class
+  attach_function :src_is_valid_ratio, :src_is_valid_ratio, [:double], :int
+
+  # Return an error number.
+  #
+  # @method src_error(state)
+  # @param [SRCSTATETag] state
+  # @return [Integer]
+  # @scope class
+  attach_function :src_error, :src_error, [SRCSTATETag], :int
+
+  # Convert the error number into a string.
+  #
+  # @method src_strerror(error)
+  # @param [Integer] error
+  # @return [String]
+  # @scope class
+  attach_function :src_strerror, :src_strerror, [:int], :string
+
+  # Extra helper functions for converting from short to float and
+  # back again.
+  #
+  # @method src_short_to_float_array(in_, out, len)
+  # @param [FFI::Pointer(*Short)] in_
+  # @param [FFI::Pointer(*Float)] out
+  # @param [Integer] len
+  # @return [nil]
+  # @scope class
+  attach_function :src_short_to_float_array, :src_short_to_float_array, [:pointer, :pointer, :int], :void
+
+  # (Not documented)
+  #
+  # @method src_float_to_short_array(in_, out, len)
+  # @param [FFI::Pointer(*Float)] in_
+  # @param [FFI::Pointer(*Short)] out
+  # @param [Integer] len
+  # @return [nil]
+  # @scope class
+  attach_function :src_float_to_short_array, :src_float_to_short_array, [:pointer, :pointer, :int], :void
+
+  # (Not documented)
+  #
+  # @method src_int_to_float_array(in_, out, len)
+  # @param [FFI::Pointer(*Int)] in_
+  # @param [FFI::Pointer(*Float)] out
+  # @param [Integer] len
+  # @return [nil]
+  # @scope class
+  attach_function :src_int_to_float_array, :src_int_to_float_array, [:pointer, :pointer, :int], :void
+
+  # (Not documented)
+  #
+  # @method src_float_to_int_array(in_, out, len)
+  # @param [FFI::Pointer(*Float)] in_
+  # @param [FFI::Pointer(*Int)] out
+  # @param [Integer] len
+  # @return [nil]
+  # @scope class
+  attach_function :src_float_to_int_array, :src_float_to_int_array, [:pointer, :pointer, :int], :void
+
+end

data/lib/libsamplerate/static_resampler.rb

@@ -0,0 +1,85 @@
+require 'ruby-audio'
+module Libsamplerate
+  class StaticResampler
+    attr_reader :in, :out, :src_data
+    def initialize in_file, out
+      @in = {
+        path: in_file,
+        info: get_info(in_file)
+      }
+      @out = out
+    end
+
+    def in_info
+      @in[:info]
+    end
+
+    def out_info
+      @out[:info]
+    end
+
+    def get_info file
+      Libsamplerate.get_sound_file_info file
+    end
+
+    def setup_src_data in_ptr, num_samples_in, out_ptr, num_samples_out, src_ratio
+      src_data[:data_in] = in_ptr
+      src_data[:input_frames] = num_samples_in
+      src_data[:data_out] = out_ptr
+      src_data[:output_frames] = num_samples_out
+      src_data[:src_ratio] = src_ratio
+    end
+
+    def src_data
+      @src_data ||= Libsamplerate::FFI::SRCDATA.new
+    end
+
+    def write_out_file
+      num_samples_out = src_data[:output_frames_gen]
+      samples = src_data[:data_out].read_array_of_float(num_samples_out * out_info.channels)
+      sound = RubyAudio::Sound.open(@out[:path], 'w', out_info)
+      buffer = RubyAudio::Buffer.float(samples.length, out_info.channels)
+      samples.each_with_index { |sample, index|
+        buffer[index] = sample
+      }
+      sound.write(buffer)
+      sound.close
+    end
+
+    def prepare_buffer
+      if in_info.channels != 1
+        Libsamplerate.stereo_to_mono @in[:path]
+      else
+        Libsamplerate.get_float_buffer_from_mono_file @in[:path]
+      end
+    end
+
+    def resample
+      input = prepare_buffer
+      num_samples = input.size
+      in_ptr = create_audio_pointer_buffer_float input
+      tRate = out_info.samplerate.to_f
+      iRate = in_info.samplerate.to_f
+      outbuffer = allocate_audio_pointer_buffer_float num_samples
+      outsamples = num_samples / 2
+      src_ratio = tRate / iRate
+      converter = Libsamplerate::CONVERTERS[:src_sinc_best_quality]
+      setup_src_data(in_ptr, num_samples, outbuffer, outsamples, src_ratio)
+      resampled = Libsamplerate::FFI.src_simple(src_data, converter, out_info.channels)
+      error = Libsamplerate::FFI.src_strerror resampled
+      error.eql? "No Error." || raise(error)
+      write_out_file
+      self
+    end
+
+    def allocate_audio_pointer_buffer_float num_samples
+       ::FFI::MemoryPointer.new :float, num_samples
+    end
+
+    def create_audio_pointer_buffer_float samples
+      ptr = ::FFI::MemoryPointer.new :float, samples.size
+      ptr.write_array_of_float samples
+      ptr
+    end
+  end
+end

data/lib/libsamplerate/version.rb

@@ -0,0 +1,3 @@
+module Libsamplerate
+  VERSION = "0.0.1"
+end

data/lib/utils.rb

@@ -0,0 +1,39 @@
+module Libsamplerate
+  def self.stereo_to_mono file_path
+    buffer = []
+    RubyAudio::Sound.open(file_path) do |snd|
+      snd.read(:float, snd.info.frames).each do |sample|
+        buffer.push(sample[0])
+      end
+    end
+    buffer
+  end
+
+  def self.get_float_buffer_from_mono_file file
+    raise "This is not a mono file" if get_sound_file_info(file).channels == 1
+    buffer = []
+    RubyAudio::Sound.open(file) do |snd|
+      snd.read(:float, snd.info.frames).each do |sample|
+        buffer.push(sample)
+      end
+    end
+    buffer
+  end
+
+  def self.get_sound_file_info file_path
+    info = nil
+    RubyAudio::Sound.open(file_path) do |snd|
+      info = snd.info
+    end
+    info
+  end
+
+  CONVERTERS =
+    {
+      src_sinc_best_quality: 0,
+      src_sinc_medium_quality: 1,
+      src_sinc_fastest: 2,
+      src_zero_order_hold: 3,
+      src_linear: 4
+  }
+end

data/libsamplerate.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'libsamplerate/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "libsamplerate"
+  spec.version       = Libsamplerate::VERSION
+  spec.authors       = ["shamangeorge"]
+  spec.email         = ["shamangeorge@fruitopology.net"]
+
+  spec.summary       = %q{ffi interface for libsamplerate}
+  spec.description   = %q{Gem to interface with secret rabbit code}
+  spec.homepage      = "https://github.com/shamangeorge/libsamplerate"
+  spec.license       = "LGPL-3.0"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f|
+    f.match(%r{^(test|spec|features)/}) || File.basename(f).start_with?(".")
+  }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_development_dependency "rspec", "~> 3.5"
+  spec.add_development_dependency "ffi_gen", "~> 1.2"
+  spec.add_development_dependency "ruby-audio", "~> 1.6.1"
+  spec.add_dependency "ffi", "~> 1.9"
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: libsamplerate
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- shamangeorge
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-02-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: ffi_gen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: ruby-audio
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+description: Gem to interface with secret rabbit code
+email:
+- shamangeorge@fruitopology.net
+executables:
+- ffi_gen_libsamplerate
+- resample-stream.rb
+- resample.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/ffi_gen_libsamplerate
+- exe/resample-stream.rb
+- exe/resample.rb
+- lib/libsamplerate.rb
+- lib/libsamplerate/ffi.rb
+- lib/libsamplerate/static_resampler.rb
+- lib/libsamplerate/version.rb
+- lib/utils.rb
+- libsamplerate.gemspec
+- wavfiles/vagelis-16k-mono.ruby-libresample.wav
+- wavfiles/vagelis.wav
+homepage: https://github.com/shamangeorge/libsamplerate
+licenses:
+- LGPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: ffi interface for libsamplerate
+test_files: []