aviglitch 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67b4c434f616f3731fd09f5b0d0263e634cc87148e8fad42dd38e6b4d554222a
-  data.tar.gz: a61ad04a958aec548dec7b554ec8f1b24ff5973d4fa76862dc0ca067fccbeb11
+  metadata.gz: 6bcaf49d8305bd36386f606954fe702468fc5196e30b0d5e4f3dea11f0bfb8a7
+  data.tar.gz: a1ede07ce50e3005abcd505e501ddf8f73c18b0241d7b34834ac78781d76e389
 SHA512:
-  metadata.gz: 20b11703e84322c798b7a450508d9848f0dd25534ff9bbf3395b269dd8959a454ad805d013dfcb3cdffadccd2c120b8a4912e1356cfa9079c7a3791284fa9bad
-  data.tar.gz: 9c5dd3b8c13a186a59b5fd4ad97c992e24c2967dd4629d86b1c6678c0b2fd07ad66a9711175dc499ec6e83893caa464fce2fa374e60d6daf79b47063e3fcf039
+  metadata.gz: b9a0c0905f0131bec187618e48e7281eac79d01d6067a66dad82bafbc2c923d84bd7472738b147fc2866ee1f5ef14b1064556e05b7109a7ffef5a0c73370ec6f
+  data.tar.gz: f698216510d97cf7713e14127cf75af8264c5c003fa876caed72e51168575eb75e0dba05930ff22c6a145c0da9a0967da9959dfc65d0276909e9db081ba6810c

data/.gitignore

@@ -9,3 +9,4 @@ tmp
 Gemfile.lock
 Guardfile
 .yardoc
+spec/files

data/ChangeLog.md

@@ -1,3 +1,11 @@
+### 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.

data/Gemfile

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

data/README.md

@@ -44,10 +44,6 @@ For more practical usages, please check <https://github.com/ucnv/aviglitch-utils
   gem install aviglitch
 ```
 
-## Known issues
-
-- This library doesn't support AVI2 format spec. This means that it will not work as expected for files larger than 1GB.
-
 ## License
 
 This library is distributed under the terms and conditions of the [MIT license](LICENSE).

data/aviglitch.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["ucnvvv@gmail.com"]
   spec.summary       = %q{A Ruby library to destroy your AVI files.}
   spec.description   = spec.summary
-  spec.homepage      = "http://ucnv.github.com/aviglitch/"
+  spec.homepage      = "https://github.com/ucnv/aviglitch"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
@@ -18,7 +18,6 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.has_rdoc = true
   spec.extra_rdoc_files = ["README.md", "LICENSE"]
   spec.rdoc_options << "-m" << "README.md"
 

data/bin/datamosh

@@ -54,7 +54,12 @@ unless fake
     (!all && i == 0) ? frame : "" # keep the first frame
   end
 end
-a.mutate_keyframes_into_deltaframes!(!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

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