one-k-rmov 0.1.4

data/CHANGELOG

@@ -0,0 +1,38 @@
+
+* adding more property information from movie and track, such as codec information
+
+1K Studios Forked Version
+
+0.1.4 (October 3rd, 2008)
+
+* adding support for several export_image formats (PNG, JPEG, TIFF, TGA, BMP, PSD)
+
+* adding movie.export_image as a generic way to export a frame to multiple formats
+
+0.1.3 (October 3rd, 2008)
+
+* some support for text tracks
+
+* adding movie.new_video_track and movie.new_audio_track methods for creating new tracks
+
+* changing Quicktime module name to QuickTime to match proper casing
+
+0.1.2 (October 3rd, 2008)
+
+* movie.poster_time and movie.poster_time=(seconds) for getting and setting a movie's poster time
+
+* track.offset and track.offset=(seconds) for getting and setting a track's offset time from the start of a movie
+
+* track.volume and track.volume=(vol) for getting and setting a track's volume
+
+* QuickTime settings dialog comes into the forground properly
+
+0.1.1 (October 3rd, 2008)
+
+* RubyGems 1.3 compatibility (updated Echoe)
+
+* fixing inline RDocs so call sequence is handled properly
+
+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,24 @@
+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

data/README.rdoc

@@ -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(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.4') 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/*", "spec/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,15 @@
+Fixes
+- check if movie/track really exists each time we call it
+
+Features
+- resize movie
+- get movie metadata (album, author, artist, etc.)
+- set movie metadata
+- add text track to movie
+- add chapters to movie
+
+Possible
+- time remapping
+- programatically adjust export settings (framerate, codec, etc.)
+- export image sequence
+- import image sequence

data/ext/exporter.c

@@ -0,0 +1,195 @@
+#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)
+{
+}
+
+/*
+  call-seq: new(movie) -> exporter
+  
+  Creates a new exporter instance. Usually this is done through 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;
+}
+
+/*
+  call-seq: export_to_file(filepath)
+  
+  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.
+*/
+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;
+}
+
+/*
+  call-seq: open_settings_dialog()
+  
+  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.
+*/
+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
+  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;
+  }
+}
+
+/*
+  call-seq: load_settings(filepath)
+  
+  Loads the settings at the given filepath. See save_settings.
+*/
+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;
+}
+
+/*
+  call-seq: save_settings(filepath)
+  
+  Saves the settings to the given filepath (usually with .st extension). 
+  See open_settings_dialog and load_settings.
+*/
+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()
+{
+  VALUE mQuickTime;
+  mQuickTime = rb_define_module("QuickTime");
+  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')