ffmpeg-ruby 0.1.0

data/Manifest

@@ -0,0 +1,16 @@
+Manifest
+README.rdoc
+Rakefile
+ext/ffmpeg_ruby/conftest.dSYM/Contents/Info.plist
+ext/ffmpeg_ruby/conftest.dSYM/Contents/Resources/DWARF/conftest
+ext/ffmpeg_ruby/extconf.rb
+ext/ffmpeg_ruby/ffmpeg_avcodec.c
+ext/ffmpeg_ruby/ffmpeg_avcodec.h
+ext/ffmpeg_ruby/ffmpeg_avformat.c
+ext/ffmpeg_ruby/ffmpeg_avformat.h
+ext/ffmpeg_ruby/ffmpeg_ruby.c
+ext/ffmpeg_ruby/ffmpeg_ruby.h
+ffmpeg-ruby.gemspec
+lib/ffmpeg-ruby.rb
+tasks/mac_specific.rake
+test/test.rb

data/README.rdoc

@@ -0,0 +1,51 @@
+= Ruby FFMpeg Library
+
+"ffmpeg-ruby" is a ruby gem library (work in progress) that provides bindings allowing you to access the ffmpeg under ruby. FFMpeg is a cross-platform solution to record, convert and stream audio and video. It includes libavcodec - the leading audio/video codec library.
+
+This implementation is starting by doing the translation for some of the functions in libavcodec and libavformat to ruby.
+
+FFMpeg is provided by http://ffmpeg.org/ under the LGPL license.
+
+This bindings gem is graciously provided by http://www.channels.com under the LGPL license.
+
+== Installing
+
+ $ gem install ffmpeg-ruby
+
+== Installation troubleshooting
+
+If you run into trouble, it could be the C bundle not building. This is known to happen on MacOS 64-bit or with the ffmpeg from macports. You basically need to run ruby extconf yourself then.
+
+
+ $ ruby extconf.rb
+
+You may need to add +--with+ on mac, to point it to macports' /opt/local for the libraries.
+
+This has worked on my snow leopard machine:
+
+  $ sudo port install ffmpeg
+  (go have coffee)
+  $ env ARCHFLAGS="-arch x86_64" ruby extconf.rb --with-avformat-dir=/opt/local
+  make
+
+This will provide you with a bundle you can require.
+
+== Usage
+
+See the code on +test/+ for usage. But basically it goes like this:
+
+  require 'ffmpeg-ruby'
+
+	# Get a list of the video codecs supported
+	FFMpeg::AVCodec.supported_video_codecs 
+
+	# Get a list of the audio codecs supported
+	FFMpeg::AVCodec.supported_video_codecs 
+
+	# Create new AVFormatContext
+	f = FFMpeg::AVFormatContext.new("/path/to/my/video.mov")
+
+	f.codec_contexts.each{ |ctx|
+	  puts ctx.name # The name of the codec this file uses.
+	}
+

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new("ffmpeg-ruby", "0.1.0") do |p|
+	p.description = "FFMpeg Ruby Bridge. Call FFMpeg/LibAVCodec/LibAVFormat directly"
+	p.url         = "http://github.com/hackerdude/ffmpeg-ruby"
+	p.author      = "David Martinez"
+	p.ignore_pattern = ["tmp/*", "script/*"]
+	p.development_dependencies = [] # TODO How to do native dependencies?
+end
+
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each{|ext| load ext }
+

data/ext/ffmpeg_ruby/conftest.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.conftest</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

data/ext/ffmpeg_ruby/extconf.rb

@@ -0,0 +1,26 @@
+require 'mkmf'
+#require 'rubygems'
+#require 'ruby-debug'
+#Debugger.start
+
+def boom(v)
+  puts(v)
+  exit 1
+end
+
+#debugger
+if RUBY_PLATFORM == "universal-darwin10.0"
+  # TODO Set the archflags to -arch x86_64 ONLY if it's a 64-bit snow leopard machine.
+	#ENV['ARCHFLAGS'] = "-arch i386 -arch x86_64"
+	$CFLAGS.sub!("-arch x86_64", "")
+end
+unless ( have_header("libavformat/avformat.h") || 
+         find_header("libavformat/avformat.h", "/opt/local/include", "/usr/local/include", "/usr/include") ) and 
+       ( have_library("avformat", "av_register_all") or 
+		     find_library("avformat", "av_register_all", "/opt/local/lib", "/usr/local/lib", "/usr/lib") )
+	boom(<<EOL)
+You need to install or tell me where to find ffmpeg. Check the mkmf.log file to see what erred out.
+EOL
+end
+
+create_makefile("ffmpeg_ruby")

data/ext/ffmpeg_ruby/ffmpeg_avcodec.c

@@ -0,0 +1,199 @@
+#include "ruby.h"
+#include <libavcodec/avcodec.h>
+
+VALUE cFFMpegAVCodec;
+VALUE cFFMpegAVCodecContext;
+
+void AVCodec_mark(void *v) {}
+void AVCodec_free(void *v) {}
+
+void AVCodecContext_mark(AVCodecContext v) {}
+void AVCodecContext_free(AVCodecContext v) {
+}
+
+VALUE AVCodecContext_codec_type(VALUE self)
+{
+  AVCodecContext *ptr;
+  Data_Get_Struct(self, AVCodecContext, ptr);
+	VALUE result = INT2NUM(ptr->codec_type);
+	return result;
+}
+
+VALUE codec_type_map()
+{
+	VALUE result = rb_hash_new();
+	rb_hash_aset(result, INT2NUM(CODEC_TYPE_VIDEO), rb_str_new2("Video"));
+	rb_hash_aset(result, INT2NUM(CODEC_TYPE_AUDIO), rb_str_new2("Audio"));
+	rb_hash_aset(result, INT2NUM(CODEC_TYPE_DATA), rb_str_new2("Data"));
+	rb_hash_aset(result, INT2NUM(CODEC_TYPE_SUBTITLE), rb_str_new2("Subtitle"));
+	rb_hash_aset(result, INT2NUM(CODEC_TYPE_ATTACHMENT), rb_str_new2("Attachment"));
+	return result;
+}
+
+
+VALUE AVCodecContext_codec_id(VALUE self)
+{
+  AVCodecContext *ptr;
+  Data_Get_Struct(self, AVCodecContext, ptr);
+	VALUE result = INT2NUM(ptr->codec_id);
+	return result;
+}
+
+VALUE AVCodecContext_width(VALUE self)
+{
+  AVCodecContext *ptr;
+  Data_Get_Struct(self, AVCodecContext, ptr);
+	VALUE result = INT2NUM(ptr->width);
+	return result;
+}
+
+VALUE AVCodecContext_height(VALUE self)
+{
+  AVCodecContext *ptr;
+  Data_Get_Struct(self, AVCodecContext, ptr);
+	VALUE result = INT2NUM(ptr->height);
+	return result;
+}
+
+VALUE AVCodecContext_channels(VALUE self)
+{
+  AVCodecContext *ptr;
+  Data_Get_Struct(self, AVCodecContext, ptr);
+	VALUE result = INT2NUM(ptr->channels);
+	return result;
+}
+
+VALUE AVCodecContext_sample_rate(VALUE self)
+{
+  AVCodecContext *ptr;
+  Data_Get_Struct(self, AVCodecContext, ptr);
+	VALUE result = INT2NUM(ptr->sample_rate);
+	return result;
+}
+
+VALUE AVCodec_long_name(VALUE self)
+{
+	char* tm;
+  AVCodec *ptr;
+  Data_Get_Struct(self, AVCodec, ptr);
+	tm = ptr->long_name;
+	return rb_str_new2(tm);
+}
+
+VALUE AVCodec_name(VALUE self)
+{
+	char* tm;
+  AVCodec *ptr;
+  Data_Get_Struct(self, AVCodec, ptr);
+	tm = ptr->name;
+	return rb_str_new2(tm);
+}
+
+VALUE AVCodec_codec_type(VALUE self)
+{
+	char* tm;
+  AVCodec *ptr;
+  Data_Get_Struct(self, AVCodec, ptr);
+	return INT2NUM(ptr->type);
+}
+
+VALUE AVCodecContext_codec_long_name(VALUE self)
+{
+	char* tm;
+  AVCodecContext *ptr;
+  Data_Get_Struct(self, AVCodecContext, ptr);
+	if (ptr->codec == NULL)
+			return Qnil;
+	tm = ptr->codec->long_name;
+	return rb_str_new2(tm);
+}
+
+VALUE AVCodecContext_codec_name(VALUE self)
+{
+	char* tm;
+  AVCodecContext *ptr;
+  Data_Get_Struct(self, AVCodecContext, ptr);
+	if (ptr->codec == NULL)
+			return Qnil;
+	tm = ptr->codec->name;
+	return rb_str_new2(tm);
+}
+
+VALUE supported_avcodecs()
+{
+	VALUE result = rb_hash_new();
+	AVCodec *pNextCodec = NULL;
+	pNextCodec = av_codec_next(pNextCodec);
+	while (pNextCodec != NULL) {
+		VALUE sNextCodecName     = rb_str_new2(pNextCodec->name);
+		//VALUE sNextCodecLongName = rb_str_new2(pNextCodec->long_name);
+		VALUE codec = Data_Wrap_Struct(cFFMpegAVCodec, AVCodecContext_mark, AVCodecContext_free, pNextCodec);
+		rb_hash_aset(result, sNextCodecName, codec);
+		pNextCodec = av_codec_next(pNextCodec);
+	}
+	return result;
+}
+
+VALUE supported_video_codecs()
+{
+	VALUE result = rb_hash_new();
+	AVCodec *pNextCodec = NULL;
+	pNextCodec = av_codec_next(pNextCodec);
+	while (pNextCodec != NULL) {
+		if (pNextCodec->type==CODEC_TYPE_VIDEO) {
+			VALUE sNextCodecName     = rb_str_new2(pNextCodec->name);
+			//VALUE sNextCodecLongName = rb_str_new2(pNextCodec->long_name);
+			VALUE codec = Data_Wrap_Struct(cFFMpegAVCodec, AVCodecContext_mark, AVCodecContext_free, pNextCodec);
+			rb_hash_aset(result, sNextCodecName, codec);
+		}
+		pNextCodec = av_codec_next(pNextCodec);
+	}
+	return result;
+}
+
+VALUE supported_audio_codecs()
+{
+	VALUE result = rb_hash_new();
+	AVCodec *pNextCodec = NULL;
+	pNextCodec = av_codec_next(pNextCodec);
+	while (pNextCodec != NULL) {
+		if (pNextCodec->type==CODEC_TYPE_AUDIO) {
+			VALUE sNextCodecName     = rb_str_new2(pNextCodec->name);
+			//VALUE sNextCodecLongName = rb_str_new2(pNextCodec->long_name);
+			VALUE codec = Data_Wrap_Struct(cFFMpegAVCodec, AVCodecContext_mark, AVCodecContext_free, pNextCodec);
+			rb_hash_aset(result, sNextCodecName, codec);
+		}
+		pNextCodec = av_codec_next(pNextCodec);
+	}
+	return result;
+}
+
+void Init_ffmpeg_ruby_avcodec(VALUE module)
+{
+
+		cFFMpegAVCodec = rb_define_class_under(module, "AVCodec", rb_cObject);
+		rb_define_method(cFFMpegAVCodec, "name", AVCodec_name, 0);
+		rb_define_method(cFFMpegAVCodec, "long_name", AVCodec_long_name, 0);
+		rb_define_method(cFFMpegAVCodec, "codec_type", AVCodec_codec_type, 0);
+		rb_define_singleton_method(cFFMpegAVCodec, "supported_avcodecs", supported_avcodecs, 0);
+		rb_define_singleton_method(cFFMpegAVCodec, "supported_video_codecs", supported_video_codecs, 0);
+		rb_define_singleton_method(cFFMpegAVCodec, "supported_audio_codecs", supported_audio_codecs, 0);
+		cFFMpegAVCodecContext = rb_define_class_under(module, "AVCodecContext", rb_cObject);
+		rb_define_method(cFFMpegAVCodecContext, "long_name", AVCodecContext_codec_long_name, 0);
+		rb_define_method(cFFMpegAVCodecContext, "name", AVCodecContext_codec_name, 0);
+		rb_define_method(cFFMpegAVCodecContext, "codec_type", AVCodecContext_codec_type, 0);
+		rb_define_method(cFFMpegAVCodecContext, "codec_id", AVCodecContext_codec_id, 0);
+		rb_define_method(cFFMpegAVCodecContext, "width", AVCodecContext_width, 0);
+		rb_define_method(cFFMpegAVCodecContext, "height", AVCodecContext_height, 0);
+		rb_define_method(cFFMpegAVCodecContext, "channels", AVCodecContext_channels, 0);
+		rb_define_method(cFFMpegAVCodecContext, "sample_rate", AVCodecContext_sample_rate, 0);
+
+		// Codec Types, for AVCodecContext
+		rb_define_const(module, "CODEC_TYPE_VIDEO", INT2NUM(CODEC_TYPE_VIDEO));
+		rb_define_const(module, "CODEC_TYPE_AUDIO", INT2NUM(CODEC_TYPE_AUDIO));
+		rb_define_const(module, "CODEC_TYPE_DATA", INT2NUM(CODEC_TYPE_DATA));
+		rb_define_const(module, "CODEC_TYPE_SUBTITLE", INT2NUM(CODEC_TYPE_SUBTITLE));
+		rb_define_const(module, "CODEC_TYPE_ATTACHMENT", INT2NUM(CODEC_TYPE_ATTACHMENT));
+		rb_define_const(module, "MAP_CODEC_TYPES", codec_type_map());
+
+}

data/ext/ffmpeg_ruby/ffmpeg_avcodec.h

@@ -0,0 +1,27 @@
+VALUE cFFMpegAVCodecContext;
+
+void Init_ffmpeg_ruby_avcodec(VALUE module)
+
+void AVCodec_mark(void *v);
+void AVCodec_free(void *v);
+
+void AVCodecContext_mark(AVCodecContext v);
+void AVCodecContext_free(AVCodecContext v);
+
+VALUE AVCodecContext_codec_type(VALUE self);
+VALUE codec_type_map();
+
+VALUE AVCodecContext_codec_id(VALUE self);
+VALUE AVCodecContext_width(VALUE self);
+VALUE AVCodecContext_height(VALUE self);
+VALUE AVCodecContext_channels(VALUE self);
+VALUE AVCodecContext_sample_rate(VALUE self);
+VALUE AVCodec_long_name(VALUE self);
+VALUE AVCodec_name(VALUE self);
+VALUE AVCodec_codec_type(VALUE self);
+VALUE AVCodecContext_codec_long_name(VALUE self);
+VALUE AVCodecContext_codec_name(VALUE self);
+VALUE supported_avcodecs();
+VALUE supported_video_codecs();
+VALUE supported_audio_codecs();
+

data/ext/ffmpeg_ruby/ffmpeg_avformat.c

@@ -0,0 +1,149 @@
+#include "ruby.h"
+#include <libavformat/avformat.h>
+#include "ffmpeg_avformat.h"
+
+void AVFormatContext_mark(void *v) {}
+
+void AVFormatContext_free(void *v) { 
+		// TODO Figure out how to avoid double-closing.
+		//AVFormatContext* f = (AVFormatContext*)v;
+		//if (f->filename != NULL)
+			//av_close_input_file(v); 
+}
+
+void AVOutputFormat_mark(void *v){}
+void AVOutputFormat_free(void *v){}
+
+VALUE supported_avformats()
+{
+	VALUE result = rb_hash_new();
+	AVOutputFormat *pNext = NULL;
+	pNext = av_oformat_next(pNext);
+	while (pNext != NULL) {
+		VALUE sNextFormatName     = rb_str_new2(pNext->name);
+		//VALUE sNextLongName = rb_str_new2(pNext->long_name);
+		VALUE format = Data_Wrap_Struct(cFFMpegAVOutputFormat, AVOutputFormat_mark, AVOutputFormat_free, pNext);
+		rb_obj_call_init(result, 0, 0);
+		rb_hash_aset(result, sNextFormatName, format);
+		pNext = av_codec_next(pNext);
+	}
+	return result;
+}
+ 
+
+VALUE AVFormatContext_dump_format(VALUE self) {
+  AVFormatContext *ptr;
+  Data_Get_Struct(self, AVFormatContext, ptr);
+	dump_format(ptr, 0, ptr->filename, 0);
+	return Qnil;
+}
+VALUE AVFormatContext_duration(VALUE self) {
+  AVFormatContext *ptr;
+  Data_Get_Struct(self, AVFormatContext, ptr);
+	//ptr->filename = NULL;
+	return INT2NUM(ptr->duration);
+}
+VALUE AVFormatContext_close_file(VALUE self) {
+  AVFormatContext *ptr;
+  Data_Get_Struct(self, AVFormatContext, ptr);
+	av_close_input_file(ptr);
+	//ptr->filename = NULL;
+	return Qnil;
+}
+VALUE AVFormatContext_new(VALUE klaas, VALUE ruby_filename) {
+		Check_Type(ruby_filename, T_STRING);
+		char* filename = StringValuePtr(ruby_filename);
+
+		AVFormatContext *pFormatCtx;
+		// Open video file
+		if(av_open_input_file(&pFormatCtx, filename, NULL, 0, NULL)!=0) {
+				rb_raise(rb_eRuntimeError, "Could not open video file %s", filename);
+			return NULL;
+		}
+	
+		// Retrieve stream information
+		if(av_find_stream_info(pFormatCtx)<0) {
+			rb_raise(rb_eRuntimeError, "Could find the stream information in file %s", filename);
+			return NULL; // Couldn't find stream information
+		}
+
+		VALUE result = Data_Wrap_Struct(klaas, AVFormatContext_mark, AVFormatContext_free, pFormatCtx);
+		rb_obj_call_init(result, 0, 0);
+		return result;
+}
+
+/* Return all the AVCodecContext entries for all streams in the file */
+VALUE AVFormatContext_codec_contexts(VALUE self) {
+  AVFormatContext *ptr;
+  Data_Get_Struct(self, AVFormatContext, ptr);
+	VALUE result = rb_ary_new();
+	int i, videoStream;
+	videoStream=-1;
+	for(i=0; i<ptr->nb_streams; i++) {
+		// Get a pointer to the codec context for the video stream
+		AVCodecContext  *pCodecCtx = ptr->streams[i]->codec;
+		AVCodec         *pCodec;
+		pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
+		pCodecCtx->codec = pCodec;
+
+		// Turn it into something ruby can understand
+		VALUE rCodec  = Data_Wrap_Struct(cFFMpegAVCodecContext, AVCodecContext_mark, AVCodecContext_free, pCodecCtx);
+		rb_obj_call_init(rCodec,0,0);
+		rb_ary_push(result, rCodec);
+	}
+	//if(videoStream==-1) {
+			//rb_raise(rb_eRuntimeError, "No video streams here!");
+			//return Qnil;
+	//}
+	return result;
+}
+
+VALUE AVFormatContext_title(VALUE self) {
+  AVFormatContext *ptr;
+  Data_Get_Struct(self, AVFormatContext, ptr);
+	return rb_str_new2(ptr->title);
+}
+
+VALUE AVFormatContext_author(VALUE self) {
+  AVFormatContext *ptr;
+  Data_Get_Struct(self, AVFormatContext, ptr);
+	return rb_str_new2(ptr->author);
+}
+
+VALUE AVFormatContext_copyright(VALUE self) {
+  AVFormatContext *ptr;
+  Data_Get_Struct(self, AVFormatContext, ptr);
+	return rb_str_new2(ptr->copyright);
+}
+
+VALUE AVFormatContext_bit_rate(VALUE self) {
+  AVFormatContext *ptr;
+  Data_Get_Struct(self, AVFormatContext, ptr);
+	return INT2NUM(ptr->bit_rate);
+}
+
+VALUE AVFormatContext_album(VALUE self) {
+  AVFormatContext *ptr;
+  Data_Get_Struct(self, AVFormatContext, ptr);
+	return rb_str_new2(ptr->album);
+}
+
+
+void Init_ffmpeg_ruby_avformat(VALUE module)
+{
+
+		cFFMpegAVFormatContext = rb_define_class_under(module, "AVFormatContext", rb_cObject);
+		rb_define_singleton_method(cFFMpegAVFormatContext, "new", AVFormatContext_new, 1);
+		rb_define_method(cFFMpegAVFormatContext, "close_file", AVFormatContext_close_file, 0);
+		rb_define_method(cFFMpegAVFormatContext, "duration", AVFormatContext_duration, 0);
+		rb_define_method(cFFMpegAVFormatContext, "title", AVFormatContext_title, 0);
+		rb_define_method(cFFMpegAVFormatContext, "copyright", AVFormatContext_copyright, 0);
+		rb_define_method(cFFMpegAVFormatContext, "author", AVFormatContext_author, 0);
+		rb_define_method(cFFMpegAVFormatContext, "album", AVFormatContext_album, 0);
+		rb_define_method(cFFMpegAVFormatContext, "bit_rate", AVFormatContext_bit_rate, 0);
+		rb_define_method(cFFMpegAVFormatContext, "codec_contexts", AVFormatContext_codec_contexts, 0);
+		rb_define_method(cFFMpegAVFormatContext, "dump_format", AVFormatContext_dump_format, 0);
+
+		cFFMpegAVOutputFormat = rb_define_class_under(module, "AVOutputFormat", rb_cObject);
+		rb_define_singleton_method(cFFMpegAVOutputFormat, "supported_avformats", supported_avformats, 0);
+}

data/ext/ffmpeg_ruby/ffmpeg_avformat.h

@@ -0,0 +1,28 @@
+#include <libavformat/avformat.h>
+#include <ruby.h>
+
+VALUE cFFMpegAVFormatContext;
+VALUE cFFMpegAVOutputFormat;
+
+void AVOutputFormat_mark(void *v);
+void AVOutputFormat_free(void *v);
+
+void AVFormatContext_mark(void *v);
+void AVFormatContext_free(void *v);
+
+VALUE AVFormatContext_dump_format(VALUE);
+VALUE AVFormatContext_duration(VALUE);
+VALUE AVFormatContext_close_file(VALUE);
+VALUE AVFormatContext_new(VALUE, VALUE);
+VALUE AVFormatContext_codec_contexts(VALUE);
+VALUE AVFormatContext_title(VALUE);
+VALUE AVFormatContext_author(VALUE);
+VALUE AVFormatContext_copyright(VALUE);
+VALUE AVFormatContext_bit_rate(VALUE);
+VALUE AVFormatContext_album(VALUE);
+void Init_ffmpeg_ruby_avformat(VALUE module);
+
+// Forward declaring some necessary avcodec stuff
+void AVCodecContext_mark(void *v);
+void AVCodecContext_free(void *v);
+extern VALUE cFFMpegAVCodecContext;

data/ext/ffmpeg_ruby/ffmpeg_ruby.c

@@ -0,0 +1,16 @@
+#include "ffmpeg_ruby.h"
+
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+
+/** FFMpeg Module */
+VALUE mFFMpeg;
+/** *** Ruby Interface *** **/
+void Init_ffmpeg_ruby()
+{
+		av_register_all();
+		mFFMpeg = rb_define_module("FFMpeg");
+		Init_ffmpeg_ruby_avcodec(mFFMpeg);
+		Init_ffmpeg_ruby_avformat(mFFMpeg);
+}
+

data/ext/ffmpeg_ruby/ffmpeg_ruby.h

@@ -0,0 +1,3 @@
+#include "ruby.h"
+
+

data/ffmpeg-ruby.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ffmpeg-ruby}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["David Martinez"]
+  s.date = %q{2010-02-10}
+  s.description = %q{FFMpeg Ruby Bridge. Call FFMpeg/LibAVCodec/LibAVFormat directly}
+  s.email = %q{}
+  s.extensions = ["ext/ffmpeg_ruby/extconf.rb"]
+  s.extra_rdoc_files = ["README.rdoc", "ext/ffmpeg_ruby/conftest.dSYM/Contents/Info.plist", "ext/ffmpeg_ruby/conftest.dSYM/Contents/Resources/DWARF/conftest", "ext/ffmpeg_ruby/extconf.rb", "ext/ffmpeg_ruby/ffmpeg_avcodec.c", "ext/ffmpeg_ruby/ffmpeg_avcodec.h", "ext/ffmpeg_ruby/ffmpeg_avformat.c", "ext/ffmpeg_ruby/ffmpeg_avformat.h", "ext/ffmpeg_ruby/ffmpeg_ruby.c", "ext/ffmpeg_ruby/ffmpeg_ruby.h", "lib/ffmpeg-ruby.rb", "tasks/mac_specific.rake"]
+  s.files = ["Manifest", "README.rdoc", "Rakefile", "ext/ffmpeg_ruby/conftest.dSYM/Contents/Info.plist", "ext/ffmpeg_ruby/conftest.dSYM/Contents/Resources/DWARF/conftest", "ext/ffmpeg_ruby/extconf.rb", "ext/ffmpeg_ruby/ffmpeg_avcodec.c", "ext/ffmpeg_ruby/ffmpeg_avcodec.h", "ext/ffmpeg_ruby/ffmpeg_avformat.c", "ext/ffmpeg_ruby/ffmpeg_avformat.h", "ext/ffmpeg_ruby/ffmpeg_ruby.c", "ext/ffmpeg_ruby/ffmpeg_ruby.h", "ffmpeg-ruby.gemspec", "lib/ffmpeg-ruby.rb", "tasks/mac_specific.rake", "test/test.rb"]
+  s.homepage = %q{http://github.com/hackerdude/ffmpeg-ruby}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Ffmpeg-ruby", "--main", "README.rdoc"]
+  s.require_paths = ["lib", "ext"]
+  s.rubyforge_project = %q{ffmpeg-ruby}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{FFMpeg Ruby Bridge. Call FFMpeg/LibAVCodec/LibAVFormat directly}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/ffmpeg-ruby.rb

@@ -0,0 +1,4 @@
+# Load the C library.
+$:.unshift "#{File.dirname(__FILE__)}/../ext/ffmpeg_ruby/"
+
+require "ffmpeg_ruby"

data/tasks/mac_specific.rake

@@ -0,0 +1,9 @@
+task :compile_mac do
+	puts "Compiling on a mac"
+	`cd ext/ffmpeg_ruby && env ARCHFLAGS="-arch x86_64" ruby extconf.rb --with-avformat-dir=/opt/local && make`
+end
+
+task :clean_mac => :clean do
+	puts "Cleaning on a mac"
+	`rm -rf ext/ffmpeg_ruby/conftest.dSYM`
+end

data/test/test.rb

@@ -0,0 +1,39 @@
+require "#{File.dirname(__FILE__)}/../lib/ffmpeg-ruby"
+
+puts "Here are the video codecs I support, of the #{FFMpeg::AVCodec.supported_avcodecs.length} codecs:"
+FFMpeg::AVCodec.supported_video_codecs.each{|k,v|
+  puts "  - #{k}=#{v.long_name} (#{v.name}) of type #{FFMpeg::MAP_CODEC_TYPES[v.codec_type]}"
+}
+
+FFMpeg::AVCodec.supported_audio_codecs.each{|k,v|
+  puts "  - #{k}=#{v.long_name} (#{v.name}) of type #{FFMpeg::MAP_CODEC_TYPES[v.codec_type]}"
+}
+puts "Creating new AVFormatContext"
+filename = '/Users/david/channels-reader/public/videos/Channels_Playlist_WEB.mov'
+if ARGV.length > 0
+  filename = ARGV[0]
+end
+f = FFMpeg::AVFormatContext.new(filename)
+"Format Information:"
+puts "  Duration: #{f.duration}"
+puts "  Title: #{f.title}"
+puts "  Copyright: #{f.copyright}"
+puts "  Author: #{f.author}"
+puts "  Album: #{f.album}"
+puts "  Bit Rate: #{f.bit_rate}"
+
+puts "\nCodec Information for #{filename}"
+f.codec_contexts.each_with_index{|ctx,i|
+	puts "Codec info for stream ##{i}"
+	puts "  Type: #{ctx.codec_type} (#{FFMpeg::MAP_CODEC_TYPES[ctx.codec_type]})"
+	puts "  Name: #{ctx.name}"
+	puts "  Long Name: #{ctx.long_name}"
+	puts "  Width: #{ctx.width}"
+	puts "  Height: #{ctx.height}"
+	puts "  Audio Channels: #{ctx.channels}"
+	puts "  Audio Sample Rate: #{ctx.sample_rate}"
+}
+
+puts "-- Now dumping the format:"
+f.dump_format
+

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: ffmpeg-ruby
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- David Martinez
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-10 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: FFMpeg Ruby Bridge. Call FFMpeg/LibAVCodec/LibAVFormat directly
+email: ""
+executables: []
+
+extensions: 
+- ext/ffmpeg_ruby/extconf.rb
+extra_rdoc_files: 
+- README.rdoc
+- ext/ffmpeg_ruby/conftest.dSYM/Contents/Info.plist
+- ext/ffmpeg_ruby/conftest.dSYM/Contents/Resources/DWARF/conftest
+- ext/ffmpeg_ruby/extconf.rb
+- ext/ffmpeg_ruby/ffmpeg_avcodec.c
+- ext/ffmpeg_ruby/ffmpeg_avcodec.h
+- ext/ffmpeg_ruby/ffmpeg_avformat.c
+- ext/ffmpeg_ruby/ffmpeg_avformat.h
+- ext/ffmpeg_ruby/ffmpeg_ruby.c
+- ext/ffmpeg_ruby/ffmpeg_ruby.h
+- lib/ffmpeg-ruby.rb
+- tasks/mac_specific.rake
+files: 
+- Manifest
+- README.rdoc
+- Rakefile
+- ext/ffmpeg_ruby/conftest.dSYM/Contents/Info.plist
+- ext/ffmpeg_ruby/conftest.dSYM/Contents/Resources/DWARF/conftest
+- ext/ffmpeg_ruby/extconf.rb
+- ext/ffmpeg_ruby/ffmpeg_avcodec.c
+- ext/ffmpeg_ruby/ffmpeg_avcodec.h
+- ext/ffmpeg_ruby/ffmpeg_avformat.c
+- ext/ffmpeg_ruby/ffmpeg_avformat.h
+- ext/ffmpeg_ruby/ffmpeg_ruby.c
+- ext/ffmpeg_ruby/ffmpeg_ruby.h
+- ffmpeg-ruby.gemspec
+- lib/ffmpeg-ruby.rb
+- tasks/mac_specific.rake
+- test/test.rb
+has_rdoc: true
+homepage: http://github.com/hackerdude/ffmpeg-ruby
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Ffmpeg-ruby
+- --main
+- README.rdoc
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: ffmpeg-ruby
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: FFMpeg Ruby Bridge. Call FFMpeg/LibAVCodec/LibAVFormat directly
+test_files: []
+