one-k-rmov 0.1.4

data/ext/track.c

@@ -0,0 +1,391 @@
+#include "rmov_ext.h"
+
+VALUE cTrack;
+
+static void track_free(struct RTrack *rTrack)
+{
+}
+
+static void track_mark(struct RTrack *rTrack)
+{
+}
+
+/*
+  call-seq: new() -> track
+  
+  Creates a new track instance. Generally you will do this through 
+  movie.tracks to fetch the Track instances for a given movie.
+*/
+static VALUE track_new(VALUE klass)
+{
+  struct RTrack *rTrack;
+  return Data_Make_Struct(klass, struct RTrack, track_mark, track_free, rTrack);
+}
+
+/*
+  call-seq: load(movie, index)
+  
+  Loads a QuickTime track from a given movie. This is done automatically 
+  when calling movie.tracks.
+*/
+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;
+}
+
+/*
+  call-seq: raw_duration() -> duration_int
+  
+  Returns the raw duration of the track. Combine this with time_scale to 
+  reach the duration in seconds.
+*/
+static VALUE track_raw_duration(VALUE obj)
+{
+  return INT2NUM(GetMediaDuration(TRACK_MEDIA(obj)));
+}
+
+/*
+  call-seq: time_scale() -> scale_int
+  
+  Returns the time scale of the track. Usually only needed when working 
+  with raw_duration.
+*/
+static VALUE track_time_scale(VALUE obj)
+{
+  return INT2NUM(GetMediaTimeScale(TRACK_MEDIA(obj)));
+}
+
+/*
+  call-seq: frame_count() -> count
+  
+  Returns the number of frames in the track.
+*/
+static VALUE track_frame_count(VALUE obj)
+{
+  return INT2NUM(GetMediaSampleCount(TRACK_MEDIA(obj)));
+}
+
+/*
+  call-seq: media_type() -> media_type_sym
+  
+  Returns either :audio or :video depending on the type of track this is.
+*/
+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 if (media_type == TextMediaType) {
+    return ID2SYM(rb_intern("text"));
+  } else {
+    return Qnil;
+  }
+}
+
+/*  returns the ImageDescriptionHandle for the track.
+    If it's not a video track, return NULL
+*/
+static ImageDescriptionHandle track_image_description(VALUE obj)
+{
+	Media track_media = TRACK_MEDIA(obj);
+  OSType media_type;
+  OSErr osErr = noErr;
+
+	/* restrict reporting to video track */
+  GetMediaHandlerDescription(track_media, &media_type, 0, 0);
+  if (media_type != VideoMediaType)
+    return NULL;
+  
+	SampleDescriptionHandle sample_description = NULL;
+  sample_description = (SampleDescriptionHandle)NewHandle(sizeof(SampleDescription));
+  if (LMGetMemErr() != noErr) {
+    rb_raise(eQuickTime, "Memory Error %d when determining image description", LMGetMemErr());
+    return NULL;
+  }
+
+	GetMediaSampleDescription(track_media, 1, sample_description);
+	osErr = GetMoviesError();
+  if (osErr != noErr) {
+    rb_raise(eQuickTime, "Movie Error %d when determining image description", osErr);
+    DisposeHandle((Handle)sample_description);
+    return NULL;
+  }
+  
+  return (ImageDescriptionHandle)sample_description;
+}
+
+
+/*
+  call-seq: track_codec() -> codec_string
+  
+  Returns the name of the codec.  Only valid for video tracks. Others return nil.
+*/
+static VALUE track_codec(VALUE obj)
+{
+	ImageDescriptionHandle image_description = track_image_description(obj);
+	
+	if (image_description == NULL)
+    return Qnil;
+
+  UInt8 *codecStr = (*image_description)->name;
+  
+  VALUE out_str = rb_str_new( (char*)codecStr+1, (UInt8)codecStr[0] );
+
+  DisposeHandle((Handle)image_description);
+
+  return out_str;
+}
+
+
+/*
+  call-seq: track_width() -> width_in_pixels
+  
+  Returns the width of track data.  Only valid for video tracks. Others return nil.
+*/
+static VALUE track_width(VALUE obj)
+{
+	ImageDescriptionHandle image_description = track_image_description(obj);
+	
+	if (image_description == NULL)
+    return Qnil;
+
+  short width = (*image_description)->width;
+  
+  DisposeHandle((Handle)image_description);
+
+  return INT2NUM(width);
+}
+
+/*
+  call-seq: track_height() -> height_in_pixels
+  
+  Returns the height of track data.  Only valid for video tracks. Others return nil.
+*/
+static VALUE track_height(VALUE obj)
+{
+	ImageDescriptionHandle image_description = track_image_description(obj);
+	
+	if (image_description == NULL)
+    return Qnil;
+
+  short height = (*image_description)->height;
+  
+  DisposeHandle((Handle)image_description);
+
+  return INT2NUM(height);
+}
+
+
+/*
+  call-seq: id() -> quicktime_track_id_int
+  
+  Returns either id number QuickTime uses to reference this track. 
+  Usually only used internally.
+*/
+static VALUE track_id(VALUE obj)
+{
+  return INT2NUM(GetTrackID(TRACK(obj)));
+}
+
+/*
+  call-seq: delete()
+  
+  Removes the track from its movie and deletes it from memory.
+*/
+static VALUE track_delete(VALUE obj)
+{
+  DisposeMovieTrack(TRACK(obj));
+  return Qnil;
+}
+
+/*
+  call-seq: disable()
+  
+  Disables the track. See enabled? to determine if it's disabled already.
+*/
+static VALUE track_disable(VALUE obj, VALUE boolean)
+{
+  SetTrackEnabled(TRACK(obj), FALSE);
+  return obj;
+}
+
+/*
+  call-seq: enable()
+  
+  Enables the track. See enabled? to determine if it's enabled already.
+*/
+static VALUE track_enable(VALUE obj, VALUE boolean)
+{
+  SetTrackEnabled(TRACK(obj), TRUE);
+  return obj;
+}
+
+/*
+  call-seq: enabled?() -> bool
+  
+  Returns true/false depending on if the track is enabled.
+*/
+static VALUE track_enabled(VALUE obj, VALUE boolean)
+{
+  if (GetTrackEnabled(TRACK(obj)) == TRUE) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+/*
+  call-seq: volume() -> volume_float
+  
+  Returns the volume of the audio from 0.0 to 1.0.
+*/
+static VALUE track_get_volume(VALUE obj)
+{
+  return rb_float_new((double)GetTrackVolume(TRACK(obj))/0x0100);
+}
+
+/*
+  call-seq: volume=(volume_float)
+  
+  Sets the volume to the given value (0.0 to 1.0)
+*/
+static VALUE track_set_volume(VALUE obj, VALUE volume_obj)
+{
+  SetTrackVolume(TRACK(obj), (short)(0x0100*NUM2DBL(volume_obj)));
+  return Qnil;
+}
+
+
+/*  returns the AudioStreamBasicDescription for the track.
+    If it's not an audio track, return NULL
+*/
+static SoundDescriptionHandle track_audio_description(VALUE obj)
+{
+	Media track_media = TRACK_MEDIA(obj);
+  OSType media_type;
+  OSErr osErr = noErr;
+
+	/* restrict reporting to audio track */
+  GetMediaHandlerDescription(track_media, &media_type, 0, 0);
+  if (media_type != SoundMediaType)
+    return NULL;
+  
+	SoundDescriptionHandle sample_description = NULL;
+  sample_description = (SoundDescriptionHandle)NewHandle(sizeof(SampleDescription));
+  if (LMGetMemErr() != noErr) {
+    rb_raise(eQuickTime, "Memory Error %d when determining audio description", LMGetMemErr());
+    return NULL;
+  }
+
+	GetMediaSampleDescription(track_media, 1, (SampleDescriptionHandle)sample_description);
+	osErr = GetMoviesError();
+  if (osErr != noErr) {
+    rb_raise(eQuickTime, "GetMediaSampleDescription Error %d when determining audio description", osErr);
+    DisposeHandle((Handle)sample_description);
+    return NULL;
+  }
+
+  return sample_description;
+}
+
+/*
+  call-seq: offset() -> seconds
+  
+  Returns the offset of the track from the beginning of the movie (in seconds).
+*/
+static VALUE track_get_offset(VALUE obj)
+{
+  return rb_float_new((double)GetTrackOffset(TRACK(obj))/GetMediaTimeScale(TRACK_MEDIA(obj)));
+}
+
+/*
+  call-seq: offset=(seconds)
+  
+  Sets the offset of the track from the start of the movie (in seconds).
+*/
+static VALUE track_set_offset(VALUE obj, VALUE seconds)
+{
+  SetTrackOffset(TRACK(obj), TRACK_TIME(obj, seconds));
+  return Qnil;
+}
+
+/*
+  call-seq: new_video_media
+  
+  Creates a new video media for this track.
+  
+  Generally this method is not called directly, instead you can make a 
+  new video track using Movie#new_video_track.
+*/
+static VALUE track_new_video_media(VALUE obj)
+{
+  NewTrackMedia(TRACK(obj), VideoMediaType, 600, 0, 0);
+  return obj;
+}
+
+/*
+  call-seq: new_audio_media
+  
+  Creates a new audio media for this track.
+  
+  Generally this method is not called directly, instead you can make a 
+  new audio track using Movie#new_audio_track.
+*/
+static VALUE track_new_audio_media(VALUE obj)
+{
+  NewTrackMedia(TRACK(obj), SoundMediaType, 44100, 0, 0);
+  return obj;
+}
+
+/*
+  call-seq: new_text_media
+  
+  Creates a new text media for this track.
+  
+  Generally this method is not called directly, instead you can make a 
+  new text track using Movie#new_text_track.
+*/
+static VALUE track_new_text_media(VALUE obj)
+{
+  NewTrackMedia(TRACK(obj), TextMediaType, 600, 0, 0);
+  return obj;
+}
+
+
+void Init_quicktime_track()
+{
+  VALUE mQuickTime;
+  mQuickTime = rb_define_module("QuickTime");
+  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, "codec", track_codec, 0);
+  rb_define_method(cTrack, "width", track_width, 0);
+  rb_define_method(cTrack, "height", track_height, 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);
+  rb_define_method(cTrack, "volume", track_get_volume, 0);
+  rb_define_method(cTrack, "volume=", track_set_volume, 1);
+  rb_define_method(cTrack, "offset", track_get_offset, 0);
+  rb_define_method(cTrack, "offset=", track_set_offset, 1);
+  rb_define_method(cTrack, "new_video_media", track_new_video_media, 0);
+  rb_define_method(cTrack, "new_audio_media", track_new_audio_media, 0);
+  rb_define_method(cTrack, "new_text_media", track_new_text_media, 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,102 @@
+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 array of text tracks in this movie.
+    def text_tracks
+      tracks.select { |t| t.text? }
+    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
+    
+    # Creates a new video track with given width/height on movie and returns it.
+    def new_video_track(width, height)
+      track = new_track(width, height)
+      track.new_video_media
+      track
+    end
+    
+    # Creates a new audio track with given width/height on movie and returns it.
+    def new_audio_track(width, height)
+      track = new_track(width, height)
+      track.new_audio_media
+      track
+    end
+    
+    # Creates a new text track with given width/height on movie and returns it.
+    def new_text_track(width, height)
+      track = new_track(width, height)
+      track.new_text_media
+      track
+    end
+    
+    # Exports a frame of the movie at the given time (in seconds) to the given file. 
+    # The image format is automatically determined from the file extension. If this
+    # cannot be determined from the extension then you can use export_image_type to
+    # specify the ostype manually.
+    def export_image(filepath, seconds)
+      # TODO support more file types
+      type = case File.extname(filepath).downcase
+        when '.pct', '.pict' then 'PICT'
+        when '.tif', '.tiff' then 'TIFF'
+        when '.jpg', '.jpeg' then 'JPEG'
+        when '.png'          then 'PNGf'
+        when '.tga'          then 'TPIC'
+        when '.bmp'          then 'BMPf'
+        when '.psd'          then '8BPS'
+        else raise QuickTime::Error, "Unable to guess ostype from file extension of #{filepath}"
+      end
+      export_image_type(filepath, seconds, type)
+    end
+  end
+end

data/lib/quicktime/track.rb

@@ -0,0 +1,31 @@
+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
+    
+    # Returns true/false depending on if track is a text track.
+    def text?
+      media_type == :text
+    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,32 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rmov}
+  s.version = "0.1.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ryan Bates"]
+  s.date = %q{2009-02-24}
+  s.description = %q{Ruby wrapper for the QuickTime C API.}
+  s.email = %q{ryan (at) railscasts (dot) com}
+  s.extensions = ["ext/extconf.rb"]
+  s.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.rdoc", "tasks/setup.rake", "tasks/spec.rake", "TODO"]
+  s.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", "Manifest", "Rakefile", "README.rdoc", "spec/fixtures/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", "rmov.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/ryanb/rmov}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Rmov", "--main", "README.rdoc"]
+  s.require_paths = ["lib", "ext"]
+  s.rubyforge_project = %q{rmov}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Ruby wrapper for the QuickTime C API.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/spec/quicktime/exporter_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe QuickTime::Exporter do
+  it "should raise error when saving with no settings" do
+    lambda { QuickTime::Exporter.new(nil).save_settings('foo') }.should raise_error(QuickTime::Error)
+  end
+  
+  it "should raise error when atempting to load no file" do
+    lambda { QuickTime::Exporter.new(nil).load_settings('foo/bar/baz') }.should raise_error(QuickTime::Error)
+  end
+  
+  describe "loaded settings.st" do
+    before(:each) do
+      @load_path = File.dirname(__FILE__) + '/../fixtures/settings.st'
+      @exporter = QuickTime::Exporter.new(nil)
+      @exporter.load_settings(@load_path)
+    end
+    
+    it "should be able to save settings to file" do
+      save_path = File.dirname(__FILE__) + '/../output/saved_settings.st'
+      @exporter.save_settings(save_path)
+      File.size(save_path).should == File.size(@load_path)
+    end
+    
+    it "should complain when attempting to save to an invalid file" do
+      lambda { @exporter.save_settings('foo/bar/baz') }.should raise_error(QuickTime::Error)
+    end
+  end
+end