Background Video Processing with Rails

Question

I am trying to get uploaded videos to be converted in the background, running windows. Some of what I am using:

gem 'paperclip'
gem 'delayed_job_active_record'
gem 'ffmpeg'

I have edited the registry to allow the ffmpeg command to be ran from anywhere, I get a popup that I assume is ffmpeg because it goes away too quickly, guess the command is wrong so if anyone knows what's wrong with it please let me know. But the real problem is that it just hangs there, it says:

[2012-12-09 22:47:03] ERROR invalid body size.
[2012-12-09 22:47:03] ERROR Errno::ECONNABORTED: An established connection was a
borted by the software in your host machine.
        C:/RailsInstaller/Ruby1.9.3/lib/ruby/1.9.1/webrick/httpresponse.rb:396:i
n `write'
        C:/RailsInstaller/Ruby1.9.3/lib/ruby/1.9.1/webrick/httpresponse.rb:396:i
n `<<'
        C:/RailsInstaller/Ruby1.9.3/lib/ruby/1.9.1/webrick/httpresponse.rb:396:i
n `_write_data'
        C:/RailsInstaller/Ruby1.9.3/lib/ruby/1.9.1/webrick/httpresponse.rb:368:i
n `send_body_string'
        C:/RailsInstaller/Ruby1.9.3/lib/ruby/1.9.1/webrick/httpresponse.rb:249:i
n `send_body'
        C:/RailsInstaller/Ruby1.9.3/lib/ruby/1.9.1/webrick/httpresponse.rb:152:i
n `send_response'
        C:/RailsInstaller/Ruby1.9.3/lib/ruby/1.9.1/webrick/httpserver.rb:110:in
`run'
        C:/RailsInstaller/Ruby1.9.3/lib/ruby/1.9.1/webrick/server.rb:191:in `blo
ck in start_thread'

Does anyone know how to properly get this working? I've went through a few tutorials that have bits and pieces of what I need but I can't get them working together. Here's what I have so far, lemme know if you need more:

Model:

class Video < ActiveRecord::Base

  belongs_to :user
  has_many :comments, dependent: :destroy
  attr_accessible :video, :user_id, :video_file_name, :title, :public, :description, :views

  has_attached_file :video, url: "/users/:user_id/videos/:id/:basename_:style.:extension"

  #process_in_background :video #causes death

  validates :video, presence: true
  validates :description, presence: true, length: { minimum: 5, maximum: 100}
  validates :title, presence: true, length: { minimum: 1, maximum: 15 }

  validates_attachment_size :video, less_than: 1.gigabytes
  validates_attachment :video, presence: true

  default_scope order: 'created_at DESC'

  Paperclip.interpolates :user_id do |attachment, style|attachment.instance.user_id
  end

  #before_post_process do |video|
   # false if video.status == "converting"
  #end

  def perform
    command = <<-end_command
      start ffmpeg -i #{ '/public/users/:user_id/videos/:id/:basename_:style.:extension' }  -ar 22050 -ab 32 -s 1280x720 -vcodec webm -r 25 -qscale 8 -f webm -y #{ '/public/users/:user_id/videos/:id/:basename_.webm' }

    end_command
    success = system(command)
    logger.debug 'Converting File: ' + success.to_s
    if success && $?.exitstatus.to_i == 0
      #self.converted!
      self.status = "converted"
    else
      #self.failure!
      self.status = "failed"
    end
  end

  handle_asynchronously :perform

  def self.search(search)
    if search
      find(:all, conditions: ["public = 't' AND title LIKE ?", "%#{search}%"], order: "created_at DESC")
    else
      find(:all, conditions: ["public = 't'"], order: "created_at DESC")
    end
  end

  def self.admin_search(search)
    if search
      find(:all, conditions: ['title LIKE ?', "%#{search}%"], order: "created_at DESC")
    else
      find(:all, order: "created_at DESC")
    end
  end

  private

    # This updates the stored filename with the new flash video file
    def set_new_filename
      #update_attribute(:filename, "#{filename}.#{id}.webm")
      update_attribute(:content_type, "video/x-webm")
    end

end

Controller:

class VideosController < ApplicationController
    before_filter :signed_in_user, only: [:upload, :update, :destroy]
    before_filter :admin_user, only: :admin_index

    def upload
        @video = Video.new
        # generate a unique id for the upload
        @uuid = (0..29).to_a.map {|x| rand(10)}
    end

    def create
        @video = Video.new(params[:video])
        @video.user_id = current_user.id

        if @video.save
            @video.delay.perform
            flash[:success] = "Uploaded Succefully!"
            redirect_to @video.user
            Delayed::Worker.new.start
        else
            render 'upload'
        end
    end

    def show
        @video = Video.find(params[:id])
        @comments = @video.comments.paginate(page: params[:page], per_page: 6)
        if !@video.public
            if !signed_in? || current_user.id != @video.user_id  && !current_user.admin && !current_user.approved?(@video.user)
            flash[:notice] = "Video is private"
            redirect_to root_path
        end
    end
    end

    def update
        @video = Video.find(params[:id])
        if @video.update_attributes(params[:video])
      flash[:success] = "Video preferences saved"
    else
        flash[:fail] = "Failed to update video preferences"
    end
    redirect_to :back
  end

    def destroy
        @video = Video.find(params[:id])
        @video.destroy
        flash[:deleted] = "Deleted Succefully!"
        redirect_to :back
    end

    def index
        @videos = Video.paginate(page: params[:page], per_page: 6).search(params[:search])
    end

    def admin_index
        @videos = Video.paginate(page: params[:page], per_page: 6).admin_search(params[:search])
    end

    def ajax_video_comments
        @video = Video.find(params[:id])
        @comments = @video.comments.paginate(page: params[:page], per_page: 6)

        respond_to do |format|
        format.js   { render partial: 'shared/comments', content_type: 'text/html' }
    end
    end

    def ajax_video_watched
        @video = Video.find(params[:id])
        @video.views += 1
        @video.save
    end

    private

    def signed_in_user
        redirect_to root_path, notice: "Please Login." unless signed_in?
    end

    def admin_user
        redirect_to(root_path) unless current_user.admin?
    end

end

Answer 1

Your table should have these columns:

• video_file_name
• video_content_type
• video_file_size
• video_updated_at
• video_meta

I added some additional paperclip magic to you model, obviously you can tweak the settings for ffmpeg. This is not all original code but I can't remember where I found bits and pieces so if someone recognizes it feel free to take credit.

class Video < ActiveRecord::Base

  belongs_to :user
  has_many :comments, dependent: :destroy
  attr_accessible :video, :user_id, :video_file_name, 
                  :title, :public, :description, :views

  has_attached_file :video, 
    url: "/users/:user_id/videos/:id/:basename_:style.:extension"
    styles: {
             :original => { :geometry => "1280x720", :format => 'mp4', :streaming => true, :convert_options => { :input => {}, :output => {'c:v' => 'libx264', vprofile: 'high', preset: 'medium', 'b:v' => '1250k', maxrate: '1250k', bufsize: '2500k', pix_fmt: 'yuv420p', flags: '+mv4+aic', threads: 'auto', 'b:a' => '128k', strict: '-2'}} },
             :medium => { :geometry => "854x480", :format => 'mp4', :streaming => true,                 :convert_options => { :input => {}, :output => {'c:v' => 'libx264', vprofile: 'high', preset: 'medium', 'b:v' => '750k', maxrate: '750k', bufsize: '1500k', pix_fmt: 'yuv420p', flags: '+mv4+aic', threads: 'auto', 'b:a' => '128k', strict: '-2'}} },
             :small => { :geometry => '640x360', :format => 'mp4', :streaming => true, :convert_options => { :input => {}, :output => {'c:v' => 'libx264', vprofile: 'high', preset: 'medium', 'b:v' => '250k', maxrate: '250k', bufsize: '500k', pix_fmt: 'yuv420p', flags: '+mv4+aic', threads: 'auto', 'b:a' => '128k', strict: '-2'}} },
             :thumb => { :geometry => "160x90", :format => 'jpg', :time => 10 }
            }, 
    processors: [:ffmpeg, :qtfaststart]

  validates :video, presence: true
  validates :description, presence: true, length: { minimum: 5, maximum: 100}
  validates :title, presence: true, length: { minimum: 1, maximum: 15 }

  validates_attachment_size :video, less_than: 1.gigabytes
  validates_attachment :video, presence: true

  default_scope order: 'created_at DESC'

  # cancel post-processing now, and set flag...


  before_post_process do |video|
    if video.status == nil
      video.status = "queuing"
      false # halts processing
    end
  end

  # ...and perform after save in background
  after_commit do |video| 
    if video.status == "queuing"
      Delayed::Job.enqueue VideoJob.new(video.id), :queue => 'video'
      video.status == "queued"
      video.save(validations: false)
    end
  end

  # generate styles (downloads original first)
  def regenerate_styles!
    self.video.reprocess!
  end

  # detect if our source file has changed
  def video_changed?
    self.video_file_size_changed? || 
    self.video_file_name_changed? ||
    self.video_content_type_changed? || 
    self.video_updated_at_changed?
  end

  # Class to perform with delayed jobs
  class VideoJob < Struct.new(:video_id)

    def perform
      video = Video.find(self.video_id)
      video.status = "processing"
      video.save(validations: false)
      video.regenerate_styles!
    end

    def success(job)
      video = Video.find(self.video_id)
      video.status = "complete"   
      video.save(:validate => false)
    end

    def error(job, exception)
      video = Video.find(self.video_id)
      video.status = "error"   
      video.save(:validate => false)
    end
  end
end

Paperclip Processors (/lib/paperclip_processors/ffmpeg.rb):

module Paperclip
  class Ffmpeg < Processor
    attr_accessor :geometry, :format, :whiny, :convert_options

    # Creates a Video object set to work on the +file+ given. It
    # will attempt to transcode the video into one defined by +target_geometry+
    # which is a "WxH"-style string. +format+ should be specified.
    # Video transcoding will raise no errors unless
    # +whiny+ is true (which it is, by default. If +convert_options+ is
    # set, the options will be appended to the convert command upon video transcoding.
    def initialize file, options = {}, attachment = nil
      @convert_options = {
        :input => {},
        :output => { :y => nil }
      }
      unless options[:convert_options].nil? || options[:convert_options].class != Hash
        unless options[:convert_options][:input].nil? || options[:convert_options][:input].class != Hash
          @convert_options[:input].reverse_merge! options[:convert_options][:input]
        end
        unless options[:convert_options][:output].nil? || options[:convert_options][:output].class != Hash
          @convert_options[:output].reverse_merge! options[:convert_options][:output]
        end
      end

      @geometry        = options[:geometry]
      @file            = file
      @keep_aspect     = !@geometry.nil? && @geometry[-1,1] != '!'
      @pad_only        = @keep_aspect    && @geometry[-1,1] == '#'
      @enlarge_only    = @keep_aspect    && @geometry[-1,1] == '<'
      @shrink_only     = @keep_aspect    && @geometry[-1,1] == '>'
      @whiny           = options[:whiny].nil? ? true : options[:whiny]
      @format          = options[:format]
      @time            = options[:time].nil? ? 3 : options[:time]
      @current_format  = File.extname(@file.path)
      @basename        = File.basename(@file.path, @current_format)
      @meta            = identify
      @pad_color       = options[:pad_color].nil? ? "black" : options[:pad_color]
      attachment.instance_write(:meta, @meta)
    end
    # Performs the transcoding of the +file+ into a thumbnail/video. Returns the Tempfile
    # that contains the new image/video.
    def make
      src = @file
      dst = Tempfile.new([@basename, @format ? ".#{@format}" : ''])
      dst.binmode

      parameters = []
      # Add geometry
      if @geometry
        # Extract target dimensions
        if @geometry =~ /(\d*)x(\d*)/
          target_width = $1
          target_height = $2
        end
        # Only calculate target dimensions if we have current dimensions
        unless @meta[:size].nil?
          current_geometry = @meta[:size].split('x')
          # Current width and height
          current_width = current_geometry[0]
          current_height = current_geometry[1]
          if @keep_aspect
            if @enlarge_only
              if current_width.to_i < target_width.to_i
                # Keep aspect ratio
                width = target_width.to_i
                height = (width.to_f / (@meta[:aspect].to_f)).to_i
                @convert_options[:output][:s] = "#{width.to_i/2*2}x#{height.to_i/2*2}"
              else
                return nil
              end
            elsif @shrink_only
              if current_width.to_i > target_width.to_i
                # Keep aspect ratio
                width = target_width.to_i
                height = (width.to_f / (@meta[:aspect].to_f)).to_i
                @convert_options[:output][:s] = "#{width.to_i/2*2}x#{height.to_i/2*2}"
              else
                return nil
              end
            elsif @pad_only
              # Keep aspect ratio
              width = target_width.to_i
              height = (width.to_f / (@meta[:aspect].to_f)).to_i
              # We should add half the delta as a padding offset Y
              pad_y = (target_height.to_f - height.to_f) / 2
              if pad_y > 0
                @convert_options[:output][:vf] = "scale=#{width}:-1,pad=#{width.to_i}:#{target_height.to_i}:0:#{pad_y}:#@pad_color"
              else
                @convert_options[:output][:vf] = "scale=#{width}:-1,crop=#{width.to_i}:#{height.to_i}"
              end
            else
              # Keep aspect ratio
              width = target_width.to_i
              height = (width.to_f / (@meta[:aspect].to_f)).to_i
              @convert_options[:output][:s] = "#{width.to_i/2*2}x#{height.to_i/2*2}"
            end
          else
            # Do not keep aspect ratio
            @convert_options[:output][:s] = "#{target_width.to_i/2*2}x#{target_height.to_i/2*2}"
          end
        end
      end
      # Add format
      case @format
      when 'jpg', 'jpeg', 'png', 'gif' # Images
        @convert_options[:input][:ss] = @time
        @convert_options[:output][:vframes] = 1
        @convert_options[:output][:f] = 'image2'
      end

      # Add source
      parameters << @convert_options[:input].map { |k,v| "-#{k.to_s} #{v} "}
      parameters << "-i ':source'"
      parameters << @convert_options[:output].map { |k,v| "-#{k.to_s} #{v} "}
      parameters << "':dest'"

      parameters = parameters.flatten.compact.join(" ").strip.squeeze(" ")

      begin
        success = Paperclip.run("ffmpeg", parameters, :source => "#{File.expand_path(src.path)}", :dest => File.expand_path(dst.path))
      rescue Cocaine::ExitStatusError => e
        raise Paperclip::Error, "error while processing video for #{@basename}: #{e}" if @whiny
      end

      dst
    end

    def identify
      meta = {}
      command = "ffmpeg -i \"#{File.expand_path(@file.path)}\" 2>&1"
      ffmpeg = IO.popen(command)
      ffmpeg.each("\r") do |line|
        # Matching lines like:
        # Video: h264, yuvj420p, 640x480 [PAR 72:72 DAR 4:3], 10301 kb/s, 30 fps, 30 tbr, 600 tbn, 600 tbc
        if line.include?(' Video: ')
          start = line.index('Video:')
          items = line[start, 150].split(',')
          size = items[2].strip!.split(' ').first
          meta[:size] = size.to_s
          meta[:aspect] = size.split('x').first.to_f / size.split('x').last.to_f
        end
        # Matching Duration: 00:01:31.66, start: 0.000000, bitrate: 10404 kb/s
        if line =~ /Duration:(\s.?(\d*):(\d*):(\d*\.\d*))/
          meta[:length] = $2.to_s + ":" + $3.to_s + ":" + $4.to_s
        end
      end
      meta
    end
  end

  class Attachment
    def meta
      instance_read(:meta)
    end
  end
end

Paperclip Processors (/lib/paperclip_processors/qtfaststart.rb):

module Paperclip
  class Qtfaststart < Processor
    attr_accessor :streaming, :format, :whiny

    # Creates a Video object set to work on the +file+ given. It
    # will attempt to reposition the moov atom in the video given
    # if +streaming+ is set.
    def initialize file, options = {}, attachment = nil
      @streaming      = options[:streaming]
      @file            = file
      @whiny           = options[:whiny].nil? ? true : options[:whiny]
      @format          = options[:format]
      @current_format  = File.extname(@file.path)
      @basename        = File.basename(@file.path, @current_format)
      @meta            = attachment.meta
      attachment.instance_write(:meta, @meta)
    end

    # Performs the atom repositioning on +file+.
    # Returns the Tempfile that contains the new video or the original
    # file if +streaming+ wasn't set. 
    def make
      return @file unless @streaming

      src = @file
      dst = Tempfile.new([@basename, @format ? ".#{@format}" : ''])
      dst.binmode

      parameters = []
      # Add source
      parameters << ":source"
      # Add destination
      parameters << ":dest"

      parameters = parameters.flatten.compact.join(" ").strip.squeeze(" ")

      Paperclip.log("[qtfaststart] #{parameters}")
      begin
        success = Paperclip.run("qt-faststart", parameters, :source => "#{File.expand_path(src.path)}", :dest => File.expand_path(dst.path))
      rescue Cocaine::ExitStatusError => e
        raise PaperclipError, "error while processing video for #{@basename}: #{e}" if @whiny
      end
      dst
    end
  end

  class Attachment
    def meta
      instance_read(:meta)
    end
  end
end

You controller could use some more cleaning but I just made adjustments to make it work with my other changes.

class VideosController < ApplicationController
    before_filter :signed_in_user, only: [:upload, :update, :destroy]
    before_filter :admin_user, only: :admin_index

    def upload
        @video = Video.new
        # generate a unique id for the upload
        @uuid = (0..29).to_a.map {|x| rand(10)}
    end

    def create
        @video = Video.new(params[:video])
        @video.user_id = current_user.id

        if @video.save
            flash[:success] = "Uploaded Succefully!"
            redirect_to @video.user
        else
            render 'upload'
        end
    end

    def show
        @video = Video.find(params[:id])
        @comments = @video.comments.paginate(page: params[:page], per_page: 6)
        if !@video.public
            if !signed_in? || current_user.id != @video.user_id  && !current_user.admin && !current_user.approved?(@video.user)
            flash[:notice] = "Video is private"
            redirect_to root_path
        end
    end
    end

    def update
        @video = Video.find(params[:id])
        if @video.update_attributes(params[:video])
      flash[:success] = "Video preferences saved"
    else
        flash[:fail] = "Failed to update video preferences"
    end
    redirect_to :back
  end

    def destroy
        @video = Video.find(params[:id])
        @video.destroy
        flash[:deleted] = "Deleted Succefully!"
        redirect_to :back
    end

    def index
        @videos = Video.paginate(page: params[:page], per_page: 6).search(params[:search])
    end

    def admin_index
        @videos = Video.paginate(page: params[:page], per_page: 6).admin_search(params[:search])
    end

    def ajax_video_comments
        @video = Video.find(params[:id])
        @comments = @video.comments.paginate(page: params[:page], per_page: 6)

        respond_to do |format|
        format.js   { render partial: 'shared/comments', content_type: 'text/html' }
    end
    end

    def ajax_video_watched
        @video = Video.find(params[:id])
        @video.views += 1
        @video.save
    end

    private

    def signed_in_user
        redirect_to root_path, notice: "Please Login." unless signed_in?
    end

    def admin_user
        redirect_to(root_path) unless current_user.admin?
    end

end

You can run a delayed_jobs worker thread how ever works best for you. I may have made some mistakes in here but I tried to adapt my method to your current model.

Answer 2

Bit late, but we use the paperclip-ffmeg gem - something you might want to check out

All you need to do is put them gem into your gemfile, and then you just have to define the processor as :ffmpeg.

Here's a live example from our code:

class Attachment < ActiveRecord::Base

        has_attached_file :attachment,
                styles:          lambda { |a| a.instance.is_image? ? {:small => "x200>", :medium => "x300>", :large => "x400>"}  : {:thumb => { :geometry => "100x100#", :format => 'jpg', :time => 10}, :medium => { :geometry => "300x300#", :format => 'jpg', :time => 10}}},
                :processors => lambda { |a| a.is_video? ? [ :ffmpeg ] : [ :thumbnail ] }

        def is_video?
                attachment.instance.attachment_content_type =~ %r(video)
        end

        def is_image?
                attachment.instance.attachment_content_type =~ %r(image)
        end

end