chromaprint 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 46c10be2f763ed40a48543683aaaa81fdd80da24
+  data.tar.gz: 6ab14b4dc5ea352d68a2274924ac950a75fc9801
+SHA512:
+  metadata.gz: d1e6683a756e65ea4dcd4e52cb3525a8a9b2062c4c335a276e80f918d6e18f0e53f0423f4945647c9216896f78029a99b13f77ab84a4eb47a7c8e37660ff123f
+  data.tar.gz: a71826f62481bcd988cb7771d746ce49b92deae867702500dc145c779f8519d82ed8202e1dfe8283a7d0597ca17532cdab6972d2e0a9fd90c75762ce2054ef62

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 TMX Credit, author Potapov Sergey
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,66 @@
+# Chromaprint
+
+Port of [Chromaprint](http://acoustid.org/chromaprint) C/C++ library to Ruby.
+
+> A client-side library that implements a custom algorithm for extracting fingerprints from any audio source.
+
+
+## Dependencies
+
+* Chromaprint
+
+### Debian / Ubuntu
+
+```sh
+apt-get install libchromaprint-dev
+```
+
+### Mac
+
+```sh
+# At the time of this writing, chromaprint is unavailable in MacPorts or Fink:
+brew install chromaprint
+```
+
+## Usage
+
+```ruby
+# Create context for rate=44100 and channel=1.
+context1 = Chromaprint::Context.new(44100, 1)
+
+# Get audio data. Data should be in raw audio format with 16-bit signed samples.
+# The library doesn't care about decoding formats like mp3 or ogg, you should
+# do it yourself.
+data1 = File.binread('/1.wav')
+
+# Create context for rate=22050 and channel=2 and get fingerprint
+context2     = Chromaprint::Context.new(22050, 1)
+fingerprint1 = context1.get_fingerprint(data1)
+
+# Get fingerprint of another audio
+context2     = Chromaprint::Context.new(44100, 2)
+fingerprint2 = context2.get_fingerprint(File.binread('/2.wav')
+
+# Compressed fingerprint, returned by chromaprint_get_fingerprint() C function.
+fingerprint1.compressed  # => "AQAALOkUKdlChE92NNeFn8EjF9..."
+
+# Raw fingerprint, returned by chromaprint_get_raw_fingerprint() C function.
+fingerprint1.raw  # => [294890785, 328373552, 315802880, 303481088, ...]
+
+# Compare 2 fingerprints, result is 0..1 range, where 1 is 100% similarity.
+fingerprint1.compare(fingerprint2)  # => 0.93231
+```
+
+## Run tests
+
+```sh
+rake spec
+```
+
+## Credits
+
+* [Sergey Potapov](https://github.com/greyblake)
+
+## Copyright
+
+Copyright (c) 2013 TMX Credit.

data/lib/chromaprint.rb

@@ -0,0 +1,31 @@
+require 'ffi'
+
+require 'chromaprint/lib'
+require 'chromaprint/context'
+require 'chromaprint/fingerprint'
+
+# Chromaprint is originally written in C/C++, a library which provides tools
+# to calculate fingerprints of audio data. This is its port for the Ruby language.
+module Chromaprint
+  # All algorithm constants are taken from +chromaprint.h+
+  ALGORITHM_TEST1 = 0
+
+  # :nodoc:
+  ALGORITHM_TEST2 = 1
+
+  # :nodoc:
+  ALGORITHM_TEST3 = 2
+
+  # Default algorithm. Taken from +chromaprint.h+
+  ALGORITHM_DEFAULT = ALGORITHM_TEST2
+
+  # Chromaprint works with 16 bit samples
+  BYTES_PER_SAMPLE = 2
+
+  # Get version of Chromaprint library
+  #
+  # @return [String] version
+  def self.lib_version
+    Lib.chromaprint_get_version
+  end
+end

data/lib/chromaprint/context.rb

@@ -0,0 +1,63 @@
+module Chromaprint
+  # Calculates fingerprints of audio data.
+  #
+  # @example
+  #  chromaprint = Chromaprint::Context.new(44100, 1)
+  #  data        = File.binread('song.wav')
+  #  fingerprint = chromaprint.get_fingerprint(data)
+  class Context
+    # @param rate [Integer] sample rate of audio
+    # @param num_channels [Integer] number of channels (1 or 2)
+    # @param algorithm [Integer] specify algorithm to be used to Chromaprint
+    #   library. Must be {ALGORITHM_TEST1}, {ALGORITHM_TEST2} or
+    #   {ALGORITHM_TEST3}.
+    def initialize(rate, num_channels, algorithm = ALGORITHM_DEFAULT)
+      @rate         = rate
+      @num_channels = num_channels
+      @algorithm    = ALGORITHM_DEFAULT
+    end
+
+
+    # Calculate raw and compressed fingerprints of  the audio data.
+    #
+    #
+    # @param data [String] raw audio data preseted by 16-bit signed integers
+    #
+    # @return [Chromaprint::Fingerprint]
+    def get_fingerprint(data)
+      # Allocate memory for context and initialize
+      p_context = Lib.chromaprint_new(@algorithm)
+      Lib.chromaprint_start(p_context, @rate, @num_channels)
+
+      # Create a pointer to the data
+      p_data = FFI::MemoryPointer.from_string(data)
+
+      # Calculate number of samples and feed data.
+      data_size = p_data.size / BYTES_PER_SAMPLE
+      Lib.chromaprint_feed(p_context, p_data, data_size)
+
+      # Calculate the fingerprint
+      Lib.chromaprint_finish(p_context)
+
+      # Get compressed fingerprint
+      p_p_fingerprint = FFI::MemoryPointer.new(:pointer)
+      Lib.chromaprint_get_fingerprint(p_context, p_p_fingerprint)
+      p_fingerprint = p_p_fingerprint.get_pointer(0)
+      fingerprint   = p_fingerprint.get_string(0)
+
+      # Get raw fingerprint
+      p_p_raw_fingerprint = FFI::MemoryPointer.new(:pointer)
+      p_size              = FFI::MemoryPointer.new(:pointer)
+      Lib.chromaprint_get_raw_fingerprint(p_context, p_p_raw_fingerprint, p_size)
+      p_raw_fingerprint = p_p_raw_fingerprint.get_pointer(0)
+      raw_fingerprint   = p_raw_fingerprint.get_array_of_uint(0, p_size.get_int32(0))
+
+      Fingerprint.new(fingerprint, raw_fingerprint)
+    ensure
+      # Free memory
+      Lib.chromaprint_free(p_context)            if p_context
+      Lib.chromaprint_dealloc(p_fingerprint)     if p_fingerprint
+      Lib.chromaprint_dealloc(p_raw_fingerprint) if p_raw_fingerprint
+    end
+  end
+end

data/lib/chromaprint/fingerprint.rb

@@ -0,0 +1,66 @@
+module Chromaprint
+  # Contains compressed and raw fingerprints and provides a method to compare
+  # them against other fingerprints.
+  class Fingerprint
+    # Number of bits in one item of raw fingerprint
+    BITS_PER_RAW_ITEM = 32
+
+    # @attr_reader compressed [String] compressed fingerprints
+    attr_reader :compressed
+
+    # @attr_reader raw [Array<Integer>] raw fingerprints,
+    #   array of 32-bit integers returned by native C library.
+    attr_reader :raw
+
+    # @param compressed [String] compressed fingerprint
+    # @param raw [Array<Integer>] raw fingerprint
+    def initialize(compressed, raw)
+      @compressed = compressed
+      @raw        = raw
+    end
+
+    # Compare a fingerprint against another fingerprint.
+    #
+    # @param fingerprint [Chromaprint::Fingerprint] fingerprint to compare against
+    #
+    # @return [Float] float in 0..1 range where 1 is 100% match
+    def compare(fingerprint)
+      max_raw_size = [@raw.size, fingerprint.raw.size].max
+      bit_size     = max_raw_size * BITS_PER_RAW_ITEM
+
+      distance     = hamming_distance(@raw, fingerprint.raw)
+
+      1 - distance.to_f / bit_size
+    end
+
+    # Calculate hamming distance between 32 bit integer arrays.
+    # In short we're calculating number of bits which are different.
+    #
+    # Read more: http://en.wikipedia.org/wiki/Hamming_distance
+    #
+    # It's sad to say but according to Stackoverflow it's the fastest
+    # way to calculate hamming distance between 2 integers in ruby:
+    #   (a^b).to_s(2).count("1")
+    #
+    #   ref: http://stackoverflow.com/questions/6395165/most-efficient-way-to-calculate-hamming-distance-in-ruby/6397116#6397116
+    #
+    # If array sizes are different we add difference to the distance.
+    #
+    # @param raw1 [Array<Integer>] array of 32 bit integers.
+    # @param raw2 [Array<Integer>] array of 32 bit integers.
+    #
+    # @return [Integer] hamming distance
+    def hamming_distance(raw1, raw2)
+      distance = 0
+
+      min_size, max_size = [raw1, raw2].map(&:size).sort
+
+      min_size.times do |i|
+        distance += (raw1[i] ^ raw2[i]).to_s(2).count('1')
+      end
+
+      distance += (max_size - min_size) * BITS_PER_RAW_ITEM
+    end
+    private :hamming_distance
+  end
+end

data/lib/chromaprint/lib.rb

@@ -0,0 +1,172 @@
+module Chromaprint
+  # Ports the chromaprint API functions. To get their detailed documentation
+  # please see +chromaprint.h+ of the original C/C++ library.
+  #
+  # ref: https://bitbucket.org/acoustid/chromaprint/src/master/src/chromaprint.h
+  module Lib
+    extend FFI::Library
+    ffi_lib 'chromaprint'
+
+    # Return the version number of Chromaprint.
+    #
+    # const char *chromaprint_get_version(void)
+    attach_function :chromaprint_get_version, [], :string
+
+    # Allocate and initialize the Chromaprint context.
+    #
+    # Parameters:
+    #  - version: Version of the fingerprint algorithm, use
+    #             CHROMAPRINT_ALGORITHM_DEFAULT for the default
+    #             algorithm
+    #
+    # Returns:
+    #  - Chromaprint context pointer
+    #
+    # ChromaprintContext *chromaprint_new(int algorithm)
+    attach_function :chromaprint_new, [:int], :pointer
+
+    # Deallocate the Chromaprint context.
+    #
+    # Parameters:
+    #  - ctx: Chromaprint context pointer
+    #
+    # void chromaprint_free(ChromaprintContext *ctx)
+    attach_function :chromaprint_free, [:pointer], :void
+
+    # Return the fingerprint algorithm this context is configured to use.
+    #
+    # int chromaprint_get_algorithm(ChromaprintContext *ctx)
+    #
+    # @note
+    #   In Debian Wheezy chromaprint.so (version 6.0.0) doesn't have
+    #   chromaprint_get_algorithm() function. So we comment it out to not
+    #   raise exception on loading.
+    #
+    # attach_function :chromaprint_get_algorithm, [:pointer], :int
+
+    # Restart the computation of a fingerprint with a new audio stream.
+    #
+    # Parameters:
+    #  - ctx: Chromaprint context pointer
+    #  - sample_rate: sample rate of the audio stream (in Hz)
+    #  - num_channels: numbers of channels in the audio stream (1 or 2)
+    #
+    # Returns:
+    #  - 0 on error, 1 on success
+    #
+    # int chromaprint_start(ChromaprintContext *ctx, int sample_rate, int num_channels)
+    attach_function :chromaprint_start, [:pointer, :int, :int], :int
+
+    # Send audio data to the fingerprint calculator.
+    #
+    # Parameters:
+    #  - ctx: Chromaprint context pointer
+    #  - data: raw audio data, should point to an array of 16-bit signed
+    #          integers in native byte-order
+    #  - size: size of the data buffer (in samples)
+    #
+    # Returns:
+    #  - 0 on error, 1 on success
+    #
+    # int chromaprint_feed(ChromaprintContext *ctx, void *data, int size)
+    attach_function :chromaprint_feed, [:pointer, :pointer, :int], :int
+
+    # Process any remaining buffered audio data and calculate the fingerprint.
+    #
+    # Parameters:
+    #  - ctx: Chromaprint context pointer
+    #
+    # Returns:
+    #  - 0 on error, 1 on success
+    #
+    # int chromaprint_finish(ChromaprintContext *ctx)
+    attach_function :chromaprint_finish, [:pointer], :int
+
+    # Return the calculated fingerprint as a compressed string.
+    #
+    # The caller is responsible for freeing the returned pointer using
+    # chromaprint_dealloc().
+    #
+    # Parameters:
+    #  - ctx: Chromaprint context pointer
+    #  - fingerprint: pointer to a pointer, where a pointer to the allocated array
+    #                 will be stored
+    #
+    # Returns:
+    #  - 0 on error, 1 on success
+    #
+    # int chromaprint_get_fingerprint(ChromaprintContext *ctx, char **fingerprint)
+    attach_function :chromaprint_get_fingerprint, [:pointer, :pointer], :int
+
+    # Return the calculated fingerprint as an array of 32-bit integers.
+    #
+    # The caller is responsible for freeing the returned pointer using
+    # chromaprint_dealloc().
+    #
+    # Parameters:
+    #  - ctx: Chromaprint context pointer
+    #  - fingerprint: pointer to a pointer, where a pointer to the allocated array
+    #                 will be stored
+    #  - size: number of items in the returned raw fingerprint
+    #
+    # Returns:
+    #  - 0 on error, 1 on success
+    #
+    # int chromaprint_get_raw_fingerprint(ChromaprintContext *ctx, void **fingerprint, int *size)
+    attach_function :chromaprint_get_raw_fingerprint, [:pointer, :pointer, :pointer], :int
+
+    # Compress and optionally base64-encode a raw fingerprint
+    #
+    # The caller is responsible for freeing the returned pointer using
+    # chromaprint_dealloc().
+    #
+    # Parameters:
+    #  - fp: pointer to an array of 32-bit integers representing the raw
+    #        fingerprint to be encoded
+    #  - size: number of items in the raw fingerprint
+    #  - algorithm: Chromaprint algorithm version which was used to generate the
+    #               raw fingerprint
+    #  - encoded_fp: pointer to a pointer, where the encoded fingerprint will be
+    #                stored
+    #  - encoded_size: size of the encoded fingerprint in bytes
+    #  - base64: Whether to return binary data or base64-encoded ASCII data. The
+    #            compressed fingerprint will be encoded using base64 with the
+    #            URL-safe scheme if you set this parameter to 1. It will return
+    #            binary data if it's 0.
+    #
+    # Returns:
+    #  - 0 on error, 1 on success
+    # int chromaprint_encode_fingerprint(void *fp, int size, int algorithm, void **encoded_fp, int *encoded_size, int base64)
+    attach_function :chromaprint_encode_fingerprint, [:pointer, :int, :int, :pointer, :pointer, :int], :int
+
+    # Uncompress and optionally base64-decode an encoded fingerprint
+    #
+    # The caller is responsible for freeing the returned pointer using
+    # chromaprint_dealloc().
+    #
+    # Parameters:
+    #  - encoded_fp: Pointer to an encoded fingerprint
+    #  - encoded_size: Size of the encoded fingerprint in bytes
+    #  - fp: Pointer to a pointer, where the decoded raw fingerprint (array
+    #        of 32-bit integers) will be stored
+    #  - size: Number of items in the returned raw fingerprint
+    #  - algorithm: Chromaprint algorithm version which was used to generate the
+    #               raw fingerprint
+    #  - base64: Whether the encoded_fp parameter contains binary data or
+    #            base64-encoded ASCII data. If 1, it will base64-decode the data
+    #            before uncompressing the fingerprint.
+    #
+    # Returns:
+    #  - 0 on error, 1 on success
+    #
+    # int chromaprint_decode_fingerprint(void *encoded_fp, int encoded_size, void **fp, int *size, int *algorithm, int base64)
+    attach_function :chromaprint_decode_fingerprint, [:pointer, :int, :pointer, :pointer, :pointer, :int], :int
+
+    # Free memory allocated by any function from the Chromaprint API.
+    #
+    #  - ptr: Pointer to be deallocated
+    #
+    # void chromaprint_dealloc(void *ptr);
+    attach_function :chromaprint_dealloc, [:pointer], :void
+  end
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: chromaprint
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- TMX Credit
+- Potapov Sergey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A client-side library that implements a custom algorithm for extracting
+  fingerprints from any audio source
+email:
+- rubygems@tmxcredit.com
+- blake131313@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.markdown
+files:
+- LICENSE.txt
+- README.markdown
+- lib/chromaprint.rb
+- lib/chromaprint/context.rb
+- lib/chromaprint/fingerprint.rb
+- lib/chromaprint/lib.rb
+homepage: http://github.com/greyblake/chromaprint
+licenses:
+- MIT
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Port of Chromaprint library to Ruby
+test_files: []