aviglitch 0.0.2 → 0.0.3

data/ChangeLog

@@ -1,3 +1,10 @@
+== 0.0.3 / 2010-07-07
+
+* Changed AviGlitch::Frames allowing to slice and concatenate frames
+(like Array).
+* Changed datamosh cli to accept multiple files.
+* And some tiny fixes.
+
 == 0.0.2 / 2010-05-17
 
 * Removed AviGlitch#new. Use AviGlitch#open instead of #new.

data/README.rdoc

@@ -1,6 +1,6 @@
 = AviGlitch
 
-* http://github.com/ucnv/aviglitch/tree/master
+* http://github.com/ucnv/aviglitch
 
 == Description
 
@@ -16,7 +16,7 @@ See following urls for details;
 
 * Not supports AVI2 files right now.
 * Not supports files with interleave.
-* Parses only container level structure, not parses codecs.
+* Parses only container level structure, doesn't parse codecs.
 
 == Synopsis
 

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/bin/datamosh

@@ -7,7 +7,6 @@ require 'aviglitch'
 
 output = './out.avi'
 all = false
-force = false
 
 opts = OptionParser.new do |opts|
   opts.banner = "datamosh - AviGlitch's datamoshing video generator."
@@ -17,9 +16,6 @@ opts = OptionParser.new do |opts|
     "Output the video to OUTPUT (./out.avi by default)") do |f|
     output = f
   end
-  opts.on("-f", "--force", "Overwrite an existing output file") do
-    force = true
-  end
   opts.on("-a", "--all", 
     "Remove all keyframes (It remains a first keyframe by default)") do
     all = true
@@ -29,23 +25,24 @@ opts = OptionParser.new do |opts|
     exit
   end
 end
+
 input = opts.parse!
 if input.empty?
   puts opts
   exit 1
 end
-if !force && File.exists?(output)
-  puts "!!! `#{output}' already exists. Use -f option to overwrite."
-  exit 1
-end
 
-a = AviGlitch.open input.first
+a = AviGlitch.open input.shift
 a.glitch_with_index :keyframe do |frame, i|
-  if !all && i == 0  # keep the first frame
-    frame
-  else
+  (!all && i == 0) ? frame : "\000" * frame.size # keep the first frame
+end
+input.each do |file|
+  b = AviGlitch.open file
+  b.glitch :keyframe do |frame|
     "\000" * frame.size
   end
+  a.frames.concat b.frames
 end
-a.output(output)
+
+a.output output
 

data/lib/aviglitch.rb

@@ -29,14 +29,18 @@ require 'aviglitch/frames'
 #
 module AviGlitch
 
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 
   class << self
     ##
     # Returns AviGlitch::Base instance.
-    # It requires +path+ as String or Pathname.
-    def AviGlitch.open path
-      AviGlitch::Base.new(Pathname(path))
+    # It requires +path_or_frames+ as String or Pathname, or Frames instance.
+    def AviGlitch.open path_or_frames
+      if path_or_frames.kind_of?(Frames)
+        path_or_frames.to_avi
+      else
+        AviGlitch::Base.new(Pathname(path_or_frames))
+      end
     end
   end
 end

data/lib/aviglitch/base.rb

@@ -8,15 +8,13 @@ module AviGlitch
   # To glitch, and save file. The instance returned through AviGlitch#open.
   #
   class Base
-    SAFE_FRAMES_COUNT = 150000 # :nodoc:
-
     # AviGlitch::Frames object generated from the +file+.
     attr_reader :frames
     # The input file (copied tempfile).
     attr_reader :file
 
     ##
-    # Create a new instance of AviGlitch::Base, open the file and 
+    # Creates a new instance of AviGlitch::Base, open the file and 
     # make it ready to manipulate.
     # It requires +path+ as Pathname.
     def initialize path
@@ -32,16 +30,12 @@ module AviGlitch
       unless AviGlitch::Base.surely_formatted? @file
         raise 'Unsupported file passed.'
       end
-      unless safe_frames_count? @file
-        close
-        exit
-      end
       @frames = Frames.new @file
       # I believe Ruby's GC to close and remove the Tempfile..
     end
 
     ##
-    # Output the glitched file to +path+, and close the file.
+    # Outputs the glitched file to +path+, and close the file.
     def output path
       FileUtils.cp @file.path, path
       close
@@ -54,7 +48,7 @@ module AviGlitch
     end
 
     ##
-    # Glitch each frame data.
+    # Glitches each frame data.
     # It is a convent method to iterate each frame.
     #
     # The argument +target+ takes symbols listed below:
@@ -67,66 +61,53 @@ 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+
     def glitch target = :all, &block  # :yield: data
-      frames.each do |frame|
+      @frames.each do |frame|
         if valid_target? target, frame
           frame.data = yield frame.data
         end
       end
+      self
     end
 
     ##
     # Do glitch with index.
     def glitch_with_index target = :all, &block  # :yield: data, index
       i = 0
-      frames.each do |frame|
+      @frames.each do |frame|
         if valid_target? target, frame
           frame.data = yield(frame.data, i)
           i += 1
         end
       end
+      self
     end
 
-    alias :write :output
+    alias_method :write, :output
+
+    ##
+    # Swaps the frames with other Frames data.
+    def frames= other
+      raise TypeError unless other.kind_of?(Frames)
+      @frames.clear
+      @frames.concat other
+    end
 
     def valid_target? target, frame # :nodoc:
       return true if target == :all
       begin
-        frame.send "is_#{target.to_s}?"
+        frame.send "is_#{target.to_s.sub(/frames$/, 'frame')}?"
       rescue
         false
       end
     end
 
-    def safe_frames_count? io # :nodoc:
-      r = true
-      io.pos = 12
-      while io.read(4) != 'idx1' do
-        s = io.read(4).unpack('V').first
-        io.pos += s
-      end
-      s = io.read(4).unpack('V').first
-      fc = s / 16
-      if fc >= SAFE_FRAMES_COUNT
-        trap(:INT) do
-          close
-          exit
-        end
-        m = ["WARNING: The passed file has too many frames (#{fc}).\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'
-      end
-      r
-    end
-
-    private_instance_methods [:valid_target?, :is_safe_frames_count?]
+    private :valid_target?
 
     class << self
       ##
-      # Check if the +file+ is a correctly formetted AVI file.
+      # 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

data/lib/aviglitch/frame.rb

@@ -13,7 +13,7 @@ module AviGlitch
     attr_reader :id, :flag
 
     ##
-    # Create a new AviGlitch::Frame object.
+    # Creates a new AviGlitch::Frame object.
     #
     # The arguments are:
     # [+data+] just data, without meta-data
@@ -35,7 +35,7 @@ module AviGlitch
 
     ##
     # Alias for is_keyframe?
-    alias :is_iframe? :is_keyframe?
+    alias_method :is_iframe?, :is_keyframe?
 
     ##
     # Returns if it is a video frame and also not a key frame.
@@ -45,7 +45,7 @@ module AviGlitch
 
     ##
     # Alias for is_deltaframe?
-    alias :is_pframe? :is_deltaframe?
+    alias_method :is_pframe?, :is_deltaframe?
 
     ##
     # Returns if it is a video frame.

data/lib/aviglitch/frames.rb

@@ -1,3 +1,5 @@
+require 'stringio'
+
 module AviGlitch
 
   # Frames provides the interface to access each frame
@@ -12,12 +14,19 @@ module AviGlitch
   #     frame.data = frame.data.gsub(/\d/, '0')
   #   end
   #
-  # In the block passed into iteration method, the parameter is the reference
+  # In the block passed into iteration method, the parameter is a reference
   # of AviGlitch::Frame object.
   #
   class Frames
     include Enumerable
 
+    SAFE_FRAMES_COUNT = 150000              # :nodoc:
+    @@warn_if_frames_are_too_large = true   # :nodoc:
+
+    attr_reader :meta
+
+    ##
+    # Creates a new AviGlitch::Frames object.
     def initialize io
       io.rewind
       io.pos = 12 # /^RIFF[\s\S]{4}AVI $/
@@ -38,38 +47,65 @@ module AviGlitch
           :size   => io.read(4).unpack('V').first,
         }
       end
+      unless safe_frames_count? @meta.size
+        @io.close!
+        exit
+      end
       io.rewind
       @io = io
     end
 
+    ##
+    # Enumerates the frames.
     def each
       temp = Tempfile.new 'frames'
-      temp.print 'movi'
+      frames_data_as_io(temp, Proc.new)
+      overwrite temp
+      temp.close!
+    end
+
+    ##
+    # Returns the number of frames.
+    def size
+      @meta.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
+        @io.pos = @pos_of_movi + m[:offset] + 8   # 8 for id and size
         frame = Frame.new(@io.read(m[:size]), m[:id], m[:flag])
-        yield frame
-        unless frame.data.nil? || frame.data.to_s.empty?
-          m[:offset] = temp.pos
+        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
-          temp.print m[:id]
-          temp.print [frame.data.size].pack('V')
-          temp.print frame.data
-          temp.print "\000" if frame.data.size % 2 == 1
+          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
+    end
 
+    def overwrite data  #:nodoc:
+      unless safe_frames_count? @meta.size
+        @io.close!
+        exit
+      end
       # Overwrite the file
-      @io.pos = @pos_of_movi - 4
-      @io.print [temp.pos].pack('V')
-      temp.rewind
-      while d = temp.read(1024) do
+      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
-      temp.close true
       @io.print 'idx1'
       @io.print [@meta.size * 16].pack('V')
       @meta.each do |m|
@@ -85,13 +121,249 @@ module AviGlitch
       @io.print [eof - 8].pack('V')
       ## frame count
       @io.pos = 48
-      @io.print [@meta.size].pack('V')
+      vid_frames = @meta.select do |m|
+        id = m[:id]
+        id[2, 2] == 'db' || id[2, 2] == 'dc'
+      end
+      @io.print [vid_frames.size].pack('V')
 
+      @io.pos
     end
 
-    def size
-      @meta.size
+    ##
+    # Removes all frames and returns self.
+    def clear
+      @meta = []
+      overwrite StringIO.new
+      self
+    end
+
+    ##
+    # Appends the frames in the other Frames into the tail of self.
+    # 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
+      end
+      @meta.concat other_meta
+      # close
+      overwrite this_data
+      this_data.close!
+    end
+
+    ##
+    # Returns a concatenation of the two Frames as a new Frames instance.
+    def + other_frames
+      r = self.to_avi
+      r.frames.concat other_frames
+      r.frames
+    end
+
+    ##
+    # Returns the new Frames as a +times+ times repeated concatenation
+    # of the original Frames.
+    def * times
+      result = self.slice 0, 0
+      frames = self.slice 0..-1
+      times.times do
+        result.concat frames
+      end
+      result
+    end
+
+    ##
+    # Returns the Frame object at the given index or
+    # returns new Frames object that sliced with the given index and length
+    # or with the Range.
+    # Just like Array.
+    def slice *args
+      b, l = get_beginning_and_length *args
+      if l.nil?
+        self.at b
+      else
+        e = b + l - 1
+        r = self.to_avi
+        r.frames.each_with_index do |f, i|
+          unless i >= b && i <= e
+            f.data = nil
+          end
+        end
+        r.frames
+      end
+    end
+
+    ##
+    # Alias for slice
+    alias_method :[], :slice
+
+    ##
+    # Removes frame(s) at the given index or the range (same as slice).
+    # Returns the new Frames contains removed frames.
+    def slice! *args
+      b, l = get_beginning_and_length *args
+      head, sliced, tail = ()
+      sliced = l.nil? ? self.slice(b) : self.slice(b, l)
+      head = self.slice(0, b)
+      l = 1 if l.nil?
+      tail = self.slice((b + l)..-1)
+      self.clear
+      self.concat head + tail
+      sliced
+    end
+
+    ##
+    # Removes frame(s) at the given index or the range (same as []).
+    # Inserts the given Frame or Frames's contents into the removed index.
+    def []= *args, value
+      b, l = get_beginning_and_length *args
+      ll = l.nil? ? 1 : l
+      head = self.slice(0, b)
+      rest = self.slice((b + ll)..-1)
+      if l.nil? || value.kind_of?(Frame)
+        head.push value
+      elsif value.kind_of?(Frames)
+        head.concat value
+      else
+        raise TypeError
+      end
+      new_frames = head + rest
+
+      self.clear
+      self.concat new_frames
+    end
+
+    ##
+    # 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
+    end
+
+    ##
+    # Returns the first Frame object.
+    def first
+      self.slice(0)
+    end
+
+    ##
+    # Returns the last Frame object.
+    def last
+      self.slice(self.size - 1)
+    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!
+      self
+    end
+
+    ##
+    # Alias for push
+    alias_method :<<, :push
+
+    ##
+    # Insert the given Frame objects into the given index.
+    def insert n, *args
+      new_frames = self.slice(0, n)
+      args.each do |f|
+        new_frames.push f
+      end
+      new_frames.concat self.slice(n..-1)
+
+      self.clear
+      self.concat new_frames
+      self
+    end
+
+    ##
+    # Deletes one Frame at the given index.
+    def delete_at n
+      self.slice! n
+    end
+
+    ##
+    # Returns true if +other+'s frames are same as self's frames.
+    def == other
+      @meta == other.meta
+    end
+
+    ##
+    # Generate new AviGlitch::Base instance using self.
+    def to_avi
+      AviGlitch.open @io.path
+    end
+
+    def get_beginning_and_length *args #:nodoc:
+      b, l = args
+      if args.first.kind_of? Range
+        r = args.first
+        b = r.begin
+        e = r.end >= 0 ? r.end : @meta.size + r.end
+        l = e - b + 1
+      end
+      b = b >= 0 ? b : @meta.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
 
+    protected :frames_data_as_io, :meta
+    private :overwrite, :get_beginning_and_length
   end
 end

data/spec/aviglitch_spec.rb

@@ -16,25 +16,18 @@ describe AviGlitch do
     FileUtils.rmdir OUTPUT_DIR
   end
 
-  it 'raise an error against unsupported files' do
+  it 'should raise an error against unsupported files' do
     lambda {
       avi = AviGlitch.open __FILE__
     }.should raise_error
   end
 
-  it 'returns AviGlitch::Base object through the method #open' do
+  it 'should return AviGlitch::Base object through the method #open' do
     avi = AviGlitch.open @in
     avi.should be_kind_of AviGlitch::Base
   end
 
-  it 'saves the same file when nothing is changed' do
-    avi = AviGlitch.open @in
-    avi.frames.each do |f|
-      ;
-    end
-    avi.output @out
-    FileUtils.cmp(@in, @out).should be true
-
+  it 'should save the same file when nothing is changed' do
     avi = AviGlitch.open @in
     avi.glitch do |d|
       d
@@ -43,19 +36,6 @@ describe AviGlitch do
     FileUtils.cmp(@in, @out).should be true
   end
 
-  it 'can manipulate each frame' do
-    avi = AviGlitch.open @in
-    f = avi.frames
-    f.should be_kind_of Enumerable
-    avi.frames.each do |f|
-      if f.is_keyframe?
-        f.data = f.data.gsub(/\d/, '0')
-      end
-    end
-    avi.output @out
-    AviGlitch::Base.surely_formatted?(@out, true).should be true
-  end
-
   it 'can glitch each keyframe' do
     avi = AviGlitch.open @in
     n = 0
@@ -86,28 +66,81 @@ describe AviGlitch do
     AviGlitch::Base.surely_formatted?(@out, true).should be true
   end
 
-  it 'can remove a frame with returning nil' do
+  it 'should have some alias methods' do
+    lambda {
+      avi = AviGlitch.open @in
+      avi.write @out
+    }.should_not raise_error
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+  end
+
+  it 'can glitch with :*frames instead of :*frame' do
     avi = AviGlitch.open @in
-    in_frame_size = avi.frames.size
-    rem_count = 0
-    avi.glitch :keyframe do |kf|
-      rem_count += 1
-      nil
+    count = 0
+    avi.glitch :keyframes do |kf|
+      count += 1
+      kf
     end
+    avi.close
+    count.should > 0
+  end
+
+  it 'should close file when output' do
+    avi = AviGlitch.open @in
     avi.output @out
-    AviGlitch::Base.surely_formatted?(@out, true).should be true
+    lambda {
+      avi.glitch do |f|
+        f
+      end
+    }.should raise_error(IOError)
+  end
+
+  it 'can explicit close file' do
+    avi = AviGlitch.open @in
+    avi.close
+    lambda {
+      avi.glitch do |f|
+        f
+      end
+    }.should raise_error(IOError)
+  end
 
-    # frames length in the output file is correct
-    avi = AviGlitch.open @out
-    out_frame_size = avi.frames.size
-    out_frame_size.should == in_frame_size - rem_count
+  it 'should offer one liner style coding' do
+    lambda {
+      AviGlitch.open(@in).glitch(:keyframe){|d| '0' * d.size}.output(@out)
+    }.should_not raise_error
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
   end
 
-  it 'has some alias methods' do
+  it 'should not raise error in multiple glitches' do
     lambda {
       avi = AviGlitch.open @in
-      avi.write @out
+      avi.glitch(:keyframe) do |d|
+        d.gsub(/\d/, '')
+      end
+      avi.glitch(:keyframe) do |d|
+        nil
+      end
+      avi.glitch(:audioframe) do |d|
+        d * 2
+      end
+      avi.output @out
     }.should_not raise_error
     AviGlitch::Base.surely_formatted?(@out, true).should be true
   end
+
+  it 'can work with another frames instance' do
+    a = AviGlitch.open @in
+    a.glitch :keyframe do |d|
+      nil
+    end
+    a.output(@out.to_s + 'x.avi')
+    b = AviGlitch.open @in
+    c = AviGlitch.open(@out.to_s + 'x.avi')
+    b.frames = c.frames
+    b.output @out
+
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+  end
+
 end

data/spec/datamosh_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe AviGlitch, 'datamosh cli' do
+
+  before :all do
+    FileUtils.mkdir OUTPUT_DIR unless File.exist? OUTPUT_DIR
+    @in = FILES_DIR + 'sample.avi'
+    @out = OUTPUT_DIR + 'out.avi'
+    datamosh = Pathname.new(
+      File.join(File.dirname(__FILE__), '..', 'bin/datamosh')
+    ).realpath
+    @cmd = "ruby %s -o %s " % [datamosh, @out]
+  end
+
+  after :each do
+    FileUtils.rm Dir.glob((OUTPUT_DIR + '*').to_s)
+  end
+
+  after :all do
+    FileUtils.rmdir OUTPUT_DIR
+  end
+
+  it 'should correctly process files' do
+    system [@cmd, @in].join(' ')
+    o = AviGlitch.open @out
+    o.frames.each_with_index do |f, i|
+      if f.is_keyframe? && i == 0
+        f.data.should_not match /^\000+$/
+      elsif f.is_keyframe?
+        f.data.should match /^\000+$/
+      end
+    end
+    o.close
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+
+    system [@cmd, '-a', @in].join(' ')
+    o = AviGlitch.open @out
+    o.frames.each do |f|
+      if f.is_keyframe?
+        f.data.should match /^\000+$/
+      end
+    end
+    o.close
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+
+    system [@cmd, @in, @in, @in].join(' ')
+    a = AviGlitch.open @in
+    o = AviGlitch.open @out
+    o.frames.size.should == a.frames.size * 3
+    o.frames.each_with_index do |f, i|
+      if f.is_keyframe? && i == 0
+        f.data.should_not match /^\000+$/
+      elsif f.is_keyframe?
+        f.data.should match /^\000+$/
+      end
+    end
+    o.close
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+  end
+
+end

data/spec/frames_spec.rb

@@ -0,0 +1,450 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe AviGlitch::Frames do
+
+  before :all do
+    AviGlitch::Frames.class_eval do
+      define_method(:get_real_id_with) do |frame|
+        pos = @io.pos
+        @io.pos -= frame.data.size
+        @io.pos -= 8
+        id = @io.read 4
+        @io.pos = pos
+        id
+      end
+    end
+
+    FileUtils.mkdir OUTPUT_DIR unless File.exist? OUTPUT_DIR
+    @in = FILES_DIR + 'sample.avi'
+    @out = OUTPUT_DIR + 'out.avi'
+  end
+
+  after :each do
+    FileUtils.rm Dir.glob((OUTPUT_DIR + '*').to_s)
+  end
+
+  after :all do
+    FileUtils.rmdir OUTPUT_DIR
+  end
+
+  it 'should save the same file when nothing is changed' do
+    avi = AviGlitch.open @in
+    avi.frames.each do |f|
+      ;
+    end
+    avi.output @out
+    FileUtils.cmp(@in, @out).should be true
+  end
+
+  it 'can manipulate each frame' do
+    avi = AviGlitch.open @in
+    f = avi.frames
+    f.should be_kind_of Enumerable
+    avi.frames.each do |f|
+      if f.is_keyframe?
+        f.data = f.data.gsub(/\d/, '0')
+      end
+    end
+    avi.output @out
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+  end
+
+  it 'should remove a frame when returning nil' do
+    avi = AviGlitch.open @in
+    in_frame_size = avi.frames.size
+    rem_count = 0
+    avi.glitch :keyframe do |kf|
+      rem_count += 1
+      nil
+    end
+    avi.output @out
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+
+    # frames length in the output file is correct
+    avi = AviGlitch.open @out
+    out_frame_size = avi.frames.size
+    out_frame_size.should == in_frame_size - rem_count
+  end
+
+  it 'should read correct positions in #each' do
+    avi = AviGlitch.open @in
+    frames = avi.frames
+    frames.each do |f|
+      real_id = frames.get_real_id_with f
+      real_id.should == f.id
+    end
+    avi.close
+  end
+
+  it 'should promise the read frame data is not nil' do
+    avi = AviGlitch.open @in
+    frames = avi.frames
+    frames.each do |f|
+      f.data.should_not == nil
+    end
+    avi.close
+  end
+
+  it 'should hide the inner variables' do
+    avi = AviGlitch.open @in
+    frames = avi.frames
+    lambda { frames.meta }.should raise_error(NoMethodError)
+    lambda { frames.io }.should raise_error(NoMethodError)
+    lambda { frames.frames_data_as_io }.should raise_error(NoMethodError)
+    avi.close
+  end
+
+  it 'should save video frames count in header' do
+    avi = AviGlitch.open @in
+    c = 0
+    avi.frames.each do |f|
+      c += 1 if f.is_videoframe?
+    end
+    avi.output @out
+    open(@out) do |f|
+      f.pos = 48
+      f.read(4).unpack('V').first.should == c
+    end
+  end
+
+  it 'should evaluate the equality with owned contents' do
+    a = AviGlitch.open @in
+    b = AviGlitch.open @in
+    a.frames.should == b.frames
+  end
+
+  it 'can generate AviGlitch::Base instance' do
+    a = AviGlitch.open @in
+    b = a.frames.slice(0, 10)
+    c = b.to_avi
+    c.should be_kind_of AviGlitch::Base
+    c.output @out
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+  end
+
+  it 'can concat with other Frames instance with #concat, destructively' do
+    a = AviGlitch.open @in
+    b = AviGlitch.open @in
+    asize = a.frames.size
+    bsize = b.frames.size
+    lambda {
+      a.frames.concat([1,2,3])
+    }.should raise_error(TypeError)
+    a.frames.concat(b.frames)
+    a.frames.size.should == asize + bsize
+    b.frames.size.should == bsize
+    a.output @out
+    b.close
+
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+  end
+
+  it 'can concat with other Frames instance with +' do
+    a = AviGlitch.open @in
+    b = AviGlitch.open @in
+    asize = a.frames.size
+    bsize = b.frames.size
+    c = a.frames + b.frames
+    a.frames.size.should == asize
+    b.frames.size.should == bsize
+    c.should be_kind_of AviGlitch::Frames
+    c.size.should == asize + bsize
+    a.close
+    b.close
+    d = AviGlitch.open c
+    d.output @out
+
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+  end
+
+  it 'can slice frames using start pos and length' do
+    avi = AviGlitch.open @in
+    a = avi.frames
+    asize = a.size
+    c = (a.size / 3).floor
+    b = a.slice(1, c)
+    b.should be_kind_of AviGlitch::Frames
+    b.size.should == c
+    lambda {
+      b.each {|x| x }
+    }.should_not raise_error
+
+    a.size.should == asize  # make sure a is not destroyed
+    lambda {
+      a.each {|x| x }
+    }.should_not raise_error
+
+    avi.frames.concat b
+    avi.output @out
+
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+  end
+
+  it 'can slice frames using Range' do
+    avi = AviGlitch.open @in
+    a = avi.frames
+    asize = a.size
+    c = (a.size / 3).floor
+    spos = 3
+    range = spos..(spos + c)
+    b = a.slice(range)
+    b.should be_kind_of AviGlitch::Frames
+    b.size.should == c + 1
+    lambda {
+      b.each {|x| x }
+    }.should_not raise_error
+
+    range = spos..-1
+    d = a.slice(range)
+    d.should be_kind_of AviGlitch::Frames
+    d.size.should == asize - spos
+    lambda {
+      d.each {|x| x }
+    }.should_not raise_error
+
+    x = -5
+    range = spos..x
+    e = a.slice(range)
+    e.should be_kind_of AviGlitch::Frames
+    e.size.should == asize - spos + x + 1
+    lambda {
+      e.each {|x| x }
+    }.should_not raise_error
+
+  end
+
+  it 'can concat repeatedly the same sliced frames' do
+    a = AviGlitch.open @in
+    b = a.frames.slice(0, 5)
+    c = a.frames.slice(0, 10)
+    10.times do
+      b.concat(c)
+    end
+    b.size.should == 5 + (10 * 10)
+  end
+
+  it 'can get one single frame using slice(n)' do
+    a = AviGlitch.open @in
+    pos = 10
+    b = nil
+    a.frames.each_with_index do |f, i|
+      b = f if i == pos
+    end
+    c = a.frames.slice(pos)
+    c.should be_kind_of AviGlitch::Frame
+    c.data.should == b.data
+  end
+
+  it 'can get one single frame using at(n)' do
+    a = AviGlitch.open @in
+    pos = 10
+    b = nil
+    a.frames.each_with_index do |f, i|
+      b = f if i == pos
+    end
+    c = a.frames.at(pos)
+    c.should be_kind_of AviGlitch::Frame
+    c.data.should == b.data
+  end
+
+  it 'can get a first frame ussing first, a last frame using last' do
+    a = AviGlitch.open @in
+    b0 = c0 = nil
+    a.frames.each_with_index do |f, i|
+      b0 = f if i == 0
+      c0 = f if i == a.frames.size - 1
+    end
+    b1 = a.frames.first
+    c1 = a.frames.last
+
+    b1.data.should == b0.data
+    c1.data.should == c0.data
+  end
+
+  it 'can add a frame at last using push' do
+    a = AviGlitch.open @in
+    s = a.frames.size
+    b = a.frames[10]
+    lambda {
+      a.frames.push 100
+    }.should raise_error(TypeError)
+    c = a.frames + a.frames.slice(10, 1)
+
+    x = a.frames.push b
+    a.frames.size.should == s + 1
+    x.should == a.frames
+    a.frames.should == c
+    a.frames.last.data.should == c.last.data
+    x = a.frames.push b
+    a.frames.size.should == s + 2
+    x.should == a.frames
+
+    a.output @out
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+  end
+
+  it 'can add a frame at last using <<' do
+    a = AviGlitch.open @in
+    s = a.frames.size
+    b = a.frames[10]
+
+    x = a.frames << b
+    a.frames.size.should == s + 1
+    x.should == a.frames
+
+    a.output @out
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+  end
+
+  it 'can delete all frames using clear' do
+    a = AviGlitch.open @in
+    a.frames.clear
+    a.frames.size.should == 0
+  end
+
+  it 'can delete one frame using delete_at' do
+    a = AviGlitch.open @in
+    l = a.frames.size
+    b = a.frames[10]
+    c = a.frames[11]
+    x = a.frames.delete_at 10
+
+    x.data.should == b.data
+    a.frames[10].data.should == c.data
+    a.frames.size.should == l - 1
+
+    a.output @out
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+  end
+
+  it 'can insert one frame into other frames using insert' do
+    a = AviGlitch.open @in
+    l = a.frames.size
+    b = a.frames[10]
+    x = a.frames.insert 5, b
+
+    x.should == a.frames
+    a.frames[5].data.should == b.data
+    a.frames[11].data.should == b.data
+    a.frames.size.should == l + 1
+
+    a.output @out
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+  end
+
+  it 'can slice frames destructively using slice!' do
+    a = AviGlitch.open @in
+    l = a.frames.size
+
+    b = a.frames.slice!(10)
+    b.should be_kind_of AviGlitch::Frame
+    a.frames.size.should == l - 1
+
+    c = a.frames.slice!(0, 10)
+    c.should be_kind_of AviGlitch::Frames
+    a.frames.size.should == l - 1 - 10
+
+    d = a.frames.slice!(0..9)
+    d.should be_kind_of AviGlitch::Frames
+    a.frames.size.should == l - 1 - 10 - 10
+  end
+
+  it 'can swap frame(s) using []=' do
+    a = AviGlitch.open @in
+    l = a.frames.size
+    lambda {
+      a.frames[10] = "xxx"
+    }.should raise_error(TypeError)
+
+    b = a.frames[20]
+    a.frames[10] = b
+    a.frames.size.should == l
+    a.frames[10].data.should == b.data
+
+    a.output @out
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+
+    a = AviGlitch.open @in
+    pl = 5
+    pp = 3
+    b = a.frames[20, pl]
+    a.frames[10..(10 + pp)] = b
+    a.frames.size.should == l - pp + pl - 1
+    pp.times do |i|
+      a.frames[10 + i].data.should == b[i].data
+    end
+
+    lambda {
+      a.frames[10] = a.frames.slice(100, 1)
+    }.should raise_error(TypeError)
+
+    a.output @out
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+  end
+
+  it 'can repeat frames using *' do
+    a = AviGlitch.open @in
+
+    r = 20
+    b = a.frames.slice(10, 10)
+    c = b * r
+    c.size.should == 10 * r
+
+    c.to_avi.output @out
+    AviGlitch::Base.surely_formatted?(@out, true).should be true
+  end
+
+  it 'should manipulate frames like array does' do
+    avi = AviGlitch.open @in
+    a = avi.frames
+    x = Array.new a.size
+
+    fa = a.slice(0, 100)
+    fx = x.slice(0, 100)
+    fa.size.should == fx.size
+
+    fa = a.slice(100..-1)
+    fx = x.slice(100..-1)
+    fa.size.should == fx.size
+
+    fa = a.slice(100..-10)
+    fx = x.slice(100..-10)
+    fa.size.should == fx.size
+
+    fa = a.slice(-200, 10)
+    fx = x.slice(-200, 10)
+    fa.size.should == fx.size
+
+    a[100] = a.at 200
+    x[100] = x.at 200
+    a.size.should == x.size
+
+    a[100..150] = a.slice(100, 100)
+    x[100..150] = x.slice(100, 100)
+    a.size.should == x.size
+  end
+
+  it 'should have the method alias to slice as []' do
+    a = AviGlitch.open @in
+
+    b = a.frames[10]
+    b.should be_kind_of AviGlitch::Frame
+
+    c = a.frames[0, 10]
+    c.should be_kind_of AviGlitch::Frames
+    c.size.should == 10
+
+    d = a.frames[0..9]
+    d.should be_kind_of AviGlitch::Frames
+    d.size.should == 10
+  end
+
+  it 'should return nil when getting a frame at out-of-range index' do
+    a = AviGlitch.open @in
+
+    x = a.frames.at(a.frames.size + 1)
+    x.should be_nil
+  end
+
+
+end

data/spec/spec.opts

@@ -1 +1,2 @@
---color
+-c
+-fs

metadata

@@ -1,12 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aviglitch
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 2
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - ucnv
@@ -14,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-17 00:00:00 +09:00
+date: 2010-07-07 00:00:00 +09:00
 default_executable: datamosh
 dependencies: []
 
@@ -39,7 +34,9 @@ files:
 - lib/aviglitch/frame.rb
 - lib/aviglitch/frames.rb
 - spec/aviglitch_spec.rb
+- spec/datamosh_spec.rb
 - spec/files/sample.avi
+- spec/frames_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 - LICENSE
@@ -56,23 +53,23 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: A Ruby library to destroy your AVI files.
 test_files: 
 - spec/aviglitch_spec.rb
+- spec/datamosh_spec.rb
+- spec/frames_spec.rb
 - spec/spec_helper.rb