Appendix A: PNGlitch library

How to use this library: The Simple Way

png = PNGlitch.open '/path/to/your/image.png'
png.glitch do |data|
  data.gsub /\d/, 'x'
end
png.save '/path/to/broken/image.png'
png.close

PNGlitch.open('/path/to/your/image.png') do |png|
  png.glitch do |data|
    data.gsub /\d/, 'x'
  end
  png.save '/path/to/broken/image.png'
end

PNGlitch.open('/path/to/your/image.png') do |png|
  buf = 2 ** 18
  png.glitch_as_io do |io|
    until io.eof? do
      d = io.read(buf)
      io.pos -= d.size
      io.print(d.gsub(/\d/, 'x'))
    end
  end
  png.save '/path/to/broken/image.png'
end

PNGlitch.open('/path/to/your/image.png') do |png|
  png.each_scanline do |scanline|
    scanline.gsub! /\d/, 'x'
  end
  png.save '/path/to/broken/image.png'
end

How to use this library: Complex Manipulatin

png.each_scanline do |scanline|
  data = scanline.data
  scanline.replace_data(data.gsub(/\d/, 'x'))
end

png.each_scanline do |scanline|
  scanline.gsub! /\d/, 'x'
end

puts png.filter_types

png.each_scanline do |scanline|
  puts scanline.filter_type
  scanline.change_filter 3
end

PNGlitch.open(infile) do |png|
  png.each_scanline do |scanline|
    scanline.change_filter 3
  end
  png.glitch do |data|
    data.gsub /\d/, 'x'
  end
  png.save outfile1
end

PNGlitch.open(infile) do |png|
png.each_scanline do |scanline|
scanline.change_filter 4
end
png.glitch do |data|
data.gsub /\d/, ‘x’
end
png.save outfile2
end

png.glitch_after_compress do |data|
  data[rand(data.size)] = 'x'
  data
end

Appendix B: PNG glitch catalogue

Replace: 

Randomly rewrite the byte string.

Transpose: 

Divide the byte string into large chunks and re-arrange them.

Defect: 

Randomly delete the byte string (to rewrite as an empty string).

require 'pnglitch'

count = 0
infiles = %w(lena.png lena-alpha.png)
infiles.each do |file|
alpha = /alpha/ =~ file
[false, true].each do |compress|
[false, true].each do |interlace|
infile = file
if interlace
system(“convert -interlace plane %s tmp.png” % infile)
infile = ‘tmp.png’
end
[:optimized, :sub, :up, :average, :paeth].each do |filter|
[:replace, :transpose, :defect].each do |method|
count += 1
png = PNGlitch.open infile
png.change_all_filters filter unless filter == :optimized
options = [filter.to_s]
options << ‘alpha’ if alpha
options << ‘interlace’ if interlace
options << ‘compress’ if compress
options << method.to_s
outfile = “lena-%03d-%s.png” % [count, options.join(‘-‘)]
process = lambda do |data, range|
case method
when :replace
range.times do
data[rand(data.size)] = ‘x’
end
data
when :transpose
x = data.size / 4
data[0, x] + data[x * 2, x] + data[x * 1, x] + data[x * 3..-1]
when :defect
(range / 5).times do
data[rand(data.size)] = ”
end
data
end
end
unless compress
png.glitch do |data|
process.call data, 50
end
else
png.glitch_after_compress do |data|
process.call data, 10
end
end
png.save outfile
png.close
end
end
end
end
end
File.unlink ‘tmp.png’

Appendix C: Incorrect filters

require 'pnglitch'
PNGlitch.open('png.png') do |png|
  png.each_scanline do |line|
    line.graft rand(5)
  end
  png.save "png-glitch-graft.png"
end

require 'pnglitch'
(0..4).each do |filter|
  PNGlitch.open('png.png') do |png|
    png.each_scanline do |line|
      line.graft filter
    end
    png.save "png-glitch-graft-#{filter}.png"
  end
end

Implementation of an incorrect filter

require 'pnglitch'
PNGlitch.open('png.png') do |p|
  p.each_scanline do |l|
    l.register_filter_encoder do |data, prev|
      data.size.times.reverse_each do |i|
        x = data.getbyte(i)
        v = prev ? prev.getbyte(i - 1) : 0
        data.setbyte(i, (x - v) & 0xff)
      end
      data
    end
  end
  p.output 'png-incorrect-filter01.png'
end

require 'pnglitch'
PNGlitch.open('png.png') do |p|
  p.change_all_filters 4
  p.each_scanline do |l|
    l.register_filter_encoder do |data, prev|
      data.size.times.reverse_each do |i|
        x = data.getbyte(i)
        v = prev ? prev.getbyte(i - 6) : 0
        data.setbyte(i, (x - v) & 0xff)
      end
      data
    end
  end
  p.output 'png-incorrect-filter02.png'
end

require 'pnglitch'
PNGlitch.open('png.png') do |png|
  png.change_all_filters 4
  sample_size = png.sample_size
  png.each_scanline do |l|
    l.register_filter_encoder do |data, prev|
      data.size.times.reverse_each do |i|
        x = data.getbyte i
        is_a_exist = i >= sample_size
        is_b_exist = !prev.nil?
        a = is_a_exist ? data.getbyte(i - sample_size) : 0
        b = is_b_exist ? prev.getbyte(i) : 0
        c = is_a_exist && is_b_exist ? prev.getbyte(i - sample_size) : 0
        p =  a + b - c
        pa = (p - a).abs
        pb = (p - b).abs
        pc = (p - c).abs
        pr = pa <= pb && pa <= pc ? a : pb <= pc ? b : c
        data.setbyte i, (x - pr) & 0xfe
      end
      data
    end
  end
  png.output 'png-incorrect-filter03.png'
end

require 'pnglitch'
PNGlitch.open('png.png') do |p|
  p.change_all_filters 2
  p.each_scanline do |l|
    l.register_filter_encoder do |data, prev|
      data.size.times.reverse_each do |i|
        x = data.getbyte(i)
        v = prev ? prev.getbyte(i) : 0
        data.setbyte(i, (x - v) & 0xfe)
      end
      data
    end
  end
  p.output 'png-incorrect-filter04.png'
end