rmovie 0.5.0 → 0.5.1

data/ext/rmovie/quadrupel/qp_animated_gif.h

@@ -0,0 +1,36 @@
+#ifndef QP_ANIMATED_GIF_H
+#define QP_ANIMATED_GIF_H
+
+#define QP_ANIMATED_GIF_NO_LOOP -1
+#define QP_ANIMATED_GIF_INFINITE_LOOP 0
+#define QP_ANIMATED_GIF_MAX_LOOP_COUNT 65535
+
+#define QP_ANIMATED_GIF_STATE_UNOPENED -1 
+#define QP_ANIMATED_GIF_STATE_CLOSED 0
+#define QP_ANIMATED_GIF_STATE_OPENED 1
+
+typedef struct {
+    int state;
+    AVStream *video_st;
+    AVOutputFormat *fmt;
+    AVFormatContext *fmt_ctx;
+    AVCodecContext *codec_ctx;
+
+    uint8_t *video_outbuf;
+    int video_outbuf_size;
+} qp_animated_gif_context;
+
+qp_animated_gif_context* qp_alloc_animated_gif_ctx(qp_malloc_t malloc_func);
+
+void qp_free_animated_gif_ctx(qp_animated_gif_context *qp_animated_gif, 
+        qp_free_t free_func);
+
+int qp_open_animated_gif_file(qp_animated_gif_context *qp_animated_gif, 
+        char* filename, int width, int height, int frame_rate, int loop_count);
+
+int qp_close_animated_gif_ctx(qp_animated_gif_context *qp_animated_gif);
+
+int qp_add_animated_gif_frame(qp_animated_gif_context *qp_animated_gif, 
+        qp_frame_context *frame);
+
+#endif // QP_ANIMATED_GIF_H

data/ext/rmovie/quadrupel/qp_movie.c

@@ -8,14 +8,6 @@
 #define LRINT(x) ((long) ((x)+0.5))
 #define MAX(a,b) ((a) > (b) ? (a) : (b))
 
-#if LIBAVFORMAT_BUILD > 4628
-#define GET_CODEC_FIELD(codec, field) codec->field
-#define GET_CODEC_PTR(codec) codec
-#else
-#define GET_CODEC_FIELD(codec, field) codec.field
-#define GET_CODEC_PTR(codec) &codec
-#endif
-
 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
 
 /* 
@@ -836,11 +828,11 @@ int write_audio_frame(qp_movie_context *movie_ctx, AVFormatContext *oc,
 AVStream *add_audio_stream(AVCodecContext *icodec,
         AVFormatContext *oc, int codec_id)
 {
-    AVCodecContext *c;
-    AVStream *st;
+    AVCodecContext *c = NULL;
+    AVStream *st = NULL;
 
     st = av_new_stream(oc, 1);
-    if (!st) {
+    if (st == NULL) {
         fprintf(stderr, "Could not alloc stream\n");
         return NULL;
     }
@@ -861,11 +853,11 @@ AVStream *add_audio_stream(AVCodecContext *icodec,
 static AVStream *add_video_stream(qp_movie_context *movie_ctx,
         AVFormatContext *oc, int codec_id)
 {
-    AVCodecContext *c;
-    AVStream *st;
+    AVCodecContext *c = NULL;
+    AVStream *st = NULL;
 
     st = av_new_stream(oc, 0);
-    if (!st) {
+    if (st == NULL) {
         fprintf(stderr, "Could not alloc stream\n");
         return NULL;
     }
@@ -914,16 +906,16 @@ static AVStream *add_video_stream(qp_movie_context *movie_ctx,
 
 AVFrame *alloc_picture(int pix_fmt, int width, int height)
 {
-    AVFrame *picture;
-    uint8_t *picture_buf;
-    int size;
+    AVFrame *picture = NULL;
+    uint8_t *picture_buf = NULL;
+    int size = 0;
 
     picture = avcodec_alloc_frame();
-    if (!picture)
+    if (picture == NULL)
         return NULL;
     size = avpicture_get_size(pix_fmt, width, height);
     picture_buf = (uint8_t *)malloc(size);
-    if (!picture_buf) {
+    if (picture_buf == NULL) {
         av_free(picture);
         return NULL;
     }
@@ -937,7 +929,7 @@ static int write_video_frame(qp_movie_context *movie_ctx, AVFormatContext *oc,
         AVStream *st, AVFrame *decoded_frame, int pixel_format)
 {
     int out_size, ret;
-    AVCodecContext *c;
+    AVCodecContext *c = NULL;
 
     c = st->codec;
 
@@ -1164,6 +1156,7 @@ int qp_export_movie(qp_movie_context *movie_ctx, const char *filename)
 
     /* free the streams */
     for (i = 0; i < oc->nb_streams; i++) {
+        av_freep(&oc->streams[i]->codec);
         av_freep(&oc->streams[i]);
     }
 

data/ext/rmovie/quadrupel/qp_util.h

@@ -4,6 +4,14 @@
 #include <ffmpeg/avcodec.h>
 #include <ffmpeg/avformat.h>
 
+#if LIBAVFORMAT_BUILD > 4628
+#define GET_CODEC_FIELD(codec, field) codec->field
+#define GET_CODEC_PTR(codec) codec
+#else
+#define GET_CODEC_FIELD(codec, field) codec.field
+#define GET_CODEC_PTR(codec) &codec
+#endif
+
 int quadrupel_is_installed();
 int quadrupel_init();
 int quadrupel_shutdown();
@@ -14,5 +22,4 @@ 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/{rmovie_main.c → rmovie.c}

@@ -4,14 +4,17 @@
 
 #include "rmovie_movie.h"
 #include "rmovie_frame.h"
+#include "rmovie_animated_gif.h"
 
-#define RMOVIE_VERSION "0.5"
+#define RMOVIE_VERSION "0.5.1"
 
 /* Module */
 static VALUE rb_mRMovie;
 
+/* Classes */
 VALUE rb_cMovie;
 VALUE rb_cFrame;
+VALUE rb_cAnimated_GIF;
 
 static void version_constants(void)
 {
@@ -94,6 +97,13 @@ void Init_rmovie()
     rb_define_method(rb_cFrame, "to_s", Frame_to_string, 0);
     rb_define_alias(rb_cFrame, "to_string", "to_s");
 
+    /* Animated GIF */
+    rb_cAnimated_GIF = rb_define_class_under(rb_mRMovie, "Animated_GIF", rb_cObject);
+    rb_define_alloc_func(rb_cAnimated_GIF, animated_gif_allocate);
+    rb_define_method(rb_cAnimated_GIF, "initialize", animated_gif_initialize, -1);
+    rb_define_method(rb_cAnimated_GIF, "add_frame", Animated_gif_add_frame, 1);
+    rb_define_method(rb_cAnimated_GIF, "close", Animated_gif_close, 0);
+
     version_constants();
 }
 

data/ext/rmovie/rmovie.h

@@ -0,0 +1,7 @@
+#ifndef RMOVIE_H
+#define RMOVIE_H
+
+#define ERR_IF_LESS_THAN(n, x, label) if ((x) < (n)) rb_raise(rb_eArgError, "%s must be greater than %d", label, n)
+#define ERR_IF_ODD(x, label) if ((x) % 2) rb_raise(rb_eArgError, "%s must be an even number", label)
+
+#endif // RMOVIE_H

data/ext/rmovie/rmovie_animated_gif.c

@@ -0,0 +1,101 @@
+#include <ruby.h>
+
+#include "qp_frame.h"
+#include "qp_animated_gif.h"
+
+#include "rmovie.h"
+#include "rmovie_animated_gif.h"
+#include "rmovie_frame.h"
+
+
+void mark_animated_gif_ctx(qp_animated_gif_context *animated_gif)
+{
+}
+
+
+static void rm_free_animated_gif_ctx(qp_animated_gif_context *animated_gif_ctx)
+{
+    qp_close_animated_gif_ctx(animated_gif_ctx);
+    qp_free_animated_gif_ctx(animated_gif_ctx, NULL);
+}
+
+
+VALUE wrap_animated_gif_ctx(VALUE klass, qp_animated_gif_context *animated_gif_ctx)
+{
+    return Data_Wrap_Struct (klass, mark_animated_gif_ctx, 
+            rm_free_animated_gif_ctx, animated_gif_ctx);
+}
+
+
+VALUE animated_gif_allocate(VALUE klass)
+{
+    qp_animated_gif_context* animated_gif = qp_alloc_animated_gif_ctx(NULL);
+    return wrap_animated_gif_ctx(klass, animated_gif);
+}
+
+
+VALUE animated_gif_initialize(int argc, VALUE *argv, VALUE self)
+{
+    qp_animated_gif_context *animated_gif_ctx;
+    int width, height, frame_rate, loop_count;
+    VALUE vfilename, vwidth, vheight, vframe_rate, vloop_count;
+    char* filename;
+
+    rb_scan_args(argc, argv, "41", &vfilename, &vwidth, &vheight, &vframe_rate, &vloop_count);
+
+    Check_Type(vfilename, T_STRING);
+    Check_Type(vwidth, T_FIXNUM);
+    Check_Type(vheight, T_FIXNUM);
+    Check_Type(vframe_rate, T_FIXNUM);
+
+
+    if (RTEST(vloop_count)) {
+        Check_Type(vloop_count, T_FIXNUM);
+        loop_count = NUM2INT(vloop_count);
+    } else {
+        loop_count = QP_ANIMATED_GIF_NO_LOOP;
+    }
+
+    width = NUM2UINT(vwidth);
+    height = NUM2UINT(vheight);
+    frame_rate = NUM2UINT(vframe_rate);
+    
+    ERR_IF_LESS_THAN(1, width, "width");
+    ERR_IF_ODD(width, "width");
+    ERR_IF_LESS_THAN(1, height, "height");
+    ERR_IF_ODD(height, "height");
+    ERR_IF_LESS_THAN(1, frame_rate, "frame rate");
+
+    Data_Get_Struct(self, qp_animated_gif_context, animated_gif_ctx);
+
+    SafeStringValue(vfilename);
+    if (qp_open_animated_gif_file(animated_gif_ctx, StringValueCStr(vfilename),
+                width, height, frame_rate, loop_count)) {
+        rb_sys_fail(filename);
+    }
+
+    return self;
+}
+
+
+VALUE Animated_gif_add_frame(VALUE self, VALUE frame)
+{
+    qp_animated_gif_context *animated_gif_ctx;
+    qp_frame_context *frame_ctx;
+
+    Data_Get_Struct(self, qp_animated_gif_context, animated_gif_ctx);
+
+    Data_Get_Struct(frame, qp_frame_context, frame_ctx);
+
+    qp_add_animated_gif_frame(animated_gif_ctx, frame_ctx);
+}
+
+
+VALUE Animated_gif_close(VALUE self)
+{
+    qp_animated_gif_context *animated_gif_ctx;
+
+    Data_Get_Struct(self, qp_animated_gif_context, animated_gif_ctx);
+
+    qp_close_animated_gif_ctx(animated_gif_ctx);
+}

data/ext/rmovie/rmovie_animated_gif.h

@@ -0,0 +1,6 @@
+
+// Methods
+VALUE animated_gif_allocate(VALUE klass);
+VALUE animated_gif_initialize(int argc, VALUE *argv, VALUE self);
+VALUE Animated_gif_add_frame(VALUE self, VALUE frame);
+VALUE Animated_gif_close(VALUE self);

data/ext/rmovie/rmovie_frame.c

@@ -1,9 +1,12 @@
 #include <ruby.h>
 
 #include "qp_frame.h"
+#include "rmovie.h"
 #include "rmovie_frame.h"
 
-void mark_frame_ctx(qp_frame_context *frame) {}
+void mark_frame_ctx(qp_frame_context *frame) 
+{
+}
 
 static void rm_free_frame_ctx(qp_frame_context *frame) {
     qp_free_frame_ctx(frame, NULL);
@@ -63,161 +66,82 @@ VALUE Frame_get_height(VALUE self)
     return rb_int_new(qp_get_frame_height(frame_ctx));
 }
 
-
-VALUE Frame_crop(int argc, VALUE *argv, VALUE self)
+VALUE Frame_crop(VALUE self, VALUE crop_top, VALUE crop_bottom, 
+        VALUE crop_left, VALUE crop_right)
 {
     qp_frame_context *frame_ctx = NULL;
-    int crop_top = 0, crop_bottom = 0, crop_left = 0, crop_right = 0;
+    int top = 0, bottom = 0, left = 0, right = 0;
+
+    Data_Get_Struct(self, qp_frame_context, frame_ctx);
+
+    Check_Type(crop_top, T_FIXNUM); 
+    Check_Type(crop_bottom, T_FIXNUM); 
+    Check_Type(crop_left, T_FIXNUM); 
+    Check_Type(crop_right, T_FIXNUM); 
+
+    top = FIX2UINT(crop_top);
+    bottom = FIX2UINT(crop_bottom);
+    left = FIX2UINT(crop_left);
+    right = FIX2UINT(crop_right);
 
     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;;
-    } 
+    ERR_IF_LESS_THAN(1, top, "crop top"); 
+    ERR_IF_ODD(top, "crop top"); 
+    ERR_IF_LESS_THAN(1, bottom, "crop bottom"); 
+    ERR_IF_ODD(bottom, "crop bottom"); 
+    ERR_IF_LESS_THAN(1, right, "crop right"); 
+    ERR_IF_ODD(right, "crop right"); 
+    ERR_IF_LESS_THAN(1, left, "crop left"); 
+    ERR_IF_ODD(left, "crop left"); 
 
     /* crop frame */
-    qp_crop_frame(frame_ctx, crop_top, crop_bottom, crop_left, crop_right);
+    qp_crop_frame(frame_ctx, right, right, left, right);
 
     return Qtrue;
 }
 
 
-VALUE Frame_resize(int argc, VALUE *argv, VALUE self)
+VALUE Frame_resize(VALUE self, VALUE wanted_width, VALUE wanted_height)
 {
     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;
+    int width = 0, height = 0;
 
+    Check_Type(wanted_width, T_FIXNUM); 
+    Check_Type(wanted_height, T_FIXNUM); 
+    
+    width = FIX2UINT(wanted_width);
+    height = FIX2UINT(wanted_height);
+ 
     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;
-    } 
+    ERR_IF_LESS_THAN(1, height, "height"); 
+    ERR_IF_ODD(height, "height"); 
+    ERR_IF_LESS_THAN(1, width, "width"); 
+    ERR_IF_ODD(width, "width"); 
+
+    /* bounds check wanted height */
+    if (height < 1) {
+        rb_raise(rb_eArgError, "frame height must be greater than zero");
+    }
+
+    /* wanted height must be even number for quadrupel resample */
+    if (height % 2) {
+        rb_raise(rb_eArgError, "frame height must be an even number.");
+    }
+
+    /* bounds check wanted width */
+    if (width < 1) {
+        rb_raise(rb_eArgError, "frame width must be greater than zero");
+    }
+
+    /* wanted width must be even number for quadrupel resample */
+    if (width % 2) {
+        rb_raise(rb_eArgError, "frame width must be an even number.");
+    }
 
     /* resize frame */
-    qp_resample_frame(frame_ctx, wanted_width, wanted_height, 
-            crop_top, crop_bottom, crop_left, crop_right);
+    qp_resample_frame(frame_ctx, width, height, 0, 0, 0, 0);
 
     return Qtrue;
 }
@@ -226,7 +150,7 @@ VALUE Frame_resize(int argc, VALUE *argv, VALUE self)
 VALUE Frame_to_string(VALUE self) {
     qp_frame_context *frame_ctx = NULL;
     unsigned char *frame_as_string = NULL;
-    int frame_size = 0;
+    unsigned int frame_size = 0;
 
     Data_Get_Struct(self, qp_frame_context, frame_ctx);