aviglitch 0.1.3 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6bcaf49d8305bd36386f606954fe702468fc5196e30b0d5e4f3dea11f0bfb8a7
+  data.tar.gz: a1ede07ce50e3005abcd505e501ddf8f73c18b0241d7b34834ac78781d76e389
+SHA512:
+  metadata.gz: b9a0c0905f0131bec187618e48e7281eac79d01d6067a66dad82bafbc2c923d84bd7472738b147fc2866ee1f5ef14b1064556e05b7109a7ffef5a0c73370ec6f
+  data.tar.gz: f698216510d97cf7713e14127cf75af8264c5c003fa876caed72e51168575eb75e0dba05930ff22c6a145c0da9a0967da9959dfc65d0276909e9db081ba6810c

data/.github/workflows/ruby.yml

@@ -0,0 +1,35 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: test
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.6', '2.7', '3.0']
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+    # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@473e4d8fe5dd94ee328fdfca9f8c9c7afc9dae5e
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rake

data/.gitignore

@@ -0,0 +1,12 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+doc
+pkg
+tmp
+*.gem
+Gemfile.lock
+Guardfile
+.yardoc
+spec/files

data/.rspec

@@ -0,0 +1,2 @@
+-c
+--format documentation

data/ChangeLog.md

@@ -0,0 +1,67 @@
+### 0.2.0 / 2021-09-13
+
+* Support for AVI2.0 formatted files. Now this library can handle files larger than 1GB.
+* Added methods to Frames, including #index, #rindex, #first_of, and #last_of
+* Removed warnings for the file size getting large.
+* Added the class AviGlitch::Avi which manages binary RIFF-AVI data.
+* A lot of internal changes.
+
+### 0.1.6 / 2021-08-21
+
+* Removed obsolete dependencies.
+
+### 0.1.5 / 2014-12-12
+
+* Fix Frames#concat and two other method to return self.
+* Some internal changes.
+
+### 0.1.4 / 2014-04-10
+
+* Added an enumerator style on AviGlitch::Base#glitch and
+AviGlitch::Frames#each
+* Added AviGlitch::Base#remove_all_keyframes!
+* Renamed #clear_keyframes! to #mutate_keyframes_into_deltaframes!
+* Improved the processing speed in some measure.
+* Some minor fixes.
+
+### 0.1.3 / 2011-08-19
+
+* Added has_keyframe? method to AviGlitch::Base
+* Added a --fake option to datamosh cli.
+
+### 0.1.2 / 2011-04-10
+
+* Fix to be able to handle data with offsets from 0 of the file.
+* Added clear_keyframes! method to AviGlitch::Frames and AviGlitch::Base.
+* Changed to be able to access frame's meta data.
+* Changed datamosh command to handle wildcard char.
+
+### 0.1.1 / 2010-09-09
+
+* Fixed a bug with windows.
+* Some tiny fixes.
+
+### 0.1.0 / 2010-07-09
+
+* Minor version up.
+* Fixed bugs with Ruby 1.8.7.
+* Fixed the synchronization problem with datamosh cli.
+
+### 0.0.3 / 2010-07-07
+
+* Changed AviGlitch::Frames allowing to slice and concatenate frames
+(like Array).
+* Changed datamosh cli to accept multiple files.
+
+### 0.0.2 / 2010-05-17
+
+* Removed AviGlitch#new. Use AviGlitch#open instead of #new.
+* Added warning for a large file.
+* Changed datamosh command interface.
+* Changed the library file layout.
+* And tiny internal changes.
+
+### 0.0.1 / 2009-08-01
+
+* initial release
+

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+gemspec
+
+group :test do
+  gem 'guard'
+  gem 'guard-rspec'
+end

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 ucnv
+Copyright (c) 2009-2021 ucnv
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,49 @@
+# AviGlitch
+
+[![Gem Version](https://badge.fury.io/rb/aviglitch.svg)](https://badge.fury.io/rb/aviglitch)
+[![test](https://github.com/ucnv/aviglitch/actions/workflows/ruby.yml/badge.svg)](https://github.com/ucnv/aviglitch/actions/workflows/ruby.yml)
+
+AviGlitch destroys your AVI files.
+
+I can't explain why they're going to destroy their own data, but they do.
+
+You can find a short guide at <https://ucnv.github.io/aviglitch/>.
+It provides a way to manipulate the data in each AVI frames.
+It will mostly be used for making datamoshing videos.
+It parses only container level structure, doesn't parse codecs.
+
+See following urls for details about visual glitch;
+
+* vimeo <http://www.vimeo.com/groups/artifacts>
+* wikipedia <http://en.wikipedia.org/wiki/Compression_artifact>
+
+## Usage
+
+```ruby
+  require 'aviglitch'
+
+  avi = AviGlitch.open('/path/to/your.avi')
+  avi.glitch(:keyframe) do |data|
+    data.gsub(/\d/, '0')
+  end
+  avi.output('/path/to/broken.avi')
+```
+
+This library also includes a command line tool named `datamosh`.
+It creates the keyframes removed video.
+
+```sh
+  $ datamosh /path/to/your.avi -o /path/to/broken.avi
+```
+
+For more practical usages, please check <https://github.com/ucnv/aviglitch-utils/tree/master/bin>.
+
+## Installation
+
+```sh
+  gem install aviglitch
+```
+
+## License
+
+This library is distributed under the terms and conditions of the [MIT license](LICENSE).

data/Rakefile

@@ -1,50 +1,13 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "aviglitch"
-    gem.summary = "A Ruby library to destroy your AVI files."
-    gem.email = "ucnvvv@gmail.com"
-    gem.homepage = "http://ucnv.github.com/aviglitch/"
-    gem.authors = ["ucnv"]
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-    gem.files = %w(README.rdoc ChangeLog Rakefile VERSION) +
-      Dir.glob("{bin,spec,lib}/**/*") 
-    gem.add_development_dependency "rspec", ">= 2.0.0"
-
-  end
-
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
-
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = FileList['spec/**/*_spec.rb']
-end
-
-RSpec::Core::RakeTask.new(:rcov) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 
+RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
 
-require 'rake/rdoctask'
+require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
-  if File.exist?('VERSION.yml')
-    config = YAML.load(File.read('VERSION.yml'))
-    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
-  else
-    version = ""
-  end
-
+  rdoc.main = "README.md"
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "aviglitch #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include(%w{LICENSE *.md lib/**/*.rb})
 end
-

data/aviglitch.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'aviglitch'
+
+Gem::Specification.new do |spec|
+  spec.name          = "aviglitch"
+  spec.version       = AviGlitch::VERSION
+  spec.authors       = ["ucnv"]
+  spec.email         = ["ucnvvv@gmail.com"]
+  spec.summary       = %q{A Ruby library to destroy your AVI files.}
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/ucnv/aviglitch"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.extra_rdoc_files = ["README.md", "LICENSE"]
+  spec.rdoc_options << "-m" << "README.md"
+
+  spec.add_development_dependency "bundler", ">= 2.2.10"
+  spec.add_development_dependency "rake", ">= 12.3.3"
+  spec.add_development_dependency "rspec"
+end

data/bin/datamosh

@@ -34,10 +34,18 @@ opts = OptionParser.new do |opts|
   end
 end
 
-input = Dir.glob opts.parse!
+input = opts.parse!
 if input.empty?
   puts opts
   exit 1
+else
+  input.each do |file|
+    if !File.exist?(file) || File.directory?(file)
+      opts.banner = "#{file}: No such file.\n\n"
+      puts opts
+      exit 1
+    end
+  end
 end
 
 a = AviGlitch.open input.shift
@@ -46,7 +54,12 @@ unless fake
     (!all && i == 0) ? frame : "" # keep the first frame
   end
 end
-a.clear_keyframes!(!all && !fake ? 1..a.frames.size : nil)
+if !all && !fake 
+  first = a.frames.index(a.frames.first_of(:keyframe))
+  a.mutate_keyframes_into_deltaframes! (first + 1)..a.frames.size
+else
+  a.mutate_keyframes_into_deltaframes!
+end
 
 input.each do |file|
   b = AviGlitch.open file
@@ -55,7 +68,7 @@ input.each do |file|
       ""
     end
   end
-  b.clear_keyframes!
+  b.mutate_keyframes_into_deltaframes!
   a.frames.concat b.frames
 end
 

data/lib/aviglitch/avi.rb

@@ -0,0 +1,550 @@
+module AviGlitch
+
+  # Avi parses the passed RIFF-AVI file and maintains binary data as 
+  # a structured object.
+  # It contains headers, frame's raw data, and indices of frames.
+  # The AviGlitch library accesses the data through this class internally.
+  #
+  class Avi
+
+    # :stopdoc:
+
+    # RiffChunk represents a parsed RIFF chunk.
+    class RiffChunk
+
+      attr_accessor :id, :list, :value, :binsize
+      
+      def initialize id, size, value, list = false
+        @binsize = size
+        @is_list = list.kind_of? Array
+        unless is_list?
+          @id = id
+          @value = value
+        else
+          @id = value
+          @list = id
+          @value = list
+        end 
+      end
+
+      def is_list?
+        @is_list
+      end
+
+      def children id
+        if is_list?
+          value.filter do |chk|
+            chk.id == id
+          end
+        else
+          []
+        end
+      end
+
+      def child id
+        children(id).first
+      end
+
+      def search *args
+        a1 = args.shift
+        r = value.filter { |v| 
+          v.id == a1
+        }.collect { |v|
+          if args.size > 0
+            v.search *args
+          else
+            v
+          end
+        }
+        r.flatten
+      end
+
+      def inspect
+        if @is_list
+          "{list: \"#{list}\", id: \"#{id}\", binsize: #{binsize}, value: #{value}}"
+        elsif !value.nil?
+          "{id: \"#{id}\", binsize: #{binsize}, value: \"#{value}\"}"
+        else 
+          "{id: \"#{id}\", binsize: #{binsize}}"
+        end
+      end
+
+    end
+
+    # :startdoc:
+
+    MAX_RIFF_SIZE = 1024 ** 3
+    # List of indices for 'movi' data.
+    attr_accessor :indices
+    # Object which represents RIFF structure.
+    attr_accessor :riff
+
+    attr_accessor :path, :movi #:nodoc:
+    protected :path, :path=, :movi, :movi=
+
+    ##
+    # Generates an instance with the necessary structure from the +path+.
+    def initialize path = nil
+      return if path.nil?
+      @path = path
+      File.open(path, 'rb') do |io|
+        @movi = Tempfile.new 'aviglitch', binmode: true
+        @riff = []
+        @indices = []
+        @superidx = []
+        @was_avi2 = false
+        io.rewind
+        parse_riff io, @riff
+        if was_avi2?
+          @indices.sort_by! { |ix| ix[:offset] }
+        end
+      end
+    end
+
+    ##
+    # Parses the passed RIFF formated file recursively.
+    def parse_riff io, target, len = 0, is_movi = false
+      offset = io.pos
+      binoffset = @movi.pos
+      while id = io.read(4) do
+        if len > 0 && io.pos >= offset + len
+          io.pos -= 4
+          break
+        end
+        size = io.read(4).unpack('V').first
+        if id == 'RIFF' || id == 'LIST'
+          lid = io.read(4)
+          newarr = []
+          chunk = RiffChunk.new id, size, lid, newarr
+          target << chunk
+          parse_riff io, newarr, size, lid == 'movi'
+        else
+          value = nil
+          if is_movi
+            if id =~ /^ix/
+              v = io.read size
+              # confirm the super index surely has information
+              @superidx.each do |sidx|
+                nent = sidx[4, 4].unpack('v').first
+                cid = sidx[8, 4]
+                nent.times do |i|
+                  ent = sidx[24 + 16 * i, 16]
+                  # we can check other informations thuogh
+                  valid = ent[0, 8].unpack('q').first == io.pos - v.size - 8
+                  parse_avi2_indices(v, binoffset) if valid
+                end
+              end
+            else
+              io.pos -= 8
+              v = io.read(size + 8)
+              @movi.print v
+              @movi.print "\0" if size % 2 == 1
+            end
+          elsif id == 'idx1'
+            v = io.read size
+            parse_avi1_indices v unless was_avi2?
+          else
+            value = io.read size
+            if id == 'indx'
+              @superidx << value
+              @was_avi2 = true
+            end
+          end
+          chunk = RiffChunk.new id, size, value
+          target << chunk
+          io.pos += 1 if size % 2 == 1
+        end
+      end
+    end
+
+    ##
+    # Closes the file.
+    def close
+      @movi.close!
+    end
+
+    ##
+    # Detects the passed file was an AVI2.0 file.
+    def was_avi2?
+      @was_avi2
+    end
+
+    ##
+    # Detects the current data will be an AVI2.0 file.
+    def is_avi2?
+      @movi.size >= MAX_RIFF_SIZE
+    end
+    
+    ##
+    # Saves data to AVI formatted file.
+    def output path
+      @index_pos = 0
+      # prepare headers by reusing existing ones
+      strl = search 'hdrl', 'strl'
+      if is_avi2?
+        # indx
+        vid_frames_size = 0
+        @indexinfo = @indices.collect { |ix|
+          vid_frames_size += 1 if ix[:id] =~ /d[bc]$/
+          ix[:id]
+        }.uniq.sort.collect { |d| 
+          [d, {}]
+        }.to_h  # should be like: {"00dc"=>{}, "01wb"=>{}}
+        strl.each_with_index do |sl, i|
+          indx = sl.child 'indx'
+          if indx.nil?
+            indx = RiffChunk.new('indx', 4120, "\0" * 4120)
+            indx.value[0, 8] = [4, 0, 0, 0].pack('vccV')
+            sl.value.push indx
+          else
+            indx.value[4, 4] = [0].pack('V')
+            indx.value[24..-1] = "\0" * (indx.value.size - 24)
+          end
+          preid = indx.value[8, 4]
+          info = @indexinfo.find do |key, val|
+            # more strict way must exist though..
+            if preid == "\0\0\0\0"
+              key.start_with? "%02d" % i
+            else
+              key == preid
+            end
+          end
+          indx.value[8, 4] = info.first if preid == "\0\0\0\0"
+          info.last[:indx] = indx
+          info.last[:fcc] = 'ix' + info.first[0, 2]
+          info.last[:cur] = []
+        end
+        # odml
+        odml = search('hdrl', 'odml').first
+        if odml.nil?
+          odml = RiffChunk.new(
+            'LIST', 260, 'odml', [RiffChunk.new('dmlh', 248, "\0" * 248)]
+          )
+          @riff.first.child('hdrl').value.push odml
+        end
+        odml.child('dmlh').value[0, 4] = [@indices.size].pack('V')
+      else
+        strl.each do |sl|
+          indx = sl.child 'indx'
+          unless indx.nil?
+            sl.value.delete indx
+          end
+        end
+      end
+
+      # movi
+      write_movi = ->(io) do
+        vid_frames_size = 0
+        io.print 'LIST'
+        io.print "\0\0\0\0"
+        data_offset = io.pos
+        io.print 'movi'
+        while io.pos - data_offset <= MAX_RIFF_SIZE
+          ix = @indices[@index_pos]
+          @indexinfo[ix[:id]][:cur] << {
+            pos: io.pos, size: ix[:size], flag: ix[:flag]
+          } if is_avi2?
+          io.print ix[:id]
+          vid_frames_size += 1 if ix[:id] =~ /d[bc]$/
+          io.print [ix[:size]].pack('V')
+          @movi.pos += 8
+          io.print @movi.read(ix[:size])
+          if ix[:size] % 2 == 1
+            io.print "\0"
+            @movi.pos += 1
+          end
+          @index_pos += 1
+          break if @index_pos > @indices.size - 1
+        end
+        # standard index
+        if is_avi2?
+          @indexinfo.each do |key, info|
+            ix_offset = io.pos
+            io.print info[:fcc]
+            io.print [24 + 8 * info[:cur].size].pack('V')
+            io.print [2, 0, 1, info[:cur].size].pack('vccV')
+            io.print key
+            io.print [data_offset, 0].pack('qV')
+            info[:cur].each.with_index do |cur, i|
+              io.print [cur[:pos] - data_offset + 8].pack('V') # 8 for LIST####
+              sz = cur[:size]
+              if cur[:flag] & Frame::AVIIF_KEYFRAME == 0 # is not keyframe
+                sz = sz | 0b1000_0000_0000_0000_0000_0000_0000_0000
+              end
+              io.print [sz].pack('V')
+            end
+            # rewrite indx
+            indx = info[:indx]
+            nent = indx.value[4, 4].unpack('V').first + 1
+            indx.value[4, 4] = [nent].pack('V')
+            indx.value[24 + 16 * (nent - 1), 16] = [
+              ix_offset, io.pos - ix_offset, info[:cur].size
+            ].pack('qVV')
+            io.pos = expected_position_of(indx) + 8
+            io.print indx.value
+            # clean up
+            info[:cur] = []
+            io.seek 0, IO::SEEK_END
+          end
+        end
+        # size of movi
+        size = io.pos - data_offset
+        io.pos = data_offset - 4
+        io.print [size].pack('V')
+        io.seek 0, IO::SEEK_END
+        io.print "\0" if size % 2 == 1
+        vid_frames_size
+      end
+
+      File.open(path, 'w+') do |io|
+        io.binmode
+        @movi.rewind
+        # normal AVI
+        # header
+        io.print 'RIFF'
+        io.print "\0\0\0\0"
+        io.print 'AVI '
+        @riff.first.value.each do |chunk|
+          break if chunk.id == 'movi'
+          print_chunk io, chunk
+        end
+        # movi
+        vid_size = write_movi.call io
+        # rewrite frame count in avih header
+        io.pos = 48
+        io.print [vid_size].pack('V')
+        io.seek 0, IO::SEEK_END
+        # idx1
+        io.print 'idx1'
+        io.print [@index_pos * 16].pack('V')
+        @indices[0..(@index_pos - 1)].each do |ix|
+          io.print ix[:id] + [ix[:flag], ix[:offset] + 4, ix[:size]].pack('V3')
+        end
+        # rewrite riff chunk size
+        avisize = io.pos - 8
+        io.pos = 4
+        io.print [avisize].pack('V')
+        io.seek 0, IO::SEEK_END
+
+        # AVI2.0
+        while @index_pos < @indices.size
+          io.print 'RIFF'
+          io.print "\0\0\0\0"
+          riff_offset = io.pos
+          io.print 'AVIX'
+          # movi
+          write_movi.call io
+          # rewrite total chunk size
+          avisize = io.pos - riff_offset
+          io.pos = riff_offset - 4
+          io.print [avisize].pack('V')
+          io.seek 0, IO::SEEK_END
+        end
+      end
+    end
+
+    ##
+    # Provides internal accesses to movi binary data.
+    # It requires the yield block to return an array of pair values 
+    # which consists of new indices array and new movi binary data.
+    def process_movi &block
+      @movi.rewind
+      newindices, newmovi = block.call @indices, @movi
+      unless @indices == newindices
+        @indices.replace newindices
+      end
+      unless @movi == newmovi
+        @movi.rewind
+        newmovi.rewind
+        while d = newmovi.read(BUFFER_SIZE) do
+          @movi.print d
+        end
+        eof = @movi.pos
+        @movi.truncate eof
+      end
+    end
+
+    ##
+    # Searches and returns RIFF values with the passed search +args+.
+    # +args+ should point the ids of the tree structured RIFF data 
+    # under the 'AVI ' chunk without omission, like:
+    # 
+    #   avi.search 'hdrl', 'strl', 'indx'
+    #
+    # It returns a list of RiffChunk object which can be modified directly.
+    # (RiffChunk class which is returned through this method also has a #search
+    # method with the same interface as this class.)
+    # This method only seeks in the first RIFF 'AVI ' tree.
+    def search *args
+      @riff.first.search *args
+    end
+
+    ##
+    # Returns true if +other+'s indices are same as self's indices.
+    def == other
+      self.indices == other.indices
+    end
+
+    def inspect #:nodoc:
+      "#<#{self.class.name}:#{sprintf("0x%x", object_id)} @movi=#{@movi.inspect}>"
+    end
+
+    def initialize_copy avi #:nodoc:
+      avi.path = @path.dup
+      md = Marshal.dump @indices
+      avi.indices = Marshal.load md
+      md = Marshal.dump @riff
+      avi.riff = Marshal.load md
+      newmovi = Tempfile.new 'aviglitch', binmode: true
+      movipos = @movi.pos
+      @movi.rewind
+      newmovi.print @movi.read
+      @movi.pos = movipos
+      newmovi.rewind
+      avi.movi = newmovi
+    end
+
+    def print_chunk io, chunk  #:nodoc:
+      offset = io.pos
+      if chunk.is_list?
+        io.print chunk.list
+        io.print "\0\0\0\0"
+        io.print chunk.id
+        chunk.value.each do |c|
+          print_chunk io, c
+        end
+      else
+        io.print chunk.id
+        io.print "\0\0\0\0"
+        io.print chunk.value
+      end
+      # rewrite size
+      size = io.pos - offset - 8
+      io.pos = offset + 4
+      io.print [size].pack('V')
+      io.seek 0, IO::SEEK_END
+      io.print "\0" if size % 2 == 1
+    end
+
+    def expected_position_of chunk  #:nodoc:
+      pos = -1
+      cur = 12
+      seek = -> (chk) do
+        if chk === chunk
+          pos = cur
+          return
+        end
+        if chk.is_list?
+          cur += 12
+          chk.value.each do |c|
+            seek.call c
+          end
+        else
+          cur += 8
+          cur += chk.value.nil? ? chk.binsize : chk.value.size
+        end
+      end
+      headers = @riff.first.value
+      headers.each do |c|
+        seek.call c
+      end
+      pos
+    end
+
+    def parse_avi1_indices data  #:nodoc:
+      # The function Frames#fix_offsets_if_needed in prev versions was now removed.
+      i = 0
+      while i * 16 < data.size do
+        @indices << {
+          :id     => data[i * 16, 4],
+          :flag   => data[i * 16 + 4, 4].unpack('V').first,
+          :offset => data[i * 16 + 8, 4].unpack('V').first - 4,
+          :size   => data[i * 16 + 12, 4].unpack('V').first,
+        }
+        i += 1
+      end
+    end
+
+    def parse_avi2_indices data, offset #:nodoc:
+      id = data[8, 4]
+      nent = data[4, 4].unpack('V').first
+      h = 24
+      i = 0
+      while h + i * 8 < data.size
+        moffset = data[h + i * 8, 4].unpack('V').first
+        msize = data[h + i * 8 + 4, 4].unpack('V').first
+        of = offset + moffset - 12 # 12 for movi + 00dc####
+        # bit 31 is set if this is NOT a keyframe
+        fl = (msize >> 31 == 1) ? 0 : Frame::AVIIF_KEYFRAME
+        sz = msize & 0b0111_1111_1111_1111_1111_1111_1111_1111
+        @indices << {
+          :id     => id,
+          :flag   => fl,
+          :offset => of,
+          :size   => sz,
+        }
+        i += 1
+      end
+    end
+
+    private :print_chunk, :expected_position_of, 
+            :parse_avi1_indices, :parse_avi2_indices
+
+    class << self
+
+      ##
+      # Parses the +file+ and returns the RIFF structure.
+      def rifftree file, out = nil
+        returnable = out.nil? 
+        out = StringIO.new if returnable 
+
+        parse = ->(io, depth = 0, len = 0) do
+          offset = io.pos
+          while id = io.read(4) do
+            if len > 0 && io.pos >= offset + len
+              io.pos -= 4
+              break
+            end
+            size = io.read(4).unpack('V').first
+            str = depth > 0 ? '   ' * depth + id : id
+            if id =~ /^(?:RIFF|LIST)$/
+              lid = io.read(4)
+              str << (' (%d)' % size) + " ’#{lid}’\n"
+              out.print str
+              parse.call io, depth + 1, size
+            else
+              str << (' (%d)' % size ) + "\n"
+              out.print str
+              io.pos += size
+              io.pos += 1 if size % 2 == 1
+            end
+          end
+        end
+      
+        io = file
+        is_io = file.respond_to?(:seek)  # Probably IO.
+        io = File.open(file, 'rb') unless is_io
+        begin
+          io.rewind
+          parse.call io
+          io.rewind
+        ensure
+          io.close unless is_io
+        end
+        
+        if returnable
+          out.rewind
+          out.read
+        end
+      end
+
+      ##
+      # Parses the +file+ and prints the RIFF structure to stdout.
+      def print_rifftree file   
+        Avi.rifftree file, $stdout
+      end
+
+    end
+
+  end
+end