rmov 0.1.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+0.1.0 (October 2nd, 2008)
+
+* initial release

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Ryan Bates
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest

@@ -0,0 +1,26 @@
+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

data/README

@@ -0,0 +1,73 @@
+= RMov
+
+Open, edit, and export QuickTime movies all within Ruby! This is an 
+unofficial wrapper around Apple's QuickTime C API. Mac OS X required.
+
+
+== Install
+
+Install the gem:
+
+  gem install rmov
+
+And then load it in your project:
+
+  require 'rmov'
+
+
+== Usage
+
+Use this gem to open QuickTime movies and edit them to your liking.
+
+  movie1 = QuickTime::Movie.open("path/to/movie.mov")
+  movie2 = QuickTime::Movie.open("path/to/another_movie.mov")
+  
+  # add movie2 to the end of movie1
+  movie1.append_movie(movie2)
+  
+  # make a new movie out of a section of movie 1
+  # this will delete 5 seconds out of the movie at 2 seconds in
+  movie3 = movie1.clip_section(movie1, 2, 5)
+  
+  # You can insert that part back into the movie at 8 seconds in
+  movie1.insert_movie(movie3, 8)
+
+Now you can export the movie. Usually this is done through a user 
+interface the first time around. The settings can then be saved to
+a file. After that you can load these settings without interfering
+the user with the dialog again.
+
+  exporter = movie1.exporter
+  
+  # if we already have saved the settings, load those
+  if File.exist? "settings.st"
+    exporter.load_settings("settings.st")
+  else
+    # otherwise open the QuickTime GUI settings dialog
+    exporter.open_settings_dialog
+    
+    # save settings to a file so we don't have to bother user next time
+    exporter.save_settings("settings.st")
+  end
+  
+  # export the movie to a file and report the progress along the way
+  exporter.export("movie.mov") do |progress|
+    percent = (progress*100).round
+    puts "#{percent}% complete"
+  end
+
+See Quicktime::Movie in the RDoc for more information.
+
+http://rmov.rubyforge.org
+
+
+== Development
+
+This project can be found on github at the following URL.
+
+http://github.com/ryanb/rmov
+
+If you find a bug, please send me a message on GitHub.
+
+If you would like to contribute to this project, please fork the 
+repository and send me a pull request.

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('rmov', '0.1.0') do |p|
+  p.summary        = "Ruby wrapper for the QuickTime C API."
+  p.description    = "Ruby wrapper for the QuickTime C API."
+  p.url            = "http://github.com/ryanb/rmov"
+  p.author         = 'Ryan Bates'
+  p.email          = "ryan (at) railscasts (dot) com"
+  p.ignore_pattern = ["script/*", "tmp/*", "output/*", "**/*.o", "**/*.bundle", "**/*.mov"]
+  p.extensions     = ["ext/extconf.rb"]
+  p.development_dependencies = []
+end
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }

data/TODO

@@ -0,0 +1,19 @@
+Fixes
+- check if movie/track really exists each time we call it
+- add rdocs
+- fill README
+
+Features
+- export a single frame as pict
+- resize movie
+- export image sequence
+- import image sequence
+- import other file formats (mpeg, aiff, mp3, etc.)
+- get movie metadata (album, author, artist, etc.)
+- set movie metadata
+- programatically adjust export settings (framerate, codec, etc.)
+
+Possible
+- add text track to movie
+- add chapters to movie
+- time remapping

data/ext/exporter.c

@@ -0,0 +1,200 @@
+#include "rmov_ext.h"
+
+VALUE cExporter;
+
+static void exporter_free(struct RExporter *rExporter)
+{
+  if (rExporter->settings) {
+    QTDisposeAtomContainer(rExporter->settings);
+  }
+}
+
+static void exporter_mark(struct RExporter *rExporter)
+{
+}
+
+/*
+  Creates a new exporter instance. Usually this is done through movie.exporter.
+
+call-seq:
+  new(movie) -> exporter
+*/
+static VALUE exporter_new(VALUE klass)
+{
+  struct RExporter *rExporter;
+  return Data_Make_Struct(klass, struct RExporter, exporter_mark, exporter_free, rExporter);
+}
+
+static ComponentInstance exporter_component(VALUE obj)
+{
+  ComponentInstance component = OpenDefaultComponent('spit', 'MooV');
+  if (REXPORTER(obj)->settings) {
+    MovieExportSetSettingsFromAtomContainer(component, REXPORTER(obj)->settings);
+  }
+  return component;
+}
+
+/*
+  Exports a movie to the given filepath. This will use either the 
+  settings you set beforehand, or QuickTime's defaults.
+
+  You can track the progress of this operation by passing a block to this 
+  method. It will be called regularly during the process and pass the 
+  percentage complete (0.0 to 1.0) as an argument to the block.
+
+call-seq:
+  export_to_file(filepath)
+*/
+static VALUE exporter_export_to_file(VALUE obj, VALUE filepath)
+{
+  OSErr err;
+  FSSpec fs;
+  Movie movie = MOVIE(rb_iv_get(obj, "@movie"));
+  ComponentInstance component = exporter_component(obj);
+  
+  if (rb_block_given_p())
+    SetMovieProgressProc(movie, (MovieProgressUPP)movie_progress_proc, rb_block_proc());
+  
+  // Activate so QuickTime doesn't export a white frame
+  SetMovieActive(movie, TRUE);
+  
+  err = NativePathNameToFSSpec(RSTRING(filepath)->ptr, &fs, 0);
+  if (err != fnfErr)
+    rb_raise(eQuicktime, "Error %d occurred while opening file for export at %s.", err, RSTRING(filepath)->ptr);
+  
+  // TODO use exporter settings when converting movie
+  err = ConvertMovieToFile(movie, 0, &fs, 'MooV', 'TVOD', 0, 0, 0, component);
+  if (err != noErr)
+    rb_raise(eQuicktime, "Error %d occurred while attempting to export movie to file %s.", err, RSTRING(filepath)->ptr);
+  
+  if (rb_block_given_p())
+    SetMovieProgressProc(movie, 0, 0);
+  
+  CloseComponent(component);
+  
+  return Qnil;
+}
+
+/*
+  Opens the offical QuickTime GUI settings dialog. The process will be 
+  suspended until the user closes the dialogue. If the user clicks Okay 
+  the settings will be applied to this Exporter. You can then use 
+  save_settings to save them to a file, and load_settings to load them 
+  back again.
+
+call-seq:
+  open_settings_dialog()
+*/
+static VALUE exporter_open_settings_dialog(VALUE obj)
+{
+  Boolean canceled;
+  OSErr err;
+  ProcessSerialNumber current_process = {0, kCurrentProcess};
+  Movie movie = MOVIE(rb_iv_get(obj, "@movie"));
+  ComponentInstance component = exporter_component(obj);
+  
+  // Bring this process to the front
+  if (!IsProcessVisible(&current_process)) {
+    err = TransformProcessType(&current_process, kProcessTransformToForegroundApplication);
+    if (err != noErr) {
+      rb_raise(eQuicktime, "Error %d occurred while brining this application to the forground.", err);
+    }
+  }
+  SetFrontProcess(&current_process);
+  
+  // Show export dialog and save settings
+  err = MovieExportDoUserDialog(component, movie, 0, 0, GetMovieDuration(movie), &canceled);
+  if (err != noErr) {
+    rb_raise(eQuicktime, "Error %d occurred while opening export dialog.", err);
+  }
+  
+  if (!canceled) {
+    // Clear existing settings if there are any
+    if (REXPORTER(obj)->settings) {
+      QTDisposeAtomContainer(REXPORTER(obj)->settings);
+    }
+    MovieExportGetSettingsAsAtomContainer(component, &REXPORTER(obj)->settings);
+  }
+  
+  CloseComponent(component);
+  
+  if (canceled) {
+    return Qfalse;
+  } else {
+    return Qtrue;
+  }
+}
+
+/*
+  Loads the settings at the given filepath. See save_settings.
+
+call-seq:
+  load_settings(filepath)
+*/
+static VALUE exporter_load_settings(VALUE obj, VALUE filepath)
+{
+  FILE *file;
+  long length, read_length;
+  
+  file = fopen(RSTRING(filepath)->ptr, "r+b");
+  if (!file) {
+    rb_raise(eQuicktime, "Unable to open file for loading at %s.", RSTRING(filepath)->ptr);
+  }
+  
+  // obtain file size:
+  fseek(file , 0, SEEK_END);
+  length = ftell(file);
+  rewind(file);
+  
+  // clear existing settings if there are any
+  if (REXPORTER(obj)->settings) {
+    QTDisposeAtomContainer(REXPORTER(obj)->settings);
+  }
+  
+  // load the file into settings
+  REXPORTER(obj)->settings = (QTAtomContainer)NewHandleClear(length);
+  read_length = fread(*(Handle)REXPORTER(obj)->settings, 1, length, file);
+  if (read_length != length) {
+    rb_raise(eQuicktime, "Unable to read entire file at %s.", RSTRING(filepath)->ptr);
+  }
+  
+  fclose(file);
+  
+  return Qnil;
+}
+
+/*
+  Saves the settings to the given filepath (usually with .st extension). 
+  See open_settings_dialog and load_settings.
+
+call-seq:
+  save_settings(filepath)
+*/
+static VALUE exporter_save_settings(VALUE obj, VALUE filepath)
+{
+  FILE *file;
+  QTAtomContainer settings = REXPORTER(obj)->settings;
+  
+  if (!settings) {
+    rb_raise(eQuicktime, "Unable to save settings because no settings are specified.");
+  }
+  
+  file = fopen(RSTRING(filepath)->ptr, "wb");
+  if (!file) {
+    rb_raise(eQuicktime, "Unable to open file for saving at %s.", RSTRING(filepath)->ptr);
+  }
+  fwrite(&settings, GetHandleSize((Handle)settings), 1, file);
+  fclose(file);
+  
+  return Qnil;
+}
+
+void Init_quicktime_exporter()
+{
+  cExporter = rb_define_class_under(mQuicktime, "Exporter", rb_cObject);
+  rb_define_alloc_func(cExporter, exporter_new);
+  rb_define_method(cExporter, "export", exporter_export_to_file, 1);
+  rb_define_method(cExporter, "open_settings_dialog", exporter_open_settings_dialog, 0);
+  rb_define_method(cExporter, "load_settings", exporter_load_settings, 1);
+  rb_define_method(cExporter, "save_settings", exporter_save_settings, 1);
+}

data/ext/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+$LDFLAGS = '-framework Quicktime'
+create_makefile('rmov_ext')

data/ext/movie.c

@@ -0,0 +1,435 @@
+#include "rmov_ext.h"
+
+VALUE cMovie;
+
+OSErr movie_progress_proc(Movie movie, short message, short operation, Fixed percent, VALUE proc)
+{
+  rb_funcall(proc, rb_intern("call"), 1, rb_float_new(FixedToFloat(percent)));
+  return 0;
+}
+
+static void movie_free(struct RMovie *rMovie)
+{
+  if (rMovie->movie) {
+    DisposeMovie(rMovie->movie);
+  }
+}
+
+static void movie_mark(struct RMovie *rMovie)
+{
+}
+
+/*
+  Creates a new movie instance. Generally you want to go through 
+  Movie.open or Movie.empty to load or create a new movie respectively. 
+  If you do no then you will need to load the movie with load_empty or 
+  load_from_file before you can accomplish anything.
+
+call-seq:
+  new() -> movie
+*/
+static VALUE movie_new(VALUE klass)
+{
+  struct RMovie *rMovie;
+  return Data_Make_Struct(klass, struct RMovie, movie_mark, movie_free, rMovie);
+}
+
+/*
+  Dispose of the loaded QuickTime movie. This will automatically be done 
+  when this movie instance is garbage collected. However if you are 
+  iterating through many movies it is often helpful to dispose of it 
+  as soon as you're done with it.
+
+call-seq:
+  dispose()
+*/
+static VALUE movie_dispose(VALUE obj)
+{
+  if (MOVIE(obj)) {
+    DisposeMovie(MOVIE(obj));
+    RMOVIE(obj)->movie = NULL;
+  }
+  return obj;
+}
+
+/*
+  Loads a new, empty QuickTime movie at given filepath. Should only be 
+  called if no movie has been loaded (or it has been disposed). Usually 
+  you go through Movie.open.
+
+call-seq:
+  load_from_file(filepath)
+*/
+static VALUE movie_load_from_file(VALUE obj, VALUE filepath)
+{
+  if (MOVIE(obj)) {
+    rb_raise(eQuicktime, "Movie has already been loaded.");
+  } else {
+    OSErr err;
+    FSSpec fs;
+    short frefnum = -1;
+    short movie_resid = 0;
+    Movie *movie = ALLOC(Movie);
+    
+    err = NativePathNameToFSSpec(RSTRING(filepath)->ptr, &fs, 0);
+    if (err != 0)
+      rb_raise(eQuicktime, "Error %d occurred while reading file at %s", err, RSTRING(filepath)->ptr);
+    
+    err = OpenMovieFile(&fs, &frefnum, fsRdPerm);
+    if (err != 0)
+      rb_raise(eQuicktime, "Error %d occurred while opening movie at %s", err, RSTRING(filepath)->ptr);
+    
+    err = NewMovieFromFile(movie, frefnum, &movie_resid, 0, newMovieActive, 0);
+    if (err != 0)
+      rb_raise(eQuicktime, "Error %d occurred while loading movie at %s", err, RSTRING(filepath)->ptr);
+    
+    err = CloseMovieFile(frefnum);
+    if (err != 0)
+      rb_raise(eQuicktime, "Error %d occurred while closing movie file at %s", err, RSTRING(filepath)->ptr);
+    
+    RMOVIE(obj)->movie = *movie;
+    
+    return obj;
+  }
+}
+
+/*
+  Loads a new, empty QuickTime movie. Should only be called if no movie 
+  has been loaded (or it has been disposed). Usually you go through 
+  Movie.empty.
+
+call-seq:
+  load_empty()
+*/
+static VALUE movie_load_empty(VALUE obj)
+{
+  if (MOVIE(obj)) {
+    rb_raise(eQuicktime, "Movie has already been loaded.");
+  } else {
+    RMOVIE(obj)->movie = NewMovie(0);
+    return obj; 
+  }
+}
+
+/*
+  Returns the raw duration of the movie. Combine this with time_scale to 
+  reach the duration in seconds.
+
+call-seq:
+  raw_duration() -> duration_int
+*/
+static VALUE movie_raw_duration(VALUE obj)
+{
+  return INT2NUM(GetMovieDuration(MOVIE(obj)));
+}
+
+/*
+  Returns the time scale of the movie. Usually only needed when working 
+  with raw_duration.
+
+call-seq:
+  time_scale() -> scale_int
+*/
+static VALUE movie_time_scale(VALUE obj)
+{
+  return INT2NUM(GetMovieTimeScale(MOVIE(obj)));
+}
+
+/*
+  Returns the number of tracks in the movie.
+
+call-seq:
+  track_count() -> count
+*/
+static VALUE movie_bounds(VALUE obj)
+{
+  VALUE bounds_hash = rb_hash_new();
+  Rect bounds;
+  GetMovieBox(MOVIE(obj), &bounds);
+  rb_hash_aset(bounds_hash, ID2SYM(rb_intern("left")), INT2NUM(bounds.left));
+  rb_hash_aset(bounds_hash, ID2SYM(rb_intern("top")), INT2NUM(bounds.top));
+  rb_hash_aset(bounds_hash, ID2SYM(rb_intern("right")), INT2NUM(bounds.right));
+  rb_hash_aset(bounds_hash, ID2SYM(rb_intern("bottom")), INT2NUM(bounds.bottom));
+  return bounds_hash;
+}
+
+/*
+  Returns the number of tracks in the movie.
+
+call-seq:
+  track_count -> count
+*/
+static VALUE movie_track_count(VALUE obj)
+{
+  return INT2NUM(GetMovieTrackCount(MOVIE(obj)));
+}
+
+/*
+  Adds the tracks of given movie into called movie at given position (in seconds).
+  
+  You can track the progress of this operation by passing a block to this 
+  method. It will be called regularly during the process and pass the 
+  percentage complete (0.0 to 1.0) as an argument to the block.
+
+call-seq:
+  composite_movie(movie, position)
+*/
+static VALUE movie_composite_movie(VALUE obj, VALUE src, VALUE position)
+{
+  if (rb_block_given_p())
+    SetMovieProgressProc(MOVIE(obj), (MovieProgressUPP)movie_progress_proc, rb_block_proc());
+  
+  SetMovieSelection(MOVIE(obj), MOVIE_TIME(obj, position), 0);
+  AddMovieSelection(MOVIE(obj), MOVIE(src));
+  
+  if (rb_block_given_p())
+    SetMovieProgressProc(MOVIE(obj), 0, 0);
+  
+  return obj;
+}
+
+/*
+  Inserts given movie into called movie at given position (in seconds).
+
+  You can track the progress of this operation by passing a block to this 
+  method. It will be called regularly during the process and pass the 
+  percentage complete (0.0 to 1.0) as an argument to the block.
+
+call-seq:
+  append_movie(movie, position)
+*/
+static VALUE movie_insert_movie(VALUE obj, VALUE src, VALUE position)
+{
+  if (rb_block_given_p())
+    SetMovieProgressProc(MOVIE(obj), (MovieProgressUPP)movie_progress_proc, rb_block_proc());
+  
+  SetMovieSelection(MOVIE(obj), MOVIE_TIME(obj, position), 0);
+  PasteMovieSelection(MOVIE(obj), MOVIE(src));
+  
+  if (rb_block_given_p())
+    SetMovieProgressProc(MOVIE(obj), 0, 0);
+  
+  return obj;
+}
+
+/*
+  Adds given movie to the end of movie which this method is called on.
+
+  You can track the progress of this operation by passing a block to this 
+  method. It will be called regularly during the process and pass the 
+  percentage complete (0.0 to 1.0) as an argument to the block.
+
+call-seq:
+  append_movie(movie)
+*/
+static VALUE movie_append_movie(VALUE obj, VALUE src)
+{
+  if (rb_block_given_p())
+    SetMovieProgressProc(MOVIE(obj), (MovieProgressUPP)movie_progress_proc, rb_block_proc());
+  
+  SetMovieSelection(MOVIE(obj), GetMovieDuration(MOVIE(obj)), 0);
+  PasteMovieSelection(MOVIE(obj), MOVIE(src));
+  
+  if (rb_block_given_p())
+    SetMovieProgressProc(MOVIE(obj), 0, 0);
+  
+  return obj;
+}
+
+/*
+  Deletes given section from movie. Both start_time and duration 
+  should be floats representing seconds.
+
+call-seq:
+  delete_section(start_time, duration)
+*/
+static VALUE movie_delete_section(VALUE obj, VALUE start, VALUE duration)
+{
+  SetMovieSelection(MOVIE(obj), MOVIE_TIME(obj, start), MOVIE_TIME(obj, duration));
+  ClearMovieSelection(MOVIE(obj));
+  return obj;
+}
+
+/*
+  Returns a new movie in the given section. Does not modify original 
+  movie. Both start_time and duration should be floats representing 
+  seconds.
+
+  You can track the progress of this operation by passing a block to this 
+  method. It will be called regularly during the process and pass the 
+  percentage complete (0.0 to 1.0) as an argument to the block.
+
+call-seq:
+  clone_section(start_time, duration) -> movie
+*/
+static VALUE movie_clone_section(VALUE obj, VALUE start, VALUE duration)
+{
+  VALUE new_movie_obj = rb_obj_alloc(cMovie);
+  
+  if (rb_block_given_p())
+    SetMovieProgressProc(MOVIE(obj), (MovieProgressUPP)movie_progress_proc, rb_block_proc());
+  
+  SetMovieSelection(MOVIE(obj), MOVIE_TIME(obj, start), MOVIE_TIME(obj, duration));
+  RMOVIE(new_movie_obj)->movie = CopyMovieSelection(MOVIE(obj));
+  
+  if (rb_block_given_p())
+    SetMovieProgressProc(MOVIE(obj), 0, 0);
+  
+  return new_movie_obj;
+}
+
+/*
+  Deletes given section on movie and returns a new movie with that 
+  section. Both start_time and duration should be floats representing 
+  seconds.
+
+  You can track the progress of this operation by passing a block to this 
+  method. It will be called regularly during the process and pass the 
+  percentage complete (0.0 to 1.0) as an argument to the block.
+
+call-seq:
+  clip_section(start_time, duration) -> movie
+*/
+static VALUE movie_clip_section(VALUE obj, VALUE start, VALUE duration)
+{
+  VALUE new_movie_obj = rb_obj_alloc(cMovie);
+  
+  if (rb_block_given_p())
+    SetMovieProgressProc(MOVIE(obj), (MovieProgressUPP)movie_progress_proc, rb_block_proc());
+  
+  SetMovieSelection(MOVIE(obj), MOVIE_TIME(obj, start), MOVIE_TIME(obj, duration));
+  RMOVIE(new_movie_obj)->movie = CutMovieSelection(MOVIE(obj));
+  
+  if (rb_block_given_p())
+    SetMovieProgressProc(MOVIE(obj), 0, 0);
+  
+  return new_movie_obj;
+}
+
+/*
+  Determine if a movie has changed since opening. Returns true/false. 
+  See reset_changed_status to reset this value.
+
+call-seq:
+  changed?() -> bool
+*/
+static VALUE movie_changed(VALUE obj)
+{
+  if (HasMovieChanged(MOVIE(obj))) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+/*
+  Resets the "changed?" status. Does not revert the movie itself.
+
+call-seq:
+  clear_changed_status()
+*/
+static VALUE movie_clear_changed_status(VALUE obj)
+{
+  ClearMovieChanged(MOVIE(obj));
+  return Qnil;
+}
+
+
+/*
+  Saves the movie to the given filepath by flattening it.
+
+call-seq:
+  flatten(filepath)
+*/
+
+static VALUE movie_flatten(VALUE obj, VALUE filepath)
+{
+  OSErr err;
+  FSSpec fs;
+  VALUE new_movie_obj = rb_obj_alloc(cMovie);
+  
+  err = NativePathNameToFSSpec(RSTRING(filepath)->ptr, &fs, 0);
+  if (err != fnfErr)
+    rb_raise(eQuicktime, "Error %d occurred while opening file for export at %s", err, RSTRING(filepath)->ptr);
+  
+  // TODO make these flags settable through an options hash
+  RMOVIE(new_movie_obj)->movie = FlattenMovieData(MOVIE(obj),
+                                  flattenDontInterleaveFlatten
+                                  | flattenCompressMovieResource
+                                  | flattenAddMovieToDataFork
+                                  | flattenForceMovieResourceBeforeMovieData,
+                                  &fs, 'TVOD', smSystemScript, createMovieFileDontCreateResFile);
+  return new_movie_obj;
+}
+
+/*
+  Exports a PICT file to given filepath (should end in .pct) at the given 
+  time. Time should be a floating point in seconds.
+
+call-seq:
+  export_pict(filepath, time)
+  
+*/
+
+static VALUE movie_export_pict(VALUE obj, VALUE filepath, VALUE frame_time)
+{
+  GraphicsImportComponent component;
+  PicHandle picture;
+  Handle handle;
+  FSSpec fs;
+  OSErr err;
+  
+  picture = GetMoviePict(MOVIE(obj), MOVIE_TIME(obj, frame_time));
+  
+  err = NativePathNameToFSSpec(RSTRING(filepath)->ptr, &fs, 0);
+  if (err != fnfErr)
+    rb_raise(eQuicktime, "Error %d occurred while opening file for export at %s.", err, RSTRING(filepath)->ptr);
+  
+  // Convert the picture handle into a PICT file (still in a handle)
+  // by adding a 512-byte header to the start.
+  handle = NewHandleClear(512);
+  err = HandAndHand((Handle)picture, handle);
+  if (err != noErr)
+    rb_raise(eQuicktime, "Error %d occurred while converting handle for pict export %s.", err, RSTRING(filepath)->ptr);
+  
+  err = OpenADefaultComponent(GraphicsImporterComponentType, kQTFileTypePicture, &component);
+  if (err != noErr)
+    rb_raise(eQuicktime, "Error %d occurred while opening picture component for %s.", err, RSTRING(filepath)->ptr);
+  
+  err = GraphicsImportSetDataHandle(component, handle);
+  if (err != noErr)
+    rb_raise(eQuicktime, "Error %d occurred while setting graphics importer data handle for %s.", err, RSTRING(filepath)->ptr);
+  
+  err = GraphicsImportExportImageFile(component, 0, 0, &fs, smSystemScript);
+  if (err != noErr)
+    rb_raise(eQuicktime, "Error %d occurred while exporting pict to file %s.", err, RSTRING(filepath)->ptr);
+  
+  CloseComponent(component);
+  DisposeHandle(handle);
+  DisposeHandle((Handle)picture);
+  
+  return Qnil;
+}
+
+void Init_quicktime_movie()
+{
+  cMovie = rb_define_class_under(mQuicktime, "Movie", rb_cObject);
+  rb_define_alloc_func(cMovie, movie_new);
+  rb_define_method(cMovie, "load_from_file", movie_load_from_file, 1);
+  rb_define_method(cMovie, "load_empty", movie_load_empty, 0);
+  rb_define_method(cMovie, "raw_duration", movie_raw_duration, 0);
+  rb_define_method(cMovie, "time_scale", movie_time_scale, 0);
+  rb_define_method(cMovie, "bounds", movie_bounds, 0);
+  rb_define_method(cMovie, "track_count", movie_track_count, 0);
+  rb_define_method(cMovie, "composite_movie", movie_composite_movie, 2);
+  rb_define_method(cMovie, "insert_movie", movie_insert_movie, 2);
+  rb_define_method(cMovie, "append_movie", movie_append_movie, 1);
+  rb_define_method(cMovie, "delete_section", movie_delete_section, 2);
+  rb_define_method(cMovie, "clone_section", movie_clone_section, 2);
+  rb_define_method(cMovie, "clip_section", movie_clip_section, 2);
+  rb_define_method(cMovie, "changed?", movie_changed, 0);
+  rb_define_method(cMovie, "clear_changed_status", movie_clear_changed_status, 0);
+  rb_define_method(cMovie, "flatten", movie_flatten, 1);
+  rb_define_method(cMovie, "export_pict", movie_export_pict, 2);
+  rb_define_method(cMovie, "dispose", movie_dispose, 0);
+}