mirror of
https://github.com/rivi-s/pfQuest-HDB.git
synced 2026-11-17 16:34:37 +00:00
277 lines
6.9 KiB
Lua
277 lines
6.9 KiB
Lua
class = require '30log'
|
|
deflate = require 'deflate'
|
|
require 'stream'
|
|
|
|
Chunk = class()
|
|
Chunk.__name = "Chunk"
|
|
Chunk.length = 0
|
|
Chunk.name = ""
|
|
Chunk.data = ""
|
|
Chunk.crc = ""
|
|
|
|
function Chunk:__init(stream)
|
|
if stream.__name == "Chunk" then
|
|
self.length = stream.length
|
|
self.name = stream.name
|
|
self.data = stream.data
|
|
self.crc = stream.crc
|
|
else
|
|
self.length = stream:readInt()
|
|
self.name = stream:readChars(4)
|
|
self.data = stream:readChars(self.length)
|
|
self.crc = stream:readChars(4)
|
|
end
|
|
end
|
|
|
|
function Chunk:getDataStream()
|
|
return Stream({input = self.data})
|
|
end
|
|
|
|
IHDR = Chunk:extends()
|
|
IHDR.__name = "IHDR"
|
|
IHDR.width = 0
|
|
IHDR.height = 0
|
|
IHDR.bitDepth = 0
|
|
IHDR.colorType = 0
|
|
IHDR.compression = 0
|
|
IHDR.filter = 0
|
|
IHDR.interlace = 0
|
|
|
|
function IHDR:__init(chunk)
|
|
self.super.__init(self, chunk)
|
|
local stream = chunk:getDataStream()
|
|
self.width = stream:readInt()
|
|
self.height = stream:readInt()
|
|
self.bitDepth = stream:readByte()
|
|
self.colorType = stream:readByte()
|
|
self.compression = stream:readByte()
|
|
self.filter = stream:readByte()
|
|
self.interlace = stream:readByte()
|
|
end
|
|
|
|
IDAT = Chunk:extends()
|
|
IDAT.__name = "IDAT"
|
|
|
|
function IDAT:__init(chunk)
|
|
self.super.__init(self, chunk)
|
|
end
|
|
|
|
PLTE = Chunk:extends()
|
|
PLTE.__name = "PLTE"
|
|
PLTE.numColors = 0
|
|
PLTE.colors = {}
|
|
|
|
function PLTE:__init(chunk)
|
|
self.super.__init(self, chunk)
|
|
self.numColors = math.floor(chunk.length/3)
|
|
local stream = chunk:getDataStream()
|
|
for i = 1, self.numColors do
|
|
self.colors[i] = {
|
|
R = stream:readByte(),
|
|
G = stream:readByte(),
|
|
B = stream:readByte(),
|
|
}
|
|
end
|
|
end
|
|
|
|
function PLTE:getColor(index)
|
|
return self.colors[index]
|
|
end
|
|
|
|
Pixel = class()
|
|
Pixel.__name = "Pixel"
|
|
Pixel.R = 0
|
|
Pixel.G = 0
|
|
Pixel.B = 0
|
|
Pixel.A = 0
|
|
|
|
function Pixel:__init(stream, depth, colorType, palette)
|
|
local bps = math.floor(depth/8)
|
|
if colorType == 0 then
|
|
local grey = stream:readInt(bps)
|
|
self.R = grey
|
|
self.G = grey
|
|
self.B = grey
|
|
self.A = 255
|
|
end
|
|
if colorType == 2 then
|
|
self.R = stream:readInt(bps)
|
|
self.G = stream:readInt(bps)
|
|
self.B = stream:readInt(bps)
|
|
self.A = 255
|
|
end
|
|
if colorType == 3 then
|
|
local index = stream:readInt(bps)+1
|
|
local color = palette:getColor(index)
|
|
self.R = color.R
|
|
self.G = color.G
|
|
self.B = color.B
|
|
self.A = 255
|
|
end
|
|
if colorType == 4 then
|
|
local grey = stream:readInt(bps)
|
|
self.R = grey
|
|
self.G = grey
|
|
self.B = grey
|
|
self.A = stream:readInt(bps)
|
|
end
|
|
if colorType == 6 then
|
|
self.R = stream:readInt(bps)
|
|
self.G = stream:readInt(bps)
|
|
self.B = stream:readInt(bps)
|
|
self.A = stream:readInt(bps)
|
|
end
|
|
end
|
|
|
|
function Pixel:format()
|
|
return string.format("R: %d, G: %d, B: %d, A: %d", self.R, self.G, self.B, self.A)
|
|
end
|
|
|
|
ScanLine = class()
|
|
ScanLine.__name = "ScanLine"
|
|
ScanLine.pixels = {}
|
|
ScanLine.filterType = 0
|
|
|
|
function ScanLine:__init(stream, depth, colorType, palette, length)
|
|
bpp = math.floor(depth/8) * self:bitFromColorType(colorType)
|
|
bpl = bpp*length
|
|
self.filterType = stream:readByte()
|
|
stream:seek(-1)
|
|
stream:writeByte(0)
|
|
local startLoc = stream.position
|
|
if self.filterType == 0 then
|
|
for i = 1, length do
|
|
self.pixels[i] = Pixel(stream, depth, colorType, palette)
|
|
end
|
|
end
|
|
if self.filterType == 1 then
|
|
for i = 1, length do
|
|
for j = 1, bpp do
|
|
local curByte = stream:readByte()
|
|
stream:seek(-(bpp+1))
|
|
local lastByte = 0
|
|
if stream.position >= startLoc then lastByte = stream:readByte() or 0 else stream:readByte() end
|
|
stream:seek(bpp-1)
|
|
stream:writeByte((curByte + lastByte) % 256)
|
|
end
|
|
stream:seek(-bpp)
|
|
self.pixels[i] = Pixel(stream, depth, colorType, palette)
|
|
end
|
|
end
|
|
if self.filterType == 2 then
|
|
for i = 1, length do
|
|
for j = 1, bpp do
|
|
local curByte = stream:readByte()
|
|
stream:seek(-(bpl+2))
|
|
local lastByte = stream:readByte() or 0
|
|
stream:seek(bpl)
|
|
stream:writeByte((curByte + lastByte) % 256)
|
|
end
|
|
stream:seek(-bpp)
|
|
self.pixels[i] = Pixel(stream, depth, colorType, palette)
|
|
end
|
|
end
|
|
if self.filterType == 3 then
|
|
for i = 1, length do
|
|
for j = 1, bpp do
|
|
local curByte = stream:readByte()
|
|
stream:seek(-(bpp+1))
|
|
local lastByte = 0
|
|
if stream.position >= startLoc then lastByte = stream:readByte() or 0 else stream:readByte() end
|
|
stream:seek(-(bpl)+bpp-2)
|
|
local priByte = stream:readByte() or 0
|
|
stream:seek(bpl)
|
|
stream:writeByte((curByte + math.floor((lastByte+priByte)/2)) % 256)
|
|
end
|
|
stream:seek(-bpp)
|
|
self.pixels[i] = Pixel(stream, depth, colorType, palette)
|
|
end
|
|
end
|
|
if self.filterType == 4 then
|
|
for i = 1, length do
|
|
for j = 1, bpp do
|
|
local curByte = stream:readByte()
|
|
stream:seek(-(bpp+1))
|
|
local lastByte = 0
|
|
if stream.position >= startLoc then lastByte = stream:readByte() or 0 else stream:readByte() end
|
|
stream:seek(-(bpl + 2 - bpp))
|
|
local priByte = stream:readByte() or 0
|
|
stream:seek(-(bpp+1))
|
|
local lastPriByte = 0
|
|
if stream.position >= startLoc - (length * bpp + 1) then lastPriByte = stream:readByte() or 0 else stream:readByte() end
|
|
stream:seek(bpl + bpp)
|
|
stream:writeByte((curByte + self:_PaethPredict(lastByte, priByte, lastPriByte)) % 256)
|
|
end
|
|
stream:seek(-bpp)
|
|
self.pixels[i] = Pixel(stream, depth, colorType, palette)
|
|
end
|
|
end
|
|
end
|
|
|
|
function ScanLine:bitFromColorType(colorType)
|
|
if colorType == 0 then return 1 end
|
|
if colorType == 2 then return 3 end
|
|
if colorType == 3 then return 1 end
|
|
if colorType == 4 then return 2 end
|
|
if colorType == 6 then return 4 end
|
|
error 'Invalid colortype'
|
|
end
|
|
|
|
function ScanLine:getPixel(pixel)
|
|
return self.pixels[pixel]
|
|
end
|
|
|
|
--Stolen right from w3.
|
|
function ScanLine:_PaethPredict(a, b, c)
|
|
local p = a + b - c
|
|
local varA = math.abs(p - a)
|
|
local varB = math.abs(p - b)
|
|
local varC = math.abs(p - c)
|
|
if varA <= varB and varA <= varC then return a end
|
|
if varB <= varC then return b end
|
|
return c
|
|
end
|
|
|
|
pngImage = class()
|
|
pngImage.__name = "PNG"
|
|
pngImage.width = 0
|
|
pngImage.height = 0
|
|
pngImage.depth = 0
|
|
pngImage.colorType = 0
|
|
pngImage.scanLines = {}
|
|
|
|
function pngImage:__init(path, progCallback)
|
|
local str = Stream({inputF = path})
|
|
if str:readChars(8) ~= "\137\080\078\071\013\010\026\010" then error 'Not a PNG' end
|
|
local ihdr = {}
|
|
local plte = {}
|
|
local idat = {}
|
|
local num = 1
|
|
while true do
|
|
ch = Chunk(str)
|
|
if ch.name == "IHDR" then ihdr = IHDR(ch) end
|
|
if ch.name == "PLTE" then plte = PLTE(ch) end
|
|
if ch.name == "IDAT" then idat[num] = IDAT(ch) num = num+1 end
|
|
if ch.name == "IEND" then break end
|
|
end
|
|
self.width = ihdr.width
|
|
self.height = ihdr.height
|
|
self.depth = ihdr.bitDepth
|
|
self.colorType = ihdr.colorType
|
|
|
|
local dataStr = ""
|
|
for k,v in pairs(idat) do dataStr = dataStr .. v.data end
|
|
local output = {}
|
|
deflate.inflate_zlib {input = dataStr, output = function(byte) output[#output+1] = string.char(byte) end, disable_crc = true}
|
|
imStr = Stream({input = table.concat(output)})
|
|
|
|
for i = 1, self.height do
|
|
self.scanLines[i] = ScanLine(imStr, self.depth, self.colorType, plte, self.width)
|
|
if progCallback ~= nil then progCallback(i, self.height) end
|
|
end
|
|
end
|
|
|
|
function pngImage:getPixel(x, y)
|
|
local pixel = self.scanLines[y].pixels[x]
|
|
return pixel
|
|
end |