Portable Network Graphics Parser

wiki

-- pngparse.lua
-- Simple example of parsing the main sections of a PNG file.
--
-- This is mostly just an example.  Not intended to be complete,
-- robust, modular, or well tested.
--
-- (c) 2008 David Manura. Licensed under the same terms as Lua (MIT license).


-- Unpack 32-bit unsigned integer (most-significant-byte, MSB, first)
-- from byte string.
local function unpack_msb_uint32(s)
  local a,b,c,d = s:byte(1,#s)
  local num = (((a*256) + b) * 256 + c) * 256 + d
  return num
end

-- Read 32-bit unsigned integer (most-significant-byte, MSB, first) from file.
local function read_msb_uint32(fh)
  return unpack_msb_uint32(fh:read(4))
end

-- Read unsigned byte (integer) from file
local function read_byte(fh)
  return fh:read(1):byte()
end


local function parse_zlib(fh, len)
  local byte1 = read_byte(fh)
  local byte2 = read_byte(fh)

  local compression_method = byte1 % 16
  local compression_info = math.floor(byte1 / 16)

  local fcheck = byte2 % 32
  local fdict = math.floor(byte2 / 32) % 1
  local flevel = math.floor(byte2 / 64)

  print("compression_method=", compression_method)
  print("compression_info=", compression_info)
  print("fcheck=", fcheck)
  print("fdict=", fdict)
  print("flevel=", flevel)

  fh:read(len - 6)
  print("(deflate data not displayed)")

  local checksum = read_msb_uint32(fh)
  print("checksum=", checksum)
end

local function parse_IHDR(fh, len)
  assert(len == 13, 'format error')
  local width = read_msb_uint32(fh)
  local height = read_msb_uint32(fh)
  local bit_depth = read_byte(fh)
  local color_type = read_byte(fh)
  local compression_method = read_byte(fh)
  local filter_method = read_byte(fh)
  local interlace_method = read_byte(fh)

  print("width=", width)
  print("height=", height)
  print("bit_depth=", bit_depth)
  print("color_type=", color_type)
  print("compression_method=", compression_method)
  print("filter_method=", filter_method)
  print("interlace_method=", interlace_method)

  return compression_method
end

local function parse_sRGB(fh, len)
  assert(len == 1, 'format error')
  local rendering_intent = read_byte(fh)
  print("rendering_intent=", rendering_intent)
end

local function parse_gAMA(fh, len)
  assert(len == 4, 'format error')
  local rendering_intent = read_msb_uint32(fh)
  print("rendering_intent=", rendering_intent)
end

local function parse_cHRM(fh, len)
  assert(len == 32, 'format error')

  local white_x = read_msb_uint32(fh)
  local white_y = read_msb_uint32(fh)
  local red_x = read_msb_uint32(fh)
  local red_y = read_msb_uint32(fh)
  local green_x = read_msb_uint32(fh)
  local green_y = read_msb_uint32(fh)
  local blue_x = read_msb_uint32(fh)
  local blue_y = read_msb_uint32(fh)
  print('white_x=', white_x)
  print('white_y=', white_y)
  print('red_x=', red_x)
  print('red_y=', red_y)
  print('green_x=', green_x)
  print('green_y=', green_y)
  print('blue_x=', blue_x)
  print('blue_y=', blue_y)
end

local function parse_IDAT(fh, len, compression_method)
  if compression_method == 0 then
    -- fh:read(len)
    parse_zlib(fh, len)
  else
    print('(unrecognized compression method)')
  end  
end

local function parse_png(fh)
  -- parse PNG header
  local bytes = fh:read(8)
  local expect = "\137\080\078\071\013\010\026\010"
  if bytes ~= expect then
    error 'not a PNG file'
  end

  -- parse chunks
  local compression_method
  while 1 do
    local len = read_msb_uint32(fh)
    local stype = fh:read(4)
    print("chunk:", "type=", stype, "len=", len)

    if stype == 'IHDR' then
      compression_method = parse_IHDR(fh, len)
    elseif stype == 'sRGB' then
      parse_sRGB(fh, len)
    elseif stype == 'gAMA' then
      parse_gAMA(fh, len)
    elseif stype == 'cHRM' then
      parse_cHRM(fh, len)
    elseif stype == 'IDAT' then
      parse_IDAT(fh, len, compression_method)
    else
      local data = fh:read(len)
      print("data=", len == 0 and "(empty)" or "(not displayed)")
    end

    local crc = read_msb_uint32(fh)
    print("crc=", crc)

    if stype == 'IEND' then
      break
    end
  end
end

local filename = arg[1]

if not filename then
  io.stderr:write("usage: lua pngparse.lua <filename>")
  os.exit(1)
end

local fh = assert(io.open(filename, 'rb'))
parse_png(fh)

Example output:

$ lua pngparse.lua myfile.png
chunk:  type=   IHDR    len=    13
width=  676
height= 647
bit_depth=      8
color_type=     2
compression_method=     0
filter_method=  0
interlace_method=       0
crc=    3625766246
chunk:  type=   sRGB    len=    1
rendering_intent=       0
crc=    2932743401
chunk:  type=   gAMA    len=    4
rendering_intent=       45455
crc=    201089285
chunk:  type=   cHRM    len=    32
white_x=        31270
white_y=        32900
red_x=  64000
red_y=  33000
green_x=        30000
green_y=        60000
blue_x= 15000
blue_y= 6000
crc=    2629456188
chunk:  type=   IDAT    len=    60975
compression_method=     8
compression_info=       7
fcheck= 30
fdict=  0
flevel= 1
(deflate data not displayed)
checksum=       2411816191
crc=    1804717936
chunk:  type=   IEND    len=    0
data=   (empty)
crc=    2923585666

--DavidManura