voyeur 0.1.2 → 0.2.0

data/.gitignore

@@ -9,6 +9,8 @@ pkg/*
 bin
 test_data/*
 *.mp4
+*.webm
+*.3gp
 *.swp
 *.swo
 *.box

data/README.md

@@ -1,5 +1,5 @@
 # Voyeur
-Voyeur is a ruby library that will take your video files and convert
+Voyeur is a ruby library that will take your video and audio files and convert
 them to common HTML5 formats exposing an easy to use API. Seriously
 it's like falling out of a tree then climbing back.
 
@@ -23,35 +23,49 @@ You can also try out automated [setup scripts](https://github.com/devthenet/ffmp
 ## Usage
 Simple conversions may be done by simply:
 
-    Voyeur::Video.new( filename: path_to_file ).convert( to: :mp4 )
+    Voyeur::Media.new( filename: path_to_file ).convert( to: :mp4 )
 
 This will convert the video into Mp4 and save it in the same directory
 as the original video.
 
+This will also work for audio using the same API by simply:
+
+    Voyeur::Media.new( filename: path_to_file ).convert( to: :acc )
+
+This will convert the sound file into acc and save it in the same directory as the original video
+
+You can call convert with a block, this will return a MediaTime object.
+
+    Voyeur::Media.new( filename: path_to_file ).convert( to: :mp4 ) do |time|
+      puts time.to_seconds
+    end
+This will output how far along the video the conversion process is, it can be used to display percentage completed.
+See bin/voyuer.rb for an example.
+
 Alternatively you can convert to all 3 types at once:
 
-    Voyeur::Video.new( filename: path_to_file ).convert_to_html5
+    Voyeur::Media.new( filename: path_to_file ).convert_to_html5
 This will convert the video into 3 formats. Mp4, Ogv and Webm and place
 them in the same folder as the parent.
 
 I have allowed the user to specify an output filename. (Note: if no
 output filename the file is just named after the original file):
 
-    Voyeur::Video.new( filename: path_to_file ).convert( to: :mp4, output_filename: "my_cool_video" )
+    Voyeur::Media.new( filename: path_to_file ).convert( to: :mp4, output_filename: "my_cool_video" )
 
 This will give you a converted video called "my_cool_video.mp4".
 
 You can also convert to all with the following:
 
-    Voyeur::Video.new( filename: path_to_file ).convert_to_html5( output_filename: "my_cool_video" )
+    Voyeur::Media.new( filename: path_to_file ).convert_to_html5( output_filename: "my_cool_video" )
 
 It is also possible to place the formatted video in a custom folder:
 
-    Voyeur::Video.new( filename: path_to_file ).convert( to: :mp4, output_path: "my/cool/file/path" )
+    Voyeur::Media.new( filename: path_to_file ).convert( to: :mp4, output_path: "my/cool/file/path" )
 
 or
 
-    Voyeur::Video.new( filename: path_to_file ).convert_to_html5( output_path: "my/cool/file/path" )
+    Voyeur::Media.new( filename: path_to_file ).convert_to_html5( output_path: "my/cool/file/path" )
 
 ## Extendibility
 

data/lib/Voyeur/audio_converters/aac.rb

@@ -0,0 +1,13 @@
+module Voyeur
+  class Aac < Converter
+
+    def file_extension
+      "aac"
+    end
+
+    def convert_options
+      "-acodec libfaac -ac 2 -ar 44100 -ab 128k"
+    end
+  end
+
+end

data/lib/Voyeur/audio_converters/ogg.rb

@@ -0,0 +1,13 @@
+module Voyeur
+  class Ogg < Converter
+
+    def file_extension
+      "ogg"
+    end
+
+    def convert_options
+      "-strict -2 -acodec vorbis -aq 60"
+    end
+  end
+
+end

data/lib/Voyeur/converter.rb

@@ -1,23 +1,30 @@
 module Voyeur
   class Converter
-    attr_accessor :input_video
-    attr_reader :output_video
+    attr_accessor :input_media
+    attr_reader :output_media
     attr_reader :status
 
     def self.create(options)
       constant = Voyeur
-      klass = "#{options[:format].capitalize}"
-      raise Voyeur::Exceptions::InvalidFormat unless constant.const_defined? klass
-      klass = constant.const_get klass
+      klass = if options[:format].is_a?(Symbol)
+                klass_name = "#{options[:format].capitalize}"
+                raise Voyeur::Exceptions::InvalidFormat unless constant.const_defined? klass_name
+                constant.const_get(klass_name)
+              else
+                options[:format]
+              end
       klass.new
     end
 
     def convert(options)
-      @input_video = options[:video]
-      raise Voyeur::Exceptions::NoVideoPresent unless @input_video
-      output_filename = self.output_path( options[:output_path] )
-      @output_video = Video.new(filename: output_file(options[:output_path], options[:output_filename]))
-      self.call_external_converter
+      @input_media = options[:media]
+      raise Voyeur::Exceptions::NoMediaPresent unless @input_media
+      @output_media = Media.new(filename: output_file(options[:output_path], options[:output_filename]))
+      if block_given?
+        self.call_external_converter{ |time| yield time }
+      else
+        self.call_external_converter
+      end
     end
 
     protected
@@ -28,27 +35,33 @@ module Voyeur
 
     def output_path(output_path = nil)
       raise Voyeur::Exceptions::InvalidLocation if output_path && !File.directory?(output_path)
-      output_path ? output_path : File.dirname(@input_video.filename)
+      output_path ? output_path : File.dirname(@input_media.filename)
     end
 
     def output_filename(input_filename = nil)
-      filename = input_filename.nil? ? @input_video.filename : input_filename
+      filename = input_filename.nil? ? @input_media.filename : input_filename
       File.basename(filename, '.*') + ".#{self.file_extension}"
     end
 
     def call_external_converter
-      command = "ffmpeg -i #{@input_video.filename} #{self.convert_options} #{@output_video.filename}"
+      command = "ffmpeg -y -i #{@input_media.filename} #{self.convert_options} #{@output_media.filename}"
       out, err = ""
 
       status = Open4::popen4(command) do |pid, stdin, stdout, stderr|
-        out = stdout.read.strip
-        err = stderr.read.strip
+        err = ''
+        out = ''
+        stderr.each("r") do |line|
+          err += line
+          if line =~ /time=(\d+:\d+:\d+.\d+)/
+            yield $1 if block_given?
+          end
+        end
       end
 
       error_message = err.split('\n').last
 
       @status = { status: status.exitstatus, stdout: out, stderr: err,
-        error_message: error_message, video: @output_video }
+                  error_message: error_message, media: @output_media }
       return @status
     end
   end

data/lib/Voyeur/exceptions.rb

@@ -1,6 +1,6 @@
 module Voyeur
   module Exceptions
-    class NoVideoPresent < StandardError; end
+    class NoMediaPresent < StandardError; end
     class InvalidFormat < StandardError; end
     class InvalidLocation < StandardError; end
   end

data/lib/Voyeur/media.rb

@@ -0,0 +1,41 @@
+module Voyeur
+  class Media
+    attr_reader :filename
+    attr_reader :raw_duration
+
+    def initialize(options)
+      @filename = options[:filename]
+      self.get_info
+    end
+
+    def get_info
+      output = ''
+      status = Open4::popen4("ffmpeg -i #{@filename}") do |pid, stdin, stdout, stderr|
+        output = stderr.read.strip
+      end
+      @raw_duration = $1 if output =~ /Duration: (\d+:\d+:\d+.\d+)/
+    end
+
+    def convert(options)
+      converter = Voyeur::Converter.create(format: options[:to])
+
+      if block_given?
+        converter.convert(media: self,
+                          output_filename: options[:output_filename],
+                          output_path: options[:output_path]){ |time| yield time }
+      else
+        converter.convert(media: self,
+                          output_filename: options[:output_filename],
+                          output_path: options[:output_path])
+      end
+    end
+
+    def convert_to_html5(options = nil)
+      [:mp4, :ogv, :webm].each do |f|
+        options_hash = {to: f}
+        options_hash.merge!(options) if options
+        convert(options_hash)
+      end
+    end
+  end
+end

data/lib/Voyeur/media_time.rb

@@ -0,0 +1,17 @@
+module Voyeur
+  class MediaTime
+    attr_accessor :raw_time
+    attr_accessor :hours, :minutes, :seconds
+
+    def initialize(raw_time)
+      @hours, @minutes, @seconds = raw_time.split(":")
+      @hours = @hours.to_i
+      @minutes = @minutes.to_i
+      @seconds = @seconds.to_i
+    end
+
+    def to_seconds
+      @seconds + (@minutes * 60) + (@hours * 60 * 60)
+    end
+  end
+end

data/lib/Voyeur/version.rb

@@ -1,3 +1,3 @@
 module Voyeur
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/lib/Voyeur/video_converters/iphone.rb

@@ -0,0 +1,14 @@
+#H.264 for iphone
+module Voyeur
+  class Iphone < Converter
+
+    def file_extension
+      "mp4"
+    end
+
+    def convert_options
+      "-s 320x240 -r 30000/1001 -b 200k -bt 240k -vcodec libx264 -vpre ipod320 -acodec libfaac -ac 2 -ar 48000 -ab 192k"
+    end
+  end
+
+end

data/lib/voyeur.rb

@@ -1,8 +1,12 @@
 require "Voyeur/version"
-require "Voyeur/video"
+require "Voyeur/media"
 require "Voyeur/exceptions"
 require "Voyeur/converter"
 require "Voyeur/video_converters/ogv"
 require "Voyeur/video_converters/mp4"
 require "Voyeur/video_converters/webm"
-require 'open4'
+require "Voyeur/video_converters/iphone"
+require "Voyeur/audio_converters/aac"
+require "Voyeur/audio_converters/ogg"
+require "Voyeur/media_time"
+require 'open4'

data/spec/converters/audio_converters/aac_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Voyeur::Aac do
+  let(:converter) { Voyeur::Converter.create(format: :aac) }
+  let(:audio) { Voyeur::Media.new(filename: valid_mpeg_file_path) }
+
+  it "should use the correct factory" do
+    converter.class.to_s.should == "Voyeur::Aac"
+  end
+
+  it "default convert string" do
+    converter.convert_options.should == "-acodec libfaac -ac 2 -ar 44100 -ab 128k"
+  end
+
+  context "A valid audio files" do
+    after :each do
+      File.delete(valid_mpeg_file_path.gsub(/mpeg/, "aac")) if File.exists?(valid_mpeg_file_path.gsub(/mpeg/, "aac"))
+    end
+
+    context "#convert_options: " do
+      it "names the file correctly" do
+        converter.convert(media: audio)
+        output_file = valid_mpeg_file_path.gsub(/mpeg/, "aac")
+        converter.output_media.filename.should == output_file
+      end
+
+      it "returns an audio file" do
+        converter.convert(media: audio)
+        converter.input_media.should == audio
+      end
+
+      context "audio file - " do
+        it "returns conversion status indicating success" do
+          result = converter.convert(media: audio)
+          result[:status].should == 0
+          result[:media].should == converter.output_media
+        end
+
+        it "allows it to be named" do
+          result = converter.convert(media: audio)
+          result[:status].should == 0
+          result[:media].should == converter.output_media
+        end
+      end
+    end
+  end
+
+  context "An invalid audio file" do
+    let(:audio) { Voyeur::Media.new(filename: 'test_media.mpeg') }
+
+    it "returns conversion status indicating failure" do
+      result = converter.convert(media: audio)
+      result[:status].should == 1
+      result[:media].should == converter.output_media
+      result[:error_message].should match(/test_media.mpeg: No such file or directory/)
+      result[:stderr].nil?.should == false
+    end
+  end
+end

data/spec/converters/audio_converters/ogg_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Voyeur::Ogg do
+  let(:converter) { Voyeur::Converter.create(format: :ogg) }
+  let(:audio) { Voyeur::Media.new(filename: valid_mpeg_file_path) }
+
+  it "uses the correct factory" do
+    converter.class.to_s.should == "Voyeur::Ogg"
+  end
+
+  it "default convert string" do
+    converter.convert_options.should == "-strict -2 -acodec vorbis -aq 60"
+  end
+
+  context "A valid audio files" do
+    after :each do
+      File.delete(valid_mpeg_file_path.gsub(/mpeg/, "ogg")) if File.exists?(valid_mpeg_file_path.gsub(/mpeg/, "ogg"))
+    end
+
+    context "#convert_options: " do
+      it "names the media correctly" do
+        converter.convert(media: audio)
+        output_file = valid_mpeg_file_path.gsub(/mpeg/, "ogg")
+        converter.output_media.filename.should == output_file
+      end
+
+      it "returns an audio file" do
+        converter.convert(media: audio)
+        converter.input_media.should == audio
+      end
+
+      context "audio file - " do
+        it "returns conversion status indicating success" do
+          result = converter.convert(media: audio)
+          result[:status].should == 0
+          result[:media].should == converter.output_media
+        end
+
+        it "allows it to be named" do
+          result = converter.convert(media: audio)
+          result[:status].should == 0
+          result[:media].should == converter.output_media
+        end
+      end
+    end
+  end
+
+  context "An invalid audio file" do
+    let(:audio) { Voyeur::Media.new(filename: 'test_media.mpeg') }
+
+    it "returns conversion status indicating failure" do
+      result = converter.convert(media: audio)
+      result[:status].should == 1
+      result[:media].should == converter.output_media
+      result[:error_message].should match(/test_media.mpeg: No such file or directory/)
+      result[:stderr].nil?.should == false
+    end
+  end
+end

data/spec/converters/video_converters/iphone_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Voyeur::Iphone do
+  let(:converter) { Voyeur::Converter.create(format: :iphone) }
+  let(:media) { Voyeur::Media.new(filename: valid_mpeg_file_path) }
+
+  it "uses the correct factory" do
+    converter.class.to_s.should == "Voyeur::Iphone"
+  end
+
+  it "default convert string" do
+    converter.convert_options.should == "-s 320x240 -r 30000/1001 -b 200k -bt 240k -vcodec libx264 -vpre ipod320 -acodec libfaac -ac 2 -ar 48000 -ab 192k"
+  end
+
+  context "A valid Media" do
+    after :each do
+      File.delete(valid_mpeg_file_path.gsub(/mpeg/, "mp4")) if File.exists?(valid_mpeg_file_path.gsub(/mpeg/, "mp4"))
+    end
+
+    context "#convert_options" do
+      it "names the media correctly" do
+        converter.convert(media: media)
+        output_file = valid_mpeg_file_path.gsub(/mpeg/, "mp4")
+        converter.output_media.filename.should == output_file
+      end
+
+      it "returns a media" do
+        converter.convert(media: media)
+        converter.input_media.should == media
+      end
+
+      context "real media" do
+        it "returns conversion status indicating success" do
+          result = converter.convert(media: media)
+          result[:status].should == 0
+          result[:media].should == converter.output_media
+        end
+
+        it "allows them to name the media" do
+          result = converter.convert(media: media)
+          result[:status].should == 0
+          result[:media].should == converter.output_media
+        end
+      end
+    end
+  end
+
+  context "An invalid Media" do
+    let(:converter) { Voyeur::Converter.create(format: :iphone) }
+    let(:media) { Voyeur::Media.new(filename: 'test_media.mpeg') }
+
+    context "File does not exist" do
+      it "returns conversion status indicating failure" do
+        result = converter.convert(media: media)
+        result[:status].should == 1
+        result[:media].should == converter.output_media
+        result[:error_message].should match(/test_media.mpeg: No such file or directory/)
+        result[:stderr].nil?.should == false
+      end
+    end
+  end
+end

data/spec/converters/video_converters/mp4_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Voyeur::Mp4 do
+  let(:converter) { Voyeur::Converter.create(format: :mp4) }
+  let(:media) { Voyeur::Media.new(filename: valid_mpeg_file_path) }
+
+  it "uses the correct factory" do
+    converter.class.to_s.should == "Voyeur::Mp4"
+  end
+
+  it "default convert string" do
+    converter.convert_options.should == "-b 1500k -vcodec libx264 -g 30"
+  end
+
+  context "A valid Media" do
+    after :each do
+      File.delete(valid_mpeg_file_path.gsub(/mpeg/, "mp4")) if File.exists?(valid_mpeg_file_path.gsub(/mpeg/, "mp4"))
+    end
+
+    context "#convert_options" do
+      it "names the media correctly" do
+        converter.convert(media: media)
+        output_file = valid_mpeg_file_path.gsub(/mpeg/, "mp4")
+        converter.output_media.filename.should == output_file
+      end
+
+      it "returns a media" do
+        converter.convert(media: media)
+        converter.input_media.should == media
+      end
+
+      context "real media" do
+        it "returns conversion status indicating success" do
+          result = converter.convert(media: media)
+          result[:status].should == 0
+          result[:media].should == converter.output_media
+        end
+
+        it "allows them to name the media" do
+          result = converter.convert(media: media)
+          result[:status].should == 0
+          result[:media].should == converter.output_media
+        end
+      end
+    end
+  end
+
+  context "An invalid Media" do
+    let(:converter) { Voyeur::Converter.create(format: :mp4) }
+    let(:media) { Voyeur::Media.new(filename: 'test_media.mpeg') }
+
+    context "File does not exist" do
+      it "returns conversion status indicating failure" do
+        result = converter.convert(media: media)
+        result[:status].should == 1
+        result[:media].should == converter.output_media
+        result[:error_message].should match(/test_media.mpeg: No such file or directory/)
+        result[:stderr].nil?.should == false
+      end
+    end
+  end
+end

data/spec/converters/video_converters/ogv_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Voyeur::Ogv do
+  context "New Video" do
+    let(:converter) { Voyeur::Converter.create(format: :ogv) }
+    let(:media) { Voyeur::Media.new(filename: 'test_media.ogv') }
+
+    it "uses the correct factory" do
+      converter.class.to_s.should == "Voyeur::Ogv"
+    end
+
+    context "#convert_options" do
+      it "default convert string" do
+        converter.convert_options.should == "-b 1500k -vcodec libtheora -acodec libvorbis -ab 160000 -g 30"
+      end
+
+      it "raises an exception if no media is passed" do
+        media = nil
+        -> { converter.convert(media: media) }.should raise_error Voyeur::Exceptions::NoMediaPresent
+      end
+
+      it "should return a media" do
+        converter.convert(media: media)
+        converter.input_media.should == media
+      end
+    end
+  end
+
+  context "An invalid Video" do
+    let(:converter) { Voyeur::Converter.create(format: :ogv) }
+    let(:media) { Voyeur::Media.new(filename: 'test_media.mpeg') }
+
+    context "File does not exist" do
+      it "returns conversion status indicating failure" do
+        result = converter.convert(media: media)
+        result[:status].should == 1
+        result[:media].should == converter.output_media
+        result[:error_message].should match(/test_media.mpeg: No such file or directory/)
+        result[:stderr].nil?.should == false
+      end
+    end
+  end
+end

data/spec/converters/video_converters/webm_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Voyeur::Webm do
+  context "New Media" do
+    let(:converter) { Voyeur::Converter.create(format: :webm) }
+    let(:media) { Voyeur::Media.new(filename: 'test_media.webm') }
+
+    it "uses the correct factory" do
+      converter.class.to_s.should == "Voyeur::Webm"
+    end
+
+    context "#convert_options" do
+      it "default convert string" do
+        converter.convert_options.should == "-b 1500k -vcodec libvpx -acodec libvorbis -ab 160000 -f webm -g 30"
+      end
+
+      it "raises an exception if no media is passed" do
+        media = nil
+        -> { converter.convert(media: media) }.should raise_error Voyeur::Exceptions::NoMediaPresent
+      end
+
+      it "returns a media" do
+        converter.convert(media: media)
+        converter.input_media.should == media
+      end
+    end
+  end
+
+  context "An invalid Media" do
+    let(:converter) { Voyeur::Converter.create(format: :webm) }
+    let(:media) { Voyeur::Media.new(filename: 'test_media.mpeg') }
+
+    context "File does not exist" do
+      it "returns conversion status indicating failure" do
+        result = converter.convert(media: media)
+        result[:status].should == 1
+        result[:media].should == converter.output_media
+        result[:error_message].should match(/test_media.mpeg: No such file or directory/)
+        result[:stderr].nil?.should == false
+      end
+    end
+  end
+end

data/spec/media_time_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Voyeur::MediaTime do
+  context "When passing a valid 0 time string in" do
+    let(:raw_time) { "00:00:00.00" }
+    let(:media_time) { Voyeur::MediaTime.new(raw_time) }
+
+    it "hours minutes and seconds should be 0" do
+      media_time.hours.should == 0
+      media_time.minutes.should == 0
+      media_time.seconds.should == 0
+    end
+
+    it "returns 0 seconds" do
+      media_time.to_seconds.should == 0
+    end
+  end
+
+  context "When passing a a valid 1 minutes long time string in" do
+    let(:raw_time) { "00:01:00.00" }
+    let(:media_time) { Voyeur::MediaTime.new(raw_time) }
+
+    it "haves minutes as one" do
+      media_time.hours.should == 0
+      media_time.minutes.should == 1
+      media_time.seconds.should == 0
+    end
+
+    it "returns 60 seconds" do
+      media_time.to_seconds.should == 60
+    end
+  end
+
+  context "When passing a valid string with 1 hour 10 minute and 20 seconds" do
+    let(:raw_time) { "01:10:20.00" }
+    let(:media_time) { Voyeur::MediaTime.new(raw_time) }
+
+    it "haves hour as one, minutes as 10 and seconds as 20" do
+      media_time.hours.should == 1
+      media_time.minutes.should == 10
+      media_time.seconds.should == 20
+    end
+
+    it "returns 4220 seconds" do
+      media_time.to_seconds.should == 4220
+    end
+  end
+end

data/spec/video_spec.rb

@@ -1,78 +1,119 @@
 require 'spec_helper'
 
-describe Voyeur::Video do
-  it 'should create a new video object from a filename' do
+describe Voyeur::Media do
+  it 'creates a new video object from a filename' do
     video_input_name = 'test_file.mpeg'
-    video = Voyeur::Video.new filename: video_input_name
+    video = Voyeur::Media.new filename: video_input_name
     video.filename.should == video_input_name
   end
 
-  it "should convert a video to ogv" do
-    Voyeur::Video.new( filename: valid_mpeg_file_path ).convert(to: :ogv)
-    File.exist?(valid_mpeg_file_path.gsub(/mpeg/, "ogv")).should be_true
-    File.delete(valid_mpeg_file_path.gsub(/mpeg/, "ogv"))
+  it 'gets duration of a media object from a filename' do
+    video = Voyeur::Media.new( filename: valid_mpeg_file_path )
+    video.raw_duration.should_not be_nil
+    video.raw_duration.should_not == ''
   end
 
-  it "should convert a video to mp4" do
-    Voyeur::Video.new( filename: valid_mpeg_file_path ).convert(to: :mp4)
-    File.exist?(valid_mpeg_file_path.gsub(/mpeg/, "mp4")).should be_true
-    File.delete(valid_mpeg_file_path.gsub(/mpeg/, "mp4"))
+  it "converts a video to ogv" do
+    Voyeur::Media.new( filename: valid_mpeg_file_path ).convert(to: :ogv)
+    ogv_file = valid_mpeg_file_path.gsub(/mpeg/, "ogv")
+    File.should exist(ogv_file)
+    File.delete(ogv_file)
   end
 
-  it "should convert a video to webm" do
-    Voyeur::Video.new( filename: valid_mpeg_file_path ).convert(to: :webm)
-    File.exist?(valid_mpeg_file_path.gsub(/mpeg/, "webm")).should be_true
-    File.delete(valid_mpeg_file_path.gsub(/mpeg/, "webm"))
+  it "converts a video to mp4" do
+    Voyeur::Media.new( filename: valid_mpeg_file_path ).convert(to: :mp4)
+    mp4_file = valid_mpeg_file_path.gsub(/mpeg/, "mp4")
+    File.should exist(mp4_file)
+    File.delete(mp4_file)
   end
 
-  it "should convert a video to all HTML5 video formats" do
-    Voyeur::Video.new( filename: valid_mpeg_file_path ).convert_to_html5
-    File.exists?(valid_mpeg_file_path.gsub(/mpeg/, "mp4")).should be_true
-    File.delete(valid_mpeg_file_path.gsub(/mpeg/, "mp4"))
-    File.exists?(valid_mpeg_file_path.gsub(/mpeg/, "ogv")).should be_true
-    File.delete(valid_mpeg_file_path.gsub(/mpeg/, "ogv"))
-    File.exists?(valid_mpeg_file_path.gsub(/mpeg/, "webm")).should be_true
-    File.delete(valid_mpeg_file_path.gsub(/mpeg/, "webm"))
+  it "converts a video to webm" do
+    Voyeur::Media.new( filename: valid_mpeg_file_path ).convert(to: :webm)
+    webm_file = valid_mpeg_file_path.gsub(/mpeg/, "webm")
+    File.should exist(webm_file)
+    File.delete(webm_file)
   end
 
-  it "should allow the user to name the video" do
-    Voyeur::Video.new( filename: valid_mpeg_file_path ).
+  it "converts a video to all HTML5 video formats" do
+    Voyeur::Media.new( filename: valid_mpeg_file_path ).convert_to_html5
+
+    mp4_file = valid_mpeg_file_path.gsub(/mpeg/, "mp4")
+    File.should exist(mp4_file)
+    File.delete(mp4_file)
+
+    ogv_file = valid_mpeg_file_path.gsub(/mpeg/, "ogv")
+    File.should exist(ogv_file)
+    File.delete(ogv_file)
+
+    webm_path = valid_mpeg_file_path.gsub(/mpeg/, "webm")
+    File.should exist(webm_path)
+    File.delete(webm_path)
+  end
+
+  it "allows the user to name the video" do
+    Voyeur::Media.new( filename: valid_mpeg_file_path ).
       convert(to: :webm, output_filename: "sexypants")
-    File.exists?("#{fixture_file_path}/sexypants.webm").should be_true
-    File.delete("#{fixture_file_path}/sexypants.webm")
+    webm_file = "#{fixture_file_path}/sexypants.webm"
+    File.should exist(webm_file)
+    File.delete(webm_file)
   end
 
-  it "should allow the user to specify a video path" do
+  it "allows the user to specify a video path" do
     output_path = "#{fixture_file_path}/converted"
-    Voyeur::Video.new( filename: valid_mpeg_file_path ).
+    Voyeur::Media.new( filename: valid_mpeg_file_path ).
       convert(to: :ogv, output_path: output_path)
-    File.exists?("#{output_path}/test.ogv").should be_true
-    File.delete("#{output_path}/test.ogv")
+    test_file = "#{output_path}/test.ogv"
+    File.should exist(test_file)
+    File.delete(test_file)
   end
 
-  it "should allow a user to specify a video path and filename" do
+  it "allows a user to specify a video path and filename" do
     output_path = "#{fixture_file_path}/converted"
-    Voyeur::Video.new( filename: valid_mpeg_file_path ).
+    Voyeur::Media.new( filename: valid_mpeg_file_path ).
       convert(to: :ogv, output_path: output_path, output_filename: "supersexypants")
-    File.exists?("#{output_path}/supersexypants.ogv").should be_true
-    File.delete("#{output_path}/supersexypants.ogv")
+    supersexypants_file = "#{output_path}/supersexypants.ogv"
+    File.should exist(supersexypants_file)
+    File.delete(supersexypants_file)
   end
 
-  it "should allow a user to specify a video path and filename when converting all formats" do
+  it "allows user to convert given to a format given a class name" do
+    Voyeur::Media.new( filename: valid_mpeg_file_path ).convert(to: Voyeur::Webm)
+    webm_file = valid_mpeg_file_path.gsub(/mpeg/, "webm")
+    File.should exist(webm_file)
+    File.delete(webm_file)
+  end
+
+  it "allows a user to specify a video path and filename when converting all formats" do
     output_path = "#{fixture_file_path}/converted"
-    Voyeur::Video.new( filename: valid_mpeg_file_path ).
+    Voyeur::Media.new( filename: valid_mpeg_file_path ).
       convert_to_html5(output_path: output_path, output_filename: "supersexypants")
-    File.exists?("#{output_path}/supersexypants.ogv").should be_true
-    File.delete("#{output_path}/supersexypants.ogv")
-    File.exists?("#{output_path}/supersexypants.mp4").should be_true
-    File.delete("#{output_path}/supersexypants.mp4")
-    File.exists?("#{output_path}/supersexypants.webm").should be_true
-    File.delete("#{output_path}/supersexypants.webm")
+    ogv_file = "#{output_path}/supersexypants.ogv"
+    File.should exist(ogv_file)
+    File.delete(ogv_file)
+
+    mp4_file = "#{output_path}/supersexypants.mp4"
+    File.should exist(mp4_file)
+    File.delete(mp4_file)
+
+    webm_file = "#{output_path}/supersexypants.webm"
+    File.should exist(webm_file)
+    File.delete(webm_file)
   end
 
-  it "should not allow the user to specify a folder that doesn't exist" do
+  it "nots allow the user to specify a folder that doesn't exist" do
     output_path = "#{fixture_file_path}/icecream"
-    -> { Voyeur::Video.new( filename: valid_mpeg_file_path ).
+    -> { Voyeur::Media.new( filename: valid_mpeg_file_path ).
       convert(to: :ogv, output_path: output_path) }.should raise_error Voyeur::Exceptions::InvalidLocation
   end
+
+  context "when convert is called with a block" do
+    it "updates the progress with time" do
+      output = ''
+      Voyeur::Media.new( filename: valid_mpeg_file_path ).convert(to: :ogv) do |time|
+        output += time
+      end
+      output.should_not == ''
+      output.length.should > 0
+    end
+  end
 end

metadata

@@ -1,119 +1,124 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: voyeur
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 2
-  version: 0.1.2
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Peter Garbers
 - Hendrik F. Louw
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-01-31 00:00:00 +02:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-08-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: open4
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: open4
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id002
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A ruby library to convert videos into common html5 formats
-email: 
+email:
 - peter.garbers@gmail.com
 - hflouw@gmail.com
-executables: []
-
+executables:
+- voyeur.rb
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - Gemfile
 - README.md
 - Rakefile
 - Voyeur.gemspec
+- bin/voyeur.rb
+- lib/Voyeur/audio_converters/aac.rb
+- lib/Voyeur/audio_converters/ogg.rb
 - lib/Voyeur/converter.rb
 - lib/Voyeur/exceptions.rb
+- lib/Voyeur/media.rb
+- lib/Voyeur/media_time.rb
 - lib/Voyeur/version.rb
-- lib/Voyeur/video.rb
+- lib/Voyeur/video_converters/iphone.rb
 - lib/Voyeur/video_converters/mp4.rb
 - lib/Voyeur/video_converters/ogv.rb
 - lib/Voyeur/video_converters/webm.rb
 - lib/voyeur.rb
 - spec/converter_spec.rb
-- spec/converters/mp4_spec.rb
-- spec/converters/ogv_spec.rb
-- spec/converters/webm_spec.rb
+- spec/converters/audio_converters/aac_spec.rb
+- spec/converters/audio_converters/ogg_spec.rb
+- spec/converters/video_converters/iphone_spec.rb
+- spec/converters/video_converters/mp4_spec.rb
+- spec/converters/video_converters/ogv_spec.rb
+- spec/converters/video_converters/webm_spec.rb
 - spec/fixtures/converted/PLACEHOLDER
-- spec/fixtures/test.3gp
 - spec/fixtures/test.mpeg
+- spec/media_time_spec.rb
 - spec/spec_helper.rb
 - spec/spec_helpers/video_file_spec_helper.rb
 - spec/video_spec.rb
-has_rdoc: true
 homepage: http://devthenet.github.com/voyeur
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: Voyeur
-rubygems_version: 1.3.6
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Ruby library to convert common video formats to HTML5 formats
-test_files: 
+test_files:
 - spec/converter_spec.rb
-- spec/converters/mp4_spec.rb
-- spec/converters/ogv_spec.rb
-- spec/converters/webm_spec.rb
+- spec/converters/audio_converters/aac_spec.rb
+- spec/converters/audio_converters/ogg_spec.rb
+- spec/converters/video_converters/iphone_spec.rb
+- spec/converters/video_converters/mp4_spec.rb
+- spec/converters/video_converters/ogv_spec.rb
+- spec/converters/video_converters/webm_spec.rb
 - spec/fixtures/converted/PLACEHOLDER
-- spec/fixtures/test.3gp
 - spec/fixtures/test.mpeg
+- spec/media_time_spec.rb
 - spec/spec_helper.rb
 - spec/spec_helpers/video_file_spec_helper.rb
 - spec/video_spec.rb

data/lib/Voyeur/video.rb

@@ -1,23 +0,0 @@
-module Voyeur
-  class Video
-    attr_reader :filename
-    def initialize(options)
-      @filename = options[:filename]
-    end
-
-    def convert(options)
-      converter = Voyeur::Converter.create(format: options[:to])
-      converter.convert(video: self,
-                        output_filename: options[:output_filename],
-                        output_path: options[:output_path])
-    end
-
-    def convert_to_html5(options = nil)
-      [:mp4, :ogv, :webm].each do |f|
-        options_hash = {to: f}
-        options_hash.merge!(options) if options
-        convert(options_hash)
-      end
-    end
-  end
-end

data/spec/converters/mp4_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-
-describe Voyeur::Mp4 do
-  before :each do
-    @converter = Voyeur::Converter.create(format: :mp4)
-    @video = Voyeur::Video.new(filename: valid_mpeg_file_path)
-  end
-
-  it "should use the correct factory" do
-    @converter.class.to_s.should == "Voyeur::Mp4"
-  end
-
-  it "default convert string" do
-    @converter.convert_options.should == "-b 1500k -vcodec libx264 -g 30"
-  end
-
-  context "A valid Video" do
-    after :each do
-      File.delete(valid_mpeg_file_path.gsub(/mpeg/, "mp4")) if File.exists?(valid_mpeg_file_path.gsub(/mpeg/, "mp4"))
-    end
-
-    context "#convert_options" do
-      it "should name the video correctly" do
-        @converter.convert(video: @video)
-        output_file = valid_mpeg_file_path.gsub(/mpeg/, "mp4")
-        @converter.output_video.filename.should == output_file
-      end
-
-      it "should return a video" do
-        @converter.convert(video: @video)
-        @converter.input_video.should == @video
-      end
-
-      context "real video" do
-        it "should return conversion status indicating success" do
-          result = @converter.convert(video: @video)
-          result[:status].should == 0
-          result[:video].should == @converter.output_video
-        end
-
-        it "should allow them to name the video" do
-          result = @converter.convert(video: @video)
-          result[:status].should == 0
-          result[:video].should == @converter.output_video
-        end
-      end
-    end
-  end
-
-  context "An invalid Video" do
-    before :each do
-      @converter = Voyeur::Converter.create(format: :mp4)
-      @video = Voyeur::Video.new(filename: 'test_video.mpeg')
-    end
-
-    context "File does not exist" do
-      it "should return conversion status indicating failure" do
-        result = @converter.convert(video: @video)
-        result[:status].should == 1
-        result[:video].should == @converter.output_video
-        result[:error_message].should match(/test_video.mpeg: No such file or directory/)
-        result[:stderr].nil?.should == false
-      end
-    end
-  end
-end

data/spec/converters/ogv_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe Voyeur::Ogv do
-  context "New Video" do
-    before :each do
-      @converter = Voyeur::Converter.create(format: :ogv)
-      @video = Voyeur::Video.new(filename: 'test_video.ogv')
-    end
-
-    it "should use the correct factory" do
-      @converter.class.to_s.should == "Voyeur::Ogv"
-    end
-
-    context "#convert_options" do
-      it "default convert string" do
-        @converter.convert_options.should == "-b 1500k -vcodec libtheora -acodec libvorbis -ab 160000 -g 30"
-      end
-
-      it "should raise an exception if no video is passed" do
-        @video = nil
-        -> { @converter.convert(video: @video) }.should raise_error Voyeur::Exceptions::NoVideoPresent
-      end
-
-      it "should return a video" do
-        @converter.convert(video: @video)
-        @converter.input_video.should == @video
-      end
-    end
-  end
-
-  context "An invalid Video" do
-    before :each do
-      @converter = Voyeur::Converter.create(format: :ogv)
-      @video = Voyeur::Video.new(filename: 'test_video.mpeg')
-    end
-    context "File does not exist" do
-      it "should return conversion status indicating failure" do
-        result = @converter.convert(video: @video)
-        result[:status].should == 1
-        result[:video].should == @converter.output_video
-        result[:error_message].should match(/test_video.mpeg: No such file or directory/)
-        result[:stderr].nil?.should == false
-      end
-    end
-  end
-end

data/spec/converters/webm_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe Voyeur::Webm do
-  context "New Video" do
-    before :each do
-      @converter = Voyeur::Converter.create(format: :webm)
-      @video = Voyeur::Video.new(filename: 'test_video.webm')
-    end
-
-    it "should use the correct factory" do
-      @converter.class.to_s.should == "Voyeur::Webm"
-    end
-
-    context "#convert_options" do
-      it "default convert string" do
-        @converter.convert_options.should == "-b 1500k -vcodec libvpx -acodec libvorbis -ab 160000 -f webm -g 30"
-      end
-
-      it "should raise an exception if no video is passed" do
-        @video = nil
-        -> { @converter.convert(video: @video) }.should raise_error Voyeur::Exceptions::NoVideoPresent
-      end
-
-      it "should return a video" do
-        @converter.convert(video: @video)
-        @converter.input_video.should == @video
-      end
-    end
-  end
-
-  context "An invalid Video" do
-    before :each do
-      @converter = Voyeur::Converter.create(format: :webm)
-      @video = Voyeur::Video.new(filename: 'test_video.mpeg')
-    end
-
-    context "File does not exist" do
-      it "should return conversion status indicating failure" do
-        result = @converter.convert(video: @video)
-        result[:status].should == 1
-        result[:video].should == @converter.output_video
-        result[:error_message].should match(/test_video.mpeg: No such file or directory/)
-        result[:stderr].nil?.should == false
-      end
-    end
-  end
-
-end