aviglitch 0.1.3 → 0.2.0

data/lib/aviglitch/base.rb

@@ -7,34 +7,29 @@ module AviGlitch
 
     # AviGlitch::Frames object generated from the +file+.
     attr_reader :frames
-    # The input file (copied tempfile).
-    attr_reader :file
+    # The input file
+    attr_reader :avi
 
     ##
     # Creates a new instance of AviGlitch::Base, open the file and 
     # make it ready to manipulate.
-    # It requires +path+ as Pathname.
-    def initialize path
-      File.open(path, 'rb') do |f|
-        # copy as tempfile
-        @file = Tempfile.open 'aviglitch'
-        f.rewind
-        while d = f.read(1024) do
-          @file.print d
+    # It requires +path+ as Pathname or an instance of AviGlirtch::Avi.
+    def initialize path_or_object
+      if path_or_object.kind_of?(Avi)
+        @avi = path_or_object
+      else
+        unless AviGlitch::Base.surely_formatted? path_or_object
+          raise 'Unsupported file passed.'
         end
+        @avi = Avi.new path_or_object
       end
-
-      unless AviGlitch::Base.surely_formatted? @file
-        raise 'Unsupported file passed.'
-      end
-      @frames = Frames.new @file
-      # I believe Ruby's GC to close and remove the Tempfile..
+      @frames = Frames.new @avi
     end
 
     ##
     # Outputs the glitched file to +path+, and close the file.
     def output path, do_file_close = true
-      FileUtils.cp @file.path, path
+      @avi.output path
       close if do_file_close
       self
     end
@@ -42,7 +37,7 @@ module AviGlitch
     ##
     # An explicit file close.
     def close
-      @file.close!
+      @avi.close
     end
 
     ##
@@ -59,34 +54,38 @@ module AviGlitch
     # It also requires a block. In the block, you take the frame data
     # as a String parameter.
     # To modify the data, simply return a modified data.
-    # It returns +self+
+    # Without a block it returns Enumerator, with a block it returns +self+.
     def glitch target = :all, &block  # :yield: data
-      @frames.each do |frame|
-        if valid_target? target, frame
-          frame.data = yield frame.data
+      if block_given?
+        @frames.each do |frame|
+          if frame.is? target
+            frame.data = yield frame.data
+          end
         end
+        self
+      else
+        self.enum_for :glitch, target
       end
-      self
     end
 
     ##
     # Do glitch with index.
     def glitch_with_index target = :all, &block  # :yield: data, index
-      i = 0
-      @frames.each do |frame|
-        if valid_target? target, frame
-          frame.data = yield(frame.data, i)
-          i += 1
+      if block_given?
+        self.glitch(target).with_index do |x, i|
+          yield x, i
         end
+        self
+      else
+        self.glitch target
       end
-      self
     end
 
     ##
-    # Clears all (or in +range+) keyframes to deltaframes.
-    # It's an alias for Frames#clear_keyframes!
-    def clear_keyframes! range = nil
-      self.frames.clear_keyframes! range
+    # Mutates all (or in +range+) keyframes into deltaframes.
+    # It's an alias for Frames#mutate_keyframes_into_deltaframes!
+    def mutate_keyframes_into_deltaframes! range = nil
+      self.frames.mutate_keyframes_into_deltaframes! range
       self
     end
 
@@ -103,6 +102,16 @@ module AviGlitch
       result
     end
 
+    ##
+    # Removes all keyframes.
+    # It is same as +glitch(:keyframes){|f| nil }+
+    def remove_all_keyframes!
+      self.glitch :keyframe do |f|
+        nil
+      end
+      self
+    end
+
     ##
     # Swaps the frames with other Frames data.
     def frames= other
@@ -114,57 +123,29 @@ module AviGlitch
     alias_method :write, :output
     alias_method :has_keyframes?, :has_keyframe?
 
-    def valid_target? target, frame #:nodoc:
-      return true if target == :all
-      begin
-        frame.send "is_#{target.to_s.sub(/frames$/, 'frame')}?"
-      rescue
-        false
-      end
-    end
-
-    private :valid_target?
-
     class << self
       ##
       # Checks if the +file+ is a correctly formetted AVI file.
       # +file+ can be String or Pathname or IO.
       def surely_formatted? file, debug = false
-        answer = true
-        is_io = file.respond_to?(:seek)  # Probably IO.
-        file = File.open(file, 'rb') unless is_io
+        passed = true
         begin
-          file.seek 0, IO::SEEK_END
-          eof = file.pos
-          file.rewind
-          unless file.read(4) == 'RIFF'
-            answer = false
-            warn 'RIFF sign is not found' if debug
-          end
-          len = file.read(4).unpack('V').first
-          unless file.read(4) == 'AVI '
-            answer = false
-            warn 'AVI sign is not found' if debug
-          end
-          while file.read(4) =~ /^(?:LIST|JUNK)$/ do
-            s = file.read(4).unpack('V').first
-            file.pos += s
-          end
-          file.pos -= 4
-          # we require idx1
-          unless file.read(4) == 'idx1'
-            answer = false
-            warn 'idx1 is not found' if debug
+          riff = Avi.rifftree file
+          {
+            'RIFF-AVI sign': /^RIFF \(\d+\) ’AVI ’$/,
+            'movi': /^\s+LIST \(\d+\) ’movi’$/,
+            'idx1': /^\s+idx1 \(\d+\)$/
+          }.each do |m, r|
+            unless riff =~ r
+              warn "#{m} is not found." if debug
+              passed = false
+            end
           end
-          s = file.read(4).unpack('V').first
-          file.pos += s
-        rescue => err
-          warn err.message if debug
-          answer = false
-        ensure
-          file.close unless is_io
+        rescue => e
+          warn e.message if debug
+          passed = false
         end
-        answer
+        passed
       end
     end
   end

data/lib/aviglitch/frame.rb

@@ -58,6 +58,26 @@ module AviGlitch
       @id[2, 2] == 'wb'
     end
 
+    ##
+    # Returns if it is a frame in +frame_type+.
+    def is? frame_type
+      return true if frame_type == :all
+      detection = "is_#{frame_type.to_s.sub(/frames$/, 'frame')}?"
+      begin 
+        self.send detection
+      rescue NoMethodError => e
+        false
+      end
+    end
+
+    ##
+    # Compares its content.
+    def == other
+      self.id == other.id &&
+      self.flag == other.flag &&
+      self.data == other.data
+    end
+
   end
 end
 

data/lib/aviglitch/frames.rb

@@ -18,124 +18,78 @@ module AviGlitch
   class Frames
     include Enumerable
 
-    SAFE_FRAMES_COUNT = 150000              #:nodoc:
-    @@warn_if_frames_are_too_large = true   #:nodoc:
-
-    attr_reader :meta
+    attr_reader :avi
 
     ##
     # Creates a new AviGlitch::Frames object.
-    def initialize io
-      io.rewind
-      io.pos = 12 # /^RIFF[\s\S]{4}AVI $/
-      while io.read(4) =~ /^(?:LIST|JUNK)$/ do
-        s = io.read(4).unpack('V').first
-        @pos_of_movi = io.pos - 4 if io.read(4) == 'movi'
-        io.pos += s - 4
-      end
-      @pos_of_idx1 = io.pos - 4 # here must be idx1
-      s = io.read(4).unpack('V').first + io.pos
-      @meta = []
-      while chunk_id = io.read(4) do
-        break if io.pos >= s
-        @meta << {
-          :id     => chunk_id,
-          :flag   => io.read(4).unpack('V').first,
-          :offset => io.read(4).unpack('V').first,
-          :size   => io.read(4).unpack('V').first,
-        }
-      end
-      fix_offsets_if_needed io
-      unless safe_frames_count? @meta.size
-        io.close!
-        exit
-      end
-      io.rewind
-      @io = io
+    def initialize avi
+      @avi = avi
     end
 
     ##
     # Enumerates the frames.
-    def each
-      temp = Tempfile.new 'frames'
-      frames_data_as_io(temp, Proc.new)
-      overwrite temp
-      temp.close!
+    # It returns Enumerator if a block is not given.
+    def each &block
+      if block_given?
+        Tempfile.open('temp', binmode: true) do |newmovi|
+          @avi.process_movi do |indices, movi|
+            newindices = indices.select do |m|
+              movi.pos = m[:offset] + 8    # 8 for id and size
+              frame = Frame.new(movi.read(m[:size]), m[:id], m[:flag])
+              block.call frame
+              unless frame.data.nil?
+                m[:offset] = newmovi.pos
+                m[:size] = frame.data.size
+                m[:flag] = frame.flag
+                m[:id] = frame.id
+                newmovi.print m[:id]
+                newmovi.print [frame.data.size].pack('V')
+                newmovi.print frame.data
+                newmovi.print "\0" if frame.data.size % 2 == 1
+                true
+              else
+                false
+              end
+            end
+            [newindices, newmovi]
+          end
+        end
+      else
+        self.enum_for :each
+      end
     end
 
     ##
     # Returns the number of frames.
     def size
-      @meta.size
+      @avi.indices.size
     end
 
-    def frames_data_as_io io = nil, block = nil  #:nodoc:
-      io = Tempfile.new('tmep') if io.nil?
-      @meta = @meta.select do |m|
-        @io.pos = @pos_of_movi + m[:offset] + 8   # 8 for id and size
-        frame = Frame.new(@io.read(m[:size]), m[:id], m[:flag])
-        block.call(frame) if block    # accept the variable block as Proc
-        yield frame if block_given?   # or a given block (or do nothing)
-        unless frame.data.nil?
-          m[:offset] = io.pos + 4   # 4 for 'movi'
-          m[:size] = frame.data.size
-          m[:flag] = frame.flag
-          m[:id] = frame.id
-          io.print m[:id]
-          io.print [frame.data.size].pack('V')
-          io.print frame.data
-          io.print "\000" if frame.data.size % 2 == 1
-          true
-        else
-          false
-        end
-      end
-      io
+    ##
+    # Returns the number of the specific +frame_type+.
+    def size_of frame_type
+      @avi.indices.select { |m|
+        Frame.new(nil, m[:id], m[:flag]).is? frame_type
+      }.size
     end
 
-    def overwrite data  #:nodoc:
-      unless safe_frames_count? @meta.size
-        @io.close!
-        exit
-      end
-      # Overwrite the file
-      data.seek 0, IO::SEEK_END
-      @io.pos = @pos_of_movi - 4  # 4 for size
-      @io.print [data.pos + 4].pack('V')  # 4 for 'movi'
-      @io.print 'movi'
-      data.rewind
-      while d = data.read(1024) do
-        @io.print d
-      end
-      @io.print 'idx1'
-      @io.print [@meta.size * 16].pack('V')
-      @meta.each do |m|
-        @io.print m[:id]
-        @io.print [m[:flag], m[:offset], m[:size]].pack('V3')
-      end
-      eof = @io.pos
-      @io.truncate eof
-
-      # Fix info
-      ## file size
-      @io.pos = 4
-      @io.print [eof - 8].pack('V')
-      ## frame count
-      @io.pos = 48
-      vid_frames = @meta.select do |m|
-        id = m[:id]
-        id[2, 2] == 'db' || id[2, 2] == 'dc'
+    ##
+    # Returns the data size of total frames.
+    def data_size
+      size = 0
+      @avi.process_movi do |indices, movi|
+        size = movi.size
+        [indices, movi]
       end
-      @io.print [vid_frames.size].pack('V')
-
-      @io.pos
+      size
     end
 
     ##
     # Removes all frames and returns self.
     def clear
-      @meta = []
-      overwrite StringIO.new
+      @avi.process_movi do |indices, movi|
+        [[], StringIO.new]
+      end
       self
     end
 
@@ -144,28 +98,25 @@ module AviGlitch
     # It is destructive like Array does.
     def concat other_frames
       raise TypeError unless other_frames.kind_of?(Frames)
-      # data
-      this_data = Tempfile.new 'this'
-      self.frames_data_as_io this_data
-      other_data = Tempfile.new 'other'
-      other_frames.frames_data_as_io other_data
-      this_data.seek 0, IO::SEEK_END
-      this_size = this_data.pos
-      other_data.rewind
-      while d = other_data.read(1024) do
-        this_data.print d
-      end
-      other_data.close!
-      # meta
-      other_meta = other_frames.meta.collect do |m|
-        x = m.dup
-        x[:offset] += this_size
-        x
+      @avi.process_movi do |this_indices, this_movi|
+        this_size = this_movi.size
+        this_movi.pos = this_size
+        other_frames.avi.process_movi do |other_indices, other_movi|
+          while d = other_movi.read(BUFFER_SIZE) do
+            this_movi.print d
+          end
+          other_meta = other_indices.collect do |m|
+            x = m.dup
+            x[:offset] += this_size
+            x
+          end
+          this_indices.concat other_meta
+          [other_indices, other_movi]
+        end
+        [this_indices, this_movi]
       end
-      @meta.concat other_meta
-      # close
-      overwrite this_data
-      this_data.close!
+
+      self
     end
 
     ##
@@ -253,11 +204,16 @@ module AviGlitch
     ##
     # Returns one Frame object at the given index.
     def at n
-      m = @meta[n]
-      return nil if m.nil?
-      @io.pos = @pos_of_movi + m[:offset] + 8
-      frame = Frame.new(@io.read(m[:size]), m[:id], m[:flag])
-      @io.rewind
+      frame = nil
+      @avi.process_movi do |indices, movi|
+        m = indices[n]
+        unless m.nil?
+          movi.pos = m[:offset] + 8
+          frame = Frame.new(movi.read(m[:size]), m[:id], m[:flag])
+          movi.rewind
+        end
+        [indices, movi]
+      end
       frame
     end
 
@@ -273,29 +229,101 @@ module AviGlitch
       self.slice(self.size - 1)
     end
 
+    ##
+    # Returns the first Frame object in +frame_type+.
+    def first_of frame_type
+      frame = nil
+      @avi.process_movi do |indices, movi|
+        indices.each do |m|
+          movi.pos = m[:offset] + 8
+          f = Frame.new(movi.read(m[:size]), m[:id], m[:flag])
+          if f.is?(frame_type)
+            frame = f
+            break
+          end
+        end
+        [indices, movi]
+      end
+      frame
+    end
+
+    ##
+    # Returns the last Frame object in +frame_type+.
+    def last_of frame_type
+      frame = nil
+      @avi.process_movi do |indices, movi|
+        indices.reverse.each do |m|
+          movi.pos = m[:offset] + 8
+          f = Frame.new(movi.read(m[:size]), m[:id], m[:flag])
+          if f.is?(frame_type)
+            frame = f
+            break
+          end
+        end
+        [indices, movi]
+      end
+      frame
+    end
+
+    ##
+    # Returns an index of the first found +frame+.
+    def index frame
+      n = -1
+      @avi.process_movi do |indices, movi|
+        indices.each_with_index do |m, i|
+          movi.pos = m[:offset] + 8
+          f = Frame.new(movi.read(m[:size]), m[:id], m[:flag]) 
+          if f == frame
+            n = i
+            break
+          end
+        end
+        [indices, movi]
+      end
+      n
+    end
+
+    ##
+    # Alias for index
+    alias_method :find_index, :index
+
+    ##
+    # Returns an index of the first found +frame+, starting from the last.
+    def rindex frame
+      n = -1
+      @avi.process_movi do |indices, movi|
+        indices.reverse.each_with_index do |m, i|
+          movi.pos = m[:offset] + 8
+          f = Frame.new(movi.read(m[:size]), m[:id], m[:flag])
+          if f == frame
+            n = indices.size - 1 - i
+            break
+          end
+        end
+        [indices, movi]
+      end
+      n
+    end
+
     ##
     # Appends the given Frame into the tail of self.
     def push frame
       raise TypeError unless frame.kind_of? Frame
-      # data
-      this_data = Tempfile.new 'this'
-      self.frames_data_as_io this_data
-      this_data.seek 0, IO::SEEK_END
-      this_size = this_data.pos
-      this_data.print frame.id
-      this_data.print [frame.data.size].pack('V')
-      this_data.print frame.data
-      this_data.print "\000" if frame.data.size % 2 == 1
-      # meta
-      @meta << {
-        :id     => frame.id,
-        :flag   => frame.flag,
-        :offset => this_size + 4, # 4 for 'movi'
-        :size   => frame.data.size,
-      }
-      # close
-      overwrite this_data
-      this_data.close!
+      @avi.process_movi do |indices, movi|
+        this_size = movi.size
+        movi.pos = this_size
+        movi.print frame.id
+        movi.print [frame.data.size].pack('V')
+        movi.print frame.data
+        movi.print "\0" if frame.data.size % 2 == 1
+        indices << {
+          :id     => frame.id,
+          :flag   => frame.flag,
+          :offset => this_size,
+          :size   => frame.data.size,
+        }
+        [indices, movi]
+      end
       self
     end
 
@@ -324,30 +352,31 @@ module AviGlitch
     end
 
     ##
-    # Modify keyframes to deltaframes at given range, or all.
-    def clear_keyframes! range = nil
+    # Mutates keyframes into deltaframes at given range, or all.
+    def mutate_keyframes_into_deltaframes! range = nil
       range = 0..self.size if range.nil?
       self.each_with_index do |frame, i|
         if range.include? i
           frame.flag = 0 if frame.is_keyframe?
         end
       end
+      self
     end
 
     ##
     # Returns true if +other+'s frames are same as self's frames.
     def == other
-      @meta == other.meta
+      @avi == other.avi
     end
 
     ##
     # Generates new AviGlitch::Base instance using self.
     def to_avi
-      AviGlitch.open @io.path
+      AviGlitch::Base.new @avi.clone
     end
 
-    def inspect # :nodec:
-      "#<#{self.class.name}:#{sprintf("0x%x", object_id)} @io=#{@io.inspect} size=#{self.size}>"
+    def inspect #:nodoc:
+      "#<#{self.class.name}:#{sprintf("0x%x", object_id)} size=#{self.size}>"
     end
 
     def get_beginning_and_length *args #:nodoc:
@@ -355,46 +384,18 @@ module AviGlitch
       if args.first.kind_of? Range
         r = args.first
         b = r.begin
-        e = r.end >= 0 ? r.end : @meta.size + r.end
+        e = r.end >= 0 ? r.end : self.size + r.end
         l = e - b + 1
       end
-      b = b >= 0 ? b : @meta.size + b
+      b = b >= 0 ? b : self.size + b
       [b, l]
     end
 
     def safe_frames_count? count #:nodoc:
-      r = true
-      if @@warn_if_frames_are_too_large && count >= SAFE_FRAMES_COUNT
-        trap(:INT) do
-          @io.close!
-          exit
-        end
-        m = ["WARNING: The avi data has too many frames (#{count}).\n",
-          "It may use a large memory to process. ",
-          "We recommend to chop the movie to smaller chunks before you glitch.\n",
-          "Do you want to continue anyway? [yN] "].join('')
-        a = Readline.readline m
-        r = a == 'y'
-        @@warn_if_frames_are_too_large = !r
-      end
-      r
-    end
-
-    def fix_offsets_if_needed io #:nodoc:
-      # rarely data offsets begin from 0 of the file
-      return if @meta.empty?
-      pos = io.pos
-      m = @meta.first
-      io.pos = @pos_of_movi + m[:offset]
-      unless io.read(4) == m[:id]
-        @meta.each do |x|
-          x[:offset] -= @pos_of_movi
-        end
-      end
-      io.pos = pos
+      warn "[DEPRECATION] `safe_frames_count?` is deprecated."
+      true
     end
 
-    protected :frames_data_as_io, :meta
-    private :overwrite, :get_beginning_and_length, :fix_offsets_if_needed
+    private :get_beginning_and_length
   end
 end