ffi-libav 0.1.0

data/lib/libav/frame.rb

@@ -0,0 +1,113 @@
+require 'ffi/libav'
+
+module Libav::Frame; end
+
+class Libav::Frame::Video
+  include FFI::Libav
+
+  attr_reader :av_frame, :stream
+  attr_accessor :number
+
+  # Initialize a new frame, and optionally allocate memory for the frame data.
+  #
+  # If only a +:stream+ is provided, the remaining attributes will be copied
+  # from that stream.
+  #
+  # ==== Options
+  # * +:stream+ - Libav::Stream this frame belongs to
+  # * +:width+  - width of the frame
+  # * +:height+ - height of the frame
+  # * +:pixel_format+ - format of the frame
+  # * +:alloc+ - Allocate space for the frame data [default: true]
+  #
+  def initialize(p={})
+    # Create our frame and alloc space for the frame data
+    @av_frame = AVFrame.new
+
+    @stream = p[:stream]
+    @av_frame[:width] = p[:width] || @stream && @stream.width
+    @av_frame[:height] = p[:height] || @stream && @stream.height
+    @av_frame[:format] = p[:pixel_format] || @stream && @stream.pixel_format
+
+    # Allocate the frame's data unless the caller doesn't want us to.
+    unless p[:alloc] == false
+      av_picture = AVPicture.new @av_frame.pointer
+      avpicture_alloc(av_picture, @av_frame[:format], @av_frame[:width],
+                      @av_frame[:height])
+      ObjectSpace.define_finalizer(self, cleanup_proc(av_picture))
+    end
+  end
+
+  # Throw together a bunch of helper methods for accessing the AVFrame
+  # attributes.
+  AVFrame.members.each do |member|
+    define_method(member) { @av_frame[member] }
+    define_method(member.to_s + "=") { |v| @av_frame[member] = v }
+  end
+
+  def key_frame?
+    key_frame == 1
+  end
+
+  def pixel_format
+    format.is_a?(Fixnum) ? PixelFormat[format] : format
+  end
+
+  def pixel_format=(v)
+    send("format=", (v.is_a?(Fixnum) ? v : PixelFormat[v]))
+  end
+
+  # Scale the frame
+  #
+  # If any of the +:width+, +:height+, or +:pixel_format+ options are not
+  # supplied, they will be copied from the +:output_frame+, if provided,
+  # otherwise they will be copied from this frame.
+  #
+  # If no +:scale_ctx+ is provided, one will be allocated and freed within this
+  # method.
+  #
+  # If no +:output_frame+ is provided, this method will allocate a new one.
+  #
+  # ==== Options
+  # * +:width+ - width of the scaled frame
+  # * +:height+ - height of the scaled frame
+  # * +:pixel_format+ - pixel format of the scaled frame
+  # * +:scale_ctx+ - optional software scaling context
+  # + +:output_frame+ - optional output frame
+  #
+  def scale(p={})
+    out = p[:output_frame] ||
+      self.class.new(:width => p[:width] || width,
+                     :height => p[:height] || height,
+                     :pixel_format => p[:pixel_format] || pixel_format,
+                     :stream => stream)
+    ctx = p[:scale_ctx] ||
+      sws_getContext(width, height, pixel_format,
+                     out.width, out.height, out.pixel_format,
+                     SWS_BICUBIC, nil, nil, nil)
+    raise NoMemoryError, "sws_getContext() failed" if ctx.nil?
+
+    # Scale the image
+    rc = sws_scale(ctx, data, linesize, 0, height, out.data, out.linesize)
+
+    # Free the scale context if one wasn't provided by the caller
+    sws_freeContext(ctx) unless p[:scale_ctx]
+
+    # Let's copy a handful of attributes to the scaled frame
+    %w{ pts number key_frame }.each do |k|
+      out.send("#{k}=", send(k))
+    end
+
+    # Return our scaled frame
+    out
+  end
+
+  private
+
+  # Returns Proc responsible for cleaning up the picture memory when it gets
+  # garbage collected.
+  def cleanup_proc(picture)
+    proc { avpicture_free(picture) }
+  end
+
+end

data/lib/libav/reader.rb

@@ -0,0 +1,114 @@
+require 'ffi/libav'
+
+# Libav file reader
+class Libav::Reader
+  include FFI::Libav
+
+  attr_reader :filename, :streams, :av_format_ctx
+
+  # Initialize a Reader for a specific file
+  #
+  # ==== Attributes
+  # * +filename+ - file to read
+  #
+  def initialize(filename, p={})
+    @filename = filename or raise ArgumentError, "No filename"
+
+    Libav.register_all
+    @av_format_ctx = FFI::MemoryPointer.new(:pointer)
+    rc = avformat_open_input(@av_format_ctx, @filename, nil, nil)
+    raise RuntimeError, "avformat_open_input() failed, filename='%s', rc=%d" %
+      [filename, rc] if rc != 0
+    @av_format_ctx = AVFormatContext.new @av_format_ctx.get_pointer(0)
+
+    rc = avformat_find_stream_info(@av_format_ctx, nil)
+    raise RuntimeError, "av_find_stream_info() failed, rc=#{rc}" if rc < 0
+
+    # Open all of our streams
+    initialize_streams(p)
+
+    # Set up a finalizer to close all the things we've opened
+    ObjectSpace.define_finalizer(self,
+      cleanup_proc(@av_format_ctx, streams.map { |s| s.av_codec_ctx }))
+
+    # Our packet for reading
+    @packet = AVPacket.new
+    av_init_packet(@packet)
+  end
+
+  # Call +av_dump_format+ to print out the format info for the video
+  def dump_format
+    FFI::Libav.av_dump_format(@av_format_ctx, 0, @filename, 0)
+  end
+
+  # Video duration in (fractional) seconds
+  def duration
+    @duration ||= @av_format_ctx[:duration].to_f / AV_TIME_BASE
+  end
+
+  # Loop through each frame
+  #
+  # ==== Argument
+  # * +block+ - block of code to call with the frame
+  #
+  # ==== Usage
+  #   # Read each frame
+  #   reader.each_frame do |frame|
+  #
+  #     # call some method for showing the frame
+  #     my_show_frame(frame)
+  #   end
+  #
+  def each_frame(&block)
+    raise ArgumentError, "No block provided" unless block_given?
+
+    while av_read_frame(@av_format_ctx, @packet) >= 0
+      frame = @streams[@packet[:stream_index]].decode_frame(@packet)
+      av_free_packet(@packet)
+      rc = frame ? yield(frame) : true
+      break if rc == false
+    end
+  end
+
+  # Get the default stream
+  def default_stream
+    @streams[av_find_default_stream_index(@av_format_ctx)]
+  end
+
+  # See Libav::Stream.seek
+  def seek(p = {})
+    default_stream.seek(p)
+  end
+
+  private
+
+  # Generate the Proc that is responsible for releasing our avcodec, avformat
+  # structures.
+  def cleanup_proc(codecs, format)
+    proc do
+      codecs.each { |codec| avcodec_close codec }
+      avformat_close_input(format)
+    end
+  end
+
+  # Lookup and initialize the streams
+  def initialize_streams(p={})
+    @streams = @av_format_ctx[:nb_streams].times.map do |i|
+      av_stream = AVStream.new \
+            @av_format_ctx[:streams].get_pointer(i * FFI::Pointer::SIZE)
+      av_codec_ctx = av_stream[:codec]
+
+      case av_codec_ctx[:codec_type]
+      when :video
+        Libav::Stream::Video.new(:reader => self,
+                                  :av_stream => av_stream,
+                                  :pixel_format => p[:pixel_format],
+                                  :width => p[:width],
+                                  :height => p[:height])
+      else
+        Libav::Stream::Unsupported.new(:reader => self,
+                                        :av_stream => av_stream)
+      end
+    end
+  end
+end

data/lib/libav/stream.rb

@@ -0,0 +1,211 @@
+require 'ffi/libav'
+
+# Generic Stream class.  Most of the logic resides in Libav::Stream::Video.
+module Libav::Stream
+  include FFI::Libav
+
+  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 = @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_open2(@av_codec_ctx, codec, nil) == 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
+
+  # Loop through each frame of this stream
+  def each_frame(&block)
+    @reader.each_frame { |frame| yield frame if frame.stream == self }
+  end
+
+  # Get the next frame in the stream
+  def next_frame
+    frame = nil
+    each_frame { |f| frame = f; break }
+    frame
+  end
+
+  # Skip some +n+ frames in the stream
+  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 Libav::Stream::Video
+  include Libav::Stream
+
+  attr_reader :raw_frame, :width, :height, :pixel_format, :reader
+
+  def initialize(p={})
+    super(p)
+
+    # Handle frame width and height and setup any scaling necessary
+    @width  = p[:widht]  || @av_codec_ctx[:width]
+    @height = p[:height] || @av_codec_ctx[:height]
+    @pixel_format = p[:pixel_format] || @av_codec_ctx[:pix_fmt]
+    init_scaling
+
+    # Our frame structure for decoding the frame
+    @raw_frame = Libav::Frame::Video.new :stream => self, :alloc => false,
+                                          :width => @av_codec_ctx[:width],
+                                          :height => @av_codec_ctx[:height],
+                                          :pixel_format =>
+                                            @av_codec_ctx[:pix_fmt]
+
+    # Pointer used to denote that decode frame was successful
+    @frame_finished = FFI::MemoryPointer.new :int
+
+    # Elaborate schemes to capture an accurate pts value.  When the buffer for
+    # the frame is allocated, we pull the dts from the last packet processed
+    # (set in decode_frame()), and set it in the opaque field of the frame.
+    #
+    # Since we may be running on a 32-bit platform, we can't just shove the
+    # 64-bit dts in the :opaque pointer, so we have to alloc some space for the
+    # address.  Instead of allocating and freeing repeatedly, we're going to
+    # alloc it once now and reuse it for each decoded frame.
+    @last_dts = nil
+    @opaque = FFI::MemoryPointer.new :uint64
+
+    @av_codec_ctx[:get_buffer] = \
+      FFI::Function.new(:int, [AVCodecContext.ptr, AVFrame.ptr]) do |ctx,frame|
+
+        # Use the default method to get the buffer
+        ret = avcodec_default_get_buffer(ctx, frame)
+
+        # Update the :opaque field point at a copy of the last pts we've seen.
+        @opaque.write_int64 @last_dts
+        frame[:opaque] = @opaque
+
+        ret
+      end
+  end
+
+  def fps
+    @av_stream[:r_frame_rate]
+  end
+
+  # Set the +width+ of the frames returned by +decode_frame+
+  def width=(width)
+    @width = width
+    init_scaling
+  end
+
+  # Set the +height+ of the frames returned by +decode_frame+
+  def height=(height)
+    @height = height
+    init_scaling
+  end
+
+  # Set the +pixel format+ of the frames returned by +decode_frame+
+  def pixel_format=(pixel_format)
+    @pixel_format = pixel_format
+    init_scaling
+  end
+
+  # Called by Libav::Reader.each_frame to decode each frame
+  def decode_frame(packet)
+    # initialize_scaling unless @scaling_initialized
+
+    @last_dts = packet[:dts]
+    avcodec_get_frame_defaults(@raw_frame.av_frame)
+    rc = avcodec_decode_video2(@av_codec_ctx, @raw_frame.av_frame,
+                               @frame_finished, packet)
+    raise RuntimeError, "avcodec_decode_video2() failed, rc=#{rc}" if rc < 0
+    return if @frame_finished.read_int == 0
+
+    @raw_frame.pts = @raw_frame.av_frame[:opaque].read_int64
+    @raw_frame.number = @av_codec_ctx[:frame_number].to_i
+
+    return @raw_frame unless @swscale_ctx
+
+    @raw_frame.scale(:scale_ctx => @swscale_ctx,
+                     :output_frame => @scaled_frame)
+  end
+
+  private
+
+  def init_scaling
+    sws_freeContext(@swscale_ctx) unless @swscale_ctx.nil?
+    @swscale_ctx = nil
+    @scaled_frame = nil
+
+    return if @width == @av_codec_ctx[:width] &&
+              @height == @av_codec_ctx[:height] &&
+              @pixel_format == @av_codec_ctx[:pix_fmt]
+
+    @swscale_ctx = sws_getContext(@av_codec_ctx[:width],
+                                  @av_codec_ctx[:height],
+                                  @av_codec_ctx[:pix_fmt],
+                                  @width, @height, @pixel_format,
+                                  SWS_BICUBIC, nil, nil, nil) or
+      raise NoMemoryError, "sws_getContext() failed"
+
+    @scaled_frame = Libav::Frame::Video.new(:width => @width,
+                                            :height => @height,
+                                            :pixel_format => @pixel_format,
+                                            :stream => self)
+  end
+end
+
+class Libav::Stream::Unsupported
+  include Libav::Stream
+
+  def initialize(p={})
+    super(p)
+    self.discard = :all
+  end
+end

data/lib/libav/version.rb

@@ -0,0 +1,3 @@
+module Libav
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: ffi-libav
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- David M. Lary
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- dmlary@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- examples/extract_keyframes.rb
+- examples/read_file.rb
+- examples/seek.rb
+- ffi-libav.gemspec
+- lib/ffi-libav.rb
+- lib/ffi/libav.i
+- lib/ffi/libav.rb
+- lib/libav/frame.rb
+- lib/libav/reader.rb
+- lib/libav/stream.rb
+- lib/libav/version.rb
+homepage: https://github.com/dmlary/ffi-libav
+licenses:
+- BSD 3-Clause
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2735303191728479060
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2735303191728479060
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby FFI bindings and wrapper for Libav
+test_files: []