rmovie 0.5.0

data/ext/rmovie/quadrupel/qp_movie.h

@@ -0,0 +1,81 @@
+#ifndef QP_MOVIE_H
+#define QP_MOVIE_H
+
+#include <ffmpeg/avcodec.h>
+#include <ffmpeg/avformat.h>
+
+#include "qp_util.h"
+#include "qp_frame.h"
+
+#define QP_FRAME_BASED 0
+#define QP_TIME_BASED 1
+
+typedef struct {
+    AVFormatContext *fmt_ctx;
+    AVCodecContext *codec_ctx[MAX_STREAMS];
+    int64_t last_pts;
+    int frame_number; /* only valid in time based movies */
+    int mode; 
+    offset_t last_file_pos;
+
+    /* qp_export_movie context stuff */
+
+    /* Video buffer */
+    uint8_t *video_outbuf;
+    int video_outbuf_size;
+
+    /* Audio buffer */
+    int16_t *audio_samples;
+    unsigned int audio_samples_size;
+
+    uint8_t *audio_outbuf;
+    int audio_outbuf_size;
+    int audio_input_frame_size;
+
+    /* User defined. */
+    void* user_defined;
+
+    /* Hack for php until I fix it up to use 'user_defined' */
+    long udef_long;
+} qp_movie_context;
+
+void qp_free_movie_ctx(qp_movie_context *movie_ctx, qp_free_t free_func);
+qp_movie_context* qp_alloc_movie_ctx();
+int qp_open_movie_file(qp_movie_context *movie_ctx, const char* filename);
+
+float qp_get_frame_rate(qp_movie_context *movie_ctx);
+float qp_get_duration(qp_movie_context *movie_ctx);
+long qp_get_frame_count(qp_movie_context *movie_ctx);
+char* qp_get_file_name(qp_movie_context *movie_ctx);
+
+/* mp3 metadata accessors */
+char* qp_get_comment(qp_movie_context *movie_ctx);
+char* qp_get_title(qp_movie_context *movie_ctx);
+char* qp_get_author(qp_movie_context *movie_ctx);
+char* qp_get_copyright(qp_movie_context *movie_ctx);
+char* qp_get_album(qp_movie_context *movie_ctx);
+char* qp_get_genre(qp_movie_context *movie_ctx);
+int qp_get_year(qp_movie_context *movie_ctx);
+int qp_get_track(qp_movie_context *movie_ctx);
+
+int qp_get_movie_width(qp_movie_context *movie_ctx);
+int qp_get_movie_height(qp_movie_context *movie_ctx);
+long qp_get_current_frame_number(qp_movie_context *movie_ctx);
+const char* qp_get_movie_pixel_format_name(qp_movie_context *movie_ctx);
+int qp_get_bit_rate(qp_movie_context *movie_ctx);
+const char* qp_get_codec_name(qp_movie_context *movie_ctx, int type);
+int qp_has_audio(qp_movie_context *movie_ctx);
+int qp_has_video(qp_movie_context *movie_ctx);
+int qp_get_num_audio_channels(qp_movie_context *movie_ctx);
+double qp_get_pixel_aspect_ratio(qp_movie_context *movie_ctx);
+int qp_export_movie(qp_movie_context *movie_ctx, const char *filename);
+int qp_get_codec_sample_rate(qp_movie_context *movie_ctx, int type);
+int qp_get_codec_bit_rate(qp_movie_context *movie_ctx, int type);
+
+
+#define QP_GETFRAME_KEYFRAME -1
+#define QP_GETFRAME_NEXTFRAME 0
+int qp_get_frame(qp_movie_context *movie_ctx, int wanted_frame,
+        qp_frame_context **frame_ctx_handle);
+
+#endif /* QP_MOVIE_H */

data/ext/rmovie/quadrupel/qp_util.c

@@ -0,0 +1,27 @@
+#include "qp_util.h"
+
+int quadrupel_is_installed() {
+    return 0;
+}
+
+int quadrupel_init() {
+    /* must be called before using avcodec libraries. */
+    avcodec_init();
+
+    /* register all codecs */
+    av_register_all();
+    return 0;
+}
+
+int quadrupel_shutdown() {
+    av_free_static();
+    return 0;
+}
+
+long qp_avcodec_version() {
+    return avcodec_version();
+}
+
+long qp_avcodec_build() {
+    return avcodec_build();
+}

data/ext/rmovie/quadrupel/qp_util.h

@@ -0,0 +1,18 @@
+#ifndef QUADRUPEL_H
+#define QUADRUPEL_H
+
+#include <ffmpeg/avcodec.h>
+#include <ffmpeg/avformat.h>
+
+int quadrupel_is_installed();
+int quadrupel_init();
+int quadrupel_shutdown();
+
+long qp_avcodec_version();
+long qp_avcodec_build();
+
+typedef void *(*qp_malloc_t)(size_t length);
+typedef void (*qp_free_t)(void* ptr);
+
+
+#endif /* QUADRUPEL_H */

data/ext/rmovie/quadrupel/test.c

@@ -0,0 +1,60 @@
+#include "quadrupel.h"
+#include "movie.h"
+#include "frame.h"
+
+int main(int argc, char **argv)
+{
+    char *filename = NULL;
+    movie_context *movie_ctx = NULL; 
+    frame_context *frame_ctx = NULL;
+    int i = 0;
+    int err = 0;
+
+    if (argc != 2) {
+        return -1;
+    }
+
+    filename = argv[1];
+
+    // must be called before using any other quadrupel functions
+    quadrupel_init();
+
+    movie_ctx = alloc_movie_ctx();
+
+    err = open_movie_file(movie_ctx, filename);
+
+    if (err) {
+        printf("Error opening file '%s' Errno: %d\n", filename, err);
+        return err;
+    }
+
+    if (has_video(movie_ctx)) {
+        char *frame_string;
+
+        for (i = 1; i <= 8; i++) {
+            printf("Frame: %d\n", i);
+
+            frame_ctx = get_frame(movie_ctx, i);
+            if (frame_ctx == NULL) {
+                printf("oops!\n");
+                exit(-1);
+            }
+
+            output_as_string(frame_ctx, &frame_string);
+
+            printf("dimensions w:%d h:%d\n", get_frame_width(frame_ctx),
+                    get_frame_height(frame_ctx));
+            crop_frame(frame_ctx, 4, 4, 4, 4);
+
+            free(frame_string);
+
+            free_frame_ctx(frame_ctx);
+        }
+
+    }
+
+    //export(movie_ctx, "out.flv");
+    free_movie_ctx(movie_ctx);
+    
+    return 0;
+}

data/ext/rmovie/rmovie_frame.c

@@ -0,0 +1,236 @@
+#include <ruby.h>
+
+#include "qp_frame.h"
+#include "rmovie_frame.h"
+
+void mark_frame_ctx(qp_frame_context *frame) {}
+
+static void rm_free_frame_ctx(qp_frame_context *frame) {
+    qp_free_frame_ctx(frame, NULL);
+}
+
+
+VALUE wrap_frame_ctx(VALUE klass, qp_frame_context *frame)
+{
+    return Data_Wrap_Struct (klass, mark_frame_ctx, 
+            rm_free_frame_ctx, frame);
+}
+
+
+VALUE frame_allocate(VALUE klass)
+{
+    qp_frame_context* frame = qp_alloc_frame_ctx(NULL);
+    return wrap_frame_ctx(klass, frame);
+}
+
+
+VALUE Frame_get_presentation_timestamp(VALUE self)
+{
+    qp_frame_context *frame_ctx = NULL;
+
+    Data_Get_Struct(self, qp_frame_context, frame_ctx);
+    
+    return rb_float_new((double)qp_get_pts(frame_ctx));
+}
+
+
+VALUE Frame_is_key_frame(VALUE self)
+{
+    qp_frame_context *frame_ctx = NULL;
+
+    Data_Get_Struct(self, qp_frame_context, frame_ctx);
+ 
+    return qp_frame_is_keyframe(frame_ctx) ? Qtrue : Qfalse; 
+}
+
+
+VALUE Frame_get_width(VALUE self)
+{
+    qp_frame_context *frame_ctx = NULL;
+
+    Data_Get_Struct(self, qp_frame_context, frame_ctx);
+    
+    return rb_int_new(qp_get_frame_width(frame_ctx));
+}
+
+
+VALUE Frame_get_height(VALUE self)
+{
+    qp_frame_context *frame_ctx = NULL;
+
+    Data_Get_Struct(self, qp_frame_context, frame_ctx);
+    
+    return rb_int_new(qp_get_frame_height(frame_ctx));
+}
+
+
+VALUE Frame_crop(int argc, VALUE *argv, VALUE self)
+{
+    qp_frame_context *frame_ctx = NULL;
+    int crop_top = 0, crop_bottom = 0, crop_left = 0, crop_right = 0;
+
+    Data_Get_Struct(self, qp_frame_context, frame_ctx);
+
+    switch (argc) {
+        case 4:
+            if (argv[3] != Qnil) {
+
+                crop_right = argv[3];
+
+                /* crop right must be even number for quadrupel cropping */
+                if (crop_right % 2) {
+                    rb_raise(rb_eArgError, "crop right value must be even number.");
+                }
+            }
+            /* fallthru */
+        case 3:
+            if (argv[2] != Qnil) {
+                crop_left = argv[2];
+
+                /*  crop left must be even number for quadrupel cropping */
+                if (crop_left % 2) {
+                    rb_raise(rb_eArgError, "crop left valus must be even number.");
+                }
+            }
+
+            /* fallthru */
+        case 2:
+            if (argv[1] != Qnil) {
+                crop_bottom = argv[1];
+
+                /*  crop bottom must be even number for quadrupel cropping */
+                if (crop_bottom % 2) {
+                    rb_raise(rb_eArgError, "crop bottom values must be even number.");
+                }
+            }
+
+            /* fallthru */
+        case 1:
+            if (argv[0] != Qnil) {
+                crop_top = argv[0];
+
+                /*  crop top  must be even number for quadrupel cropping */
+                if (crop_top % 2) {
+                    rb_raise(rb_eArgError, "crop top value must be even number.");
+                }
+            }
+            break;
+        default:
+            rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 to 4)", argc);
+            break;;
+    } 
+
+    /* crop frame */
+    qp_crop_frame(frame_ctx, crop_top, crop_bottom, crop_left, crop_right);
+
+    return Qtrue;
+}
+
+
+VALUE Frame_resize(int argc, VALUE *argv, VALUE self)
+{
+    qp_frame_context *frame_ctx = NULL;
+    int wanted_width = 0, wanted_height = 0;
+    int crop_top = 0, crop_bottom = 0, crop_left = 0, crop_right = 0;
+
+    Data_Get_Struct(self, qp_frame_context, frame_ctx);
+
+    switch (argc) {
+        case 6:
+            if (argv[5] != Qnil) {
+                crop_right = argv[5];
+
+                /* crop right must be even number for quadrupel cropping */
+                if (crop_right % 2) {
+                    rb_raise(rb_eArgError, "crop right value must be an even number");
+                }
+            }
+
+            /* fallthru */
+        case 5:
+            if (argv[4] != Qnil) {
+                crop_left = argv[4];
+
+                /*  crop left must be even number for quadrupel cropping */
+                if (crop_left % 2) {
+                    rb_raise(rb_eArgError, "crop left value must be an even number");
+                }
+            }
+
+            /* fallthru */
+        case 4:
+            if (argv[3] != Qnil) {
+                crop_bottom = argv[3];
+
+                /*  crop bottom must be even number for quadrupel cropping */
+                if (crop_bottom % 2) {
+                    rb_raise(rb_eArgError, "crop top value must be an even number");
+                }
+            }
+
+            /* fallthru */
+        case 3:
+            if (argv[2] != Qnil) {
+                crop_top = argv[2];
+
+                /*  crop top must be even number for quadrupel cropping */
+                if (crop_top % 2) {
+                    rb_raise(rb_eArgError, "crop values must be even numbers");
+                }
+            }
+
+            /* fallthru */
+        case 2:
+            if (argv[1] != Qnil) {
+                wanted_height = argv[1];
+
+                /* bounds check wanted height */
+                if (wanted_height < 1) {
+                    rb_raise(rb_eArgError, "frame height must be greater than zero");
+                }
+
+                /* wanted height must be even number for quadrupel resample */
+                if (wanted_height % 2) {
+                    rb_raise(rb_eArgError, "frame height must be an even number.");
+                }
+            }
+        case 1:
+            if (argv[0] != Qnil) {
+                /* width arg */
+                wanted_width = argv[0];
+
+                /* bounds check wanted width */
+                if (wanted_width < 1) {
+                    rb_raise(rb_eArgError, "frame width must be greater than zero");
+                }
+
+                /* wanted width must be even number for quadrupel resample */
+                if (wanted_width % 2) {
+                    rb_raise(rb_eArgError, "frame width must be an even number.");
+                }
+            }
+            break;
+        default:
+            rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 to 6)", argc);
+            break;
+    } 
+
+    /* resize frame */
+    qp_resample_frame(frame_ctx, wanted_width, wanted_height, 
+            crop_top, crop_bottom, crop_left, crop_right);
+
+    return Qtrue;
+}
+
+
+VALUE Frame_to_string(VALUE self) {
+    qp_frame_context *frame_ctx = NULL;
+    unsigned char *frame_as_string = NULL;
+    int frame_size = 0;
+
+    Data_Get_Struct(self, qp_frame_context, frame_ctx);
+
+    frame_size = qp_output_frame_as_string(frame_ctx, &frame_as_string);
+
+    return rb_tainted_str_new(frame_as_string, frame_size);
+}

data/ext/rmovie/rmovie_frame.h

@@ -0,0 +1,10 @@
+
+// Methods
+VALUE frame_allocate(VALUE klass);
+VALUE Frame_get_width(VALUE);
+VALUE Frame_get_height(VALUE);
+VALUE Frame_resize(int argc, VALUE *argv, VALUE self);
+VALUE Frame_crop(int argc, VALUE *argv, VALUE self);
+VALUE Frame_is_key_frame(VALUE);
+VALUE Frame_get_presentation_timestamp(VALUE);
+VALUE Frame_to_string(VALUE);

data/ext/rmovie/rmovie_main.c

@@ -0,0 +1,100 @@
+#include <ruby.h>
+
+#include "qp_util.h"
+
+#include "rmovie_movie.h"
+#include "rmovie_frame.h"
+
+#define RMOVIE_VERSION "0.5"
+
+/* Module */
+static VALUE rb_mRMovie;
+
+VALUE rb_cMovie;
+VALUE rb_cFrame;
+
+static void version_constants(void)
+{
+    const char *rmovie_version;
+    volatile VALUE str;
+    char long_version[1000];
+
+    rmovie_version = RMOVIE_VERSION;
+
+    str = rb_str_new2(rmovie_version);
+    rb_obj_freeze(str);
+    rb_define_const(rb_mRMovie, "Version", str);
+
+    sprintf(long_version,
+        "This is rmovie %s. Copyright (C) 2006 by Todd Kirby\n"
+        "Web page: http://rmovie.rubyforge.org\n"
+        "Email: ffmpeg.php@gmail.com\n",
+        rmovie_version);
+
+    str = rb_str_new2(long_version);
+    rb_obj_freeze(str);
+    rb_define_const(rb_mRMovie, "Long_version", str);
+
+}
+
+
+void Init_rmovie()
+{
+    rb_mRMovie = rb_define_module("RMovie");
+
+    /* Must be called before using any quadrupal functions */
+    quadrupel_init();
+
+    /* Movie */
+    rb_cMovie = rb_define_class_under(rb_mRMovie, "Movie", rb_cObject);
+    rb_define_alloc_func(rb_cMovie, movie_allocate);
+    rb_define_method(rb_cMovie, "initialize", movie_initialize, 1);
+    rb_define_method(rb_cMovie, "duration", Movie_get_duration, 0);
+    rb_define_method(rb_cMovie, "frame_count", Movie_get_frame_count, 0);
+    rb_define_method(rb_cMovie, "frame_rate", Movie_get_frame_rate, 0);
+    rb_define_method(rb_cMovie, "file_name", Movie_get_file_name, 0);
+    rb_define_method(rb_cMovie, "comment", Movie_get_comment, 0);
+    rb_define_method(rb_cMovie, "title", Movie_get_title, 0);
+    rb_define_method(rb_cMovie, "author", Movie_get_author, 0);
+    rb_define_alias(rb_cMovie, "artist", "author");
+    rb_define_method(rb_cMovie, "copyright", Movie_get_copyright, 0);
+    rb_define_method(rb_cMovie, "album", Movie_get_album, 0);
+    rb_define_method(rb_cMovie, "genre", Movie_get_genre, 0);
+    rb_define_method(rb_cMovie, "year", Movie_get_year, 0);
+    rb_define_method(rb_cMovie, "track", Movie_get_track, 0);
+    rb_define_method(rb_cMovie, "frame_width", Movie_get_frame_width, 0);
+    rb_define_method(rb_cMovie, "frame_height", Movie_get_frame_height, 0);
+    rb_define_method(rb_cMovie, "frame_number", 
+            Movie_get_frame_number, 0);
+    rb_define_method(rb_cMovie, "pixel_format", Movie_get_pixel_format, 0);
+    rb_define_method(rb_cMovie, "bit_rate", Movie_get_bit_rate, 0);
+    rb_define_method(rb_cMovie, "has_audio?", Movie_has_audio, 0);
+    rb_define_method(rb_cMovie, "video_codec", Movie_get_video_codec, 0);
+    rb_define_method(rb_cMovie, "audio_codec", Movie_get_audio_codec, 0);
+    rb_define_method(rb_cMovie, "audio_channels", 
+            Movie_get_num_audio_channels, 0);
+    rb_define_method(rb_cMovie, "pixel_aspect_ratio", 
+            Movie_get_pixel_aspect_ratio, 0);
+    rb_define_alias(rb_cMovie, "aspect_ratio", "pixel_aspect_ratio");
+    rb_define_method(rb_cMovie, "frame", Movie_get_frame, -1);
+    rb_define_method(rb_cMovie, "next_key_frame", Movie_get_next_key_frame, 0);
+    rb_define_method(rb_cMovie, "export", Movie_export, 1);
+
+    /* Frame */
+    rb_cFrame = rb_define_class_under (rb_mRMovie, "Frame", rb_cObject);
+    rb_define_alloc_func(rb_cFrame, frame_allocate);
+    rb_define_method(rb_cFrame, "width", Frame_get_width, 0);
+    rb_define_method(rb_cFrame, "height", Frame_get_height, 0);
+    rb_define_method(rb_cFrame, "resize!", Frame_resize, 2);
+    rb_define_method(rb_cFrame, "crop!", Frame_crop, 4);
+    rb_define_method(rb_cFrame, "key_frame?", Frame_is_key_frame, 0);
+    rb_define_method(rb_cFrame, "presentation_timestamp",
+                Frame_get_presentation_timestamp, 0);
+    rb_define_alias(rb_cFrame, "pts", "presentation_timestamp");
+    rb_define_method(rb_cFrame, "to_s", Frame_to_string, 0);
+    rb_define_alias(rb_cFrame, "to_string", "to_s");
+
+    version_constants();
+}
+
+