carrierwave-video 0.0.1.pre

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in carrierwave-video.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,58 @@
+= CarrierWave Video Converter
+
+This gem adds a video converter using ffmpeg and the streamio-ffmpeg rubygem.
+Note: for watermarking to work, there a fork of the streamio-ffmpeg gem that must be used.
+
+= Installation
+
+    gem install carrierwave-video
+
+Using bundler:
+
+    gem 'carrierwave-video'
+
+= Usage
+
+    class VideoUploader < CarrierWave::Uploader::Base
+      include CarrierWave::VideoConverter
+
+      process encode_video: [:mp4, after_transcode: :set_success ]
+    end
+
+    class Video
+      mount_uploader :file, VideoUploader
+
+      def set_success
+        self.success = true
+      end
+    end
+
+= Possible Options
+
+Pass in options to process:
+
+    process encode_video: [:mp4, resolution: "200x200"]
+
+Resolution passed to ffmpeg:
+    resolution: "640x360"
+
+Watermark:
+    watermark: {
+      path: File.join(Rails.root, "directory", "file.png"),
+      position: :bottom_right, # also: :top_right, :bottom_left, :bottom_right
+      pixels_from_edge: 10
+    }
+
+Callbacks:
+    callbacks: {
+      before_transcode: :method
+      after_transcode: :method
+      ensure: :method
+    }
+
+Logging:
+    logger: :method  #returns object that behaves like Logger
+
+= Upcoming
+
+* screengrabs

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/carrierwave-video.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "carrierwave-video/version"
+
+Gem::Specification.new do |s|
+  s.name        = "carrierwave-video"
+  s.version     = Carrierwave::Video::VERSION
+  s.authors     = ["rheaton"]
+  s.email       = ["rachelmheaton@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Carrierwave extension that uses ffmpeg to transcode videos.}
+  s.description = %q{Transcodes to html5-friendly videos.}
+
+  s.rubyforge_project = "carrierwave-video"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+
+  s.add_runtime_dependency 'streamio-ffmpeg'#, :git => 'git://github.com/stakach/streamio-ffmpeg.git'
+  s.add_runtime_dependency 'carrierwave'
+  s.requirements << 'ruby, version 1.9 or greater'
+  s.requirements << 'ffmpeg, version 0.10 or greater with libx256, libfaac, libtheora, libvorbid, libvpx enabled'
+end

data/lib/carrierwave-video/version.rb

@@ -0,0 +1,5 @@
+module Carrierwave
+  module Video
+    VERSION = "0.0.1.pre"
+  end
+end

data/lib/carrierwave/video.rb

@@ -0,0 +1,59 @@
+require 'streamio-ffmpeg'
+require 'carrierwave'
+require 'carrierwave/video/ffmpeg_options'
+
+module CarrierWave
+  module Video
+    extend ActiveSupport::Concern
+    module ClassMethods
+      def encode_video(target_format, options={})
+        process encode_video: [target_format, options]
+      end
+    end
+
+    def encode_video(format, opts={})
+      # move upload to local cache
+      cache_stored_file! if !cached?
+
+      options = CarrierWave::Video::FfmpegOptions.new(format, opts)
+      tmp_path  = File.join( File.dirname(current_path), "tmpfile.#{format}" )
+
+
+      with_callbacks(opts) do
+        file = ::FFMPEG::Movie.new(current_path)
+        file.transcode(tmp_path, options.format_options, options.encoder_options)
+        File.rename tmp_path, current_path
+      end
+    end
+
+    private
+      def with_callbacks(opts, &block)
+        callbacks = opts[:callbacks] || {}
+        logger_opt = opts[:logger]
+        begin
+          send_callback(callbacks[:before_transcode])
+          setup_logger(logger_opt)
+          block.call
+          send_callback(callbacks[:after_transcode])
+        ensure
+          reset_logger
+          send_callback(callbacks[:ensure])
+        end
+      end
+
+      def send_callback(callback)
+        model.send(callback) if callback.present?
+      end
+
+      def setup_logger(opt)
+        return unless opt.present?
+        @ffmpeg_logger = ::FFMPEG.logger
+        ::FFMPEG.logger = model.send(opt)
+      end
+
+      def reset_logger
+        return unless @ffmpeg_logger
+        ::FFMPEG.logger = @ffmpeg_logger
+      end
+  end
+end

data/lib/carrierwave/video/ffmpeg_options.rb

@@ -0,0 +1,69 @@
+module CarrierWave
+  module Video
+    class FfmpegOptions
+      attr_reader :watermark_path, :watermark_position, :watermark_pixels,
+        :format, :resolution
+
+      def initialize(format, options)
+        @format = format.to_s
+        @watermark = options[:watermark].present?
+        @resolution = options[:resolution] || "640x360"
+        if watermark?
+          @watermark_path = options[:watermark][:path]
+          @watermark_position = options[:watermark][:position].to_s || :bottom_right
+          @watermark_pixels = options[:watermark][:pixels_from_edge] || 10
+        end
+      end
+
+      def encoder_options
+        {preserve_aspect_ratio: :width}
+      end
+
+      def format_options
+        format_options = case format
+        when "mp4"
+          {
+            video_codec: 'libx264',
+            audio_codec: 'libfaac',
+            custom: "-b 1500k -vpre slow -vpre baseline -g 30 #{watermark_params}"
+          }
+        when "webm"
+          {
+            video_codec: 'libvpx',
+            audio_codec: 'libvorbis',
+            custom: "-b 1500k -ab 160000 -f webm -g 30 #{watermark_params}"
+          }
+        when "ogv"
+          {
+            video_codec: 'libtheora',
+            audio_codec: 'libvorbis',
+            custom: "-b 1500k -ab 160000 -g 30 #{watermark_params}"
+          }
+        else
+          {}
+        end
+        { resolution: resolution }.merge(format_options)
+      end
+
+      def watermark?
+        @watermark
+      end
+
+      def watermark_params
+        return "" unless watermark?
+        positioning = case watermark_position
+                        when 'bottom_left'
+                          "#{watermark_pixels}:main_h-overlay_h-#{watermark_pixels}"
+                        when 'bottom_right'
+                          "main_w-overlay_w-#{watermark_pixels}:main_h-overlay_h-#{watermark_pixels}"
+                        when 'top_left'
+                          "#{watermark_pixels}:#{watermark_pixels}"
+                        when 'top_right'
+                          "main_w-overlay_w-#{watermark_pixels}:#{watermark_pixels}"
+                      end
+
+        "-vf \"movie=#{watermark_path} [logo]; [in][logo] overlay=#{positioning} [out]\""
+      end
+    end
+  end
+end

data/spec/lib/carrierwave_video_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe CarrierWave::Video do
+  class Video; end
+
+  class TestVideoUploader
+    include CarrierWave::Video
+    def cached?; end
+    def cache_stored_file!; end
+    def model
+      @video ||= Video.new
+    end
+  end
+
+  let(:converter) { TestVideoUploader.new }
+
+  describe ".encode_video" do
+    it "processes the model" do
+      TestVideoUploader.should_receive(:process).with(encode_video: ["format", :opts])
+      TestVideoUploader.encode_video("format", :opts)
+    end
+
+    it "does not require options" do
+      TestVideoUploader.should_receive(:process).with(encode_video: ["format", {}])
+      TestVideoUploader.encode_video("format")
+    end
+  end
+
+  describe "#encode_video" do
+    let(:format) { 'webm' }
+    let(:movie) { mock }
+
+    before do
+      converter.stub(:current_path).and_return('video/path/file.mov')
+
+      FFMPEG::Movie.should_receive(:new).and_return(movie)
+    end
+
+    context "no options set" do
+      before {  File.should_receive(:rename) }
+      it "is calls transcode with correct format options" do
+        movie.should_receive(:transcode) do |path, opts, codec_opts|
+          codec_opts.should == {preserve_aspect_ratio: :width}
+
+          opts[:video_codec].should == 'libvpx'
+          opts[:audio_codec].should == 'libvorbis'
+          opts[:custom].should == '-b 1500k -ab 160000 -f webm -g 30 '
+
+          path.should == "video/path/tmpfile.#{format}"
+        end
+
+        converter.encode_video(format)
+      end
+    end
+
+    context "callbacks set" do
+      before { movie.should_receive(:transcode) }
+
+      context "no exceptions raised" do
+        before {  File.should_receive(:rename) }
+
+        it "calls before_transcode, after_transcode, and ensure" do
+          converter.model.should_receive(:method1).ordered
+          converter.model.should_receive(:method2).ordered
+          converter.model.should_receive(:method3).ordered
+
+          converter.encode_video(format, callbacks: {
+                                 before_transcode: :method1,
+                                 after_transcode: :method2,
+                                 ensure: :method3
+          })
+        end
+      end
+
+      context "exception raised" do
+        let(:e) { StandardError.new("test error") }
+        before { File.should_receive(:rename).and_raise(e) }
+
+        it "calls before_transcode and ensure" do
+          converter.model.should_receive(:method1).ordered
+          converter.model.should_not_receive(:method2)
+          converter.model.should_receive(:method3).ordered
+
+          lambda do
+            converter.encode_video(format, callbacks: {
+                                   before_transcode: :method1,
+                                   after_transcode: :method2,
+                                   ensure: :method3
+            })
+          end.should raise_exception(e)
+        end
+      end
+    end
+
+    context "logger set" do
+      let(:logger) { mock }
+      before do
+        converter.model.stub(:logger).and_return(logger)
+        movie.should_receive(:transcode)
+      end
+
+      context "with no exceptions" do
+        before { File.should_receive(:rename) }
+
+        it "sets FFMPEG logger to logger and resets" do
+          old_logger = ::FFMPEG.logger
+          ::FFMPEG.should_receive(:logger=).with(logger).ordered
+          ::FFMPEG.should_receive(:logger=).with(old_logger).ordered
+          converter.encode_video(format, logger: :logger)
+        end
+      end
+
+      context "with exceptions" do
+        let(:e) { StandardError.new("test error") }
+        before { File.should_receive(:rename).and_raise(e) }
+
+        it "logs exception" do
+          lambda do
+            converter.encode_video(format, logger: :logger)
+          end.should raise_exception(e)
+        end
+      end
+    end
+
+    context "watermark set" do
+      before { File.should_receive(:rename) }
+
+      it "appends watermark params to custom params for ffmpeg" do
+        movie.should_receive(:transcode) do |path, opts, codec_opts|
+          codec_opts.should == {preserve_aspect_ratio: :width}
+
+          opts[:video_codec].should == 'libvpx'
+          opts[:audio_codec].should == 'libvorbis'
+          opts[:custom].should == "-b 1500k -ab 160000 -f webm -g 30 -vf \"movie=path/to/file.png [logo]; [in][logo] overlay=5:main_h-overlay_h-5 [out]\""
+
+          path.should == "video/path/tmpfile.#{format}"
+        end
+
+        converter.encode_video(format, watermark: {
+          path: 'path/to/file.png',
+          position: :bottom_left,
+          pixels_from_edge: 5
+        })
+      end
+
+      it "only requires path watermark parameter" do
+        movie.should_receive(:transcode) do |path, opts, codec_opts|
+          codec_opts.should == {preserve_aspect_ratio: :width}
+
+          opts[:video_codec].should == 'libvpx'
+          opts[:audio_codec].should == 'libvorbis'
+          opts[:custom].should == "-b 1500k -ab 160000 -f webm -g 30 -vf \"movie=path/to/file.png [logo]; [in][logo] overlay= [out]\""
+
+          path.should == "video/path/tmpfile.#{format}"
+        end
+
+        converter.encode_video(format, watermark: {
+          path: 'path/to/file.png'
+        })
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'streamio-ffmpeg'
+require 'carrierwave/video'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: carrierwave-video
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre
+  prerelease: 6
+platform: ruby
+authors:
+- rheaton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70335404267560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70335404267560
+- !ruby/object:Gem::Dependency
+  name: streamio-ffmpeg
+  requirement: &70335404266960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70335404266960
+- !ruby/object:Gem::Dependency
+  name: carrierwave
+  requirement: &70335404266520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70335404266520
+description: Transcodes to html5-friendly videos.
+email:
+- rachelmheaton@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- carrierwave-video.gemspec
+- lib/carrierwave-video/version.rb
+- lib/carrierwave/video.rb
+- lib/carrierwave/video/ffmpeg_options.rb
+- spec/lib/carrierwave_video_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+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: 1.3.1
+requirements:
+- ruby, version 1.9 or greater
+- ffmpeg, version 0.10 or greater with libx256, libfaac, libtheora, libvorbid, libvpx
+  enabled
+rubyforge_project: carrierwave-video
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Carrierwave extension that uses ffmpeg to transcode videos.
+test_files:
+- spec/lib/carrierwave_video_spec.rb
+- spec/spec_helper.rb