ffi-ffmpeg 0.5.8135c9c5dc36

data/lib/ffmpeg/frame.rb

@@ -0,0 +1,58 @@
+require 'ffi/ffmpeg'
+
+module FFmpeg::Frame; end
+
+class FFmpeg::Frame::Video
+  include FFI::FFmpeg
+
+  attr_reader :av_frame, :width, :height, :pixel_format, :stream
+  attr_accessor :pts, :number
+
+  def initialize(p={})
+    @stream = p[:stream] or raise ArgumentError, "no :stream"
+    @width = p[:width] or raise ArgumentError, "no :width"
+    @height = p[:height] or raise ArgumentError, "no :height"
+    @pixel_format = p[:pixel_format] or
+      raise ArgumentError "no :pixel_format"
+    @av_frame = avcodec_alloc_frame or
+      raise NoMemoryError "avcodec_alloc_frame() failed"
+    @av_frame = AVFrame.new @av_frame
+  
+    # Set up our finalizer which calls av_free() on the av_frame.
+    ObjectSpace.define_finalizer(self, self.class.method(:finalize).to_proc)
+
+    bytes = avpicture_get_size(@pixel_format, @width, @height)
+    @buffer = FFI::MemoryPointer.new(:uchar, bytes)
+    avpicture_fill(@av_frame, @buffer, @pixel_format, @width, @height)
+  end
+
+  def self.finalize(id)
+    av_free(@av_frame)
+  end
+
+  def key_frame?
+    @av_frame[:key_frame] == 1
+  end
+
+  def scale(p={})
+    width = p[:width] || @width
+    height = p[:height] || @height
+    pixel_format = p[:pixel_format] || @pixel_format
+    out = FFmpeg::Frame::Video.new(:width => width, :height => height, 
+                                   :pixel_format => pixel_format,
+                                   :stream => stream)
+
+    scale_ctx = sws_getContext(@width, @height, @pixel_format,
+                               width, height, pixel_format,
+                              :bicubic, nil, nil, nil) or
+      raise NoMemoryError, "sws_getContext() failed"
+
+    rc = sws_scale(scale_ctx, @av_frame[:data], @av_frame[:linesize], 0,
+                   @height, out.av_frame[:data], out.av_frame[:linesize])
+    sws_freeContext(scale_ctx)
+
+    out.pts = @pts
+    out.number = @number
+    out
+  end
+end

data/lib/ffmpeg/reader.rb

@@ -0,0 +1,74 @@
+require 'ffi/ffmpeg'
+
+class FFmpeg::Reader
+  include FFI::FFmpeg
+
+  attr_reader :filename, :streams, :av_format_ctx
+
+  def initialize(filename, p={})
+    @filename = filename or raise ArgumentError, "No filename"
+
+    FFmpeg.register_all
+    @av_format_ctx = FFI::MemoryPointer.new(:pointer)
+    rc = av_open_input_file(@av_format_ctx, @filename, nil, 0, nil) 
+    raise RuntimeError, "av_open_input_file() failed, filename='%s', rc=%d" %
+      [filename, rc] if rc != 0
+    @av_format_ctx = AVFormatContext.new @av_format_ctx.get_pointer(0)
+
+    rc = av_find_stream_info(@av_format_ctx)
+    raise RuntimeError, "av_find_stream_info() failed, rc=#{rc}" if rc < 0
+    
+    initialize_streams(p)
+  end
+
+  def dump_format
+    FFI::FFmpeg.dump_format(@av_format_ctx, 0, @filename, 0)
+  end
+
+  def each_frame(&block)
+    raise ArgumentError, "No block provided" unless block_given?
+
+    packet = avcodec_alloc_frame or
+      raise NoMemoryError, "avcodec_alloc_frame() failed"
+    packet = AVPacket.new packet
+
+    while av_read_frame(@av_format_ctx, packet) >= 0
+      frame = @streams[packet[:stream_index]].decode_frame(packet)
+      rc = frame ? yield(frame) : true
+      av_free_packet(packet)
+
+      break if rc == false
+    end
+
+    av_free(packet)
+  end
+
+  def default_stream
+    @streams[av_find_default_stream_index(@av_format_ctx)]
+  end
+
+  def seek(p = {})
+    default_stream.seek(p)
+  end
+
+  private
+
+  def initialize_streams(p={})
+    @streams = @av_format_ctx[:nb_streams].times.map do |i|
+      av_stream = AVStream.new @av_format_ctx[:streams][i]
+      av_codec_ctx = AVCodecContext.new av_stream[:codec]
+
+      case av_codec_ctx[:codec_type]
+      when :video
+        FFmpeg::Stream::Video.new(:reader => self,
+                                  :av_stream => av_stream,
+                                  :pixel_format => p[:pixel_format],
+                                  :width => p[:width],
+                                  :height => p[:height])
+      else
+        FFmpeg::Stream::Unsupported.new(:reader => self, 
+                                        :av_stream => av_stream)
+      end
+    end
+  end
+end

data/lib/ffmpeg/stream.rb

@@ -0,0 +1,244 @@
+require 'ffi/ffmpeg'
+require 'pp'
+
+class String
+  def hexdump
+    buf = ""
+    offset = 0
+    words = self.unpack("N%d" % (self.length/4.0).ceil)
+    until words.empty?
+      line = words.shift(4).compact
+      buf += sprintf("[%04x] " + ("%08x " * line.size) + "|%s|\n", 
+                     offset * 16, *line, 
+                     line.pack("N%d" % line.size).tr("^\040-\176","."))
+      offset += 1
+    end
+    buf
+  end
+end
+
+module FFmpeg::Stream
+  include FFI::FFmpeg
+
+  attr_reader :reader, :av_stream, :av_codec_ctx
+
+  def initialize(p={})
+    @reader = p[:reader] or raise ArgumentError, "no :reader"
+    @av_stream = p[:av_stream] or raise ArgumentError, "no :av_stream"
+    @av_codec_ctx = AVCodecContext.new @av_stream[:codec]
+
+    # open the codec
+    codec = avcodec_find_decoder(@av_codec_ctx[:codec_id]) or
+      raise RuntimeError, "No decoder found for #{@av_codec_ctx[:codec_id]}"
+    avcodec_open(@av_codec_ctx, codec) == 0 or
+      raise RuntimeError, "avcodec_open() failed"
+  end
+
+  def discard=(value)
+    @av_stream[:discard] = value
+  end
+
+  def discard
+    @av_stream[:discard]
+  end
+
+  def type
+    @av_codec_ctx[:codec_type]
+  end
+
+  def index
+    @av_stream[:index]
+  end
+
+  def decode_frame(packet)
+    return false
+    raise NotImplementedError, "decode_frame() not defined for #{self.class}"
+  end
+
+  def each_frame
+    @reader.each_frame { |frame| yield frame if frame.stream == self }
+  end
+
+  def next_frame
+    frame = nil
+    each_frame { |f| frame = f; break }
+    frame
+  end
+
+  def skip_frames(n)
+    raise RuntimeError, "Cannot skip frames when discarding all frames" if
+      discard == :all
+    each_frame { |f| n -= 1 != 0 }
+  end
+
+  # Seek to a specific location within the stream; the location can be either
+  # a PTS value or an absolute byte position.
+  #
+  # Arguments:
+  #   [:pts]  PTS location
+  #   [:pos]  Byte location
+  #   [:backward] Seek backward
+  #   [:any]  Seek to non-key frames
+  #
+  def seek(p={})
+    p = { :pts => p } unless p.is_a? Hash
+
+    raise ArgumentError, ":pts and :pos are mutually exclusive" \
+      if p[:pts] and p[:pos]
+
+    pos = p[:pts] || p[:pos]
+    flags = 0
+    flags |= AVSEEK_FLAG_BYTE if p[:pos]
+    flags |= AVSEEK_FLAG_BACKWARD if p[:backward]
+    flags |= AVSEEK_FLAG_ANY if p[:any]
+
+    rc = av_seek_frame(@reader.av_format_ctx, @av_stream[:index], pos, flags)
+    raise RuntimeError, "av_seek_frame() failed, %d" % rc if rc < 0
+    true
+  end
+end
+
+class FFmpeg::Stream::Video
+  include FFmpeg::Stream
+
+  attr_reader :raw_frame, :width, :height, :pixel_format, :buffer_size, :reader
+
+  def initialize(p={})
+    super(p)
+    @width  = p[:widht]  || @av_codec_ctx[:width]
+    @height = p[:height] || @av_codec_ctx[:height]
+    @pixel_format = p[:pixel_format] || @av_codec_ctx[:pix_fmt]
+    @buffer_size = p[:buffer_size] || 1
+
+    @raw_frame = FFmpeg::Frame::Video.new :stream => self,
+                                          :width => @av_codec_ctx[:width],
+                                          :height => @av_codec_ctx[:height],
+                                          :pixel_format => 
+                                            @av_codec_ctx[:pix_fmt]
+
+    @frame_finished = FFI::MemoryPointer.new :int
+
+    @scaling_initialized = false
+    @swscale_ctx = nil
+    @buffered_frames = nil
+    @last_pts = nil
+
+    # Callback function for storing the dts at the time of buffer
+    # allocation to later be used as pts.
+    @av_codec_ctx[:get_buffer] = @get_buffer_callback = \
+        FFI::Function.new(:void, [:pointer, :pointer]) do |ctx, frame|
+      ret = avcodec_default_get_buffer(ctx, frame)
+      AVFrame.new(frame)[:opaque] = FFI::Pointer.new(@last_pts)
+      # pp :alloc => @last_pts
+      ret
+    end
+  end
+    
+  def fps
+    @av_stream[:r_frame_rate]
+  end
+
+  def width=(width)
+    @scaling_initialized = false
+    @width = width
+  end
+
+  def height=(height)
+    @scaling_initialized = false
+    @height = height
+  end
+
+  def pixel_format=(pixel_format)
+    @scaling_initialized = false
+    @pixel_format = pixel_format
+  end
+
+  def buffer_size=(frames)
+    @scaling_initialized = false
+    @buffer_size = frames
+  end
+
+  def decode_frame(packet)
+    initialize_scaling unless @scaling_initialized
+    
+    # pp :read => packet[:dts]
+    @last_pts = packet[:dts]
+    rc = avcodec_decode_video(@av_codec_ctx, @raw_frame.av_frame,
+                              @frame_finished, packet[:data], packet[:size])
+    raise RuntimeError, "avcodec_decode_video() failed, rc=#{rc}" if rc < 0
+
+    return if @frame_finished.read_int == 0
+    # pp :finished => @raw_frame.av_frame[:opaque].address, 
+    #    :pts => @raw_frame.av_frame[:pts],
+    #    :dts => packet[:dts],
+    #    :type => @raw_frame.av_frame[:pict_type],
+    #    :key_frame => @raw_frame.av_frame[:key_frame]
+
+    # avcodec_decode_video() returns frames in the correct pts order, and
+    # according to the dranger tutorial, the packet's dts is the frame's
+    # pts.  When the dts has not been set (AV_NOPTS_VALUE) use the dts from
+    # the first packet of the frame which is stored in the :opaque field of
+    # the AVFrame.
+    @raw_frame.pts = nil
+    @raw_frame.pts = packet[:dts] unless packet[:dts] == AV_NOPTS_VALUE
+    @raw_frame.pts ||= @raw_frame.av_frame[:opaque].address
+
+    @raw_frame.number = @av_codec_ctx[:frame_number].to_i
+    
+    return @raw_frame unless @swscale_ctx
+
+    # XXX Need to provide a better mechanism for making sure buffer is ready
+    # for use.
+    scaled_frame = @buffered_frames.shift
+    @buffered_frames << scaled_frame
+
+    out_frame = scaled_frame.av_frame
+    in_frame = @raw_frame.av_frame
+
+    # Make sure we copy the key_frame value across.
+    # XXX Need to also do this for some other fields
+    out_frame[:key_frame] = in_frame[:key_frame]
+
+    rc = sws_scale(@swscale_ctx, in_frame[:data], in_frame[:linesize], 0,
+              @raw_frame.height, out_frame[:data], out_frame[:linesize])
+    scaled_frame.pts = @raw_frame.pts
+    scaled_frame.number = @av_codec_ctx[:frame_number]
+    scaled_frame
+  end
+
+  private
+
+  def initialize_scaling
+    @scaling_initialized = true
+    @swscale_ctx = nil
+    @buffered_frames = nil
+
+    return if @width == @av_codec_ctx[:width] &&
+              @height == @av_codec_ctx[:height] &&
+              @pixel_format == @av_codec_ctx[:pix_fmt] &&
+              @buffer_size < 2
+
+    @buffered_frames = @buffer_size.times.map do
+      FFmpeg::Frame::Video.new :stream => self,
+                               :width => @width, 
+                               :height => @height,
+                               :pixel_format => @pixel_format
+    end
+
+    @swscale_ctx = sws_getContext(@av_codec_ctx[:width], 
+                                  @av_codec_ctx[:height],
+                                  @av_codec_ctx[:pix_fmt],
+                                  @width, @height, @pixel_format,
+                                  :bicubic, nil, nil, nil) or
+      raise NoMemoryError, "sws_getContext() failed"
+  end
+end
+
+class FFmpeg::Stream::Unsupported
+  include FFmpeg::Stream
+
+  def initialize(p={})
+    super(p)
+    self.discard = :all
+  end
+end

data/lib/ffmpeg/version.rb

@@ -0,0 +1,3 @@
+module FFmpeg
+  VERSION = "0.5"
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: ffi-ffmpeg
+version: !ruby/object:Gem::Version
+  version: 0.5.8135c9c5dc36
+  prerelease: 8
+platform: ruby
+authors:
+- David M. Lary
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-01 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: &12966700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *12966700
+description: ! "Ruby FFI bindings for FFmpeg libraries:\n                      * libavformat\n
+  \                     * libavcodec\n                      * libavutil\n                      *
+  libswscale"
+email:
+- dmlary@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .hgignore
+- Gemfile
+- README.md
+- Rakefile
+- examples/extract_keyframes.rb
+- examples/read_file.rb
+- examples/seek.rb
+- ffi-ffmpeg.gemspec
+- lib/ffi-ffmpeg.rb
+- lib/ffi/ffmpeg.rb
+- lib/ffmpeg/frame.rb
+- lib/ffmpeg/reader.rb
+- lib/ffmpeg/stream.rb
+- lib/ffmpeg/version.rb
+homepage: http://bitbucket.com/dmlary/ffi-ffmpeg
+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: []
+rubyforge_project: ffi-ffmpeg
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Ruby FFI bindings for FFmpeg libraries
+test_files: []