ffi-ffmpeg 0.5.8135c9c5dc36

data/.hgignore

@@ -0,0 +1,10 @@
+syntax: glob
+*.gem
+.bundle
+Gemfire.lock
+pkg/*
+
+*.png
+.*.sw[a-z]
+.AppleDouble
+.DS_Store

data/Gemfile

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

data/README.md

@@ -0,0 +1,70 @@
+ffi-ffmpeg
+==========
+http://github.com/dmlary/ffi-ffmpeg
+
+Description
+-----------
+Ruby-FFI bindings and wrappers for FFmpeg libraries.
+
+Features
+--------
+Right now this library only supports the reading of video streams.
+
+What's missing
+--------------
+* Reading audio streams
+* Execute ffmpeg cleanup when Reader, Stream, Frame instances are gc'ed
+* Encoding
+
+Usage
+-----
+    ruby
+    require 'ffi-ffmpeg'
+
+    # Allocate a reader for our video file
+    reader = FFmpeg::Reader.new(ARGV[0], :pixel_format => :rgb24)
+      
+    # Dump the format information for the file
+    reader.dump_format
+
+    # Grab the first video stream in the file
+    stream = reader.streams.select { |s| s.type == :video }.first
+
+    # Discard non-key frames
+    stream.discard = :nonkey
+
+    # Loop through the key frames for the first video stream
+    stream.each_frame do |frame|
+      # Do something interesting with the frame...
+      # pixel data is in frame.av_frame[:data]
+    end
+
+
+Copyright
+---------
+Copyright (c) 2011, David M. Lary 
+All rights reserved.
+
+License
+-------
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+*  Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+*  Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+*  The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

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

data/examples/extract_keyframes.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+require 'ffi-ffmpeg'
+
+def write_frame(filename, frame)
+  file = File.new(filename, "w")
+  file.write "P6\n%d %d\n255\n" % [frame.width, frame.height]
+
+  data = frame.av_frame[:data][0]
+  linesize = frame.av_frame[:linesize][0]
+  bytes_per_row = 3 * frame.width
+
+  frame.height.times do |row|
+    file.write data.slice(row * linesize, bytes_per_row)\
+                   .read_string_length(bytes_per_row)
+  end
+  file.close
+end
+
+# Open our video file
+reader = FFmpeg::Reader.new(ARGV[0], :pixel_format => :rgb24)
+
+reader.dump_format
+# Find the first video stream
+stream = reader.streams.select { |s| s.discard = :all; s.type == :video } .first
+
+# Tell the library to discard all non-key frames
+stream.discard = :nonkey
+
+# Write the first five key frames to disk
+5.times do |i|
+  frame = stream.next_frame
+  write_frame("image-%d.ppm" % i, frame)
+  puts "wrote frame %d" % frame.number
+end
+
+stream.pixel_format = :gray8
+
+# Write the first five key frames to disk
+5.times do |i|
+  frame = stream.next_frame
+  scaled = frame.scale(:width => 100, :height => 100, :pixel_format => :rgb24)
+  write_frame("small-%d.ppm" % i, scaled)
+  puts "wrote small frame %d" % scaled.number
+end
+

data/examples/read_file.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+require 'ffi-ffmpeg'
+require 'pp'
+
+def format_seconds(s)
+  s = s.to_i
+  h = s/3600
+  s -= h * 3600
+  m = s/60
+  s -= m * 60
+  "%02d:%02d:%02d" % [ h, m, s ]
+end
+
+GLYPHS = %w{ | / - \\ }
+@first = nil
+@last  = nil
+@calls = 0
+def spin(frame)
+  now = Time.now()
+  @first ||= now
+  @last  ||= now
+
+  @calls += 1
+
+  if (@last + 0.25 < now)
+    fps = @calls.to_f / (now - @first)
+    pos = frame.number / frame.stream.fps.to_f
+    printf("\r[%s] %0.03f fps, frame: %d, pos: %s",
+            format_seconds(now - @first), fps, frame.number,
+            format_seconds(pos))
+    @last = now
+  end
+end
+
+# open our video file
+reader = FFmpeg::Reader.new(ARGV[0])
+reader.dump_format
+
+# Find the first video stream
+reader.streams.each { |s| s.discard == :all }
+stream = reader.default_stream
+stream.discard = :default
+# stream.buffer_size = 2
+stream.each_frame { |frame| spin frame}

data/examples/seek.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require 'pp'
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+require 'ffi-ffmpeg'
+
+def write_frame(filename, frame)
+  file = File.new(filename, "w")
+  file.write "P6\n%d %d\n255\n" % [frame.width, frame.height]
+
+  data = frame.av_frame[:data][0]
+  linesize = frame.av_frame[:linesize][0]
+  bytes_per_row = 3 * frame.width
+
+  frame.height.times do |row|
+    file.write data.slice(row * linesize, bytes_per_row)\
+                   .read_string_length(bytes_per_row)
+  end
+  file.close
+end
+
+# Open our video file
+reader = FFmpeg::Reader.new(ARGV[0], :pixel_format => :rgb24)
+stream = reader.default_stream
+
+# Find the first video stream
+reader.streams.each { |s| s.discard = :all unless s == stream }
+stream.discard = :nonkey
+
+count = ARGV[1] ? ARGV[1].to_i : 10
+step = File.size(ARGV[0]) / (count + 2)
+
+count.times do |i|
+  i += 1
+  puts "Seeking to %d" % (i * step)
+  stream.seek(:pos => i * step)
+
+  frame = stream.next_frame
+
+  # For some reason, when working on MPEG-TS files, following the seek,
+  # the packet DTS of the next packet read is -1 * AV_NOPTS_VALUE.  When
+  # we save that frame it looks like a stale buffer.  So we want to skip
+  # the frame if the pts is this value.  Also only accept key frames.
+  until frame.key_frame? and frame.pts != -1 * FFI::FFmpeg::AV_NOPTS_VALUE
+    frame = stream.next_frame
+  end
+  puts "Saving frame %d, pts %d" % [ frame.number, frame.pts ]
+  write_frame("seek-%02d.ppm" % i, frame)
+end

data/ffi-ffmpeg.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ffi-ffmpeg"
+
+Gem::Specification.new do |s|
+  s.name        = "ffi-ffmpeg"
+  s.version     = "%s.%s" % [ FFmpeg::VERSION, 
+                            `hg id -i`.chomp.sub("+", "m") ]
+  s.authors     = ["David M. Lary"]
+  s.email       = ["dmlary@gmail.com"]
+  s.homepage    = "http://bitbucket.com/dmlary/ffi-ffmpeg"
+  s.summary     = %q{Ruby FFI bindings for FFmpeg libraries}
+  s.description = %q{Ruby FFI bindings for FFmpeg libraries:
+                      * libavformat
+                      * libavcodec
+                      * libavutil
+                      * libswscale}
+
+  s.rubyforge_project = "ffi-ffmpeg"
+
+  s.files         = `hg locate`.split("\n")
+  s.test_files    = `hg locate -- {test,spec,features}/*`.split("\n")
+  s.executables   = `hg locate -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.add_dependency "ffi"
+end

data/lib/ffi-ffmpeg.rb

@@ -0,0 +1,30 @@
+require "ffi/ffmpeg"
+require "ffmpeg/version"
+require "ffmpeg/frame"
+require "ffmpeg/stream"
+require "ffmpeg/reader"
+
+module FFmpeg
+
+  # Get the logging level
+  def self.log_level
+    FFI::FFmpeg.av_log_get_level
+  end
+
+  # Set the logging level
+  #
+  # [:level] Logging level in FFI::FFMpeg::AVLogLevel
+  #
+  def self.log_level=(level)
+    FFI::FFmpeg.av_log_set_level level
+  end
+
+  private
+
+  @@registered_all = false
+  def self.register_all
+    return if @@registered_all
+    FFI::FFmpeg.av_register_all
+    @@registered_all = true
+  end
+end

data/lib/ffi/ffmpeg.rb

@@ -0,0 +1,629 @@
+require 'ffi'
+
+module FFI
+  module FFmpeg
+    extend FFI::Library
+
+    AV_NOPTS_VALUE = 0x8000000000000000
+
+    ffi_lib "libavutil.so.49"
+
+    AVMediaType = enum :unknown, -1,
+                       :video,
+                       :audio,
+                       :data,
+                       :subtitle,
+                       :attachment
+
+    BIG_ENDIAN = [1].pack("I") == [1].pack("N")
+    PixelFormat = enum :none, -1,
+                       :yuv420p,
+                       :yuyv422,
+                       :rgb24,
+                       :bgr24,
+                       :yuv422p,
+                       :yuv444p,
+                       :yuv410p,
+                       :yuv411p,
+                       :gray8,
+                       :monowhite,
+                       :monoblack,
+                       :pal8,
+                       :yuvj420p,
+                       :yuvj422p,
+                       :yuvj444p,
+                       :xvmc_mpeg2_mc,
+                       :xvmc_mpeg2_idct,
+                       :uyvy422,
+                       :uyyvyy411,
+                       :bgr8,
+                       :bgr4,
+                       :bgr4_byte,
+                       :rgb8,
+                       :rgb4,
+                       :rgb4_byte,
+                       :nv12,
+                       :nv21,
+                       BIG_ENDIAN ? :rgb32 : :bgr32_1,    # :argb
+                       BIG_ENDIAN ? :rgb32_1 : :bgr32,    # :rgba
+                       BIG_ENDIAN ? :bgr32 : :rgb32_1,    # :abgr
+                       BIG_ENDIAN ? :bgr32_1 : :rgb32,    # :bgra
+                       BIG_ENDIAN ? :gray16 : :gray16_1,  # :gray16be
+                       BIG_ENDIAN ? :gray16_1 : :gray16,  # :gray16le
+                       :yuv440p,
+                       :yuvj440p,
+                       :yuva420p,
+                       :vdpau_h264,
+                       :vdpau_mpeg1,
+                       :vdpau_mpeg2,
+                       :vdpau_wmv3,
+                       :vdpau_vc1,
+                       BIG_ENDIAN ? :rgb48 : :rgb48_1,    # :rgb48be
+                       BIG_ENDIAN ? :rgb48_1 : :rgb48,    # :rgb48le
+                       BIG_ENDIAN ? :rgb565 : :rgb565_1,  # :rgb565be
+                       BIG_ENDIAN ? :rgb565_1 : :rgb565,  # :rgb565le
+                       BIG_ENDIAN ? :rgb555 : :rgb555_1,  # :rgb555be
+                       BIG_ENDIAN ? :rgb555_1 : :rgb555,  # :rgb555le
+                       BIG_ENDIAN ? :bgr565 : :bgr565_1,  # :bgr565be
+                       BIG_ENDIAN ? :bgr565_1 : :bgr565,  # :bgr565le
+                       BIG_ENDIAN ? :bgr555 : :bgr555_1,  # :bgr555be
+                       BIG_ENDIAN ? :bgr555_1 : :bgr555,  # :bgr555le
+                       :vaapi_moco,
+                       :vaapi_idct,
+                       :vaapi_vld,
+                       BIG_ENDIAN ? :yuv420p16_1 : :yuv420p16, # :yuv420p16le
+                       BIG_ENDIAN ? :yuv420p16 : :yuv420p16_1, # :yuv420p16be
+                       BIG_ENDIAN ? :yuv422p16_1 : :yuv422p16, # :yuv422p16le
+                       BIG_ENDIAN ? :yuv422p16 : :yuv422p16_1, # :yuv422p16be
+                       BIG_ENDIAN ? :yuv444p16_1 : :yuv444p16, # :yuv444p16le
+                       BIG_ENDIAN ? :yuv444p16 : :yuv444p16_1, # :yuv444p16be
+                       :vdpau_mpeg4,
+                       :dxva2_vld,
+                       BIG_ENDIAN ? :rgb444 : :rgb444_1,  # :rgb444be
+                       BIG_ENDIAN ? :rgb444_1 : :rgb444,  # :rgb444le
+                       BIG_ENDIAN ? :bgr444 : :bgr444_1,  # :bgr444be
+                       BIG_ENDIAN ? :bgr444_1 : :bgr444,  # :bgr444le
+                       :y400a
+
+    # Not actually an enum in libavutil.h, but we make it one here to
+    # make the api prettier.
+    AVLogLevel = enum :quiet, -8,
+                      :panic, 0,
+                      :fatal, 8,
+                      :error, 16,
+                      :warning, 24,
+                      :info, 32,
+                      :verbose, 40,
+                      :debug, 48
+
+    attach_function :av_log_get_level, [], AVLogLevel
+    attach_function :av_log_set_level, [AVLogLevel], :void
+    attach_function :av_free, [:pointer], :void
+    attach_function :av_malloc, [:uint], :pointer
+
+    ffi_lib "libavformat.so.52"
+
+    MAX_STREAMS = 20
+    MAX_REORDER_DELAY = 16
+
+    AVSEEK_FLAG_BACKWARD = 1
+    AVSEEK_FLAG_BYTE     = 2
+    AVSEEK_FLAG_ANY      = 4
+    
+    attach_function :av_register_all, [], :void
+    attach_function :av_open_input_file,
+                      [:pointer, :string, :pointer, :int, :pointer],
+                      :int
+    attach_function :av_find_stream_info, [:pointer], :int
+    attach_function :dump_format,
+                      [:pointer, :int, :string, :int],
+                      :void
+    attach_function :av_read_frame, [:pointer, :pointer], :int
+    attach_function :av_seek_frame, [:pointer, :int, :long_long, :int], :int
+    attach_function :av_find_default_stream_index, [ :pointer ], :int
+
+    # Defining this manually since it's a static inline:
+    #
+    # static inline void av_free_packet(AVPacket *pkt)
+    # {
+    #     if (pkt && pkt->destruct) {
+    #         pkt->destruct(pkt);
+    #     }
+    # }
+    #
+    def self.av_free_packet(pkt)
+      return unless pkt and pkt[:destruct]
+
+      FFI::Function.new(:void, [:pointer], pkt[:destruct], 
+                        :blocking => true).call(pkt)
+    end
+    
+    def av_free_packet(pkt)
+      FFI::FFmpeg.av_free_packet(pkt)
+    end
+
+    ffi_lib "libavcodec.so.52"
+    AV_PARSER_PTS_NB = 4
+
+    AVDiscard = enum :none, -16,
+                     :default, 0,
+                     :nonref, 8,
+                     :bidir, 16,
+                     :nonkey, 32,
+                     :all, 48
+
+    attach_function :avcodec_find_decoder, [:int], :pointer
+    attach_function :avcodec_open, [:pointer, :pointer], :int
+    attach_function :avcodec_alloc_frame, [], :pointer
+    attach_function :avpicture_get_size, [PixelFormat, :int, :int], :int
+    attach_function :avpicture_fill, 
+                    [:pointer, :pointer, PixelFormat, :int, :int],
+                    :int
+    attach_function :avcodec_decode_video, [:pointer, :pointer, :pointer,
+                                            :pointer, :int], :int,
+                                           { :blocking => true }
+    attach_function :avcodec_default_get_buffer, [:pointer, :pointer], :int
+    attach_function :avcodec_default_release_buffer, [:pointer, :pointer], :int
+
+    ffi_lib "libswscale.so.0"
+    SWScaleFlags = enum :fast_bilinear, 0x001,
+                        :bilinear,      0x002,
+                        :bicubic,       0x004,
+                        :x,             0x008,
+                        :point,         0x010,
+                        :area,          0x020,
+                        :bicublin,      0x040,
+                        :gauss,         0x080,
+                        :sinc,          0x100,
+                        :lanczos,       0x200,
+                        :spline,        0x400
+
+    attach_function :sws_getContext, 
+                    [:int, :int, PixelFormat, :int, :int, PixelFormat,
+                     SWScaleFlags, :pointer, :pointer, :pointer],
+                    :pointer
+    attach_function :sws_freeContext,
+                    [:pointer],
+                    :void
+    attach_function :sws_scale,
+                    [:pointer, :pointer, :pointer, :int, 
+                     :int, :pointer, :pointer],
+                    :int,
+                    { :blocking => true }
+
+
+    class AVRational < FFI::Struct
+      layout  :num, :int,
+              :den, :int
+
+      def to_f
+        self[:num].to_f / self[:den]
+      end
+
+      def to_float
+        to_f
+      end
+
+      def to_i
+        self[:num] / self[:den]
+      end
+
+      def to_s
+        "#<AVRational:0x%016x num=%d, den=%d, %f>" %
+          [object_id, self[:num], self[:den], to_f]
+      end
+    end
+
+    class AVFrac < FFI::Struct
+      layout  :val, :long_long,
+              :num, :long_long,
+              :den, :long_long
+
+      def to_f
+        self[:val] + self[:num].to_f / self[:den]
+      end
+
+      def to_i
+        self[:val] + self[:num] / self[:den]
+      end
+
+      def to_s
+        "#<AVRational:0x%016x val=%d, num=%d, den=%d, %f>" %
+          [object_id, self[:val], self[:num], self[:den], to_f]
+      end
+    end
+
+    class AVProbeData < FFI::Struct
+      layout  :filename, :string,
+              :buf, :pointer,
+              :buf_size, :int
+    end
+
+    class AVPacket < FFI::Struct
+      layout  :pts, :long,
+              :dts, :long,
+              :data, :pointer,
+              :size, :int,
+              :stream_index, :int,
+              :flags, :int,
+              :duration, :int,
+              :destruct, :pointer,
+              :priv, :pointer,
+              :pos, :long,
+              :convergence_duration, :long
+    end
+
+    class AVPacketList < FFI::Struct
+      layout  :pkt, AVPacket,
+              :next, :pointer
+    end
+
+    class AVStream < FFI::Struct
+      layout  :index, :int,
+              :id, :int,
+              :codec, :pointer,
+              :r_frame_rate, AVRational,
+              :priv_data, :pointer,
+              :first_dts, :long_long,
+              :pts, AVFrac,
+              :time_base, AVRational,
+              :pts_wrap_bits, :int,
+              :stream_copy, :int,
+              :discard, AVDiscard,
+              :quality, :float,
+              :start_time, :long_long,
+              :duration, :long_long,
+              :language, [:char, 4],
+              :need_parsing, :int,          # enum AVStreamParseType,
+              :parser, :pointer,
+              :cur_dts, :long_long,
+              :last_IP_duration, :int,
+              :last_IP_pts, :long_long,
+              :index_entries, :pointer,
+              :nb_index_entries, :int,
+              :index_entries_allocated_size, :uint,
+              :nb_frames, :long_long,
+              :unused, [:long_long, 5],
+              :filename, :string,
+              :disposition, :int,
+              :probe_data, AVProbeData,
+              :pts_buffer, [:long_long, MAX_REORDER_DELAY + 1],
+              :sample_aspect_ratio, AVRational,
+              :metadata, :pointer,
+              :cur_ptr, :pointer,
+              :cur_len, :int,
+              :cur_pkt, AVPacket,
+              :reference_dts, :long_long,
+              :probe_packets, :int,
+              :last_in_packet_butter, AVPacketList,
+              :avg_frame_rate, AVRational,
+              :codec_info_nb_frames, :int
+      
+      def codec
+        AVCodecContext.new send(:[], :codec)
+      end
+        
+      def to_s
+        '#<AVStream:0x%08x index=%d, id=%d, codec_type=:%s>' % 
+          [ object_id, self[:index], self[:id], codec[:codec_type] ]
+      end
+
+      def discard=(type)
+        send(:[]=, :discard, type)
+      end
+    end
+
+    callback :av_codec_context_get_buffer, [:pointer, :pointer], :int
+
+    class AVCodecContext < FFI::Struct
+      layout  :av_class, :pointer,
+              :bit_rate, :int,
+              :bit_rate_rolerance, :int,
+              :flags, :int,
+              :sub_id, :int,
+              :me_method, :int,
+              :extradata, :pointer,
+              :extradata_size, :int,
+              :time_base, AVRational,
+              :width, :int,
+              :height, :int,
+              :gop_size, :int,
+              :pix_fmt, PixelFormat,
+              :rate_emu, :int,
+              :draw_horiz_band, :pointer,
+              :sample_rate, :int,
+              :channels, :int,
+              :sample_fmt, :int,    # TODO enum SampleFormat
+              :frame_size, :int,
+              :frame_number, :int,
+              :real_pict_num, :int,
+              :delay, :int,
+              :qcompress, :float,
+              :qblur, :float,
+              :qmin, :int,
+              :qmax, :int,
+              :max_qdiff, :int,
+              :max_b_frames, :int,
+              :b_quant_factor, :float,
+              :rc_strategy, :int,
+              :b_frame_strategy, :int,
+              :hurry_up, :int,
+              :codec, :pointer,
+              :priv_data, :pointer,
+              :rtp_payload_size, :int,
+              :rtp_callback, :pointer,
+              :mv_bits, :int,
+              :header_bits, :int,
+              :i_tex_bits, :int,
+              :p_tex_bits, :int,
+              :i_count, :int,
+              :p_count, :int,
+              :skip_count, :int,
+              :misc_bits, :int,
+              :frame_bits, :int,
+              :opaque, :pointer,
+              :codec_name, [:char, 32],
+              :codec_type, AVMediaType,
+              :codec_id, :int,      # TODO enum CodecID
+              :codec_tag, :uint,
+              :workaround_bugs, :int,
+              :luma_elim_threshold, :int,
+              :chroma_elim_threshold, :int,
+              :strict_std_compliance, :int,
+              :b_quant_offset, :float,
+              :error_recognition, :int,
+              :get_buffer, :av_codec_context_get_buffer,
+              :release_buffer, :pointer,
+              :has_b_frames, :int,
+              :block_align, :int,
+              :parse_only, :int,
+              :mpeg_quant, :int,
+              :stats_out, :pointer,
+              :stats_in, :pointer,
+              :rc_qsquish, :float,
+              :rc_qmod_amp, :float,
+              :rc_qmod_freq, :int,
+              :rc_override, :pointer,
+              :rc_override_count, :int,
+              :rc_eq, :pointer,
+              :rc_max_rate, :int,
+              :rc_min_rate, :int,
+              :rc_buffer_size, :int,
+              :rc_buffer_aggressivity, :float,
+              :i_quant_factor, :float,
+              :i_quant_offset, :float,
+              :rc_initial_cplx, :float,
+              :dct_algo, :int,
+              :lumi_masking, :float,
+              :temporal_cplx_masking, :float,
+              :spatial_cplx_masking, :float,
+              :p_masking, :float,
+              :dark_masking, :float,
+              :idct_algo, :int,
+              :splice_count, :int,
+              :slice_offset, :pointer,
+              :error_concealment, :int,
+              :dsp_mask, :uint,
+              :bits_per_coded_sample, :int,
+              :prediction_method, :int,
+              :sample_aspect_ratio, AVRational,
+              :coded_frame, :pointer,
+              :debug, :int,
+              :debug_mv, :int,
+              :error, [:ulong_long, 4],
+              :mb_qmin, :int,
+              :mb_qmax, :int,
+              :me_cmp, :int,
+              :me_sub_cmp, :int,
+              :ildct_cmp, :int,
+              :dia_size, :int,
+              :last_predictor_count, :int,
+              :pre_me, :int,
+              :me_pre_cmp, :int,
+              :pre_dia_size, :int,
+              :me_subpel_quality, :int,
+              :get_format, :pointer,
+              :dtg_active_format, :int,
+              :me_range, :int,
+              :intra_quant_bias, :int,
+              :inter_quant_bias, :int,
+              :color_table_id, :int,
+              :internal_buffer_count, :int,
+              :internal_buffer, :pointer,
+              :global_quality, :int,
+              :coder_type, :int,
+              :context_model, :int,
+              :slice_flags, :int,
+              :xvmc_acceleration, :int,
+              :mb_decision, :int,
+              :intra_matrix, :pointer,
+              :inter_matrix, :pointer,
+              :stream_codec_tag, :int,
+              :scenechange_threshold, :int,
+              :lmin, :int,
+              :lmax, :int,
+              :palctrl, :pointer,
+              :noise_reduction, :int,
+              :reget_buffer, :pointer,
+              :rc_initial_buffer_occupancy, :int,
+              :inter_threshold, :int,
+              :flags2, :int,
+              :error_rate, :int,
+              :antialias_algo, :int,
+              :quantizer_noise_shaping, :int,
+              :thread_count, :int,
+              :execute, :pointer,
+              :thread_opaque, :pointer,
+              :me_threshold, :int,
+              :mb_threshold, :int,
+              :intra_dc_precision, :int,
+              :nsse_weight, :int,
+              :skip_top, :int,
+              :skip_bottom, :int,
+              :profile, :int,
+              :level, :int,
+              :lowres, :int,
+              :coded_width, :int,
+              :coded_height, :int,
+              :frame_skip_threshold, :int,
+              :frame_skip_factor, :int,
+              :frame_skip_cmp, :int,
+              :border_masking, :float,
+              :mb_lmin, :int,
+              :mb_lmax, :int,
+              :me_penalty_compensation, :int,
+              :skip_loop_filter, :int,      # TODO enum AVDiscard
+              :skip_idct, :int,             # TODO enum AVDiscard
+              :skip_frame, :int,            # TODO enum AVDiscard
+              :bidir_refine, :int,
+              :brd_scale, :int,
+              :crf, :float,
+              :cqp, :int,
+              :keyint_min, :int,
+              :refs, :int,
+              :chromaoffset, :int,
+              :bframebias, :int,
+              :trellis, :int,
+              :complexityblur, :float,
+              :deblockalpha, :int,
+              :deblockbeta, :int,
+              :partitions, :int,
+              :directpred, :int,
+              :cutoff, :int,
+              :scenechange_factor, :int,
+              :mv0_threshold, :int,
+              :b_sensitivity, :int,
+              :compression_level, :int,
+              :use_lpc, :int,
+              :lpc_coeff_precision, :int,
+              :min_prediction_order, :int,
+              :max_prediction_order, :int,
+              :prediction_order_method, :int,
+              :min_partition_order, :int,
+              :max_partition_order, :int,
+              :timecode_frame_start, :long_long,
+              :request_channel, :int,
+              :drc_scale, :float,
+              :reordered_opaque, :long_long,
+              :bits_per_raw_sample, :int,
+              :channel_layout, :long_long,
+              :request_channel_layout, :long_long,
+              :rc_max_available_vbv_use, :float,
+              :rc_min_vbv_overflow_use, :float,
+              :hwaccel, :pointer,
+              :ticks_per_frame, :int,
+              :hwaccel_context, :pointer,
+              :color_primaries, :int,       # enum AVColorPrimaries
+              :color_trc, :int,             # enum AVColorTransferCharacteristic
+              :colorspace, :int,            # enum AVColorSpace
+              :color_range, :int,           # enum AVColorRange
+              :chroma_sample_location, :int,# enum AVChromaLocation
+              :execute2, :pointer,
+              :weighted_p_pred, :int,
+              :aq_mode, :int,
+              :aq_strength, :float,
+              :psy_rd, :float,
+              :psy_trellis, :float,
+              :rc_lookahead, :int
+              # LONGEST STRUCTURE EVER!!!!
+    end
+
+    class AVFormatContext < FFI::Struct
+      layout  :av_class,      :pointer,
+              :iformat,       :pointer,
+              :oformat,       :pointer,
+              :priv_data,     :pointer,
+              :pb,            :pointer,
+              :nb_streams,    :uint,
+              :streams,       [:pointer, MAX_STREAMS],
+              :filename,      [:char, 1024],
+              :timestamp,     :long_long,
+              :title,         [:char, 512],
+              :author,        [:char, 512],
+              :copyright,     [:char, 512],
+              :comment,       [:char, 512],
+              :album,         [:char, 512],
+              :year,          :int,
+              :track,         :int,
+              :genre,         [:char, 32],
+              :ctx_flags,     :int,
+              :packet_buffer, :pointer,
+              :start_time,    :long_long,
+              :duration,      :long_long,
+              :file_size,     :long_long,
+              :bitrate,       :int,
+              :cur_st,        :pointer,
+              :cur_ptr_deprecated,  :pointer,
+              :cur_len_deprecated,  :int,
+              :cur_pkt_deprecated,  AVPacket,
+              :data_offset,   :long_long,
+              :index_build,   :int,
+              :mux_rate,      :int,
+              :packet_size,   :uint,
+              :max_delay,     :int,
+              :loop_output,   :int,
+              :flags,         :int,
+              :loop_input,    :int,
+              :probesize,     :uint,
+              :max_analyze_diration,  :int,
+              :key,           :pointer,
+              :keylen,        :int,
+              :nb_programs,   :uint,
+              :programs,      :pointer,
+              :video_codec_id,  :uint,      # enum CodecID
+              :audio_codec_id,  :uint,      # enum CodecID
+              :subtitle_codec_id, :uint,    # enum CodecID
+              :max_index_size,  :uint,
+              :max_picture_buffer,  :uint,
+              :nb_chapters,   :uint,
+              :chapters,      :pointer,
+              :debug,         :int,
+              :raw_packet_buffer, :pointer,
+              :raw_packet_buffer_end, :pointer,
+              :packet_buffet_end, :pointer,
+              :metadata,      :pointer,
+              :raw_packet_buffer_remaining_size, :int,
+              :start_time_realtime, :long_long
+    end
+    
+    class AVPicture < FFI::Struct
+      layout  :data, [:pointer, 4],
+              :linesize, [:int, 4]
+    end
+
+    class AVFrame < FFI::Struct
+      layout  :data, [:pointer, 4],
+              :linesize, [:int, 4],
+              :base, [:pointer, 4],
+              :key_frame, :int,
+              :pict_type, :int,
+              :pts, :int64,
+              :coded_picture_number, :int,
+              :dispay_picture_number, :int,
+              :quality, :int,
+              :age, :int,
+              :reference, :int,
+              :qscale_table, :pointer,
+              :qstride, :int,
+              :mbskip_table, :pointer,
+              :motion_val, [:pointer, 2],
+              :mb_type, :pointer,
+              :motion_subsample_log2, :uint8,
+              :opaque, :pointer,
+              :error, [:uint64, 4],
+              :type, :int,
+              :repeat_pict, :int,
+              :qscale_type, :int,
+              :interlaced_frame, :int,
+              :top_field_first, :int,
+              :pan_scan, :pointer,
+              :palette_has_changed, :int,
+              :buffer_hints, :int,
+              :dct_coeff, :pointer,
+              :ref_index, [:pointer, 2],
+              :reordered_opaque, :long_long
+    end
+
+
+  end # module FFmpeg
+end # module FFI