rtrack 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2d02c55bbd7729e987cdcb9f0c13b425ae9b3f7d
+  data.tar.gz: 8ffdfc4796d22c2703aff633bfc0cbbba2dd6e1a
+SHA512:
+  metadata.gz: 54457b9e1da6673b26a189067266bdc90d6226a278e05d196491b93a111bd7c8d93c190fd231992447f11080473258487b46418755edd65d223e9a998183547d
+  data.tar.gz: 9b9c94fb0aa422bb8d8e1c68004ff1e8e2aff86a761a71f71b9386e82321b21572ed5d9fd1523fc48525f6105d41563ac8c34fc8eccf74ac05cadd5846b1de31

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rtrack.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 marcwebbie
+
+MIT License
+
+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.md

@@ -0,0 +1,133 @@
+# Rtrack
+
+RTrack is a object-oriented wrapper around ffmpeg to manipulate audiofiles easily from ruby code.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rtrack'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rtrack
+
+## Usage
+
+Open a wave file
+
+```ruby
+require 'rtrack'
+
+song = AudioTrack.from_file "never_gonna_give_you_up.wav"
+```
+
+...or a mp3 file
+
+
+```ruby
+require 'rtrack'
+
+song = AudioTrack.from_file "never_gonna_give_you_up.mp3"
+```
+
+... or an ogg, or flv, or [anything else ffmpeg supports](http://www.ffmpeg.org/general.html#File-Formats)
+
+```ruby
+ogg_version = AudioTrack.from_file "never_gonna_give_you_up.ogg"
+flv_version = AudioTrack.from_file "never_gonna_give_you_up.flv"
+mp4_version = AudioTrack.from_file "never_gonna_give_you_up.mp4"
+wma_version = AudioTrack.from_file "never_gonna_give_you_up.wma"
+aac_version = AudioTrack.from_file "never_gonna_give_you_up.aiff"
+```
+
+You can concatenate multiple AudioTracks together
+
+```ruby
+song_one = AudioTrack.from_file "one_love.mp3"
+song_two = AudioTrack.from_file "jamming.ogg"
+
+song_three = song_one + song_two
+
+song_four = song_one + song_two + song_three + AudioTrack.from_file "buffallo_soldiers.mp3"
+```
+
+Get a slice of a track, first 10 seconds
+
+```ruby
+song = AudioTrack.from_file "mozart.mp3"
+slice = song[10000] # rtrack works on milliseconds
+```
+
+Wonder how long is that song?
+
+```
+song = AudioTrack.from_file "jamming.mp3"
+puts song.seconds
+```
+
+Repeat track 4 times
+
+```ruby
+beat = AudioTrack.from_file "beat.wav"
+remix = beat * 4
+```
+
+Save the result to disk
+
+```ruby
+remix.export "remix.mp3", "mp3"
+# or
+remix.save "remix.mp3", "mp3"
+```
+
+Save the results with bitrate
+
+```ruby
+remix.export "remix.mp3", "mp3", "192k"
+```
+
+## Examples
+
+Let's suppose you have plenty of `mp4` videos that you'd like to convert to
+`mp3` so you can listen on your mp3 player on the road.
+
+```ruby
+require "rtrack"
+
+Dir[Dir.home + "/Videos/*.mp4"].each do |video_path|
+  video_name = File.basename(video_path, File.extname(video_path))
+  puts "converting #{video_name}"
+  song = AudioTrack.from_file video_path
+  song.export "#{video_name}.mp3"
+end
+```
+
+## Dependencies
+
+Requires ffmpeg or avconv for encoding and decoding.
+
+ - ffmpeg (http://www.ffmpeg.org/)
+
+ -OR-
+
+ - avconv (http://libav.org/)
+ 
+## Trivia
+
++ RTrack is inspired by [pydub](http://www.github.com/jiaaro/pydub) and [jquery](http://www.jquery.com)
++ As in pydub all AudioTrack objects are [immutable](http://rubylearning.com/satishtalim/mutable_and_immutable_objects.html)
++ As in jquery you can chain operations using AudioTrack objects
+
+
+## Contributing
+
+1. Fork it ( http://github.com/marcwebbie/rtrack/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+task :default => :test

data/lib/rtrack.rb

@@ -0,0 +1,58 @@
+require "tempfile"
+
+require "rtrack/version"
+require "rtrack/transcoder"
+
+class AudioTrack
+  attr_reader :wavefile, :duration
+  
+  def initialize (wavefile, duration)
+    @wavefile = wavefile
+    @duration = duration
+  end
+
+  def self.from_file(infile)
+    if not (File.exists? infile)
+      fail StandardError, "Couldn't find file from path: #{infile}"
+    end
+    infile = File.open(infile)
+    wavefile = Tempfile.new ['','.wav']
+    duration = RTrack::Transcoder.to_wave(infile.path, wavefile.path)
+    AudioTrack.new wavefile, duration
+  end
+
+  def seconds
+    @duration / 1000
+  end
+  
+  def path
+    @wavefile.path
+  end
+  
+  def [](slice_range)
+    if not slice_range.class == Range
+      fail StandardError, "Invalid slice was given: #{slice_range}"
+    end
+    
+    slice_start, slice_end = slice_range.min, slice_range.max
+    new_wavefile = Tempfile.new ['','.wav']
+    duration = RTrack::Transcoder.to_slice(@wavefile.path,
+      new_wavefile.path,
+      slice_start,
+      slice_end)
+    
+    AudioTrack.new new_wavefile, duration
+  end
+
+  def +(other)
+    info = RTrack::Transcoder.concat @wavefile.path, other.wavefile.path
+    AudioTrack.new info["wavefile"], info["duration"]
+  end
+
+  def export(outpath, format="mp3", bitrate="128k")
+    return_code = RTrack::Transcoder.export(@wavefile.path, outpath, format, bitrate)
+    return_code
+  end
+
+  alias_method :save, :export
+end

data/lib/rtrack/transcoder.rb

@@ -0,0 +1,74 @@
+
+module RTrack
+  class Transcoder
+    BIN = "ffmpeg"
+    PROBER = "ffprobe"
+
+    def self._clean_output output
+      output.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
+    end
+    
+    def self.bin
+      @@bin
+    end
+
+    def self.to_milliseconds(hours, mins, secs, msecs=0)
+      (hours * 3600000) + (mins * 60000) + (secs * 1000) + msecs
+    end
+
+    def self.parse_duration(output)
+      begin
+        output = self._clean_output output
+        time_string = output.scan(/time\=(\d+:\d+:\d+\.\d+)/).last.last
+      rescue NoMethodError
+        raise StandardError, "Couldn't parse duration from transcoder output"
+      end
+      
+      mobj = time_string.match(/(?<hours>\d+):(?<mins>\d+):(?<secs>\d+)\.(?<msecs>\d+)/)
+      hours = mobj["hours"].to_i
+      mins = mobj["mins"].to_i 
+      secs = mobj["secs"].to_i
+      msecs = mobj["msecs"].ljust(3, "0").to_i
+      
+      to_milliseconds hours, mins, secs, msecs
+    end
+
+    def self.to_wave(infile_path, wavefile_path)
+      cmd = "#{self::BIN} -y -i #{infile_path} -f wav #{wavefile_path} 2>&1"
+      output = `#{cmd}`
+      self.parse_duration output
+    end
+
+    def self.to_slice(infile_path, wavefile_path, start, to)
+      cmd = "#{self::BIN} -y -i #{infile_path} -ss #{start} -to #{to} -f wav #{wavefile_path} 2>&1"
+      output = `#{cmd}`
+      self.parse_duration output
+    end
+
+    def self.concat(media_one, media_two)
+      new_wavefile = Tempfile.new ['','.wav']
+      cmd = "#{self::BIN} -y -i #{media_one} -i #{media_two} -filter_complex '[0:0][1:0]concat=n=2:v=0:a=1[out]' -map '[out]' #{new_wavefile.path} 2>&1"
+      output = `#{cmd}`
+      duration = self.parse_duration output 
+      {"wavefile" => new_wavefile, "duration" => duration}
+    end
+
+    def self.is_media?(filepath)
+      cmd = "#{self::PROBER} #{filepath} >/dev/null 2>&1"
+      `#{cmd}`
+      $?.success?
+    end
+
+    def self.export(inpath, outpath, format, bitrate)
+      cmd = "#{self::BIN} -y -i #{inpath} -f #{format} -b:a #{bitrate} #{outpath} 2>&1"
+      `#{cmd}`
+      $?.success?
+    end
+
+    def self.info mediapath
+      cmd = "#{self::PROBER} -v quiet -print_format json -show_format -show_streams #{mediapath}"
+      output = `#{cmd}`
+      JSON::parse output
+    end
+  end
+end

data/lib/rtrack/version.rb

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

data/rtrack.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rtrack/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rtrack"
+  spec.version       = Rtrack::VERSION
+  spec.authors       = ["marcwebbie"]
+  spec.email         = ["marcwebbie@gmail.com"]
+  spec.summary       = "RTrack is a object-oriented wrapper around ffmpeg to manipulate audiofiles easily from ruby code."
+  spec.description   = "RTrack is a object-oriented wrapper around ffmpeg to manipulate audiofiles easily from ruby code."
+  spec.homepage      = "http://github.com/marcwebbie/rtrack"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+end

data/test/test_rtrack.rb

@@ -0,0 +1,99 @@
+require 'test/unit'
+require 'tempfile'
+
+require 'rtrack'
+require 'rtrack/transcoder'
+
+class Audiorack_Tests < Test::Unit::TestCase
+  def setup
+    @track = AudioTrack.from_file "test/data/test.mp3"
+  end
+
+  def test_instantiate_audio_track_from_file
+    test_track = AudioTrack.from_file "test/data/test.mp3"
+    assert_not_nil test_track
+    assert_equal test_track.class, AudioTrack
+  end
+
+  def test_from_file_throw_exception_when_wrong_infile_path_is_given
+    assert_raises(StandardError) do
+      test_track = AudioTrack.from_file "test/data/wrong_path.mp3"
+      assert_not_nil test_track
+    end    
+  end
+
+  def test_audio_track_has_a_not_nil_wavefile_from_given_infile
+    test_track = AudioTrack.from_file "test/data/test.mp3"
+    assert_not_nil test_track.wavefile
+  end
+
+  def test_from_file_returns_audio_track_with_valid_wavefile
+    test_track = AudioTrack.from_file "test/data/test.mp3"
+    wavefile = test_track.wavefile
+    assert_respond_to wavefile, "path"
+    assert_equal File.exists?(wavefile.path), true
+    assert_equal wavefile.path.end_with?(".wav"), true
+  end
+
+  def test_from_file_returns_audio_track_with_expected_duration
+    test_track = AudioTrack.from_file "test/data/test.mp3"
+    expected_duration = 10040
+    assert_respond_to test_track, "duration"
+    assert_equal expected_duration, test_track.duration
+
+    test_track = AudioTrack.from_file "test/data/test2.mp3"
+    expected_duration = 5040
+    assert_respond_to test_track, "duration"
+    assert_equal expected_duration, test_track.duration
+  end
+
+  def test_duration_seconds_match_duration
+    assert_respond_to @track, "seconds"
+    expected_seconds = @track.duration/1000
+    assert_equal expected_seconds, @track.seconds
+  end
+
+  def test_slice_from_song_has_expected_duration
+    assert_respond_to @track, "[]"
+    expected_seconds = Random.rand(1..10)
+
+    slice = AudioTrack.from_file(@track.path)[0..expected_seconds]
+    assert_equal slice.seconds, expected_seconds
+    slice = AudioTrack.from_file(@track.path)[0...expected_seconds]
+    assert_equal slice.seconds, expected_seconds-1
+  end
+
+  def test_slice_operation_throws_exception_when_invalid_slice_range_is_given
+    assert_raises(StandardError) do
+      @track[nil]
+    end
+
+    assert_raises(StandardError) do
+      @track[50]
+    end
+  end
+
+  def test_concatenate_two_audio_tracks_has_duration_equal_to_sum_of_durations
+    track_one = AudioTrack.from_file("test/data/test.mp3")
+    track_two = AudioTrack.from_file("test/data/test2.mp3")
+
+    assert_respond_to track_one, "+"
+    track_three = track_one + track_two
+    assert_equal track_three.seconds, track_one.seconds + track_two.seconds
+  end
+
+  def test_export_track
+    remix = @track + @track
+    destination_file = Tempfile.new ["",".mp3"]
+
+    assert_respond_to remix, "export"
+    assert_equal false, RTrack::Transcoder.is_media?(destination_file.path)
+    remix.export destination_file.path
+    assert_equal true, RTrack::Transcoder.is_media?(destination_file.path)
+  end
+
+  def test_save_is_same_as_export
+    assert_respond_to @track, "save"
+    assert_equal @track.method(:save), @track.method(:export)
+  end
+end

data/test/test_transcoder.rb

@@ -0,0 +1,31 @@
+require 'test/unit'
+require 'tempfile'
+require 'json'
+
+require 'rtrack'
+
+class Transcoder_Tests < Test::Unit::TestCase
+  def test_transcoder_raises_standard_error_when_missing_time_from_transcoder_output
+    assert_raises(StandardError) do
+      RTrack::Transcoder.parse_duration "bad output"
+    end
+  end
+
+  def test_trascoder_check_if_mp3_is_valid_media
+    assert_equal true, RTrack::Transcoder.is_media?("test/data/test2.mp3")
+    assert_equal false, RTrack::Transcoder.is_media?("test/data/bad.mp3")
+  end
+
+  def test_transcoder_parse_duration_returns_expected_milliseconds
+    mock_output = "time=00:00:10.04"
+    expected_milliseconds = 10040
+    assert_equal expected_milliseconds, RTrack::Transcoder.parse_duration(mock_output)
+  end
+
+  def test_transcoder_info_returns_expected_hash_with_info_about_media
+    assert_respond_to RTrack::Transcoder, "info"
+    info = RTrack::Transcoder.info "test/data/test3.mp3"
+    assert_equal true, info.keys.include?("streams"), "info doesn't contain streams"
+    assert_equal true, info.keys.include?("format"), "info doens't contain formats"
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: rtrack
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- marcwebbie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: RTrack is a object-oriented wrapper around ffmpeg to manipulate audiofiles
+  easily from ruby code.
+email:
+- marcwebbie@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rtrack.rb
+- lib/rtrack/transcoder.rb
+- lib/rtrack/version.rb
+- rtrack.gemspec
+- test/data/bach.ogg
+- test/data/bad.mp3
+- test/data/party.mp3
+- test/data/test.mp3
+- test/data/test2.mp3
+- test/data/test3.mp3
+- test/test_rtrack.rb
+- test/test_transcoder.rb
+homepage: http://github.com/marcwebbie/rtrack
+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.2.2
+signing_key: 
+specification_version: 4
+summary: RTrack is a object-oriented wrapper around ffmpeg to manipulate audiofiles
+  easily from ruby code.
+test_files:
+- test/data/bach.ogg
+- test/data/bad.mp3
+- test/data/party.mp3
+- test/data/test.mp3
+- test/data/test2.mp3
+- test/data/test3.mp3
+- test/test_rtrack.rb
+- test/test_transcoder.rb