puremotion 0.0.1 → 0.1.0

data/ext/puremotion/puremotion.c

@@ -0,0 +1,26 @@
+#include "puremotion.h"
+
+VALUE rb_mPureMotion;
+VALUE rb_mStreams;
+
+void Init_puremotion_native() {
+
+    av_register_all();
+    avcodec_register_all();
+
+    // Don't sent all output into ruby interpreter
+    // This will eventually be changed by calling av_log_callback
+    // If you want to develop it's best you set this to AV_LOG_VERBOSE
+    av_log_set_level(AV_LOG_QUIET);
+
+    rb_mPureMotion = rb_define_module("PureMotion");
+    rb_mStreams = rb_define_module_under(rb_mPureMotion, "Streams");
+
+    Init_media();
+    Init_stream();
+    Init_video_stream();
+    Init_audio_stream();
+    Init_stream_collection();
+    Init_frame();
+
+}

data/ext/puremotion/puremotion.h

@@ -0,0 +1,38 @@
+#include <libavformat/avformat.h>
+#include <libavutil/avutil.h>
+#include <libavcodec/avcodec.h>
+#include <libswscale/swscale.h>
+#include <gd.h>
+
+#ifdef RSHIFT
+#undef RSHIFT
+#endif
+
+#define DEBUG
+
+#include "ruby.h"
+
+RUBY_EXTERN VALUE rb_mPureMotion;
+RUBY_EXTERN VALUE rb_mStreams;
+RUBY_EXTERN VALUE rb_cMedia;
+RUBY_EXTERN VALUE rb_cStream;
+RUBY_EXTERN VALUE rb_cVideoStream;
+RUBY_EXTERN VALUE rb_cAudioStream;
+RUBY_EXTERN VALUE rb_cStreamCollection;
+RUBY_EXTERN VALUE rb_cFrame;
+
+RUBY_EXTERN VALUE rb_eUnsupportedFormat;
+
+RUBY_EXTERN void Init_puremotion_native();
+RUBY_EXTERN void Init_media();
+RUBY_EXTERN void Init_stream();
+RUBY_EXTERN void Init_video_stream();
+RUBY_EXTERN void Init_audio_stream();
+RUBY_EXTERN void Init_stream_collection();
+RUBY_EXTERN void Init_frame();
+
+VALUE build_stream_collection(VALUE media);
+VALUE build_stream(AVStream *stream, VALUE rb_media);
+VALUE build_video_stream(AVStream *stream, VALUE rb_media);
+VALUE build_audio_stream(AVStream *stream, VALUE rb_media);
+VALUE build_frame_object(AVFrame * frame, int width, int height, int pixel_format);

data/ext/puremotion/stream.c

@@ -0,0 +1,128 @@
+#include "puremotion.h"
+#include "utils.h"
+
+VALUE rb_cStream;
+VALUE rb_mStreams;
+
+static int next_packet(AVFormatContext * format_context, AVPacket * packet)
+{
+    if(packet->data != NULL)
+        av_free_packet(packet);
+
+    if(av_read_frame(format_context, packet) < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+static int next_packet_for_stream(AVFormatContext * format_context, int stream_index, AVPacket * packet)
+{
+    int ret = 0;
+    do {
+        ret = next_packet(format_context, packet);
+    } while(packet->stream_index != stream_index && ret == 0);
+
+    return ret;
+}
+
+static VALUE stream_type( VALUE self ) {
+    AVStream * stream = get_stream(self);
+
+    VALUE type = rb_sym("unknown");
+
+    switch( stream->codec->codec_type ) {
+        case CODEC_TYPE_AUDIO:
+            type = rb_sym("audio");
+        break;
+        case CODEC_TYPE_VIDEO:
+            type = rb_sym("video");
+        break;
+    }
+
+    return type;
+
+}
+
+static VALUE stream_duration(VALUE self) {
+    AVStream *stream = get_stream(self);
+
+    if (stream->duration == AV_NOPTS_VALUE) return Qnil;
+
+    return (rb_float_new(stream->duration * av_q2d(stream->time_base)));
+}
+
+static VALUE stream_seek(VALUE self, VALUE position) {
+    AVFormatContext * format_context = get_format_context(rb_iv_get(self, "@media"));
+    AVStream * stream = get_stream(self);
+
+    int64_t timestamp = NUM2LONG(position) / av_q2d(stream->time_base);
+
+    int ret;
+    if (format_context->start_time != AV_NOPTS_VALUE)
+        timestamp += format_context->start_time;
+
+    //fprintf(stderr, "seeking to %d\n", NUM2INT(position));
+    ret = av_seek_frame(format_context, stream->index, timestamp, 0);
+    if (ret < 0) {
+        rb_raise(rb_eRangeError, "could not seek %s to pos %f",
+            format_context->filename, timestamp * av_q2d(stream->time_base));
+    }
+
+    //fprintf(stderr, "seeked.\n");
+    return self;
+}
+
+static VALUE stream_bitrate(VALUE self) {
+    AVStream * stream = get_stream(self);
+
+    rb_float_new(stream->codec->bit_rate);
+}
+
+
+static VALUE stream_position(VALUE self) {
+    AVFormatContext * format_context = get_format_context(rb_iv_get(self, "@media"));
+    AVStream * stream = get_stream(self);
+    AVPacket decoding_packet;
+
+    av_init_packet(&decoding_packet);
+
+    do {
+        if(av_read_frame(format_context, &decoding_packet) < 0) {
+            rb_raise(rb_eRuntimeError, "error extracting packet");
+        }
+    } while(decoding_packet.stream_index != stream->index);
+
+    return rb_float_new(decoding_packet.pts * (double)av_q2d(stream->time_base));
+}
+
+static VALUE stream_init(VALUE self, VALUE media) {
+    //printf("Stream initialized\n");
+    rb_iv_set(self, "@media", media);
+    return self;
+}
+
+static VALUE alloc_stream(VALUE self) {
+    //printf("Stream allocating...\n");
+    AVStream * stream = av_new_stream(NULL, 0);
+    //printf("Stream wrapping...\n");
+    return Data_Wrap_Struct(rb_cStream, 0, 0, stream);
+}
+
+VALUE build_stream(AVStream *stream, VALUE rb_media) {
+    //printf("Stream building...\n");
+    VALUE rb_stream = Data_Wrap_Struct(rb_cStream, 0, 0, stream);
+    //printf("Stream wrapped\n");
+    return stream_init(rb_stream, rb_media);
+}
+
+void Init_stream() {
+    rb_cStream = rb_define_class_under(rb_mStreams, "Stream", rb_cObject);
+    rb_define_alloc_func(rb_cStream, alloc_stream);
+
+    rb_define_method(rb_cStream, "type",  stream_type, 0);
+    rb_define_method(rb_cStream, "duration",  stream_duration, 0);
+    rb_define_method(rb_cStream, "bitrate",  stream_bitrate, 0);
+    rb_define_method(rb_cStream, "seek",  stream_seek, 1);
+    rb_define_method(rb_cStream, "position", stream_position, 0);
+}

data/ext/puremotion/stream_collection.c

@@ -0,0 +1,44 @@
+#include "puremotion.h"
+
+VALUE rb_cStreamCollection;
+VALUE rb_mStreams;
+
+static VALUE stream_collection_init(VALUE self) {
+
+    return self;
+
+}
+
+VALUE build_stream_collection(VALUE media) {
+
+
+    AVFormatContext *format_context = get_format_context(media);
+
+    VALUE rb_streams = rb_ary_new();
+
+    int i, stream_idx = 0;
+
+    for( i = 0; i < format_context->nb_streams; i++ ) {
+        AVStream *stream = format_context->streams[i];
+
+        VALUE rb_stream = Qnil;
+
+        if( stream->codec->codec_type == CODEC_TYPE_VIDEO ) rb_stream = build_video_stream( stream, media );
+        if( stream->codec->codec_type == CODEC_TYPE_AUDIO ) rb_stream = build_audio_stream( stream, media );
+
+        if( rb_stream != Qnil ) {
+            rb_ary_store(rb_streams, stream_idx, rb_stream);
+            stream_idx++;
+        }
+
+    }
+
+    return rb_streams;
+}
+
+void Init_stream_collection() {
+
+    rb_cStreamCollection = rb_define_class_under(rb_mStreams, "Collection", rb_cArray);
+    // rb_define_method(rb_cStreamCollection, "initialize", stream_collection_init, 1);
+
+}

data/ext/puremotion/utils.c

@@ -0,0 +1,81 @@
+#include "utils.h"
+
+AVFormatContext * get_format_context(VALUE self)
+{
+    AVFormatContext * format_context = NULL;
+    Data_Get_Struct(self, AVFormatContext, format_context);
+    if (NULL == format_context) {
+        rb_fatal("FFMPEG internal error\n");
+    }
+    return format_context;
+}
+
+AVStream * get_stream(VALUE self)
+{
+    AVStream * stream = NULL;
+    Data_Get_Struct(self, AVStream, stream);
+    if (NULL == stream) {
+        rb_fatal("FFMPEG internal error\n");
+    }
+    return stream;
+}
+
+AVCodecContext * get_codec_context(VALUE self)
+{
+    AVCodecContext * codec_context = NULL;
+    Data_Get_Struct(self, AVCodecContext, codec_context);
+    if (NULL == codec_context) {
+        rb_fatal("FFMPEG internal error\n");
+    }
+    return codec_context;
+}
+
+AVFrame * get_frame(VALUE self)
+{
+     AVFrame * frame = NULL;
+    Data_Get_Struct(self, AVFrame, frame);
+    if (NULL == frame) {
+        rb_fatal("FFMPEG internal error\n");
+    }
+    return frame;
+}
+
+VALUE rb_sym(const char *s) {
+    return rb_str_intern(rb_str_new2(s));
+}
+
+VALUE codec_type_id_to_sym(int codec_type)
+{
+    VALUE type_sym;
+    switch(codec_type) {
+        case CODEC_TYPE_AUDIO:
+            type_sym = rb_sym("audio");
+            break;
+
+        case CODEC_TYPE_VIDEO:
+            type_sym = rb_sym("video");
+            break;
+
+        case CODEC_TYPE_SUBTITLE:
+            type_sym = rb_sym("subtitle");
+            break;
+
+        case CODEC_TYPE_DATA:
+            type_sym = rb_sym("data");
+            break;
+
+        case CODEC_TYPE_ATTACHMENT:
+            type_sym = rb_sym("attachment");
+            break;
+
+        case CODEC_TYPE_NB:
+            type_sym = rb_sym("nb");
+            break;
+
+        default:
+            type_sym = rb_sym("unknown");
+            break;
+    }
+
+    return type_sym;
+}

data/ext/puremotion/utils.h

@@ -0,0 +1,6 @@
+#include "puremotion.h"
+
+AVFormatContext * get_format_context(VALUE self);
+AVStream * get_stream(VALUE self);
+AVCodecContext * get_codec_context(VALUE self);
+AVFrame * get_frame(VALUE self);

data/ext/puremotion/video.c

@@ -0,0 +1,141 @@
+#include "puremotion.h"
+#include "utils.h"
+
+VALUE rb_cStream;
+VALUE rb_cVideoStream;
+VALUE rb_mStreams;
+
+static VALUE stream_frame_rate(VALUE self) {
+    AVStream * stream = get_stream(self);
+    return(rb_float_new(av_q2d(stream->r_frame_rate)));
+}
+
+static int extract_next_frame(AVFormatContext * format_context, AVCodecContext * codec_context, int stream_index, AVFrame * frame, AVPacket * decoding_packet) {
+    // open codec to decode the video if needed
+    if (NULL == codec_context->codec) {
+            rb_fatal("codec should have already been opened");
+    }
+
+    uint8_t * databuffer;
+
+    int remaining = 0;
+    int decoded;
+    int frame_complete = 0;
+    int next;
+
+    while(!frame_complete &&
+            0 == (next = next_packet_for_stream(format_context, stream_index, decoding_packet))) {
+        // setting parameters before processing decoding_packet data
+        remaining = decoding_packet->size;
+        databuffer = decoding_packet->data;
+
+        while(remaining > 0) {
+            decoded = avcodec_decode_video(codec_context, frame, &frame_complete,
+                databuffer, remaining);
+            remaining -= decoded;
+            // pointer seek forward
+            databuffer += decoded;
+        }
+    }
+
+    return next;
+}
+
+/*
+ * call-seq: grab => PureMotion::Frame
+ *
+ *
+ *
+ */
+
+static VALUE stream_grab(VALUE self) {
+    AVFormatContext * format_context = get_format_context(rb_iv_get(self, "@media"));
+    AVStream * stream = get_stream(self);
+
+    AVCodecContext * codec_context = stream->codec;
+
+    // open codec to decode the video if needed
+    if (!codec_context->codec) {
+        AVCodec * codec = avcodec_find_decoder(codec_context->codec_id);
+        if (!codec)
+            rb_raise(rb_eRuntimeError, "error codec not found");
+        if (avcodec_open(codec_context, codec) < 0)
+            rb_raise(rb_eRuntimeError, "error while opening codec : %s", codec->name);
+    }
+
+    VALUE rb_frame = rb_funcall(rb_const_get(rb_mPureMotion, rb_intern("Frame")),
+        rb_intern("new"), 3,
+        INT2NUM(codec_context->width),
+        INT2NUM(codec_context->height),
+        INT2NUM(codec_context->pix_fmt));
+
+    AVFrame * frame = get_frame(rb_frame);
+    avcodec_get_frame_defaults(frame);
+
+    AVPacket decoding_packet;
+    av_init_packet(&decoding_packet);
+
+    if (rb_block_given_p()) {
+        int ret;
+        do {
+            ret = extract_next_frame(format_context, stream->codec,
+                stream->index, frame, &decoding_packet);
+            rb_yield(
+                rb_ary_new3(
+                    3,
+                    rb_frame,
+                    rb_float_new(decoding_packet.pts * (double)av_q2d(stream->time_base)),
+                    rb_float_new(decoding_packet.dts * (double)av_q2d(stream->time_base))
+                )
+            );
+        } while (ret == 0);
+    } else {
+        extract_next_frame(format_context, stream->codec,
+            stream->index, frame, &decoding_packet);
+        return rb_frame;
+    }
+
+    return self;
+}
+
+static VALUE stream_resolution(VALUE self, VALUE media) {
+    AVFormatContext * format_context = get_format_context(rb_iv_get(self, "@media"));
+    AVStream * stream = get_stream(self);
+
+    VALUE width = INT2NUM(stream->codec->width);
+    VALUE height = INT2NUM(stream->codec->height);
+
+    VALUE res = rb_ary_new2(2);
+    rb_ary_store(res, 0, width);
+    rb_ary_store(res, 1, height);
+
+    return res;
+}
+
+static VALUE video_stream_init(VALUE self, VALUE media) {
+    //printf("Stream initialized\n");
+    rb_iv_set(self, "@media", media);
+    return self;
+}
+
+static VALUE alloc_video_stream(VALUE self) {
+    //printf("Stream allocating...\n");
+    AVStream * stream = av_new_stream(NULL, 0);
+    //printf("Stream wrapping...\n");
+    return Data_Wrap_Struct(rb_cVideoStream, 0, 0, stream);
+}
+
+VALUE build_video_stream(AVStream *stream, VALUE rb_media) {
+    //printf("Stream building...\n");
+    VALUE rb_stream = Data_Wrap_Struct(rb_cVideoStream, 0, 0, stream);
+    //printf("Stream wrapped\n");
+    return video_stream_init(rb_stream, rb_media);
+}
+
+void Init_video_stream() {
+    rb_cVideoStream = rb_define_class_under(rb_mStreams, "Video", rb_cStream);
+
+    rb_define_method(rb_cVideoStream, "resolution", stream_resolution, 0);
+    rb_define_method(rb_cVideoStream, "frame_rate", stream_frame_rate, 0);
+    rb_define_method(rb_cVideoStream, "grab", stream_grab, 0);
+}