puremotion 0.0.1 → 0.1.0

data/.yardopts

@@ -0,0 +1 @@
+--no-private

data/README.md

@@ -0,0 +1,69 @@
+PureMotion (0.1.0)
+==================
+
+**Homepage**:  [http://github.com/ominiom/puremotion](http://github.com/ominiom/puremotion)
+
+OVERVIEW
+--------
+
+PureMotion is a Ruby gem for handling media files through ffmpeg
+
+
+FEATURES
+--------
+
+**1. Media Information**:
+
+PureMotion uses the libav* libraries from the FFmpeg project to read information 
+from all FFmpeg supported media files.
+
+
+**2. Transcoding**:
+
+PureMotion provides a DSL for building and running ffmpeg transcodes with progress
+reporting and logging. Consider the following code for transcoding a video to flv :
+
+    Transcode do
+
+        input 'sample.ogv'
+
+        video do
+            codec :flv
+            resize 320, 240
+            bitrate '320k'
+        end
+
+        audio do
+            codec :libmp3lame
+            channels 2
+            bitrate '64k'
+        end
+
+        output 'converted.flv'
+
+        log 'transcode.log'
+
+        event :progress do |transcode, progress|
+            puts "#{progress[:percent]}%"
+        end
+
+    end
+
+**3. Thumbnails**:
+
+The GD image library is used to resize and save in PNG format captured images from
+a video stream.
+
+    Media 'sample.mp4' do
+
+        if video? then
+            seek(5).grab.resize(320, 240).save('thumb.png')
+        end
+
+    end
+
+BUILDING
+--------
+
+To build the PureMotion gem from source you will need to have libav* and libgd
+installed.

data/Rakefile

@@ -6,11 +6,24 @@ begin
   Jeweler::Tasks.new do |gem|
     gem.name = "puremotion"
     gem.summary = %Q{PureMotion}
-    gem.description = %Q{A Ruby wrapper for analysis and conversion of media using FFmpeg}
-    gem.email = "iain.iw.wilson@googlemail.com"
+    gem.description = %Q{A Ruby wrapper for FFmpeg}
+    gem.email = "iain@ominiom.com"
     gem.homepage = "http://github.com/ominiom/puremotion"
     gem.authors = ["Ominiom"]
-    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    gem.extensions = ["ext/puremotion/extconf.rb"]
+    gem.files = [
+      "README.md",
+      "LICENSE",
+      "Rakefile",
+      ".yardopts",
+      "ext/puremotion/*.c",
+      "ext/puremotion/*.h",
+      "ext/puremotion/*.rb",
+      "lib/*",
+      "lib/*",
+      "lib/*/*",
+      "lib/*/*/*",
+    ]
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new
@@ -42,12 +55,11 @@ task :test => :check_dependencies
 
 task :default => :test
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "puremotion #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
 end

data/examples/progress_reporting.rb

@@ -0,0 +1,26 @@
+Transcode do
+
+  input '../spec/samples/sample.ogv'
+
+  overwrite!
+
+  video do
+    codec :flv
+    resolution 320, 240
+    bitrate '240k'
+  end
+
+  audio do
+    codec :libmp3lame
+    bitrate '64k'
+  end
+
+  output 'test.flv'
+
+  log 'simple.log'
+
+  event :progress do |transcode, progress|
+    puts "#{progress[:percent]}%"
+  end
+
+end

data/examples/simple.rb

@@ -0,0 +1,22 @@
+Transcode do
+
+  input '../spec/samples/sample.ogv'
+
+  overwrite!
+
+  video do
+    codec :flv
+    resolution 320, 240
+    bitrate '240k'
+  end
+
+  audio do
+    codec :libmp3lame
+    bitrate '64k'
+  end
+
+  output 'test.flv'
+
+  log 'simple.log'
+
+end

data/ext/puremotion/audio.c

@@ -0,0 +1,38 @@
+#include "puremotion.h"
+#include "utils.h"
+
+VALUE rb_cStream;
+VALUE rb_cAudioStream;
+VALUE rb_mStreams;
+
+static VALUE stream_sample_rate(VALUE self) {
+    AVStream * stream = get_stream(self);
+
+    rb_float_new(stream->codec->sample_rate);
+}
+
+static VALUE audio_stream_init(VALUE self, VALUE media) {
+    //printf("Stream initialized\n");
+    rb_iv_set(self, "@media", media);
+    return self;
+}
+
+static VALUE alloc_audio_stream(VALUE self) {
+    //printf("Stream allocating...\n");
+    AVStream * stream = av_new_stream(NULL, 0);
+    //printf("Stream wrapping...\n");
+    return Data_Wrap_Struct(rb_cAudioStream, 0, 0, stream);
+}
+
+VALUE build_audio_stream(AVStream *stream, VALUE rb_media) {
+    //printf("Stream building...\n");
+    VALUE rb_stream = Data_Wrap_Struct(rb_cAudioStream, 0, 0, stream);
+    //printf("Stream wrapped\n");
+    return audio_stream_init(rb_stream, rb_media);
+}
+
+void Init_audio_stream() {
+    rb_cAudioStream = rb_define_class_under(rb_mStreams, "Audio", rb_cStream);
+
+    rb_define_method(rb_cAudioStream, "sample_rate",  stream_sample_rate, 0);
+}

data/ext/puremotion/extconf.rb

@@ -0,0 +1,34 @@
+require 'mkmf'
+
+if find_executable('pkg-config')
+  $CFLAGS << ' ' + `pkg-config libavfilter --cflags`.strip
+  $CFLAGS << ' ' + `pkg-config libavcodec --cflags`.strip
+  $CFLAGS << ' ' + `pkg-config libavutil --cflags`.strip
+  $CFLAGS << ' ' + `pkg-config libswscale --cflags`.strip
+  $LDFLAGS << ' ' + `pkg-config libavfilter --libs`.strip
+  $LDFLAGS << ' ' + `pkg-config libavcodec --libs`.strip
+  $LDFLAGS << ' ' + `pkg-config libavutil --libs`.strip
+  $LDFLAGS << ' ' + `pkg-config libswscale --libs`.strip
+  $LDFLAGS << ' ' + `pkg-config libgd --libs`.strip
+end
+
+ffmpeg_include, ffmpeg_lib = dir_config("ffmpeg")
+dir_config("libswscale")
+
+$CFLAGS << " -W -Wall -static"
+#$LDFLAGS << " -rpath #{ffmpeg_lib}"
+
+if have_library("avformat") and find_header('libavformat/avformat.h') and
+   have_library("avcodec") and find_header('libavutil/avutil.h') and
+   have_library("avutil") and find_header('libavcodec/avcodec.h') and
+   have_library("swscale") and find_header('libswscale/swscale.h') and
+   have_library("gd") and find_header('gd.h') then
+
+$objs = %w(puremotion.o media.o stream_collection.o stream.o video.o audio.o utils.o frame.o)
+
+create_makefile("puremotion_native")
+
+else
+  STDERR.puts "missing library"
+  exit 1
+end

data/ext/puremotion/frame.c

@@ -0,0 +1,176 @@
+#include "puremotion.h"
+#include "utils.h"
+
+VALUE rb_cFrame;
+
+static AVFrame * alloc_picture(int pix_fmt, int width, int height) {
+    AVFrame *picture;
+    uint8_t *picture_buf;
+    int size;
+
+    picture = avcodec_alloc_frame();
+    if (!picture)
+        return NULL;
+    size = avpicture_get_size(pix_fmt, width, height);
+    picture_buf = av_malloc(size);
+    if (!picture_buf) {
+        av_free(picture);
+        return NULL;
+    }
+    avpicture_fill((AVPicture *)picture, picture_buf,
+        pix_fmt, width, height);
+    return picture;
+}
+
+static VALUE frame_to_rgb24(VALUE self) {
+    int width = NUM2INT(rb_iv_get(self, "@width"));
+    int height = NUM2INT(rb_iv_get(self, "@height"));
+    int pixel_format = NUM2INT(rb_iv_get(self, "@pixel_format"));
+
+    struct SwsContext *img_convert_ctx = NULL;
+    img_convert_ctx = sws_getContext(width, height, pixel_format,
+        width, height, PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL, NULL);
+
+    AVFrame * from = get_frame(self);
+    AVFrame * to = alloc_picture(PIX_FMT_RGB24, width, height);
+
+    sws_scale(img_convert_ctx, from->data, from->linesize,
+        0, height, to->data, to->linesize);
+
+    av_free(img_convert_ctx);
+
+    return build_frame_object(to, width, height, PIX_FMT_RGB24);
+}
+
+
+
+static VALUE frame_to_ppm(VALUE self) {
+    VALUE rb_frame = frame_to_rgb24(self);
+    AVFrame * frame = get_frame(rb_frame);
+
+    int width = NUM2INT(rb_iv_get(self, "@width"));
+    int height = NUM2INT(rb_iv_get(self, "@height"));
+
+    char header[255];
+    sprintf(header, "P6\n%d %d\n255\n", width, height);
+
+    int size = strlen(header) + frame->linesize[0] * height;
+    char * data_string = malloc(size);
+    strcpy(data_string, header);
+
+    memcpy(data_string + strlen(header), frame->data[0], frame->linesize[0] * height);
+
+    return rb_str_new(data_string, size);
+}
+
+static VALUE frame_resize(VALUE self, VALUE w, VALUE h) {
+
+    int orig_width = NUM2INT(rb_iv_get(self, "@width"));
+    int orig_height = NUM2INT(rb_iv_get(self, "@height"));
+
+    int new_width = NUM2INT(w);
+    int new_height = NUM2INT(h);
+
+    int pixel_format = NUM2INT(rb_iv_get(self, "@pixel_format"));
+
+    struct SwsContext *img_convert_ctx = NULL;
+    img_convert_ctx = sws_getContext(orig_width, orig_height, pixel_format,
+        new_width, new_height, PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL, NULL);
+
+    AVFrame * from = get_frame(self);
+    AVFrame * to = alloc_picture(PIX_FMT_RGB24, new_width, new_height);
+
+    sws_scale(img_convert_ctx, from->data, from->linesize,
+        0, orig_height, to->data, to->linesize);
+
+    av_free(img_convert_ctx);
+
+    return build_frame_object(to, new_width, new_height, PIX_FMT_RGB24);
+    
+}
+
+static VALUE frame_save(VALUE self, VALUE filename) {
+
+    int w = NUM2INT(rb_iv_get(self, "@width"));
+    int h = NUM2INT(rb_iv_get(self, "@height"));
+
+    gdImagePtr img = gdImageCreateTrueColor(w, h);
+
+    AVFrame *frame = get_frame(self);
+
+    int x, y;
+
+    // Copy pixel by pixel...
+    for( x = 0; x <= w; x++ ) {
+        for( y = 0; y <= h; y++ ) {
+
+            int off = (y * frame->linesize[0])+(3*x);
+            int red = frame->data[0][off];
+            int green = frame->data[0][off + 1];
+            int blue = frame->data[0][off + 2];
+            
+            int c = gdImageColorAllocate(img,
+                red,
+                green,
+                blue
+            );
+            
+            gdImageSetPixel(img, x, y, c);
+        }
+    }
+
+    FILE *f = fopen(StringValuePtr(filename), "wb");
+    gdImagePng(img, f);
+    fclose(f);
+
+    // Gone forever....
+    gdImageDestroy(img);
+
+    return self;
+
+}
+
+static void free_frame(AVFrame * frame) {
+    //fprintf(stderr, "will free frame\n");
+    av_free(frame);
+}
+
+static VALUE alloc_frame(VALUE klass) {
+    AVFrame * frame = avcodec_alloc_frame();
+    VALUE obj;
+    obj = Data_Wrap_Struct(klass, 0, free_frame, frame);
+    return obj;
+}
+
+static VALUE frame_init(VALUE self, VALUE width, VALUE height, VALUE pixel_format) {
+    //fprintf(stderr, "new frame : %dx%d, pix:%d\n", NUM2INT(width), NUM2INT(height), NUM2INT(pixel_format));
+    rb_iv_set(self, "@width", width);
+    rb_iv_set(self, "@height", height);
+    rb_iv_set(self, "@pixel_format", pixel_format);
+    return self;
+}
+
+VALUE build_frame_object(AVFrame * frame, int width, int height, int pixel_format) {
+    VALUE obj = Data_Wrap_Struct(rb_cFrame, 0, free_frame, frame);
+
+    return frame_init(obj,
+        INT2FIX(width),
+        INT2FIX(height),
+        INT2FIX(pixel_format));
+}
+
+void Init_frame() {
+    rb_cFrame = rb_define_class_under(rb_mPureMotion, "Frame", rb_cObject);
+
+    rb_define_alloc_func(rb_cFrame, alloc_frame);
+    rb_define_method(rb_cFrame, "initialize", frame_init, 3);
+
+    rb_funcall(rb_cFrame, rb_intern("attr_reader"), 1, rb_sym("width"));
+    rb_funcall(rb_cFrame, rb_intern("attr_reader"), 1, rb_sym("height"));
+    rb_funcall(rb_cFrame, rb_intern("attr_reader"), 1, rb_sym("pixel_format"));
+
+    rb_define_method(rb_cFrame, "to_rgb24", frame_to_rgb24, 0);
+    rb_define_method(rb_cFrame, "to_ppm", frame_to_ppm, 0);
+    rb_define_method(rb_cFrame, "resize", frame_resize, 2);
+    rb_define_method(rb_cFrame, "save", frame_save, 1);
+}

data/ext/puremotion/media.c

@@ -0,0 +1,175 @@
+#include "puremotion.h"
+#include "utils.h"
+
+VALUE rb_cMedia;
+VALUE rb_cStreamCollection;
+VALUE rb_eUnsupportedFormat;
+
+/* call-seq: filename => String
+ *
+ * Returns the path to the file encapsulated by this instance of the media class
+ *
+ * @return [String]
+ *
+ */
+static VALUE media_filename(VALUE self) {
+    AVFormatContext * format_context = get_format_context(self);
+    if( format_context->filename == NULL ) return Qnil;
+    return rb_funcall(rb_cFile, rb_intern("expand_path"), 1, rb_str_new2(format_context->filename));
+}
+
+/* call-seq: streams => Array<PureMotion::Streams::Stream>
+ *
+ * Collection of streams in the media
+ *
+ * @return [Array<PureMotion::Streams::Stream>]
+ */
+static VALUE media_streams(VALUE self) {
+
+    return build_stream_collection(self);
+
+}
+
+/* call-seq: bitrate => Number
+ *
+ * Media bitrate in bytes/sec
+ *
+ * @return [Number]
+ */
+static VALUE media_bitrate(VALUE self) {
+    AVFormatContext * format_context = get_format_context(self);
+    return INT2NUM( format_context->bit_rate );
+}
+
+/* call-seq: duration => Float
+ *
+ * Media duration in seconds
+ *
+ * @return [Float]
+ */
+static VALUE media_duration(VALUE self) {
+    AVFormatContext * format_context = get_format_context(self);
+
+    if (format_context->duration == AV_NOPTS_VALUE) return Qnil;
+
+    return rb_float_new(format_context->duration / (double)AV_TIME_BASE);
+}
+
+/* call-seq: duration_human => String
+ *
+ * Formatted human-readable duration string
+ *
+ * @return [String]
+ */
+static VALUE media_duration_human(VALUE self) {
+    AVFormatContext * format_context = get_format_context(self);
+
+    if (format_context->duration == AV_NOPTS_VALUE) return Qnil;
+
+    int hours, mins, secs, us;
+    char cstr[64] = "";
+
+    secs = format_context->duration / AV_TIME_BASE;
+    us = format_context->duration % AV_TIME_BASE;
+    mins = secs / 60;
+    secs %= 60;
+    hours = mins / 60;
+    mins %= 60;
+    sprintf(cstr, "%02d:%02d:%02d.%01d", hours, mins, secs,
+           (10 * us) / AV_TIME_BASE);
+
+    return rb_str_new2(cstr);
+}
+
+// Determines if the file can be read and processed
+// @return [Boolean]
+static VALUE media_valid(VALUE self) {
+    return rb_iv_get(self, "@valid");
+}
+
+/* call-seq: initialize(String) => Media
+ * 
+ * Loads a media file
+ *
+ * @param [String] file Path to a media file to load
+ */
+static VALUE media_init(VALUE self, VALUE file) {
+
+
+    AVFormatContext *fmt_ctx = get_format_context(self);
+
+    AVFormatParameters fp, *ap = &fp;
+
+    memset(ap, 0, sizeof(fp));
+
+    ap->prealloced_context = 1;
+    ap->width = 0;
+    ap->height = 0;
+    ap->pix_fmt = PIX_FMT_NONE;
+
+    if( rb_funcall(rb_cFile, rb_intern("file?"), 1, file) == Qfalse )
+        rb_raise(rb_eArgError, "File not found '%s'", StringValuePtr(file));
+
+    int error = av_open_input_file(&fmt_ctx, StringValuePtr(file), NULL, 0, ap);
+
+    if( error < 0 ) {
+        rb_raise(rb_eUnsupportedFormat, "File '%s' unable to be opened. Unsupported format.", StringValuePtr(file));
+        rb_iv_set(self, "@valid", Qfalse);
+        return Qnil;
+    }
+
+    error = av_find_stream_info(fmt_ctx);
+
+    if( error < 0 ) {
+        rb_raise(rb_eUnsupportedFormat, "File '%s': Streams are unreadable.", StringValuePtr(file));
+        rb_iv_set(self, "@valid", Qfalse);
+    }
+
+    rb_iv_set(self, "@valid", Qtrue);
+
+    return self;
+    
+}
+
+static void free_media(AVFormatContext *fmt_ctx) {
+    if ( fmt_ctx == NULL) return;
+    int i;
+    
+    rb_funcall(rb_mKernel, "puts", 1, INT2NUM(fmt_ctx->nb_streams));
+
+    for(i = 0; i < fmt_ctx->nb_streams; i++) {
+        if( fmt_ctx->streams[i]->codec->codec != NULL )
+            avcodec_close(fmt_ctx->streams[i]->codec);
+    }
+    
+    if( fmt_ctx->iformat ) av_close_input_file(fmt_ctx);
+    else av_free(fmt_ctx);
+}
+
+static VALUE alloc_media(VALUE self) {
+    AVFormatContext * fmt_ctx = av_alloc_format_context();
+    VALUE obj;
+    fmt_ctx->oformat = NULL;
+    fmt_ctx->iformat = NULL;
+
+    obj = Data_Wrap_Struct(self, 0, free_media, fmt_ctx);
+    return obj;
+}
+
+void Init_media() {
+
+    rb_cMedia = rb_define_class_under(rb_mPureMotion, "Media", rb_cObject);
+
+    rb_define_alloc_func(rb_cMedia, alloc_media);
+    rb_define_method(rb_cMedia, "initialize", media_init, 1);
+
+    rb_define_method(rb_cMedia, "duration", media_duration, 0);
+    rb_define_method(rb_cMedia, "duration_human", media_duration_human, 0);
+    rb_define_method(rb_cMedia, "bitrate", media_bitrate, 0);
+    rb_define_method(rb_cMedia, "filename", media_filename, 0);
+    rb_define_method(rb_cMedia, "streams", media_streams, 0);
+    rb_define_method(rb_cMedia, "valid?", media_valid, 0);
+
+    rb_eUnsupportedFormat = rb_define_class_under(rb_mPureMotion, "UnsupportedFormat", rb_eStandardError);
+
+}