rmovie 0.5.0

data/ext/rmovie/Makefile

@@ -0,0 +1,149 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /usr/lib/ruby/1.8/i686-linux
+hdrdir = $(topdir)
+VPATH = $(srcdir):$(topdir):$(hdrdir)
+prefix = $(DESTDIR)/usr
+exec_prefix = $(DESTDIR)/usr
+sitedir = $(DESTDIR)/usr/lib/ruby/site_ruby
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+docdir = $(datarootdir)/doc/$(PACKAGE)
+dvidir = $(docdir)
+datarootdir = $(prefix)/share
+archdir = $(rubylibdir)/$(arch)
+sbindir = $(exec_prefix)/sbin
+psdir = $(docdir)
+localedir = $(datarootdir)/locale
+htmldir = $(docdir)
+datadir = $(DESTDIR)/usr/share
+includedir = $(prefix)/include
+infodir = $(DESTDIR)/usr/share/info
+sysconfdir = $(DESTDIR)/etc
+mandir = $(DESTDIR)/usr/share/man
+libdir = $(DESTDIR)/usr/lib
+sharedstatedir = $(prefix)/com
+oldincludedir = $(DESTDIR)/usr/include
+pdfdir = $(docdir)
+sitearchdir = $(sitelibdir)/$(sitearch)
+bindir = $(exec_prefix)/bin
+localstatedir = $(DESTDIR)/var/lib
+sitelibdir = $(sitedir)/$(ruby_version)
+libexecdir = $(exec_prefix)/libexec
+
+CC = i686-pc-linux-gnu-gcc
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -Wl,-R -Wl,$(libdir) -L$(libdir) -L. -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+
+RUBY_EXTCONF_H = config.h
+CFLAGS   =  -fPIC -O2 -march=athlon-xp  -fPIC 
+INCFLAGS = -I. -I. -I/usr/lib/ruby/1.8/i686-linux -I. -Iquadrupel
+CPPFLAGS = -DRUBY_EXTCONF_H=\"$(RUBY_EXTCONF_H)\" 
+CXXFLAGS = $(CFLAGS) 
+DLDFLAGS =  -Lquadrupel/  
+LDSHARED = $(CC) -shared
+AR = i686-pc-linux-gnu-ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby18
+RUBY_SO_NAME = ruby18
+arch = i686-linux
+sitearch = i686-linux
+ruby_version = 1.8
+ruby = /usr/bin/ruby18
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = /bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = $(libdir)
+LIBPATH =  -L'$(libdir)' -Wl,-R'$(libdir)'
+DEFFILE = 
+
+CLEANFILES = 
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED) -lavformat -lavcodec  -ldl -lcrypt -lm   -lc -lquadrupel
+SRCS = rmovie_frame.c rmovie_movie.c rmovie_main.c
+OBJS = rmovie_frame.o rmovie_movie.o rmovie_main.o
+TARGET = rmovie
+DLLIB = $(TARGET).so
+EXTSTATIC = 
+STATIC_LIB = 
+
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).so $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.C.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $<
+
+$(DLLIB): $(OBJS)
+	@-$(RM) $@
+	$(LDSHARED) $(DLDFLAGS) $(LIBPATH) -o $@ $(OBJS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h $(RUBY_EXTCONF_H)

data/ext/rmovie/config.h

@@ -0,0 +1,3 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+#endif

data/ext/rmovie/extconf.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+require 'mkmf'
+
+dir_config("ffmpeg")
+#dir_config("quadrupel")
+
+def fail(err)
+      printf(" extconf failed: %s\n", err)
+      exit 1
+end
+
+unless have_library('avcodec', 'avcodec_init')
+      fail('need avcodec library')
+end
+
+unless have_library('avformat', 'av_register_all')
+      fail('need avformat library')
+end
+
+#unless have_library('quadrupel', 'quadrupel_init')
+#      fail('need quadrupel library')
+#end
+
+#unless have_header("qp_util.h")
+#    fail("can't find quadrupel header files")
+#end
+
+if with_config("strict") or enable_config("strict")
+    $CFLAGS += " -Wall "
+end
+
+if with_config("debug") or enable_config("debug")
+    $CFLAGS += " -g"
+end
+
+# hard code quadrupel stuff for now
+$INCFLAGS << ' ' + '-Iquadrupel'.chomp
+$LDFLAGS << ' ' + '-Lquadrupel/'.chomp
+$LIBS << ' ' + '-lquadrupel'.chomp
+
+create_header "config.h" 
+create_makefile("rmovie")

data/ext/rmovie/mkmf.log

@@ -0,0 +1,24 @@
+have_library: checking for avcodec_init() in -lavcodec... -------------------- yes
+
+"i686-pc-linux-gnu-gcc -o conftest -I. -I/usr/lib/ruby/1.8/i686-linux -I.  -O2 -march=athlon-xp  -fPIC conftest.c  -L'/usr/lib' -Wl,-R'/usr/lib'      -lruby18-static -lavcodec  -ldl -lcrypt -lm   -lc"
+checked program was:
+/* begin */
+1: /*top*/
+2: int main() { return 0; }
+3: int t() { avcodec_init(); return 0; }
+/* end */
+
+--------------------
+
+have_library: checking for av_register_all() in -lavformat... -------------------- yes
+
+"i686-pc-linux-gnu-gcc -o conftest -I. -I/usr/lib/ruby/1.8/i686-linux -I.  -O2 -march=athlon-xp  -fPIC conftest.c  -L'/usr/lib' -Wl,-R'/usr/lib'     -lavcodec  -lruby18-static -lavformat -lavcodec  -ldl -lcrypt -lm   -lc"
+checked program was:
+/* begin */
+1: /*top*/
+2: int main() { return 0; }
+3: int t() { av_register_all(); return 0; }
+/* end */
+
+--------------------
+

data/ext/rmovie/pre-setup.rb

@@ -0,0 +1,4 @@
+# pre-setup.rb
+
+# build quadrupel 
+system "cd quadrupel && make"

data/ext/rmovie/quadrupel/Makefile

@@ -0,0 +1,32 @@
+.SUFFIXES:
+.SUFFIXES: .c .o
+
+CC = gcc
+CFLAGS = -g
+ALL_CFLAGS = -fpic $(CFLAGS)
+
+LIBNAME = libquadrupel.a
+HEADERS = qp_movie.h qp_frame.h qp_util.h
+OBJ = qp_movie.o qp_frame.o qp_util.o
+ARFLAGS = -rcs
+
+srcdir= ./
+prefix = ./
+libdir = $(prefix)/lib/
+includedir = $(prefix)/include/
+
+%.o : %.c $(HEADERS)
+	$(CC) -c $(ALL_CFLAGS) $(CPPFLAGS) $< -o $@
+
+all: $(OBJ)
+	$(AR) $(ARFLAGS) $(LIBNAME) *.o
+
+install: all installdirs
+	cp $(HEADERS) $(includedir) 
+	cp $(LIBNAME) $(libdir) 
+
+installdirs:
+	$(srcdir)/mkinstalldirs $(libdir) $(includedir)
+
+clean:
+	rm -f $(OBJ) $(LIBNAME) 

data/ext/rmovie/quadrupel/TODO

@@ -0,0 +1,15 @@
+TODO:
+
+* Add flag to allow creation of frame based/time based movies
+    time based: allows seeking, not frame accurate.
+    frame based: no seek support, frame accurate, slower since it must
+        decode to move thru a movie.
+
+* Implement seeking using blender's anim.c code as a starting point.
+
+* Optimize av_get_frame to decode directly into a buffer managed by the
+    library using gstreamer's gst-ffmpeg decoder as a starting point.
+
+* Implement audio in export
+
+* Re-add support for raw video input (it was part of output_example.c but I removed it until I get basic exporting working)

data/ext/rmovie/quadrupel/mkinstalldirs

@@ -0,0 +1,100 @@
+#!/bin/sh
+# mkinstalldirs --- make directory hierarchy
+# Author: Noah Friedman <friedman@prep.ai.mit.edu>
+# Created: 1993-05-16
+# Public domain
+
+errstatus=0
+dirmode=""
+
+usage="\
+Usage: mkinstalldirs [-h] [--help] [-m mode] dir ..."
+
+# process command line arguments
+while test $# -gt 0 ; do
+   case "${1}" in
+     -h | --help | --h* )                       # -h for help
+    echo "${usage}" 1>&2; exit 0 ;;
+     -m )                                       # -m PERM arg
+    shift
+    test $# -eq 0 && { echo "${usage}" 1>&2; exit 1; }
+    dirmode="${1}"
+    shift ;;
+     -- ) shift; break ;;                       # stop option processing
+     -* ) echo "${usage}" 1>&2; exit 1 ;;       # unknown option
+     * )  break ;;                              # first non-opt arg
+   esac
+done
+
+for file
+do
+  if test -d "$file"; then
+    shift
+  else
+    break
+  fi
+done
+
+case $# in
+0) exit 0 ;;
+esac
+
+case $dirmode in
+'')
+  if mkdir -p -- . 2>/dev/null; then
+    echo "mkdir -p -- $*"
+    exec mkdir -p -- "$@"
+  fi ;;
+*)
+  if mkdir -m "$dirmode" -p -- . 2>/dev/null; then
+    echo "mkdir -m $dirmode -p -- $*"
+    exec mkdir -m "$dirmode" -p -- "$@"
+  fi ;;
+esac
+
+for file
+do
+   set fnord `echo ":$file" | sed -ne 's/^:\//#/;s/^://;s/\// /g;s/^#/\//;p'`
+   shift
+
+   pathcomp=
+   for d
+   do
+     pathcomp="$pathcomp$d"
+     case "$pathcomp" in
+       -* ) pathcomp=./$pathcomp ;;
+     esac
+
+     if test ! -d "$pathcomp"; then
+    echo "mkdir $pathcomp"
+
+    mkdir "$pathcomp" || lasterr=$?
+
+    if test ! -d "$pathcomp"; then
+      errstatus=$lasterr
+    else
+      if test ! -z "$dirmode"; then
+         echo "chmod $dirmode $pathcomp"
+
+         lasterr=""
+         chmod "$dirmode" "$pathcomp" || lasterr=$?
+
+         if test ! -z "$lasterr"; then
+           errstatus=$lasterr
+         fi
+      fi
+    fi
+     fi
+
+     pathcomp="$pathcomp/"
+   done
+done
+
+exit $errstatus
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 3
+# End:
+# mkinstalldirs ends here
+

data/ext/rmovie/quadrupel/qp_frame.c

@@ -0,0 +1,266 @@
+#include <stdlib.h>
+
+#include "qp_util.h"
+#include "qp_frame.h"
+
+qp_frame_context* qp_alloc_frame_ctx(qp_malloc_t malloc_func)
+{
+    qp_frame_context *frame = NULL;
+
+    qp_malloc_t malloc_function = malloc_func ? malloc_func : malloc;
+
+    frame = (qp_frame_context *)malloc_function(sizeof(qp_frame_context));
+
+    if (!frame) {
+        return NULL;
+    }
+
+    frame->av_frame = NULL;
+    frame->width = 0;
+    frame->height = 0;
+    frame->pixel_format = 0;
+
+    return frame;
+}
+
+
+void qp_free_av_frame(AVFrame *av_frame)
+{
+    if (av_frame) {
+        if (av_frame->data[0]) {
+            av_free(av_frame->data[0]);
+        }
+        av_free(av_frame);
+        av_frame = NULL;
+    }
+}
+
+
+void qp_free_frame_ctx(qp_frame_context *frame, qp_free_t free_func)
+{
+    qp_free_t free_function = free_func ? free_func : free;
+    qp_free_av_frame(frame->av_frame);
+    free_function(frame);
+}
+
+
+int qp_get_frame_height(qp_frame_context *frame)
+{
+    if(frame) {
+        return frame->height;
+    }
+    return 0;
+}
+
+int qp_get_frame_width(qp_frame_context *frame)
+{
+    if(frame) {
+        return frame->width;
+    }
+    return 0;
+}
+
+
+const char* qp_get_frame_pixel_format_name(qp_frame_context *frame_ctx)
+{
+    const char *fmt = avcodec_get_pix_fmt_name(frame_ctx->pixel_format);
+
+    if (fmt) {
+        return fmt;
+    } else {
+        return NULL;
+    }
+}
+
+
+
+int qp_convert_av_frame(AVFrame **av_frame, int pixel_format, 
+        int new_format, int width, int height, int free_buffers)
+{
+    AVFrame *new_format_frame = avcodec_alloc_frame();
+    AVFrame *old_format_frame = *av_frame;
+
+    avpicture_alloc((AVPicture*)new_format_frame, new_format, width, height);
+    if (img_convert((AVPicture*)new_format_frame, new_format,
+                (AVPicture *)old_format_frame, pixel_format, width, height) < 0) {
+        return -1;
+    }
+
+    *av_frame = new_format_frame;
+
+    if (free_buffers) {
+        qp_free_av_frame(old_format_frame);
+    } else {
+        /* free av_frame struct but leave buffers intact. This is needed
+           in the case where buffers are managed by the decoder. */
+        free(old_format_frame);
+    }
+
+    return 0;
+}
+
+
+int qp_convert_frame(qp_frame_context *frame, int new_pixel_format)
+{
+    if (!frame->av_frame) {
+        return -1;
+    }
+
+    /* Don't convert if new format is the same as current. */
+    if (frame->pixel_format == new_pixel_format) {
+        return 0;
+    }
+
+    if (qp_convert_av_frame(&frame->av_frame, frame->pixel_format, 
+                new_pixel_format, frame->width, frame->height, 1) != 0) {
+        return -2;
+    }
+
+    frame->pixel_format = new_pixel_format;
+    return 0;
+}
+
+
+int qp_crop_frame(qp_frame_context *frame,
+        int crop_top, int crop_bottom, int crop_left, int crop_right)
+{
+    AVFrame *cropped_frame, *tmp_src;
+    AVFrame crop_temp;
+    int cropped_width, cropped_height;
+
+    if (!frame->av_frame) {
+        return -1;
+    }
+
+    tmp_src =frame->av_frame;
+
+    crop_temp.data[0] = tmp_src->data[0] +
+        (crop_top * tmp_src->linesize[0]) + crop_left;
+
+    crop_temp.data[1] = tmp_src->data[1] +
+        ((crop_top >> 1) * tmp_src->linesize[1]) +
+        (crop_left >> 1);
+
+    crop_temp.data[2] = tmp_src->data[2] +
+        ((crop_top >> 1) * tmp_src->linesize[2]) +
+        (crop_left >> 1);
+
+    crop_temp.linesize[0] = tmp_src->linesize[0];
+    crop_temp.linesize[1] = tmp_src->linesize[1];
+    crop_temp.linesize[2] = tmp_src->linesize[2];
+
+    cropped_frame = avcodec_alloc_frame();
+
+    cropped_width = frame->width - (crop_left + crop_right);
+    cropped_height = frame->height - (crop_top + crop_bottom);
+
+    avpicture_alloc((AVPicture*)cropped_frame, frame->pixel_format,
+            cropped_width, cropped_height);
+
+    img_copy((AVPicture*)cropped_frame,
+            (AVPicture *)&crop_temp, frame->pixel_format,
+            cropped_width, cropped_height);
+
+    /* free original uncropped frame */
+    qp_free_av_frame(frame->av_frame);
+
+    frame->av_frame = cropped_frame;
+    frame->width = cropped_width;
+    frame->height = cropped_height;
+    return 0;
+}
+
+
+int qp_resample_frame(qp_frame_context *frame,
+        int wanted_width, int wanted_height, int crop_top, int crop_bottom,
+        int crop_left, int crop_right)
+{
+    AVFrame *resampled_frame;
+    ImgReSampleContext *img_resample_ctx = NULL;
+
+    if (!frame->av_frame) {
+        return -1;
+    }
+
+    /*
+     * do nothing if width and height are the same as the frame and no
+     * cropping was specified
+     */
+    if (wanted_width == frame->width &&
+            wanted_height == frame->height &&
+            (!crop_left && !crop_right && !crop_top && !crop_bottom)) {
+        return 0;
+    }
+
+    /* just crop if wanted dimensions - crop bands = same width/height */
+    if (wanted_width == frame->width - (crop_left + crop_right) &&
+            wanted_height == frame->height - (crop_left + crop_right)) {
+        qp_crop_frame(frame, crop_top, crop_bottom, crop_left, crop_right);
+        return 0;
+    }
+
+    /* convert to PIX_FMT_YUV420P required for resampling */
+    qp_convert_frame(frame, PIX_FMT_YUV420P);
+
+    img_resample_ctx = img_resample_full_init(
+            wanted_width, wanted_height,
+            frame->width, frame->height,
+            crop_top, crop_bottom, crop_left, crop_right,
+            0, 0, 0, 0);
+    if (!img_resample_ctx) {
+        return -1;
+    }
+
+    resampled_frame = avcodec_alloc_frame();
+    avpicture_alloc((AVPicture*)resampled_frame, PIX_FMT_YUV420P,
+            wanted_width, wanted_height);
+
+    img_resample(img_resample_ctx, (AVPicture*)resampled_frame,
+            (AVPicture*)frame->av_frame);
+
+    qp_free_av_frame(frame->av_frame);
+
+    img_resample_close(img_resample_ctx);
+
+    frame->av_frame = resampled_frame;
+    frame->width = wanted_width;
+    frame->height = wanted_height;
+
+    return 0;
+}
+
+
+/* 
+ * output_as_string - create a packed RGB24 string from this frame's data in 
+ * char_ptr. It is the caller's resposibility to free char_ptr.
+ */
+int qp_output_frame_as_string(qp_frame_context *frame, unsigned char **char_ptr)
+{
+    AVFrame *new_format_frame = avcodec_alloc_frame();
+
+    avpicture_alloc((AVPicture*)new_format_frame, PIX_FMT_RGB24, 
+            frame->width, frame->height);
+
+    if (img_convert((AVPicture*)new_format_frame, PIX_FMT_RGB24,
+                (AVPicture *)frame->av_frame, frame->pixel_format, 
+                frame->width, frame->height) < 0) {
+        return -1;
+    }
+
+    *char_ptr = new_format_frame->data[0];
+
+    /* free the frame struct that was allocated by avcodec_alloc_frame. This will
+       not free the actual frame data that we are returning. */
+    free(new_format_frame);
+
+    return avpicture_get_size(PIX_FMT_RGB24, frame->width, frame->height);
+}
+
+
+double qp_get_pts(qp_frame_context *frame) {
+    return ((double)frame->pts / AV_TIME_BASE);
+}
+
+long qp_frame_is_keyframe(qp_frame_context *frame) {
+    return (long)frame->keyframe;
+}