rmov 0.1.0

data/ext/rmov_ext.c

@@ -0,0 +1,14 @@
+#include "rmov_ext.h"
+
+VALUE mQuicktime;
+VALUE eQuicktime;
+
+void Init_rmov_ext()
+{
+  EnterMovies(); // Enables the QuickTime framework
+  mQuicktime = rb_define_module("Quicktime");
+  eQuicktime = rb_define_class_under(mQuicktime, "Error", rb_eStandardError);
+  Init_quicktime_movie();
+  Init_quicktime_track();
+  Init_quicktime_exporter();
+}

data/ext/rmov_ext.h

@@ -0,0 +1,41 @@
+#include <ruby.h>
+#include <QuickTime/QuickTime.h>
+
+extern VALUE mQuicktime, eQuicktime, cMovie, cTrack, cExporter;
+
+/*** MOVIE ***/
+
+void Init_quicktime_movie();
+OSErr movie_progress_proc(Movie movie, short message, short operation, Fixed percent, VALUE proc);
+
+#define RMOVIE(obj) (Check_Type(obj, T_DATA), (struct RMovie*)DATA_PTR(obj))
+#define MOVIE(obj) (RMOVIE(obj)->movie)
+#define MOVIE_TIME(obj, seconds) (floor(NUM2DBL(seconds)*GetMovieTimeScale(MOVIE(obj))))
+
+struct RMovie {
+  Movie movie;
+};
+
+
+/*** TRACK ***/
+
+void Init_quicktime_track();
+
+#define RTRACK(obj) (Check_Type(obj, T_DATA), (struct RTrack*)DATA_PTR(obj))
+#define TRACK(obj) (RTRACK(obj)->track)
+#define TRACK_MEDIA(obj) (GetTrackMedia(TRACK(obj)))
+
+struct RTrack {
+  Track track;
+};
+
+
+/*** EXPORTER ***/
+
+void Init_quicktime_exporter();
+
+#define REXPORTER(obj) (Check_Type(obj, T_DATA), (struct RExporter*)DATA_PTR(obj))
+
+struct RExporter {
+  QTAtomContainer settings;
+};

data/ext/track.c

@@ -0,0 +1,174 @@
+#include "rmov_ext.h"
+
+VALUE cTrack;
+
+static void track_free(struct RTrack *rTrack)
+{
+}
+
+static void track_mark(struct RTrack *rTrack)
+{
+}
+
+/*
+  Creates a new track instance. Generally you will do this through 
+  movie.tracks to fetch the Track instances for a given movie.
+
+call-seq:
+  new() -> track
+*/
+static VALUE track_new(VALUE klass)
+{
+  struct RTrack *rTrack;
+  return Data_Make_Struct(klass, struct RTrack, track_mark, track_free, rTrack);
+}
+
+/*
+  Loads a QuickTime track from a given movie. This is done automatically 
+  when calling movie.tracks.
+
+call-seq:
+  load(movie, index)
+*/
+static VALUE track_load(VALUE obj, VALUE movie_obj, VALUE index_obj)
+{
+  RTRACK(obj)->track = GetMovieIndTrack(MOVIE(movie_obj), NUM2INT(index_obj));
+  if (!RTRACK(obj)->track)
+    rb_raise(eQuicktime, "Unable to fetch track for movie at index %d", NUM2INT(index_obj));
+  
+  return obj;
+}
+
+/*
+  Returns the raw duration of the track. Combine this with time_scale to 
+  reach the duration in seconds.
+
+call-seq:
+  raw_duration() -> duration_int
+*/
+static VALUE track_raw_duration(VALUE obj)
+{
+  return INT2NUM(GetMediaDuration(TRACK_MEDIA(obj)));
+}
+
+/*
+  Returns the time scale of the track. Usually only needed when working 
+  with raw_duration.
+
+call-seq:
+  time_scale() -> scale_int
+*/
+static VALUE track_time_scale(VALUE obj)
+{
+  return INT2NUM(GetMediaTimeScale(TRACK_MEDIA(obj)));
+}
+
+/*
+  Returns the number of frames in the track.
+
+call-seq:
+  frame_count() -> count
+*/
+static VALUE track_frame_count(VALUE obj)
+{
+  return INT2NUM(GetMediaSampleCount(TRACK_MEDIA(obj)));
+}
+
+/*
+  Returns either :audio or :video depending on the type of track this is.
+
+call-seq:
+  media_type() -> media_type_sym
+*/
+static VALUE track_media_type(VALUE obj)
+{
+  OSType media_type;
+  
+  GetMediaHandlerDescription(TRACK_MEDIA(obj), &media_type, 0, 0);
+  if (media_type == SoundMediaType) {
+    return ID2SYM(rb_intern("audio"));
+  } else if (media_type == VideoMediaType) {
+    return ID2SYM(rb_intern("video"));
+  } else {
+    return Qnil;
+  }
+}
+
+/*
+  Returns either id number QuickTime uses to reference this track. 
+  Usually only used internally.
+
+call-seq:
+  id() -> quicktime_track_id_int
+*/
+static VALUE track_id(VALUE obj)
+{
+  return INT2NUM(GetTrackID(TRACK(obj)));
+}
+
+/*
+  Removes the track from its movie and deletes it from memory.
+
+call-seq:
+  delete()
+*/
+static VALUE track_delete(VALUE obj)
+{
+  DisposeMovieTrack(TRACK(obj));
+  return Qnil;
+}
+
+/*
+  Disables the track. See enabled? to determine if it's disabled already.
+
+call-seq:
+  disable()
+*/
+static VALUE track_disable(VALUE obj, VALUE boolean)
+{
+  SetTrackEnabled(TRACK(obj), FALSE);
+  return obj;
+}
+
+/*
+  Enables the track. See enabled? to determine if it's enabled already.
+
+call-seq:
+  enable()
+*/
+static VALUE track_enable(VALUE obj, VALUE boolean)
+{
+  SetTrackEnabled(TRACK(obj), TRUE);
+  return obj;
+}
+
+/*
+  Returns true/false depending on if the track is enabled.
+
+call-seq:
+  enabled?() -> bool
+*/
+static VALUE track_enabled(VALUE obj, VALUE boolean)
+{
+  if (GetTrackEnabled(TRACK(obj)) == TRUE) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+void Init_quicktime_track()
+{
+  cTrack = rb_define_class_under(mQuicktime, "Track", rb_cObject);
+  rb_define_alloc_func(cTrack, track_new);
+  rb_define_method(cTrack, "load_from_movie", track_load, 2);
+  rb_define_method(cTrack, "raw_duration", track_raw_duration, 0);
+  rb_define_method(cTrack, "time_scale", track_time_scale, 0);
+  rb_define_method(cTrack, "frame_count", track_frame_count, 0);
+  rb_define_method(cTrack, "media_type", track_media_type, 0);
+  rb_define_method(cTrack, "id", track_id, 0);
+  rb_define_method(cTrack, "delete", track_delete, 0);
+  rb_define_method(cTrack, "enabled?", track_enabled, 0);
+  rb_define_method(cTrack, "enable", track_enable, 0);
+  rb_define_method(cTrack, "disable", track_disable, 0);
+}

data/lib/quicktime/exporter.rb

@@ -0,0 +1,10 @@
+module Quicktime
+  # see ext/exporter.c for additional methods
+  class Exporter
+    attr_reader :movie
+    
+    def initialize(movie)
+      @movie = movie
+    end
+  end
+end

data/lib/quicktime/movie.rb

@@ -0,0 +1,57 @@
+module Quicktime
+  # see ext/movie.c for additional methods
+  class Movie
+    # Opens a movie at filepath.
+    def self.open(filepath)
+      new.load_from_file(filepath)
+    end
+    
+    # Returns a new, empty movie.
+    def self.empty
+      new.load_empty
+    end
+    
+    # Returns the length of this movie in seconds
+    # using raw_duration and time_scale.
+    def duration
+      raw_duration.to_f/time_scale
+    end
+    
+    # Returns the bounding width of this movie in number of pixels.
+    def width
+      bounds[:right] - bounds[:left]
+    end
+    
+    # Returns the bounding height of this movie in number of pixels.
+    def height
+      bounds[:bottom] - bounds[:top]
+    end
+    
+    # Returns an array of tracks in this movie.
+    def tracks
+      (1..track_count).map do |i|
+        Track.new.load_from_movie(self, i)
+      end
+    end
+    
+    # Returns an array of audio tracks in this movie.
+    def audio_tracks
+      tracks.select { |t| t.audio? }
+    end
+    
+    # Returns an array of video tracks in this movie.
+    def video_tracks
+      tracks.select { |t| t.video? }
+    end
+    
+    # Returns an Exporter instance for this movie.
+    def exporter
+      Exporter.new(self)
+    end
+    
+    # Convenience method for exporting the movie. See Exporter::export.
+    def export(*args, &block)
+      exporter.export(*args, &block)
+    end
+  end
+end

data/lib/quicktime/track.rb

@@ -0,0 +1,25 @@
+module Quicktime
+  # see ext/track.c for additional methods
+  class Track
+    # Returns the length of this track in seconds
+    # using raw_duration and time_scale.
+    def duration
+      raw_duration.to_f/time_scale
+    end
+    
+    # The average frame_rate for this track. May not be exact.
+    def frame_rate # what about odd frame rates such as 29.97?
+      frame_count/duration
+    end
+    
+    # Returns true/false depending on if track is an audio track.
+    def audio?
+      media_type == :audio
+    end
+    
+    # Returns true/false depending on if track is a video track.
+    def video?
+      media_type == :video
+    end
+  end
+end

data/lib/rmov.rb

@@ -0,0 +1,12 @@
+$:.unshift(File.dirname(__FILE__))
+
+require File.dirname(__FILE__) + '/../ext/rmov_ext'
+
+require 'quicktime/movie'
+require 'quicktime/track'
+require 'quicktime/exporter'
+
+
+# RMov is made up of several parts. To start, see Quicktime::Movie.
+module Quicktime
+end

data/rmov.gemspec

@@ -0,0 +1,101 @@
+
+# Gem::Specification for Rmov-0.1.0
+# Originally generated by Echoe
+
+--- !ruby/object:Gem::Specification 
+name: rmov
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ryan Bates
+autorequire: 
+bindir: bin
+
+date: 2008-10-02 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Ruby wrapper for the QuickTime C API.
+email: ryan (at) railscasts (dot) com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- CHANGELOG
+- ext/exporter.c
+- ext/extconf.rb
+- ext/movie.c
+- ext/rmov_ext.c
+- ext/rmov_ext.h
+- ext/track.c
+- lib/quicktime/exporter.rb
+- lib/quicktime/movie.rb
+- lib/quicktime/track.rb
+- lib/rmov.rb
+- LICENSE
+- README
+- tasks/setup.rake
+- tasks/spec.rake
+- TODO
+files: 
+- CHANGELOG
+- ext/exporter.c
+- ext/extconf.rb
+- ext/movie.c
+- ext/rmov_ext.c
+- ext/rmov_ext.h
+- ext/track.c
+- lib/quicktime/exporter.rb
+- lib/quicktime/movie.rb
+- lib/quicktime/track.rb
+- lib/rmov.rb
+- LICENSE
+- Rakefile
+- README
+- spec/fixtures/settings.st
+- spec/output/example.pct
+- spec/output/saved_settings.st
+- spec/quicktime/exporter_spec.rb
+- spec/quicktime/movie_spec.rb
+- spec/quicktime/track_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/setup.rake
+- tasks/spec.rake
+- TODO
+- Manifest
+- rmov.gemspec
+has_rdoc: true
+homepage: http://github.com/ryanb/rmov
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Rmov
+- --main
+- README
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - "="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: rmov
+rubygems_version: 1.2.0
+specification_version: 2
+summary: Ruby wrapper for the QuickTime C API.
+test_files: []