edl 0.0.1

data/History.txt

@@ -0,0 +1,5 @@
+=== 0.0.1 / 2008-12-22
+
+* 1 major enhancement
+
+  * Birthday!

data/README.txt

@@ -0,0 +1,46 @@
+= EDL
+
+== DESCRIPTION:
+
+Work with EDL files from Ruby
+
+
+== SYNOPSIS:
+
+  list = EDL::Parser.new(fps=25).parse(File.open('OFFLINE.EDL'))
+  list.events.each do | evt |
+    puts evt.inspect
+  end
+  
+== REQUIREMENTS:
+
+* Timecode gem (sudo gem install timecode)
+
+== INSTALL:
+
+* sudo gem install edl
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Julik Tarkhanov <me@julik.nl>
+
+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/Rakefile

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'hoe'
+require './lib/edl.rb'
+
+Hoe.new('edl', EDL::VERSION) do |p|
+  p.rubyforge_name = 'wiretap'
+  p.developer('Julik', 'me@julik.nl')
+  p.extra_deps << "flexmock" << "timecode"
+end

data/lib/edl.rb

@@ -0,0 +1,426 @@
+require "rubygems"
+require "timecode"
+
+# A simplistic EDL parser. Current limitations: no support for DF timecode, no support for audio,
+# no support for split edits, no support for key effects, no support for audio
+module EDL
+  VERSION = "0.0.1"
+  
+  DEFAULT_FPS = 25
+  
+  # Represents an EDL, is returned from the parser. Traditional operation is functional style, i.e.
+  #  edl.renumbered.without_transitions.without_generators
+  class List
+    attr_accessor :events, :fps
+    
+    def initialize(events = [])
+      @events = events.dup
+    end
+    
+    # Return the same EDL with all dissolves stripped and replaced by the clips under them
+    def without_transitions
+      # Find dissolves
+      cpy = []
+      
+      @events.each_with_index do | e, i |
+        # A dissolve always FOLLOWS the incoming clip
+        if @events[i+1] && @events[i+1].has_transition?
+          dissolve = @events[i+1]
+          len = dissolve.transition.duration.to_i
+          
+          # The dissolve contains the OUTGOING clip, we are the INCOMING. Extend the
+          # incoming clip by the length of the dissolve, that's the whole mission actually
+          incoming = e.copy_properties_to(e.class.new)
+          incoming.src_end_tc += len
+          incoming.rec_end_tc += len
+          
+          outgoing = dissolve.copy_properties_to(Clip.new)
+          
+          # Add the A suffix to the ex-dissolve
+          outgoing.num += 'A'
+          
+          # Take care to join the two if they overlap - TODO
+          cpy << incoming
+          cpy << outgoing
+        elsif e.has_transition?
+          # Skip, already handled!
+        else
+          cpy << e.dup
+        end
+      end
+      # Do not renumber events
+      # (0...cpy.length).map{|e| cpy[e].num = "%03d" % e }
+      self.class.new(cpy)
+    end
+    
+    def renumbered
+      renumed = @events.dup
+      pad = renumed.length.to_s.length
+      pad = 3 if pad < 3
+      
+      (0...renumed.length).map{|e| renumed[e].num = "%0#{pad}d" % (e+1) }
+      x = self.class.new(renumed)
+      puts x.inspect
+      x
+    end
+        
+    # Return the same EDL with all timewarps expanded to native length. Clip length
+    # changes have rippling effect on footage that comes after the timewarped clip
+    # (so this is best used in concert with the original EDL where record TC is pristine)
+    def without_timewarps
+      self.class.new(
+        @events.map do | e |
+          
+          if e.has_timewarp?
+            repl = e.copy_properties_to(e.class.new)
+            from, to = e.timewarp.actual_src_start_tc, e.timewarp.actual_src_end_tc
+            repl.src_start_tc, repl.src_end_tc, repl.timewarp = from, to, nil
+            repl
+          else
+            e
+          end
+        end
+      )
+    end
+    
+    # Return the same EDL without AX, BL and other GEN events (like slug, text and solids).
+    # Usually used in concert with "without_transitions"
+    def without_generators
+      self.class.new(@events.reject{|e| e.generator? })
+    end
+    
+    # Return the list of clips used by this EDL at full capture length
+    def capture_list
+      without_generators.without_timewarps.spliced.from_zero
+    end
+    
+    # Return the same EDL with the first event starting at 00:00:00:00 and all subsequent events
+    # shifted accordingly
+    def from_zero
+      shift_by = @events[0].rec_start_tc
+      self.class.new(
+        @events.map do | original |
+          e = original.dup
+          e.rec_start_tc =  (e.rec_start_tc - shift_by)
+          e.rec_end_tc =  (e.rec_end_tc - shift_by)
+          e
+        end
+      )
+    end
+    
+    # Return the same EDL with neighbouring clips joined at cuts where applicable (if a clip
+    # is divided in two pieces it will be spliced). Most useful in combination with without_timewarps
+    def spliced
+      spliced_edl = @events.inject([]) do | spliced, cur  |
+        latest = spliced[-1]
+        # Append to latest if splicable
+        if latest && (latest.reel == cur.reel) && (cur.src_start_tc == (latest.src_end_tc + 1))
+          latest.src_end_tc = cur.src_end_tc
+          latest.rec_end_tc = cur.rec_end_tc
+        else
+          spliced << cur.dup
+        end
+        spliced
+      end
+      self.class.new(spliced_edl)
+    end
+  end
+  
+  # Represents an edit event
+  class Event
+    attr_accessor :num, 
+      :reel, 
+      :track,
+      :src_start_tc, 
+      :src_end_tc, 
+      :rec_start_tc, 
+      :rec_end_tc,
+      :comments,
+      :original_line
+    
+    def to_s
+      %w( num reel track src_start_tc src_end_tc rec_start_tc rec_end_tc).map{|a| self.send(a).to_s}.join("  ")
+    end
+    
+    def inspect
+      to_s
+    end
+    
+    def copy_properties_to(evt)
+      %w( num reel track src_start_tc src_end_tc rec_start_tc rec_end_tc).each do | k |
+        evt.send("#{k}=", send(k)) if evt.respond_to?(k)
+      end
+      evt
+    end
+  end
+  
+  class Clip < Event
+    attr_accessor :clip_name, :timewarp
+    attr_accessor :transition
+    
+    # Returns true if the clip starts with a transiton (not a jump cut)
+    def has_transition?
+      !transition.nil?
+    end
+    
+    def has_timewarp?
+      !timewarp.nil?
+    end
+    
+    def black?
+      reel == 'BL'
+    end
+    alias_method :slug?, :black?
+    
+    def length
+      (rec_end_tc - rec_start_tc).to_i
+    end
+    
+    def generator?
+      black? || (%(AX GEN).include?(reel))
+    end
+  end
+  
+  # Represents a transition. We currently only support dissolves and SMPTE wipes
+  # Will be avilable as EDL::Clip#transition
+  class Transition
+    attr_accessor :duration, :effect
+  end
+  
+  # Represents a dissolve
+  class Dissolve < Transition; end
+  
+  # Represents an SMPTE wipe
+  class Wipe < Transition
+    attr_accessor :smpte_wipe_index
+  end
+  
+  # Represents a timewarp
+  class Timewarp
+    attr_accessor :actual_framerate
+    attr_accessor :clip
+    
+    def speed_in_percent
+      (actual_framerate.to_f / DEFAULT_FPS.to_f ) * 100
+    end
+    
+    # Get the actual end of source that is needed for the timewarp to be computed properly,
+    # round up to not generate stills at ends of clips
+    def actual_src_end_tc
+      unless reverse?
+        clip.src_start_tc + actual_length_of_source
+      else
+        clip.src_start_tc
+      end
+    end
+    
+    def actual_src_start_tc
+      unless reverse?
+        clip.src_start_tc
+      else
+        clip.src_start_tc - actual_length_of_source
+      end
+    end
+    
+    # Returns the true number of frames that is needed to complete the timewarp edit
+    def actual_length_of_source
+      length_in_edit = (clip.src_end_tc - clip.src_start_tc).to_i
+      ((length_in_edit / 25.0) * actual_framerate).ceil.abs
+    end
+    
+    def reverse?
+      actual_framerate < 0
+    end
+  end
+  
+  # A generic matcher
+  class Matcher
+    class ApplyError < RuntimeError
+      def initialize(msg, line)
+        super("%s - offending line was '%s'" % [msg, line])
+      end
+    end
+    
+    def initialize(with_regexp)
+      @regexp = with_regexp
+    end
+    
+    def matches?(line)
+      line =~ @regexp
+    end
+    
+    def apply(stack, line)
+      STDERR.puts "Skipping #{line}"
+    end
+  end
+  
+  class NameMatcher < Matcher
+    def initialize
+      super(/\* FROM CLIP NAME:(\s+)(.+)/)
+    end
+    
+    def apply(stack, line)
+      stack[-1].clip_name = line.scan(@regexp).flatten.pop.strip
+    end
+  end
+  
+  class EffectMatcher < Matcher
+    def initialize
+      super(/\* EFFECT NAME:(\s+)(.+)/)
+    end
+    
+    def apply(stack, line)
+      stack[-1].transition.effect = line.scan(@regexp).flatten.pop.strip
+    end
+  end
+  
+  class TimewarpMatcher < Matcher
+    
+    attr_reader :fps
+    
+    def initialize(fps)
+      @fps = fps
+      @regexp = /M2(\s+)(\w+)(\s+)(\-?\d+\.\d+)(\s+)(\d{1,2}):(\d{1,2}):(\d{1,2}):(\d{1,2})/
+    end
+    
+    def apply(stack, line)
+      matches = line.scan(@regexp).flatten.map{|e| e.strip}.reject{|e| e.nil? || e.empty?}
+      
+      from_reel = matches.shift
+      fps = matches.shift
+      
+      begin
+        # FIXME
+        tw_start_source_tc = Parser.timecode_from_line_elements(matches, @fps)
+      rescue Timecode::Error => e
+        raise ApplyError, "Invalid TC in timewarp (#{e})", line
+      end
+      
+      evt_with_tw = stack.reverse.find{|e| e.src_start_tc == tw_start_source_tc && e.reel == from_reel }
+
+      unless evt_with_tw
+        raise ApplyError, "Cannot find event marked by timewarp", line
+      else
+        tw = Timewarp.new
+        tw.actual_framerate, tw.clip = fps.to_f, evt_with_tw
+        evt_with_tw.timewarp = tw
+      end
+    end
+  end
+  
+  # Drop frame goodbye
+  TC = /(\d{1,2}):(\d{1,2}):(\d{1,2}):(\d{1,2})/
+  
+  class EventMatcher < Matcher
+
+    # 021  009      V     C        00:39:04:21 00:39:05:09 01:00:26:17 01:00:27:05
+    EVENT_PAT = /(\d+)(\s+)(\w+)(\s+)(\w+)(\s+)(\w+)(\s+)((\w+\s+)?)#{TC} #{TC} #{TC} #{TC}/
+    
+    attr_reader :fps
+    
+    def initialize(some_fps)
+      super(EVENT_PAT)
+      @fps = some_fps
+    end
+    
+    def apply(stack, line)
+      
+      matches = line.scan(@regexp).shift
+      props = {:original_line => line}
+      
+      # FIrst one is the event number
+      props[:num] = matches.shift
+      matches.shift
+
+      # Then the reel
+      props[:reel] = matches.shift
+      matches.shift
+
+      # Then the track
+      props[:track] = matches.shift
+      matches.shift
+
+      # Then the type
+      props[:transition] = matches.shift
+      matches.shift
+      
+      # Then the optional generator group - skip for now
+      if props[:transition] != 'C'
+        props[:duration] = matches.shift.strip
+      else
+        matches.shift
+      end
+      matches.shift
+      
+      # Then the timecodes
+      [:src_start_tc, :src_end_tc, :rec_start_tc, :rec_end_tc].each do | k |
+        begin
+          PROPS[K] = edl::pARSER.TIMECODE_FROM_LINE_ELEMENTS(MATCHES, @FPS)
+        rescue Timecode::Error => e 
+          raise ApplyError, "Cannot parse timecode - #{e}", line
+        end
+      end
+      
+      evt = Clip.new
+      transition_idx = props.delete(:transition)
+      evt.transition = case transition_idx
+        when 'D'
+          d = Dissolve.new
+          d.duration = props.delete(:duration)
+          d
+        when /W/
+          w = Wipe.new
+          w.duration = props.delete(:duration)
+          w.smpte_wipe_index = transition_idx.gsub(/W/, '')
+          w
+        else
+          nil
+      end
+      
+      props.each_pair { | k, v | evt.send("#{k}=", v) }
+      
+      stack << evt
+      evt # FIXME - we dont need to return this is only used by tests
+    end
+  end
+  
+  class Parser
+    
+    attr_reader :fps
+    
+    # Initialize an EDL parser. Pass the FPS to it, as the usual EDL does not contain any kind of reference 
+    # to it's framerate
+    def initialize(with_fps = DEFAULT_FPS)
+      @fps = with_fps
+    end
+    
+    def get_matchers
+      [ EventMatcher.new(@fps), EffectMatcher.new, NameMatcher.new, TimewarpMatcher.new(@fps) ]
+    end
+    
+    def parse(io)
+      stack, matchers = [], get_matchers
+      until io.eof?
+        current_line = io.gets.strip
+        matchers.each do | matcher |
+          next unless matcher.matches?(current_line)
+          
+          begin
+            matcher.apply(stack, current_line)
+          rescue Matcher::ApplyError => e
+            STDERR.puts "Cannot parse #{current_line} - #{e}"
+          end
+        end
+      end
+      
+      return List.new(stack)
+    end
+    
+    def self.timecode_from_line_elements(elements, fps)
+      args = (0..3).map{|_| elements.shift.to_i} + [fps]
+      Timecode.at(*args)
+    end
+  end
+  
+  
+end

data/lib/edl/cutter.rb

@@ -0,0 +1,34 @@
+module EDL
+  # Can chop an offline edit into events according to the EDL
+  class Cutter
+    def initialize(source_path)
+      @source_path = source_path
+    end
+    
+    def cut(edl)
+      source_for_cutting = edl.from_zero #.without_transitions.without_generators
+      # We need to use the original length in record
+      source_for_cutting.events.each do | evt |
+        cut_segment(evt, evt.rec_start_tc, evt.rec_start_tc + evt.length)
+      end
+    end
+    
+    def cut_segment(evt, start_at, end_at)
+      STDERR.puts "Cutting #{@source_path} from #{start_at} to #{end_at} - #{evt.num}"
+    end
+  end
+  
+  class FFMpegCutter < Cutter
+    def cut_segment(evt, start_at, end_at)
+      source_dir, source_file = File.dirname(@source_path), File.basename(@source_path)
+      dest_segment = File.join(source_dir, ('%s_%s' % [evt.num, source_file]))
+    # dest_segment.gsub!(/\.mov$/i, '.mp4')
+      
+      offset = end_at - start_at
+      
+      cmd = "/opt/local/bin/ffmpeg -i #{@source_path} -ss #{start_at} -vframes #{offset.total} -vcodec photojpeg -acodec copy #{dest_segment}"
+     #puts cmd 
+     `#{cmd}`
+    end
+  end
+end

data/lib/edl/grabber.rb

@@ -0,0 +1,30 @@
+module EDL
+  # When initialized with a file and passed an EDL, will generate thumbnail images
+  # of the first frame of every event. It is assumed that the movie file starts at the same
+  # frame as the first EDL event.
+  class Grabber
+    attr_accessor :ffmpeg_bin, :offset
+    def initialize(with_file)
+      @source_path = with_file
+    end
+    
+    def ffmpeg_bin
+      @ffmpeg_bin || 'ffmpeg'
+    end
+    
+    def grab(edl)
+      edl.from_zero.events.each do | evt |
+        grab_frame_tc = evt.rec_start_tc + (offset || 0 )
+        
+        to_file = File.dirname(@source_path) + '/' + evt.num + '_' + File.basename(@source_path).gsub(/\.(\w+)$/, '')
+        generate_grab(evt.num, grab_frame_tc, to_file)
+      end
+    end
+    
+    def generate_grab(evt, at, to_file)
+#      cmd = "#{ffmpeg_bin} -i #{@source_path} -an -ss #{at} -vframes 1 -r #{at.fps} -y #{to_file}%d.jpg"
+      cmd = "#{ffmpeg_bin} -i #{@source_path} -an -ss #{at} -vframes 1 -y #{to_file}%d.jpg"
+      `#{cmd}`
+    end
+  end
+end

data/test/samples/45S_SAMPLE.EDL

@@ -0,0 +1,48 @@
+TITLE:   EDIT 15 [14-11-08] 45 SEC EDL 
+001  106771   V     C        04:00:57:05 04:00:58:10 10:00:00:00 10:00:01:05 
+002  106771   V     C        04:03:44:06 04:03:45:08 10:00:01:05 10:00:02:07 
+003  106770   V     C        00:06:55:13 00:06:57:01 10:00:02:07 10:00:03:20 
+004  106771   V     C        03:16:35:05 03:16:36:05 10:00:03:20 10:00:04:20 
+005  106770   V     C        00:13:03:17 00:13:04:20 10:00:04:20 10:00:05:23 
+006  106771   V     C        03:11:43:02 03:11:44:04 10:00:05:23 10:00:07:00 
+007  106857   V     C        07:18:40:24 07:18:41:17 10:00:07:00 10:00:07:18 
+008  106857   V     C        07:22:25:19 07:22:27:02 10:00:07:18 10:00:09:01 
+009  106863   V     C        13:12:46:23 13:12:48:11 10:00:09:01 10:00:10:14 
+010  106857   V     C        08:00:32:00 08:00:33:10 10:00:10:14 10:00:11:24 
+011  106857   V     C        08:05:36:18 08:05:37:19 10:00:11:24 10:00:13:00 
+012  106857   V     C        07:04:47:06 07:04:50:13 10:00:13:00 10:00:16:07 
+M2   106857         012.5                07:04:47:06 
+013  106863   V     C        10:11:06:07 10:11:08:00 10:00:16:07 10:00:18:00 
+014  106863   V     C        10:09:16:21 10:09:18:11 10:00:18:00 10:00:19:15 
+015  106857   V     C        07:06:02:17 07:06:04:07 10:00:19:15 10:00:21:05 
+016  106857   V     C        09:07:18:07 09:07:20:16 10:00:21:05 10:00:23:14 
+M2   106857         002.5                09:07:18:07 
+017  106863   V     C        11:02:46:06 11:02:47:06 10:00:23:14 10:00:24:14 
+018  106863   V     C        11:10:17:04 11:10:17:20 10:00:24:14 10:00:25:05 
+019  106863   V     C        12:06:09:18 12:06:10:16 10:00:25:05 10:00:26:03 
+020  106863   V     C        12:10:49:17 12:10:51:02 10:00:26:03 10:00:27:13 
+021  106815   V     C        05:01:22:21 05:01:24:05 10:00:27:13 10:00:28:22 
+022  106815   V     C        06:01:35:03 06:01:36:18 10:00:28:22 10:00:30:12 
+023  106815   V     C        05:13:38:19 05:13:40:10 10:00:30:12 10:00:32:03 
+M2   106815        -025.0                05:13:38:19 
+024  106857   V     C        09:13:03:09 09:13:05:11 10:00:32:03 10:00:34:05 
+M2   106857        -025.0                09:13:03:09 
+025  106857   V     C        09:13:01:07 09:13:01:07 10:00:34:05 10:00:34:05 
+025  106771   V     D    022 03:11:55:00 03:11:56:17 10:00:34:05 10:00:35:22 
+M2   106857        -025.0                09:13:01:07 
+* BLEND, DISSOLVE 
+026  106771   V     C        03:11:56:17 03:11:56:17 10:00:35:22 10:00:35:22 
+026  106771   V     D    012 03:06:30:09 03:06:31:19 10:00:35:22 10:00:37:07 
+* BLEND, DISSOLVE 
+027  106863   V     C        13:15:29:20 13:15:31:02 10:00:37:07 10:00:38:14 
+028  106771   V     C        03:15:40:22 03:15:42:11 10:00:38:14 10:00:40:03 
+029  106863   V     C        13:15:51:02 13:15:52:08 10:00:40:03 10:00:41:09 
+030  106863   V     C        13:15:52:08 13:15:52:08 10:00:41:09 10:00:41:09 
+030     BL    V     D    032 00:00:00:00 00:00:01:07 10:00:41:09 10:00:42:16 
+* BLEND, DISSOLVE 
+>>> SOURCE 106770   106770           4919975f.793b8d33 
+>>> SOURCE 106771   106771           4919a179.79630563 
+>>> SOURCE 106815   106815           4919b521.79afcb70 
+>>> SOURCE 106857   106857           4919cbb9.7a080d9d 
+>>> SOURCE 106863   106863           4919e0c3.7a5a3cfc 
+

data/test/samples/REVERSE.EDL

@@ -0,0 +1,3 @@
+TITLE:   REVERSED_EDL 
+001  106857   V     C        09:13:03:09 09:13:05:11 10:00:32:03 10:00:34:05 
+M2   106857        -025.0                09:13:03:09 

data/test/samples/SIMPLE_DISSOLVE.EDL

@@ -0,0 +1,9 @@
+TITLE: SIMPLE_DISSOLVE
+FCM: NON-DROP FRAME
+
+001        BL V     C        00:00:00:00 00:00:00:00 01:00:00:00 01:00:00:00  
+001  006I     V     D    043 06:42:50:18 06:42:52:13 01:00:00:00 01:00:01:20  
+* EFFECT NAME: CROSS DISSOLVE
+* TO CLIP NAME:  TAPE_6-10.MOV
+* COMMENT: 
+

data/test/samples/SPLICEME.EDL

@@ -0,0 +1,8 @@
+TITLE: SPLICEME
+FCM: NON-DROP FRAME
+
+001  006I     V     C        06:42:50:18 06:42:52:13 01:00:00:00 01:00:01:20  
+
+002  006I     V     C        06:42:52:14 06:42:52:16 01:00:01:21 01:00:01:23
+
+003  006I     V     C        06:42:52:17 06:42:52:24 01:00:01:24 01:00:02:06

data/test/samples/TIMEWARP.EDL

@@ -0,0 +1,5 @@
+TITLE: TIMEWARP_EDL
+FCM: NON-DROP FRAME
+
+001  003      V     C        03:03:19:19 03:03:20:04 01:00:04:03 01:00:04:13  
+M2   003            309.6                03:03:19:19

data/test/samples/TIMEWARP_HALF.EDL

@@ -0,0 +1,5 @@
+TITLE: TIMEWARP_HALF_EDL
+FCM: NON-DROP FRAME
+
+001  003      V     C        03:03:19:19 03:03:20:04 01:00:04:03 01:00:04:13  
+M2   003            12.5                03:03:19:19

data/test/test_edl.rb

@@ -0,0 +1,303 @@
+require File.dirname(__FILE__) + '/../lib/edl'
+require File.dirname(__FILE__) + '/../lib/edl/cutter'
+require File.dirname(__FILE__) + '/../lib/edl/grabber'
+
+require 'rubygems'
+require 'test/unit'
+require 'flexmock'
+require 'flexmock/test_unit'
+
+TRAILER_EDL      = File.dirname(__FILE__) + '/samples/TRAILER_EDL.edl'
+SIMPLE_DISSOLVE  = File.dirname(__FILE__) + '/samples/SIMPLE_DISSOLVE.EDL'
+SPLICEME         = File.dirname(__FILE__) + '/samples/SPLICEME.EDL'
+SIMPLE_TIMEWARP  = File.dirname(__FILE__) + '/samples/TIMEWARP.EDL'
+SLOMO_TIMEWARP   = File.dirname(__FILE__) + '/samples/TIMEWARP_HALF.EDL'
+FORTY_FIVER      = File.dirname(__FILE__) + '/samples/45S_SAMPLE.EDL'
+REVERSE          = File.dirname(__FILE__) + '/samples/REVERSE.EDL'
+
+class TestEvent < Test::Unit::TestCase
+  def test_attributes_defined
+    evt = EDL::Event.new
+    %w(  num reel track src_start_tc src_end_tc rec_start_tc rec_end_tc ).each do | em |
+      assert_respond_to evt, em
+    end
+  end
+end
+
+class Test::Unit::TestCase
+  def parse_evt(matcher_klass, line)
+    stack = []
+    matcher_klass.new.apply(stack, line)
+    stack.pop
+  end
+end
+
+class TestParser < Test::Unit::TestCase
+  def test_inst
+    assert_nothing_raised { EDL::Parser.new }
+  end
+  
+  
+  def test_inits_matchers_with_framerate
+    p = EDL::Parser.new(30)
+    matchers = p.get_matchers
+    event_matcher = matchers.find{|e| e.is_a?(EDL::EventMatcher) }
+    assert_equal 30, event_matcher.fps
+  end
+  
+  def test_timecode_from_elements
+    elems = ["08", "04", "24", "24"]
+    assert_nothing_raised { @tc = EDL::Parser.timecode_from_line_elements(elems, 30) }
+    assert_kind_of Timecode, @tc
+    assert_equal "08:04:24:24", @tc.to_s
+    assert_equal 30, @tc.fps
+    assert elems.empty?, "The elements used for timecode should have been removed from the array"
+  end
+  
+  def test_dissolve
+    p = EDL::Parser.new
+    assert_nothing_raised{ @edl = p.parse File.open(SIMPLE_DISSOLVE) }
+    assert_kind_of EDL::List, @edl
+    assert_equal 2, @edl.events.length
+    
+    first = @edl.events[0]
+    assert_kind_of EDL::Clip, first
+    
+    second = @edl.events[1]
+    assert_kind_of EDL::Clip, second
+    assert second.has_transition?
+    
+    no_trans = @edl.without_transitions
+    
+    assert_equal 2, no_trans.events.length
+    target_tc = (Timecode.parse('01:00:00:00') + 43)
+    assert_equal target_tc, no_trans.events[0].rec_end_tc, 
+      "The incoming clip should have been extended by the length of the dissolve"
+    
+    target_tc = Timecode.parse('01:00:00:00')
+    assert_equal target_tc, no_trans.events[1].rec_start_tc
+      "The outgoing clip should have been left in place"
+  end
+  
+  def test_spliced
+    p = EDL::Parser.new
+    assert_nothing_raised{ @edl = p.parse(File.open(SPLICEME)) }
+    assert_equal 3, @edl.events.length
+    
+    spliced = @edl.spliced
+    assert_equal 1, spliced.events.length, "Should have been spliced to one event"
+  end
+end
+
+class TimewarpMatcherTest < Test::Unit::TestCase
+
+  def test_parses_as_one_event
+    @edl = EDL::Parser.new.parse(File.open(SIMPLE_TIMEWARP))
+    assert_kind_of EDL::List, @edl
+    assert_equal 1, @edl.events.length
+  end
+
+  def test_timewarp_attributes
+    @edl = EDL::Parser.new.parse(File.open(SIMPLE_TIMEWARP))
+    assert_kind_of EDL::List, @edl
+    assert_equal 1, @edl.events.length
+    
+    clip = @edl.events[0]
+    assert clip.has_timewarp?, "Should respond true to has_timewarp?"
+    assert_not_nil clip.timewarp
+    assert_kind_of EDL::Timewarp, clip.timewarp
+
+    assert clip.timewarp.actual_src_end_tc > clip.src_end_tc
+    assert_equal "03:03:24:18", clip.timewarp.actual_src_end_tc.to_s
+    assert_equal 124, clip.timewarp.actual_length_of_source
+    assert !clip.timewarp.reverse?
+    
+  end
+  
+  def test_timwarp_slomo
+    @edl = EDL::Parser.new.parse(File.open(SLOMO_TIMEWARP))
+    clip = @edl.events[0]
+    assert clip.has_timewarp?, "Should respond true to has_timewarp?"
+    assert_not_nil clip.timewarp
+    assert_kind_of EDL::Timewarp, clip.timewarp
+
+    assert clip.timewarp.actual_src_end_tc < clip.src_end_tc
+    assert_equal "03:03:19:24", clip.timewarp.actual_src_end_tc.to_s
+    assert_equal 10, clip.length
+    assert_equal 5, clip.timewarp.actual_length_of_source
+    assert_equal 50, clip.timewarp.speed_in_percent.to_i
+    assert !clip.timewarp.reverse?
+    
+  end
+end
+
+class ReverseTimewarpTest < Test::Unit::TestCase
+  def test_parse
+    @edl = EDL::Parser.new.parse(File.open(REVERSE))
+    assert_equal 1, @edl.events.length
+    
+    clip = @edl.events[0]
+    assert_equal 52, clip.length
+    
+    assert clip.has_timewarp?, "Should respond true to has_timewarp?"
+    tw = clip.timewarp
+    
+    assert_equal( -25, tw.actual_framerate.to_i)
+    assert tw.reverse?
+    assert_equal clip.length, tw.actual_length_of_source
+    assert_equal clip.src_start_tc, tw.actual_src_end_tc
+    assert_equal clip.src_start_tc - 52, tw.actual_src_start_tc
+    assert_equal( -100, clip.timewarp.speed_in_percent.to_i)
+    
+  end
+end
+
+class EventMatcherTest < Test::Unit::TestCase
+
+  EVT_PATTERNS = [
+    '020  008C     V     C        08:04:24:24 08:04:25:19 01:00:25:22 01:00:26:17', 
+    '021  009      V     C        00:39:04:21 00:39:05:09 01:00:26:17 01:00:27:05', 
+    '022  008C     V     C        08:08:01:23 08:08:02:18 01:00:27:05 01:00:28:00', 
+    '023  008C     V     C        08:07:30:02 08:07:30:21 01:00:28:00 01:00:28:19', 
+    '024        AX V     C        00:00:00:00 00:00:01:00 01:00:28:19 01:00:29:19', 
+    '025        BL V     C        00:00:00:00 00:00:00:00 01:00:29:19 01:00:29:19', 
+    '025  GEN      V     D    025 00:00:55:10 00:00:58:11 01:00:29:19 01:00:32:20',
+  ]
+
+  def test_clip_generation_from_line
+    m = EDL::EventMatcher.new(25)
+    
+    clip = m.apply([],
+      '020  008C     V     C        08:04:24:24 08:04:25:19 01:00:25:22 01:00:26:17'
+    )
+    
+    assert_not_nil clip
+    assert_kind_of EDL::Clip, clip
+    assert_equal '020', clip.num
+    assert_equal '008C', clip.reel
+    assert_equal 'V', clip.track
+    assert_equal '08:04:24:24', clip.src_start_tc.to_s
+    assert_equal '08:04:25:19', clip.src_end_tc.to_s
+    assert_equal '01:00:25:22', clip.rec_start_tc.to_s
+    assert_equal '01:00:26:17', clip.rec_end_tc.to_s
+    assert_equal '020  008C     V     C        08:04:24:24 08:04:25:19 01:00:25:22 01:00:26:17', clip.original_line
+  end
+  
+  def test_dissolve_generation_from_line
+    m = EDL::EventMatcher.new(25)
+    dissolve = m.apply([],
+      '025  GEN      V     D    025 00:00:55:10 00:00:58:11 01:00:29:19 01:00:32:20'
+    )
+    assert_not_nil dissolve
+    assert_kind_of EDL::Clip, dissolve
+    assert_equal '025', dissolve.num
+    assert_equal 'GEN', dissolve.reel
+    assert_equal 'V', dissolve.track
+    
+    assert dissolve.has_transition?
+    assert_not_nil dissolve.transition
+    assert_kind_of EDL::Dissolve, dissolve.transition
+    assert_equal '025', dissolve.transition.duration
+  end
+
+  def test_wipe_generation_from_line
+    m = EDL::EventMatcher.new(25)
+    wipe = m.apply([],
+      '025  GEN      V     W001  025 00:00:55:10 00:00:58:11 01:00:29:19 01:00:32:20'
+    )
+    assert_not_nil wipe
+    assert_kind_of EDL::Clip, wipe
+    assert wipe.generator?
+    assert_equal '025', wipe.num
+    assert_equal 'GEN', wipe.reel
+    assert_equal 'V', wipe.track
+    
+    assert wipe.has_transition?
+    
+    assert_not_nil wipe.transition
+    assert_kind_of EDL::Wipe, wipe.transition
+    assert_equal '025', wipe.transition.duration
+    assert_equal '001', wipe.transition.smpte_wipe_index
+  end
+  
+  def test_black_generation_from_line
+    m = EDL::EventMatcher.new(25)
+    black = m.apply([],
+      '025        BL V     C        00:00:00:00 00:00:00:00 01:00:29:19 01:00:29:19' 
+    )
+    
+    assert_not_nil black
+    
+    assert black.black?, "Black should be black?"
+    assert black.slug?, "Black should be slug?"
+    
+    assert black.generator?, "Should be generator?"
+    assert_equal '025', black.num
+    assert_equal 'BL', black.reel
+    assert_equal 'V', black.track
+    assert_equal '025        BL V     C        00:00:00:00 00:00:00:00 01:00:29:19 01:00:29:19', black.original_line
+  end
+  
+  def test_matches_all_patterns
+    EVT_PATTERNS.each do | pat |
+      assert EDL::EventMatcher.new(25).matches?(pat), "EventMatcher should match #{pat}"
+    end
+  end
+end
+
+class ClipNameMatcherTest < Test::Unit::TestCase
+  def test_matches
+    line = "* FROM CLIP NAME:  TAPE_6-10.MOV"
+    assert EDL::NameMatcher.new.matches?(line)
+  end
+  
+  def test_apply
+    line = "* FROM CLIP NAME:  TAPE_6-10.MOV"
+    mok_evt = flexmock
+    mok_evt.should_receive(:clip_name=).with('TAPE_6-10.MOV').once
+    EDL::NameMatcher.new.apply([mok_evt], line)
+  end
+end
+
+class EffectMatcherTest < Test::Unit::TestCase
+  def test_matches
+    line = "* EFFECT NAME: CROSS DISSOLVE"
+    assert EDL::EffectMatcher.new.matches?(line)
+  end
+  
+  def test_apply
+    line = "* EFFECT NAME: CROSS DISSOLVE"
+    mok_evt, mok_transition = flexmock, flexmock
+    
+    mok_evt.should_receive(:transition).once.and_return(mok_transition)
+    mok_transition.should_receive(:effect=).with("CROSS DISSOLVE").once
+    
+    EDL::EffectMatcher.new.apply([mok_evt], line)
+  end
+end
+
+class ComplexTest < Test::Unit::TestCase
+  def test_parses_cleanly
+    assert_nothing_raised { EDL::Parser.new.parse(File.open(FORTY_FIVER)) }
+  end
+  
+  def test_from_zero
+    complex = EDL::Parser.new.parse(File.open(FORTY_FIVER))
+    
+    from_zero = complex.from_zero
+    assert_equal '00:00:00:00', from_zero.events[0].rec_start_tc.to_s,
+      "The starting timecode of the first event should have been shifted to zero"
+    assert_equal '00:00:42:16', from_zero.events[-1].rec_end_tc.to_s,
+      "The ending timecode of the last event should have been shifted 10 hours back"
+  end
+end
+
+# class GrabberTest < Test::Unit::TestCase
+#   FILM = '/Users/julik/Downloads/HC_CORRECT-TCS_VIDEO1.edl.txt'
+#   def test_cutter
+#     complex = EDL::Parser.new.parse(File.open(FILM))
+#     cutter = EDL::Grabber.new("/Users/julik/Desktop/Cutto/HC_CORRECT-TCS.mov")
+#     cutter.ffmpeg_bin = '/opt/local/bin/ffmpeg'
+#     cutter.grab(complex)
+#   end
+# end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: edl
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Julik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-27 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: flexmock
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: timecode
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.2
+    version: 
+description: Work with EDL files from Ruby
+email: 
+- me@julik.nl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- README.txt
+files: 
+- lib/edl.rb
+- lib/edl/cutter.rb
+- lib/edl/grabber.rb
+- test/samples/45S_SAMPLE.EDL
+- test/samples/REVERSE.EDL
+- test/samples/SIMPLE_DISSOLVE.EDL
+- test/samples/SPLICEME.EDL
+- test/samples/TIMEWARP.EDL
+- test/samples/TIMEWARP_HALF.EDL
+- test/samples/TRAILER_EDL.edl
+- test/test_edl.rb
+- Rakefile
+- History.txt
+- README.txt
+has_rdoc: true
+homepage: 
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+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: "0"
+  version: 
+requirements: []
+
+rubyforge_project: wiretap
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Work with EDL files from Ruby
+test_files: 
+- test/test_edl.rb