aviglitch 0.0.1

data/ChangeLog

@@ -0,0 +1,4 @@
+== 0.0.1 / 2009-08-01
+
+* initial release
+

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 ucnv
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,43 @@
+= AviGlitch
+
+* http://github.com/ucnv/aviglitch/tree/master
+
+== Description
+
+AviGlitch destroys your AVI files.
+
+I can't explain why they're going to destroy their own data.
+
+See followig urls for details;
+* vimeo http://www.vimeo.com/groups/artifacts
+* wikipedia http://en.wikipedia.org/wiki/Compression_artifact
+
+== Features/Problems
+
+* Not supports AVI2 files right now.
+* Not supports files with interleave.
+* Parses only container level structure, not parses codecs.
+
+== Synopsis
+
+  require 'aviglitch'
+
+  avi = AviGlitch.new('/path/to/your.avi')
+  avi.glitch(:keyframe) do |data|
+    data.gsub(/\d/, '0')
+  end
+  avi.write('/path/to/broken.avi')
+
+This library also includes a command tool named +datamosh+.
+It creates the keyframes removed video.
+
+  $ datamosh /path/to/your.avi /path/to/broken.avi
+
+== Installation
+
+  gem sources -a http://gems.github.com
+  sudo gem install ucnv-aviglitch
+
+== Copyright
+
+Copyright (c) 2009 ucnv. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,51 @@
+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://github.com/ucnv/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}/**/*") 
+
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+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.rdoc_dir = 'rdoc'
+  rdoc.title = "aviglitch #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/datamosh

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# Generate datamoshing
+
+require 'rubygems'
+require 'aviglitch'
+
+if ARGV.size < 1 || ARGV.first == '--help'
+  puts <<-BANNER.gsub(/^\s+/, '')
+    Usage: #{File.basename $0} INPUT [OUTPUT]
+    Generate a datamoshing video from INPUT to OUTPUT (./out.avi by default).
+  BANNER
+  exit 0
+end
+
+input, output = ARGV
+
+a = AviGlitch.new input
+a.glitch_with_index :keyframe do |frame, i|
+  if i == 0  # keep the first frame
+    frame
+  else
+    "\000" * frame.size
+  end
+end
+a.write(output || 'out.avi')

data/lib/aviglitch.rb

@@ -0,0 +1,170 @@
+require 'tempfile'
+require 'fileutils'
+require 'aviglitch/frame'
+require 'aviglitch/frames'
+
+# AviGlitch provides the ways to glitch AVI formatted video files.
+#
+# == Synopsis:
+#
+# You can manipulate each frame, like:
+#
+#   avi = Aviglitch.new '/path/to/your.avi'
+#   avi.frames.each |frame|
+#     if frame.is_keyframe?
+#       frame.data = frame.data.gsub(/\d/, '0')
+#     end
+#   end
+#   avi.write '/path/to/broken.avi'
+#
+# Using the method glitch, it can be written like:
+#
+#   avi = AviGlitch.new '/path/to/your.avi'
+#   avi.glitch(:keyframe) do |data|
+#     data.gsub(/\d/, '0')
+#   end
+#   avi.write '/path/to/broken.avi'
+#
+#--
+# It does not support AVI2, interleave format.
+#
+class AviGlitch
+
+  VERSION = '0.0.1'
+
+  # AviGlitch::Frames object generated from the +file+.
+  attr_reader :frames
+  # The input file (copied tempfile).
+  attr_reader :file
+
+  ##
+  # Create a new instance of AviGlitch, open the file and 
+  # make it ready to manipulate.
+  # It requires +path+ as String or Pathname.
+  def initialize path
+    File.open(path) do |f|
+      # copy as tempfile
+      @file = Tempfile.open 'aviglitch'
+      f.rewind
+      while d = f.read(1024) do
+        @file.print d
+      end
+    end
+
+    unless AviGlitch.surely_formatted? @file
+      raise 'Unsupported file passed.'
+    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.
+  def write path
+    FileUtils.cp @file.path, path
+    close
+  end
+
+  ##
+  # An explicit file close.
+  def close
+    @file.close!
+  end
+
+  ##
+  # Glitch each frame data.
+  # It is a convent method to iterate each frame.
+  #
+  # The argument +target+ takes symbols listed below:
+  # [<tt>:keyframe</tt> or <tt>:iframe</tt>]   select video key frames (aka I-frame)
+  # [<tt>:deltaframe</tt> or <tt>:pframe</tt>] select video delta frames (difference frames)
+  # [<tt>:videoframe</tt>] select both of keyframe and deltaframe
+  # [<tt>:audioframe</tt>] select audio frames
+  # [<tt>:all</tt>]        select all frames
+  #
+  # 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.
+  def glitch target = :all, &block  # :yield: data
+    frames.each do |frame|
+      if valid_target? target, frame
+        frame.data = yield frame.data
+      end
+    end
+  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
+      end
+    end
+  end
+
+  alias :output :write
+
+  def valid_target? target, frame # :nodoc:
+    return true if target == :all
+    begin
+      frame.send "is_#{target.to_s}?"
+    rescue
+      false
+    end
+  end
+
+  private_instance_methods :valid_target?
+  class << self
+
+    ##
+    # Check 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) unless is_io
+      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 len + 8 == eof
+          answer = false
+          warn 'Length info is invalid' if debug
+        end
+        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
+        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
+      end
+      answer
+    end
+
+    alias :open :new
+
+  end
+end

data/lib/aviglitch/frame.rb

@@ -0,0 +1,64 @@
+class AviGlitch
+  
+  # Frame is the struct of the frame data and meta-data.
+  # You can access this class through AviGlitch::Frames.
+  # To modify the binary data, operate the +data+ property.
+  class Frame
+
+    AVIIF_LIST     = 0x00000001
+    AVIIF_KEYFRAME = 0x00000010
+    AVIIF_NO_TIME  = 0x00000100
+
+    attr_accessor :data
+    attr_reader :id, :flag
+
+    ##
+    # Create a new AviGlitch::Frame object.
+    #
+    # The arguments are:
+    # [+data+] just data, without meta-data
+    # [+id+]   id for the stream number and content type code
+    #          (like "00dc")
+    # [+flag+] flag that describes the chunk type (taken from idx1)
+    #
+    def initialize data, id, flag
+      @data = data
+      @id = id
+      @flag = flag
+    end
+
+    ##
+    # Returns if it is a video frame and also a key frame.
+    def is_keyframe?
+      is_videoframe? && @flag & AVIIF_KEYFRAME != 0
+    end
+
+    ##
+    # Alias for is_keyframe?
+    alias :is_iframe? :is_keyframe?
+
+    ##
+    # Returns if it is a video frame and also not a key frame.
+    def is_deltaframe?
+      is_videoframe? && @flag & AVIIF_KEYFRAME == 0
+    end
+
+    ##
+    # Alias for is_deltaframe?
+    alias :is_pframe? :is_deltaframe?
+
+    ##
+    # Returns if it is a video frame.
+    def is_videoframe?
+      @id[2, 2] == 'db' || @id[2, 2] == 'dc'
+    end
+
+    ##
+    # Returns if it is an audio frame.
+    def is_audioframe?
+      @id[2, 2] == 'wb'
+    end
+
+  end
+end
+

data/lib/aviglitch/frames.rb

@@ -0,0 +1,97 @@
+class AviGlitch
+
+  # Frames provides the interface to access each frame
+  # in the AVI file.
+  # It is implemented as Enumerable. You can access this object
+  # through AviGlitch#frames, for example:
+  #
+  #   avi = AviGlitch.new '/path/to/your.avi'
+  #   frames = avi.frames
+  #   frames.each do |frame|
+  #     ## frame is a reference of a AviGlitch::Frame object
+  #     frame.data = frame.data.gsub(/\d/, '0')
+  #   end
+  #
+  # In the block passed into iteration method, the parameter is the reference
+  # of AviGlitch::Frame object.
+  #
+  class Frames
+    include Enumerable
+
+    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
+      io.rewind
+      @io = io
+    end
+
+    def each
+      temp = Tempfile.new 'frames'
+      temp.print 'movi'
+      @meta = @meta.select do |m|
+        @io.pos = @pos_of_movi + m[:offset] + 8
+        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
+          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
+          true
+        else
+          false
+        end
+      end
+
+      # Overwrite the file
+      @io.pos = @pos_of_movi - 4
+      @io.print [temp.pos].pack('V')
+      temp.rewind
+      while d = temp.read(1024) do
+        @io.print d
+      end
+      temp.close true
+      @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
+      @io.print [@meta.size].pack('V')
+
+    end
+
+    def size
+      @meta.size
+    end
+
+  end
+end

data/spec/aviglitch_spec.rb

@@ -0,0 +1,109 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe AviGlitch do
+
+  before :all do
+    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 'raise an error against unsupported files' do
+    lambda {
+      avi = AviGlitch.new __FILE__
+    }.should raise_error
+  end
+
+  it 'saves the same file when nothing is changed' do
+    avi = AviGlitch.new @in
+    avi.frames.each do |f|
+      ;
+    end
+    avi.write @out
+    FileUtils.cmp(@in, @out).should be true
+
+    avi = AviGlitch.new @in
+    avi.glitch do |d|
+      d
+    end
+    avi.write @out
+    FileUtils.cmp(@in, @out).should be true
+  end
+
+  it 'can manipulate each frame' do
+    avi = AviGlitch.new @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.write @out
+    AviGlitch.surely_formatted?(@out, true).should be true
+  end
+
+  it 'can glitch each keyframe' do
+    avi = AviGlitch.new @in
+    n = 0
+    avi.glitch :keyframe do |kf|
+      n += 1
+      kf.slice(10..kf.size)
+    end
+    avi.write @out
+    i_size = File.stat(@in).size
+    o_size = File.stat(@out).size
+    o_size.should == i_size - (10 * n)
+    AviGlitch.surely_formatted?(@out, true).should be true
+  end
+
+  it 'can glitch each keyframe with index' do
+    avi = AviGlitch.new @in
+    avi.glitch_with_index :keyframe do |kf, idx|
+      if idx < 25
+        kf.slice(10..kf.size)
+      else
+        kf
+      end
+    end
+    avi.write @out
+    i_size = File.stat(@in).size
+    o_size = File.stat(@out).size
+    o_size.should == i_size - (10 * 25)
+    AviGlitch.surely_formatted?(@out, true).should be true
+  end
+
+  it 'can remove a frame with returning nil' do
+    avi = AviGlitch.new @in
+    in_frame_size = avi.frames.size
+    rem_count = 0
+    avi.glitch :keyframe do |kf|
+      rem_count += 1
+      nil
+    end
+    avi.write @out
+    AviGlitch.surely_formatted?(@out, true).should be true
+
+    # frames length in the output file is correct
+    avi = AviGlitch.new @out
+    out_frame_size = avi.frames.size
+    out_frame_size.should == in_frame_size - rem_count
+  end
+
+  it 'has some alias methods' do
+    lambda {
+      avi = AviGlitch.open @in
+      avi.output @out
+    }.should_not raise_error
+    AviGlitch.surely_formatted?(@out, true).should be true
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'aviglitch'
+require 'pathname'
+require 'fileutils'
+
+FILES_DIR = Pathname.new(File.dirname(__FILE__)).realpath + 'files'
+OUTPUT_DIR = FILES_DIR + 'output'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: aviglitch
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- ucnv
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-02 00:00:00 +09:00
+default_executable: datamosh
+dependencies: []
+
+description: 
+email: ucnvvv@gmail.com
+executables: 
+- datamosh
+extensions: []
+
+extra_rdoc_files: 
+- ChangeLog
+- LICENSE
+- README.rdoc
+files: 
+- ChangeLog
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/datamosh
+- lib/aviglitch.rb
+- lib/aviglitch/frame.rb
+- lib/aviglitch/frames.rb
+- spec/aviglitch_spec.rb
+- spec/files/sample.avi
+- spec/spec_helper.rb
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/ucnv/aviglitch
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A Ruby library to destroy your AVI files.
+test_files: 
+- spec/aviglitch_spec.rb
+- spec/spec_helper.rb