# Portable Network Graphics Encoder and Decoder written in Nim # # Copyright (c) 2015 Andri Lim # # 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. # # this is a rewrite of LodePNG(www.lodev.org/lodepng) # to be as idiomatic Nim as possible # part of nimPDF sister projects #------------------------------------- import unsigned, streams, endians, tables, hashes, math, nimz const NIM_PNG_VERSION = "0.1.1" type PNGChunkType = distinct int32 PNGcolorType* = enum LCT_GREY = 0, # greyscale: 1,2,4,8,16 bit LCT_RGB = 2, # RGB: 8,16 bit LCT_PALETTE = 3, # palette: 1,2,4,8 bit LCT_GREY_ALPHA = 4, # greyscale with alpha: 8,16 bit LCT_RGBA = 6 # RGB with alpha: 8,16 bit PNGFilter0 = enum FLT_NONE, FLT_SUB, FLT_UP, FLT_AVERAGE, FLT_PAETH PNGSettings = ref object of RootObj PNGDecoder* = ref object of PNGSettings colorConvert*: bool #if false but rememberUnknownChunks is true, they're stored in the unknown chunks #(off by default, useful for a png editor) readTextChunks*: bool rememberUnknownChunks*: bool ignoreCRC*: bool PNGInterlace* = enum IM_NONE = 0, IM_INTERLACED = 1 PNGChunk = ref object of RootObj length: range[0..0x7FFFFFFF] chunkType: PNGChunkType crc: uint32 data: string pos: int PNGHeader = ref object of PNGChunk width, height: range[1..0x7FFFFFFF] bitDepth: int colorType: PNGcolorType compressionMethod: int filterMethod: int interlaceMethod: PNGInterlace RGBA8* = object r*, g*, b*, a*: char RGBA16* = object r*, g*, b*, a*: uint16 ColorTree8 = Table[RGBA8, int] PNGPalette = ref object of PNGChunk palette: seq[RGBA8] PNGData = ref object of PNGChunk idat: string PNGTime = ref object of PNGChunk year: range[0..65535] month: range[1..12] day: range[1..31] hour: range[0..23] minute: range[0..59] second: range[0..60] #to allow for leap seconds PNGPhys = ref object of PNGChunk physX, physY: int unit: int PNGTrans = ref object of PNGChunk keyR, keyG, keyB: int PNGBackground = ref object of PNGChunk bkgdR, bkgdG, bkgdB: int PNGText = ref object of PNGChunk keyword: string text: string PNGZtxt = ref object of PNGChunk keyword: string text: string PNGItxt = ref object of PNGChunk keyword: string text: string languageTag: string translatedKeyword: string PNGGamma = ref object of PNGChunk gamma: int PNGChroma = ref object of PNGChunk whitePointX, whitePointY: int redX, redY: int greenX, greenY: int blueX, blueY: int PNGStandarRGB = ref object of PNGChunk renderingIntent: int PNGICCProfile = ref object of PNGChunk profileName: string profile: string PNGSPEntry = object red, green, blue, alpha, frequency: int PNGSPalette = ref object of PNGChunk paletteName: string sampleDepth: int palette: seq[PNGSPEntry] PNGHist = ref object of PNGChunk histogram: seq[int] PNGSbit = ref object of PNGChunk PNGPass = object w, h: array[0..6, int] filterStart, paddedStart, start: array[0..7, int] PNGColorMode* = ref object colorType*: PNGcolorType bitDepth*: int paletteSize*: int palette*: seq[RGBA8] keyDefined*: bool keyR*, keyG*, keyB*: int PNGInfo* = ref object width*: int height*: int mode*: PNGColorMode backgroundDefined*: bool backgroundR*, backgroundG*, backgroundB*: int physDefined*: bool physX*, physY*, physUnit*: int timeDefined*: bool year*: range[0..65535] month*: range[1..12] day*: range[1..31] hour*: range[0..23] minute*: range[0..59] second*: range[0..60] #to allow for leap seconds PNG* = ref object settings*: PNGSettings chunks*: seq[PNGChunk] pixels*: string PNGResult* = ref object width*: int height*: int data*: string proc makePNGDecoder*(): PNGDecoder = var s: PNGDecoder new(s) s.colorConvert = true s.readTextChunks = false s.rememberUnknownChunks = false s.ignoreCRC = false result = s proc signatureMaker(): string {. compiletime .} = const signatureBytes = [137, 80, 78, 71, 13, 10, 26, 10] result = "" for c in signatureBytes: result.add chr(c) proc makeChunkType*(val: string): PNGChunkType = assert (val.len == 4) result = PNGChunkType((ord(val[0]) shl 24) or (ord(val[1]) shl 16) or (ord(val[2]) shl 8) or ord(val[3])) proc `$`*(tag: PNGChunkType): string = result = newString(4) let t = int(tag) result[0] = chr(toU32(t shr 24) and 0xFF) result[1] = chr(toU32(t shr 16) and 0xFF) result[2] = chr(toU32(t shr 8) and 0xFF) result[3] = chr(toU32(t) and 0xFF) proc `==`(a, b: PNGChunkType): bool = int(a) == int(b) #proc isAncillary(a: PNGChunkType): bool = (int(a) and (32 shl 24)) != 0 #proc isPrivate(a: PNGChunkType): bool = (int(a) and (32 shl 16)) != 0 #proc isSafeToCopy(a: PNGChunkType): bool = (int(a) and 32) != 0 proc crc32(crc: uint32, buf: string): uint32 = const kcrc32 = [ 0'u32, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c, 0xedb88320'u32, 0xf00f9344'u32, 0xd6d6a3e8'u32, 0xcb61b38c'u32, 0x9b64c2b0'u32, 0x86d3d2d4'u32, 0xa00ae278'u32, 0xbdbdf21c'u32] var crcu32 = not crc for b in buf: crcu32 = (crcu32 shr 4) xor kcrc32[(crcu32 and 0xF) xor (ord(b) and 0xF)] crcu32 = (crcu32 shr 4) xor kcrc32[(crcu32 and 0xF) xor (ord(b) shr 4)] result = not crcu32 const PNGSignature = signatureMaker() IHDR = makeChunkType("IHDR") IEND = makeChunkType("IEND") PLTE = makeChunkType("PLTE") IDAT = makeChunkType("IDAT") tRNS = makeChunkType("tRNS") bKGD = makeChunkType("bKGD") pHYs = makeChunkType("pHYs") tIME = makeChunkType("tIME") iTXt = makeChunkType("iTXt") zTXt = makeChunkType("zTXt") tEXt = makeChunkType("tEXt") gAMA = makeChunkType("gAMA") cHRM = makeChunkType("cHRM") sRGB = makeChunkType("sRGB") iCCP = makeChunkType("iCCP") sBIT = makeChunkType("sBIT") sPLT = makeChunkType("sPLT") hIST = makeChunkType("hIST") # shared values used by multiple Adam7 related functions ADAM7_IX = [ 0, 4, 0, 2, 0, 1, 0 ] # x start values ADAM7_IY = [ 0, 0, 4, 0, 2, 0, 1 ] # y start values ADAM7_DX = [ 8, 8, 4, 4, 2, 2, 1 ] # x delta values ADAM7_DY = [ 8, 8, 8, 4, 4, 2, 2 ] # y delta values proc PNGError(msg: string): ref Exception = new(result) result.msg = msg proc newColorMode*(colorType=LCT_RGBA, bitDepth=8): PNGColorMode = new(result) result.keyDefined = false result.keyR = 0 result.keyG = 0 result.keyB = 0 result.colorType = colorType result.bitDepth = bitDepth result.paletteSize = 0 proc copyTo*(src, dest: PNGColorMode) = dest.keyDefined = src.keyDefined dest.keyR = src.keyR dest.keyG = src.keyG dest.keyB = src.keyB dest.colorType = src.colorType dest.bitDepth = src.bitDepth dest.paletteSize = src.paletteSize if src.palette != nil: newSeq(dest.palette, src.paletteSize) for i in 0..src.palette.len-1: dest.palette[i] = src.palette[i] proc newColorMode*(mode: PNGColorMode): PNGColorMode = new(result) mode.copyTo(result) proc addPalette*(mode: PNGColorMode, r, g, b, a: int) = if mode.palette == nil: mode.palette = @[] mode.palette.add RGBA8(r: chr(r), g: chr(g), b: chr(b), a: chr(a)) mode.paletteSize = mode.palette.len proc `==`(a, b: PNGColorMode): bool = if a.colorType != b.colorType: return false if a.bitDepth != b.bitDepth: return false if a.keyDefined != b.keyDefined: return false if a.keyDefined: if a.keyR != b.keyR: return false if a.keyG != b.keyG: return false if a.keyB != b.keyB: return false if a.paletteSize != b.paletteSize: return false for i in 0..a.palette.len-1: if a.palette[i] != b.palette[i]: return false result = true proc `!=`(a, b: PNGColorMode): bool = not (a == b) proc readInt32(s: PNGChunk): int = if s.pos + 4 > s.data.len: raise PNGError("index out of bound 4") result = ord(s.data[s.pos]) shl 8 result = (result + ord(s.data[s.pos + 1])) shl 8 result = (result + ord(s.data[s.pos + 2])) shl 8 result = result + ord(s.data[s.pos + 3]) inc(s.pos, 4) proc readInt16(s: PNGChunk): int = if s.pos + 2 > s.data.len: raise PNGError("index out of bound 2") result = ord(s.data[s.pos]) shl 8 result = result + ord(s.data[s.pos + 1]) inc(s.pos, 2) proc readInt32BE(s: Stream): int = var val = s.readInt32() bigEndian32(addr(result), addr(val)) proc readByte(s: PNGChunk): int = if s.pos + 1 > s.data.len: raise PNGError("index out of bound 1") result = ord(s.data[s.pos]) inc s.pos proc setPosition(s: PNGChunk, pos: int) = if pos < 0 or pos > s.data.len: raise PNGError("set position error") s.pos = pos proc hasChunk*(png: PNG, chunkType: PNGChunkType): bool = for c in png.chunks: if c.chunkType == chunkType: return true result = false proc getChunk*(png: PNG, chunkType: PNGChunkType): PNGChunk = for c in png.chunks: if c.chunkType == chunkType: return c proc bitDepthAllowed(colorType: PNGcolorType, bitDepth: int): bool = case colorType of LCT_GREY : result = bitDepth in {1, 2, 4, 8, 16} of LCT_PALETTE: result = bitDepth in {1, 2, 4, 8} else: result = bitDepth in {8, 16} method validateChunk(chunk: PNGChunk, png: PNG): bool = true method parseChunk(chunk: PNGChunk, png: PNG): bool = true method validateChunk(header: PNGHeader, png: PNG): bool = if header.width < 1 or header.width > 0x7FFFFFFF: raise PNGError("image width not allowed: " & $header.width) if header.height < 1 or header.height > 0x7FFFFFFF: raise PNGError("image width not allowed: " & $header.height) if header.colorType notin {LCT_GREY, LCT_RGB, LCT_PALETTE, LCT_GREY_ALPHA, LCT_RGBA}: raise PNGError("color type not allowed: " & $int(header.colorType)) if not bitDepthAllowed(header.colorType, header.bitDepth): raise PNGError("bit depth not allowed: " & $header.bitDepth) if header.compressionMethod != 0: raise PNGError("unsupported compression method") if header.filterMethod != 0: raise PNGError("unsupported filter method") if header.interlaceMethod notin {IM_NONE, IM_INTERLACED}: raise PNGError("unsupported interlace method") result = true method parseChunk(chunk: PNGHeader, png: PNG): bool = if chunk.length != 13: return false chunk.width = chunk.readInt32() chunk.height = chunk.readInt32() chunk.bitDepth = chunk.readByte() chunk.colorType = PNGcolorType(chunk.readByte()) chunk.compressionMethod = chunk.readByte() chunk.filterMethod = chunk.readByte() chunk.interlaceMethod = PNGInterlace(chunk.readByte()) result = true method parseChunk(chunk: PNGPalette, png: PNG): bool = let paletteSize = chunk.length div 3 if paletteSize > 256: raise PNGError("palette size to big") newSeq(chunk.palette, paletteSize) for px in mitems(chunk.palette): px.r = chr(chunk.readByte()) px.g = chr(chunk.readByte()) px.b = chr(chunk.readByte()) px.a = chr(255) result = true proc numChannels(colorType: PNGcolorType): int = case colorType of LCT_GREY: result = 1 of LCT_RGB : result = 3 of LCT_PALETTE: result = 1 of LCT_GREY_ALPHA: result = 2 of LCT_RGBA: result = 4 proc LCTBPP(colorType: PNGcolorType, bitDepth: int): int = # bits per pixel is amount of channels * bits per channel result = numChannels(colorType) * bitDepth proc getBPP(header: PNGHeader): int = # calculate bits per pixel out of colorType and bitDepth result = LCTBPP(header.colorType, header.bitDepth) proc getBPP(color: PNGColorMode): int = # calculate bits per pixel out of colorType and bitDepth result = LCTBPP(color.colorType, color.bitDepth) proc idatRawSize(w, h: int, header: PNGHeader): int = result = h * ((w * getBPP(header) + 7) div 8) proc getRawSize(w, h: int, color: PNGColorMode): int = result = (w * h * getBPP(color) + 7) div 8 #proc getRawSizeLct(w, h: int, colorType: PNGcolorType, bitDepth: int): int = # result = (w * h * LCTBPP(colorType, bitDepth) + 7) div 8 method validateChunk(chunk: PNGData, png: PNG): bool = var header = PNGHeader(png.getChunk(IHDR)) var predict = 0 if header.interlaceMethod == IM_NONE: # The extra header.height is added because this are the filter bytes every scanLine starts with predict = idatRawSize(header.width, header.height, header) + header.height else: # Adam-7 interlaced: predicted size is the sum of the 7 sub-images sizes let w = header.width let h = header.height predict += idatRawSize((w + 7) div 8, (h + 7) div 8, header) + (h + 7) div 8 if w > 4: predict += idatRawSize((w + 3) div 8, (h + 7) div 8, header) + (h + 7) div 8 predict += idatRawSize((w + 3) div 4, (h + 3) div 8, header) + (h + 3) div 8 if w > 2: predict += idatRawSize((w + 1) div 4, (h + 3) div 4, header) + (h + 3) div 4 predict += idatRawSize((w + 1) div 2, (h + 1) div 4, header) + (h + 1) div 4 if w > 1: predict += idatRawSize((w + 0) div 2, (h + 1) div 2, header) + (h + 1) div 2 predict += idatRawSize((w + 0) div 1, (h + 0) div 2, header) + (h + 0) div 2 if chunk.idat.len != predict: raise PNGError("Decompress size doesn't match predict") result = true method parseChunk(chunk: PNGData, png: PNG): bool = var nz = nzInflateInit(chunk.data) chunk.idat = zlib_decompress(nz) result = true method parseChunk(chunk: PNGTrans, png: PNG): bool = var header = PNGHeader(png.getChunk(IHDR)) if header == nil: return false if header.colorType == LCT_PALETTE: var plte = PNGPalette(png.getChunk(PLTE)) if plte == nil: return false # error: more alpha values given than there are palette entries if chunk.length > plte.palette.len: raise PNGError("more alpha value than palette entries") #can contain fewer values than palette entries for i in 0..chunk.length-1: plte.palette[i].a = chr(chunk.readByte()) elif header.colorType == LCT_GREY: # error: this chunk must be 2 bytes for greyscale image if chunk.length != 2: raise PNGError("tRNS must be 2 bytes") chunk.keyR = chunk.readInt16() chunk.keyG = chunk.keyR chunk.keyB = chunk.keyR elif header.colorType == LCT_RGB: # error: this chunk must be 6 bytes for RGB image if chunk.length != 6: raise PNGError("tRNS must be 6 bytes") chunk.keyR = chunk.readInt16() chunk.keyG = chunk.readInt16() chunk.keyB = chunk.readInt16() else: raise PNGError("tRNS chunk not allowed for other color models") result = true method parseChunk(chunk: PNGBackground, png: PNG): bool = var header = PNGHeader(png.getChunk(IHDR)) if header.colorType == LCT_PALETTE: # error: this chunk must be 1 byte for indexed color image if chunk.length != 1: raise PNGError("bkgd must be 1 byte") chunk.bkgdR = chunk.readByte() chunk.bkgdG = chunk.bkgdR chunk.bkgdB = chunk.bkgdR elif header.colorType in {LCT_GREY, LCT_GREY_ALPHA}: # error: this chunk must be 2 bytes for greyscale image if chunk.length != 2: raise PNGError("bkgd must be 2 byte") chunk.bkgdR = chunk.readInt16() chunk.bkgdG = chunk.bkgdR chunk.bkgdB = chunk.bkgdR elif header.colorType in {LCT_RGB, LCT_RGBA}: # error: this chunk must be 6 bytes for greyscale image if chunk.length != 6: raise PNGError("bkgd must be 6 byte") chunk.bkgdR = chunk.readInt16() chunk.bkgdG = chunk.readInt16() chunk.bkgdB = chunk.readInt16() result = true proc initChunk(chunk: PNGChunk, chunkType: PNGChunkType, data: string, crc: uint32) = chunk.length = data.len chunk.crc = crc chunk.chunkType = chunkType chunk.data = data chunk.pos = 0 method validateChunk(chunk: PNGTime, png: PNG): bool = if chunk.year < 0 or chunk.year > 65535: raise PNGError("invalid year range[0..65535]") if chunk.month < 1 or chunk.month > 12: raise PNGError("invalid month range[1..12]") if chunk.day < 1 or chunk.day > 31: raise PNGError("invalid day range[1..32]") if chunk.hour < 0 or chunk.hour > 23: raise PNGError("invalid hour range[0..23]") if chunk.minute < 0 or chunk.minute > 59: raise PNGError("invalid minute range[0..59]") #to allow for leap seconds if chunk.second < 0 or chunk.second > 60: raise PNGError("invalid second range[0..60]") result = true method parseChunk(chunk: PNGTime, png: PNG): bool = if chunk.length != 7: raise PNGError("tIME must be 7 bytes") chunk.year = chunk.readInt16() chunk.month = chunk.readByte() chunk.day = chunk.readByte() chunk.hour = chunk.readByte() chunk.minute = chunk.readByte() chunk.second = chunk.readByte() result = true method parseChunk(chunk: PNGPhys, png: PNG): bool = if chunk.length != 9: raise PNGError("pHYs must be 9 bytes") chunk.physX = chunk.readInt32() chunk.physY = chunk.readInt32() chunk.unit = chunk.readByte() result = true method validateChunk(chunk: PNGText, png: PNG): bool = if(chunk.keyword.len < 1) or (chunk.keyword.len > 79): raise PNGError("keyword too short or too long") result = true method parseChunk(chunk: PNGText, png: PNG): bool = var len = 0 while(len < chunk.length) and (chunk.data[len] != chr(0)): inc len if(len < 1) or (len > 79): raise PNGError("keyword too short or too long") chunk.keyword = chunk.data.substr(0, len) var textBegin = len + 1 # skip keyword null terminator chunk.text = chunk.data.substr(textBegin) result = true method validateChunk(chunk: PNGZtxt, png: PNG): bool = if(chunk.keyword.len < 1) or (chunk.keyword.len > 79): raise PNGError("keyword too short or too long") result = true method parseChunk(chunk: PNGZtxt, png: PNG): bool = var len = 0 while(len < chunk.length) and (chunk.data[len] != chr(0)): inc len if(len < 1) or (len > 79): raise PNGError("keyword too short or too long") chunk.keyword = chunk.data.substr(0, len) var compMethod = ord(chunk.data[len + 1]) # skip keyword null terminator if compMethod != 0: raise PNGError("unsupported comp method") var nz = nzInflateInit(chunk.data.substr(len + 2)) chunk.text = zlib_decompress(nz) result = true method validateChunk(chunk: PNGItxt, png: PNG): bool = if(chunk.keyword.len < 1) or (chunk.keyword.len > 79): raise PNGError("keyword too short or too long") result = true method parseChunk(chunk: PNGItxt, png: PNG): bool = if chunk.length < 5: raise PNGError("iTXt len too short") var len = 0 while(len < chunk.length) and (chunk.data[len] != chr(0)): inc len if(len + 3) >= chunk.length: raise PNGError("no null termination char, corrupt?") if(len < 1) or (len > 79): raise PNGError("keyword too short or too long") chunk.keyword = chunk.data.substr(0, len) var compressed = ord(chunk.data[len + 1]) == 1 # skip keyword null terminator var compMethod = ord(chunk.data[len + 2]) if compMethod != 0: raise PNGError("unsupported comp method") len = 0 var i = len + 3 while(i < chunk.length) and (chunk.data[i] != chr(0)): inc len inc i chunk.languageTag = chunk.data.substr(i, i + len) len = 0 i += len + 1 while(i < chunk.length) and (chunk.data[i] != chr(0)): inc len inc i chunk.translatedKeyword = chunk.data.substr(i, i + len) let textBegin = i + len + 1 if compressed: var nz = nzInflateInit(chunk.data.substr(textBegin)) chunk.text = zlib_decompress(nz) else: chunk.text = chunk.data.substr(textBegin) result = true method parseChunk(chunk: PNGGamma, png: PNG): bool = if chunk.length != 4: raise PNGError("invalid gAMA length") chunk.gamma = chunk.readInt32() result = true method parseChunk(chunk: PNGChroma, png: PNG): bool = if chunk.length != 32: raise PNGError("invalid Chroma length") chunk.whitePointX = chunk.readInt32() chunk.whitePointY = chunk.readInt32() chunk.redX = chunk.readInt32() chunk.redY = chunk.readInt32() chunk.greenX = chunk.readInt32() chunk.greenY = chunk.readInt32() chunk.blueX = chunk.readInt32() chunk.blueY = chunk.readInt32() result = true method parseChunk(chunk: PNGStandarRGB, png: PNG): bool = if chunk.length != 1: raise PNGError("invalid sRGB length") chunk.renderingIntent = chunk.readByte() result = true method validateChunk(chunk: PNGICCProfile, png: PNG): bool = if(chunk.profileName.len < 1) or (chunk.profileName.len > 79): raise PNGError("keyword too short or too long") result = true method parseChunk(chunk: PNGICCProfile, png: PNG): bool = var len = 0 while(len < chunk.length) and (chunk.data[len] != chr(0)): inc len if(len < 1) or (len > 79): raise PNGError("keyword too short or too long") chunk.profileName = chunk.data.substr(0, len) var compMethod = ord(chunk.data[len + 1]) # skip keyword null terminator if compMethod != 0: raise PNGError("unsupported comp method") var nz = nzInflateInit(chunk.data.substr(len + 2)) chunk.profile = zlib_decompress(nz) result = true method parseChunk(chunk: PNGSPalette, png: PNG): bool = var len = 0 while(len < chunk.length) and (chunk.data[len] != chr(0)): inc len if(len < 1) or (len > 79): raise PNGError("keyword too short or too long") chunk.paletteName = chunk.data.substr(0, len) chunk.setPosition(len + 1) chunk.sampleDepth = chunk.readByte() if chunk.sampleDepth notin {8, 16}: raise PNGError("palette sample depth error") let remainingLength = (chunk.length - (len + 2)) if chunk.sampleDepth == 8: if (remainingLength mod 6) != 0: raise PNGError("palette length not divisible by 6") let numSamples = remainingLength div 6 newSeq(chunk.palette, numSamples) for p in mitems(chunk.palette): p.red = chunk.readByte() p.green = chunk.readByte() p.blue = chunk.readByte() p.alpha = chunk.readByte() p.frequency = chunk.readInt16() else: # chunk.sampleDepth == 16: if (remainingLength mod 10) != 0: raise PNGError("palette length not divisible by 10") let numSamples = remainingLength div 10 newSeq(chunk.palette, numSamples) for p in mitems(chunk.palette): p.red = chunk.readInt16() p.green = chunk.readInt16() p.blue = chunk.readInt16() p.alpha = chunk.readInt16() p.frequency = chunk.readInt16() result = true method parseChunk(chunk: PNGHist, png: PNG): bool = if not png.hasChunk(PLTE): raise PNGError("Histogram need PLTE") var plte = PNGPalette(png.getChunk(PLTE)) if plte.palette.len != (chunk.length div 2): raise PNGError("invalid histogram length") newSeq(chunk.histogram, plte.palette.len) for i in 0..chunk.histogram.high: chunk.histogram[i] = chunk.readInt16() result = true method parseChunk(chunk: PNGSbit, png: PNG): bool = let header = PNGHEader(png.getChunk(IHDR)) var expectedLen = 0 case header.colorType of LCT_GREY: expectedLen = 1 of LCT_RGB: expectedLen = 3 of LCT_PALETTE: expectedLen = 3 of LCT_GREY_ALPHA: expectedLen = 2 of LCT_RGBA: expectedLen = 4 if chunk.length != expectedLen: raise PNGError("invalid sBIT length") var expectedDepth = 8 #LCT_PALETTE if header.colorType != LCT_PALETTE: expectedDepth = header.bitDepth for c in chunk.data: if (ord(c) == 0) or (ord(c) > expectedDepth): raise PNGError("invalid sBIT value") result = true proc make[T](): T = new(result) proc createChunk(png: PNG, chunkType: PNGChunkType, data: string, crc: uint32): PNGChunk = var settings = PNGDecoder(png.settings) result = nil if chunkType == IHDR: result = make[PNGHeader]() elif chunkType == PLTE: result = make[PNGPalette]() elif chunkType == IDAT: if not png.hasChunk(IDAT): result = make[PNGData]() else: var idat = PNGData(png.getChunk(IDAT)) idat.data.add data return idat elif chunkType == tRNS: result = make[PNGTrans]() elif chunkType == bKGD: result = make[PNGBackground]() elif chunkType == tIME: result = make[PNGTime]() elif chunkType == pHYs: result = make[PNGPhys]() elif chunkType == tEXt: if settings.readTextChunks: result = make[PNGTExt]() else: if settings.rememberUnknownChunks: new(result) elif chunkType == zTXt: if settings.readTextChunks: result = make[PNGZtxt]() else: if settings.rememberUnknownChunks: new(result) elif chunkType == iTXt: if settings.readTextChunks: result = make[PNGItxt]() else: if settings.rememberUnknownChunks: new(result) elif chunkType == gAMA: result = make[PNGGamma]() elif chunkType == cHRM: result = make[PNGChroma]() elif chunkType == iCCP: result = make[PNGICCProfile]() elif chunkType == sRGB: result = make[PNGStandarRGB]() elif chunkType == sPLT: result = make[PNGSPalette]() elif chunkType == hIST: result = make[PNGHist]() elif chunkType == sBIT: result = make[PNGSbit]() else: if settings.rememberUnknownChunks: new(result) if result != nil: result.initChunk(chunkType, data, crc) proc parsePNG(s: Stream, settings: PNGDecoder): PNG = var png: PNG new(png) png.chunks = @[] if settings == nil: png.settings = makePNGDecoder() else: png.settings = settings let signature = s.readStr(8) if signature != PNGSignature: raise PNGError("signature mismatch") while not s.atEnd(): let length = s.readInt32BE() let chunkType = PNGChunkType(s.readInt32BE()) let data = s.readStr(length) let crc = cast[uint32](s.readInt32BE()) let calculatedCRC = crc32(crc32(0, $chunkType), data) if calculatedCRC != crc and not PNGDecoder(png.settings).ignoreCRC: raise PNGError("wrong crc for: " & $chunkType) var chunk = png.createChunk(chunkType, data, crc) if chunkType != IDAT and chunk != nil: if not chunk.parseChunk(png): raise PNGError("error parse chunk: " & $chunkType) if not chunk.validateChunk(png): raise PNGError("invalid chunk: " & $chunkType) if chunk != nil: png.chunks.add chunk if chunkType == IEND: break if not png.hasChunk(IHDR): raise PNGError("no IHDR found") if not png.hasChunk(IDAT): raise PNGError("no IDAT found") var header = PNGHeader(png.getChunk(IHDR)) if header.colorType == LCT_PALETTE and not png.hasChunk(PLTE): raise PNGError("expected PLTE not found") # IDAT get special treatment because it can appear in multiple chunk var idat = PNGData(png.getChunk(IDAT)) if not idat.parseChunk(png): raise PNGError("IDAT parse error") if not idat.validateChunk(png): raise PNGError("bad IDAT") result = png # Paeth predicter, used by PNG filter type 4 proc paethPredictor(a, b, c: int): int = let pa = abs(b - c) let pb = abs(a - c) let pc = abs(a + b - c - c) if(pc < pa) and (pc < pb): return c elif pb < pa: return b result = a proc readBitFromReversedStream(bitptr: var int, bitstream: cstring): int = result = ((ord(bitstream[bitptr shr 3]) shr (7 - (bitptr and 0x7))) and 1) inc bitptr proc readBitsFromReversedStream(bitptr: var int, bitstream: cstring, nbits: int): int = result = 0 var i = nbits - 1 while i > -1: result += readBitFromReversedStream(bitptr, bitstream) shl i dec i proc `&=`(a: var char, b: char) = a = chr(ord(a) and ord(b)) proc `|=`(a: var char, b: char) = a = chr(ord(a) or ord(b)) proc setBitOfReversedStream0(bitptr: var int, bitstream: var cstring, bit: int) = # the current bit in bitstream must be 0 for this to work if bit != 0: # earlier bit of huffman code is in a lesser significant bit of an earlier byte bitstream[bitptr shr 3] |= cast[char](bit shl (7 - (bitptr and 0x7))) inc bitptr proc setBitOfReversedStream(bitptr: var int, bitstream: var cstring, bit: int) = #the current bit in bitstream may be 0 or 1 for this to work if bit == 0: bitstream[bitptr shr 3] &= cast[char](not (1 shl (7 - (bitptr and 0x7)))) else: bitstream[bitptr shr 3] |= cast[char](1 shl (7 - (bitptr and 0x7))) inc bitptr # index: bitgroup index, bits: bitgroup size(1, 2 or 4), in: bitgroup value, out: octet array to add bits to proc addColorBits(output: var cstring, index, bits, input: int) = var m = 1 if bits == 1: m = 7 elif bits == 2: m = 3 # p = the partial index in the byte, e.g. with 4 palettebits it is 0 for first half or 1 for second half let p = index and m var val = input and ((1 shl bits) - 1) #filter out any other bits of the input value val = val shl (bits * (m - p)) let idx = index * bits div 8 if p == 0: output[idx] = chr(val) else: output[idx] = chr(ord(output[idx]) or val) proc unfilterScanLine(recon: var cstring, scanLine, precon: cstring, byteWidth, len: int, filterType: PNGFilter0) = # For PNG filter method 0 # unfilter a PNG image scanLine by scanLine. when the pixels are smaller than 1 byte, # the filter works byte per byte (byteWidth = 1) # precon is the previous unfiltered scanLine, recon the result, scanLine the current one # the incoming scanLines do NOT include the filtertype byte, that one is given in the parameter filterType instead # recon and scanLine MAY be the same memory address! precon must be disjoint. case filterType of FLT_NONE: for i in 0..len-1: recon[i] = scanLine[i] of FLT_SUB: for i in 0..byteWidth-1: recon[i] = scanLine[i] for i in byteWidth..len-1: recon[i] = chr((ord(scanLine[i]) + ord(recon[i - byteWidth])) mod 256) of FLT_UP: if precon != nil: for i in 0..len-1: recon[i] = chr((ord(scanLine[i]) + ord(precon[i])) mod 256) else: for i in 0..len-1: recon[i] = scanLine[i] of FLT_AVERAGE: if precon != nil: for i in 0..byteWidth-1: recon[i] = chr((ord(scanLine[i]) + ord(precon[i]) div 2) mod 256) for i in byteWidth..len-1: recon[i] = chr((ord(scanLine[i]) + ((ord(recon[i - byteWidth]) + ord(precon[i])) div 2)) mod 256) else: for i in 0..byteWidth-1: recon[i] = scanLine[i] for i in byteWidth..len-1: recon[i] = chr((ord(scanLine[i]) + ord(recon[i - byteWidth]) div 2) mod 256) of FLT_PAETH: if precon != nil: for i in 0..byteWidth-1: recon[i] = chr((ord(scanLine[i]) + ord(precon[i])) mod 256) #paethPredictor(0, precon[i], 0) is always precon[i] for i in byteWidth..len-1: recon[i] = chr((ord(scanLine[i]) + paethPredictor(ord(recon[i - byteWidth]), ord(precon[i]), ord(precon[i - byteWidth]))) mod 256) else: for i in 0..byteWidth-1: recon[i] = scanLine[i] for i in byteWidth..len-1: # paethPredictor(recon[i - byteWidth], 0, 0) is always recon[i - byteWidth] recon[i] = chr((ord(scanLine[i]) + ord(recon[i - byteWidth])) mod 256) proc unfilter(output: var cstring, input: cstring, w, h, bpp: int) = # For PNG filter method 0 # this function unfilters a single image (e.g. without interlacing this is called once, with Adam7 seven times) # output must have enough bytes allocated already, input must have the scanLines + 1 filtertype byte per scanLine # w and h are image dimensions or dimensions of reduced image, bpp is bits per pixel # input and output are allowed to be the same memory address (but aren't the same size since in has the extra filter bytes) var prevLine = cstring(nil) var inp = input # byteWidth is used for filtering, is 1 when bpp < 8, number of bytes per pixel otherwise let byteWidth = (bpp + 7) div 8 let lineBytes = (w * bpp + 7) div 8 for y in 0..h-1: let outIndex = lineBytes * y let inIndex = (1 + lineBytes) * y # the extra filterbyte added to each row let filterType = PNGFilter0(input[inindex]) let scanLine: cstring = addr(inp[inIndex + 1]) var outp: cstring = addr(output[outIndex]) unfilterScanLine(outp, scanLine, prevLine, byteWidth, lineBytes, filterType) prevLine = addr(output[outIndex]) proc removePaddingBits(output: var cstring, input: cstring, olinebits, ilinebits, h: int) = # After filtering there are still padding bits if scanLines have non multiple of 8 bit amounts. They need # to be removed (except at last scanLine of (Adam7-reduced) image) before working with pure image buffers # for the Adam7 code, the color convert code and the output to the user. # in and out are allowed to be the same buffer, in may also be higher but still overlapping; in must # have >= ilinebits*h bits, out must have >= olinebits*h bits, olinebits must be <= ilinebits # also used to move bits after earlier such operations happened, e.g. in a sequence of reduced images from Adam7 # only useful if (ilinebits - olinebits) is a value in the range 1..7 let diff = ilinebits - olinebits var ibp = 0 obp = 0 # input and output bit pointers for y in 0..h-1: for x in 0..olinebits-1: var bit = readBitFromReversedStream(ibp, input) setBitOfReversedStream(obp, output, bit) inc(ibp, diff) # Outputs various dimensions and positions in the image related to the Adam7 reduced images. # passw: output containing the width of the 7 passes # passh: output containing the height of the 7 passes # filter_passstart: output containing the index of the start and end of each # reduced image with filter bytes # padded_passstart output containing the index of the start and end of each # reduced image when without filter bytes but with padded scanLines # passstart: output containing the index of the start and end of each reduced # image without padding between scanLines, but still padding between the images # w, h: width and height of non-interlaced image # bpp: bits per pixel # "padded" is only relevant if bpp is less than 8 and a scanLine or image does not # end at a full byte proc Adam7PassValues(pass: var PNGPass, w, h, bpp: int) = #the passstart values have 8 values: # the 8th one indicates the byte after the end of the 7th (= last) pass # calculate width and height in pixels of each pass for i in 0..6: pass.w[i] = (w + ADAM7_DX[i] - ADAM7_IX[i] - 1) div ADAM7_DX[i] pass.h[i] = (h + ADAM7_DY[i] - ADAM7_IY[i] - 1) div ADAM7_DY[i] if pass.w[i] == 0: pass.h[i] = 0 if pass.h[i] == 0: pass.w[i] = 0 pass.filterStart[0] = 0 pass.paddedStart[0] = 0 pass.start[0] = 0 for i in 0..6: # if passw[i] is 0, it's 0 bytes, not 1 (no filtertype-byte) pass.filterStart[i + 1] = pass.filterStart[i] if (pass.w[i] != 0) and (pass.h[i] != 0): pass.filterStart[i + 1] += pass.h[i] * (1 + (pass.w[i] * bpp + 7) div 8) # bits padded if needed to fill full byte at end of each scanLine pass.paddedStart[i + 1] = pass.paddedStart[i] + pass.h[i] * ((pass.w[i] * bpp + 7) div 8) # only padded at end of reduced image pass.start[i + 1] = pass.start[i] + (pass.h[i] * pass.w[i] * bpp + 7) div 8 # input: Adam7 interlaced image, with no padding bits between scanLines, but between # reduced images so that each reduced image starts at a byte. # output: the same pixels, but re-ordered so that they're now a non-interlaced image with size w*h # bpp: bits per pixel # output has the following size in bits: w * h * bpp. # input is possibly bigger due to padding bits between reduced images. # output must be big enough AND must be 0 everywhere if bpp < 8 in the current implementation # (because that's likely a little bit faster) # NOTE: comments about padding bits are only relevant if bpp < 8 proc Adam7Deinterlace(output: var cstring, input: cstring, w, h, bpp: int) = var pass: PNGPass Adam7PassValues(pass, w, h, bpp) if bpp >= 8: for i in 0..6: var byteWidth = bpp div 8 for y in 0..pass.h[i]-1: for x in 0..pass.w[i]-1: var inStart = pass.start[i] + (y * pass.w[i] + x) * byteWidth var outStart = ((ADAM7_IY[i] + y * ADAM7_DY[i]) * w + ADAM7_IX[i] + x * ADAM7_DX[i]) * byteWidth for b in 0..byteWidth-1: output[outStart + b] = input[inStart + b] else: # bpp < 8: Adam7 with pixels < 8 bit is a bit trickier: with bit pointers for i in 0..6: var ilinebits = bpp * pass.w[i] var olinebits = bpp * w for y in 0..pass.h[i]-1: for x in 0..pass.w[i]-1: var ibp = (8 * pass.start[i]) + (y * ilinebits + x * bpp) var obp = (ADAM7_IY[i] + y * ADAM7_DY[i]) * olinebits + (ADAM7_IX[i] + x * ADAM7_DX[i]) * bpp for b in 0..bpp-1: var bit = readBitFromReversedStream(ibp, input) # note that this function assumes the out buffer is completely 0, use setBitOfReversedStream otherwise setBitOfReversedStream0(obp, output, bit) proc postProcessscanLines(png: PNG) = # This function converts the filtered-padded-interlaced data # into pure 2D image buffer with the PNG's colorType. # Steps: # *) if no Adam7: 1) unfilter 2) remove padding bits (= posible extra bits per scanLine if bpp < 8) # *) if adam7: 1) 7x unfilter 2) 7x remove padding bits 3) Adam7_deinterlace # NOTE: the input buffer will be overwritten with intermediate data! var header = PNGHeader(png.getChunk(IHDR)) let bpp = header.getBPP() let w = header.width let h = header.height let bitsPerLine = w * bpp let bitsPerPaddedLine = ((w * bpp + 7) div 8) * 8 var idat = PNGData(png.getChunk(IDAT)) png.pixels = newString(idatRawSize(header.width, header.height, header)) var input = cstring(idat.idat) var output = cstring(png.pixels) zeroMem(output, png.pixels.len) if header.interlaceMethod == IM_NONE: if(bpp < 8) and (bitsPerLine != bitsPerPaddedLine): unfilter(input, input, w, h, bpp) removePaddingBits(output, input, bitsPerLine, bitsPerPaddedLine, h) # we can immediatly filter into the out buffer, no other steps needed else: unfilter(output, input, w, h, bpp) else: # interlace_method is 1 (Adam7) var pass: PNGPass Adam7PassValues(pass, w, h, bpp) for i in 0..6: var outp: cstring = addr(input[pass.paddedStart[i]]) var inp: cstring = addr(input[pass.filterStart[i]]) unfilter(outp, inp, pass.w[i], pass.h[i], bpp) # TODO: possible efficiency improvement: # if in this reduced image the bits fit nicely in 1 scanLine, # move bytes instead of bits or move not at all if bpp < 8: # remove padding bits in scanLines; after this there still may be padding # bits between the different reduced images: each reduced image still starts nicely at a byte outp = addr(input[pass.start[i]]) inp = addr(input[pass.paddedStart[i]]) removePaddingBits(outp, inp, pass.w[i] * bpp, ((pass.w[i] * bpp + 7) div 8) * 8, pass.h[i]) Adam7Deinterlace(output, input, w, h, bpp) proc getColorMode(png: PNG): PNGColorMode = var header = PNGHeader(png.getChunk(IHDR)) var cm = newColorMode(header.colorType, header.bitDepth) var plte = PNGPalette(png.getChunk(PLTE)) if plte != nil: cm.paletteSize = plte.palette.len newSeq(cm.palette, cm.paletteSize) for i in 0..cm.paletteSize-1: cm.palette[i] = plte.palette[i] var trans = PNGTrans(png.getChunk(tRNS)) if trans != nil: if cm.colorType in {LCT_GREY, LCT_RGB}: cm.keyDefined = true cm.keyR = trans.keyR cm.keyG = trans.keyG cm.keyB = trans.keyB result = cm proc getInfo*(png: PNG): PNGInfo = new(result) result.mode = png.getColorMode() var header = PNGHeader(png.getChunk(IHDR)) result.width = header.width result.height = header.height var bkgd = PNGBackground(png.getChunk(bKGD)) if bkgd == nil: result.backgroundDefined = false else: result.backgroundDefined = true result.backgroundR = bkgd.bkgdR result.backgroundG = bkgd.bkgdG result.backgroundB = bkgd.bkgdB var phys = PNGPhys(png.getChunk(pHYs)) if phys == nil: result.physDefined = false else: result.physDefined = true result.physX = phys.physX result.physY = phys.physY result.physUnit = phys.unit var time = PNGTime(png.getChunk(tIME)) if time == nil: result.timeDefined = false else: result.timeDefined = true result.year = time.year result.month = time.month result.day = time.day result.hour = time.hour result.minute = time.minute result.second = time.second proc getChunkNames*(png: PNG): string = result = "" var i = 0 for c in png.chunks: result.add ($c.chunkType) if i < png.chunks.high: result.add ' ' inc i proc RGBFromGrey8(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 3 output[x] = input[i] output[x+1] = input[i] output[x+2] = input[i] proc RGBFromGrey16(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 3 let y = i * 2 output[x] = input[y] output[x+1] = input[y] output[x+2] = input[y] proc RGBFromGrey124(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = var highest = ((1 shl mode.bitDepth) - 1) #highest possible value for this bit depth var obp = 0 for i in 0..numPixels-1: let val = chr((readBitsFromReversedStream(obp, input, mode.bitDepth) * 255) div highest) let x = i * 3 output[x] = val output[x+1] = val output[x+2] = val proc RGBFromRGB8(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 3 output[x] = input[x] output[x+1] = input[x+1] output[x+2] = input[x+2] proc RGBFromRGB16(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 3 let y = i * 6 output[x] = input[y] output[x+1] = input[y+2] output[x+2] = input[y+4] proc RGBFromPalette8(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 3 let index = ord(input[i]) if index >= mode.paletteSize: # This is an error according to the PNG spec, but most PNG decoders make it black instead. # Done here too, slightly faster due to no error handling needed. output[x] = chr(0) output[x+1] = chr(0) output[x+2] = chr(0) else: output[x] = mode.palette[index].r output[x+1] = mode.palette[index].g output[x+2] = mode.palette[index].b proc RGBFromPalette124(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = var obp = 0 for i in 0..numPixels-1: let x = i * 3 let index = readBitsFromReversedStream(obp, input, mode.bitDepth) if index >= mode.paletteSize: # This is an error according to the PNG spec, but most PNG decoders make it black instead. # Done here too, slightly faster due to no error handling needed. output[x] = chr(0) output[x+1] = chr(0) output[x+2] = chr(0) else: output[x] = mode.palette[index].r output[x+1] = mode.palette[index].g output[x+2] = mode.palette[index].b proc RGBFromGreyAlpha8(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 3 let val = input[i * 2] output[x] = val output[x+1] = val output[x+2] = val proc RGBFromGreyAlpha16(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 3 let val = input[i * 4] output[x] = val output[x+1] = val output[x+2] = val proc RGBFromRGBA8(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 3 let y = i * 4 output[x] = input[y] output[x+1] = input[y+1] output[x+2] = input[y+2] proc RGBFromRGBA16(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 3 let y = i * 8 output[x] = input[y] output[x+1] = input[y+2] output[x+2] = input[y+4] proc RGBAFromGrey8(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 4 output[x] = input[i] output[x+1] = input[i] output[x+2] = input[i] if mode.keyDefined and (ord(input[i]) == mode.keyR): output[x+3] = chr(0) else: output[x+3] = chr(255) proc RGBAFromGrey16(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 4 let y = i * 2 output[x] = input[y] output[x+1] = input[y] output[x+2] = input[y] let keyR = 256 * ord(input[y + 0]) + ord(input[y + 1]) if mode.keyDefined and (keyR == mode.keyR): output[x+3] = chr(0) else: output[x+3] = chr(255) proc RGBAFromGrey124(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = var highest = ((1 shl mode.bitDepth) - 1) #highest possible value for this bit depth var obp = 0 for i in 0..numPixels-1: let val = readBitsFromReversedStream(obp, input, mode.bitDepth) let value = chr((val * 255) div highest) let x = i * 4 output[x] = value output[x+1] = value output[x+2] = value if mode.keyDefined and (ord(val) == mode.keyR): output[x+3] = chr(0) else: output[x+3] = chr(255) proc RGBAFromRGB8(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 4 let y = i * 3 output[x] = input[y] output[x+1] = input[y+1] output[x+2] = input[y+2] if mode.keyDefined and (mode.keyR == ord(input[y])) and (mode.keyG == ord(input[y+1])) and (mode.keyB == ord(input[y+2])): output[x+3] = chr(0) else: output[x+3] = chr(255) proc RGBAFromRGB16(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 4 let y = i * 6 output[x] = input[y] output[x+1] = input[y+2] output[x+2] = input[y+4] let keyR = 256 * ord(input[y]) + ord(input[y+1]) let keyG = 256 * ord(input[y+2]) + ord(input[y+3]) let keyB = 256 * ord(input[y+4]) + ord(input[y+5]) if mode.keyDefined and (mode.keyR == keyR) and (mode.keyG == keyG) and (mode.keyB == keyB): output[x+3] = chr(0) else: output[x+3] = chr(255) proc RGBAFromPalette8(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 4 let index = ord(input[i]) if index >= mode.paletteSize: # This is an error according to the PNG spec, but most PNG decoders make it black instead. # Done here too, slightly faster due to no error handling needed. output[x] = chr(0) output[x+1] = chr(0) output[x+2] = chr(0) output[x+3] = chr(0) else: output[x] = mode.palette[index].r output[x+1] = mode.palette[index].g output[x+2] = mode.palette[index].b output[x+3] = mode.palette[index].a proc RGBAFromPalette124(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = var obp = 0 for i in 0..numPixels-1: let x = i * 4 let index = readBitsFromReversedStream(obp, input, mode.bitDepth) if index >= mode.paletteSize: # This is an error according to the PNG spec, but most PNG decoders make it black instead. # Done here too, slightly faster due to no error handling needed. output[x] = chr(0) output[x+1] = chr(0) output[x+2] = chr(0) output[x+3] = chr(0) else: output[x] = mode.palette[index].r output[x+1] = mode.palette[index].g output[x+2] = mode.palette[index].b output[x+3] = mode.palette[index].a proc RGBAFromGreyAlpha8(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 4 let val = input[i * 2] output[x] = val output[x+1] = val output[x+2] = val output[x+3] = input[i * 2 + 1] proc RGBAFromGreyAlpha16(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 4 let val = input[i * 4] output[x] = val output[x+1] = val output[x+2] = val output[x+3] = input[i * 4 + 2] proc RGBAFromRGBA8(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 4 let y = i * 4 output[x] = input[y] output[x+1] = input[y+1] output[x+2] = input[y+2] output[x+3] = input[y+3] proc RGBAFromRGBA16(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) = for i in 0..numPixels-1: let x = i * 4 let y = i * 8 output[x] = input[y] output[x+1] = input[y+2] output[x+2] = input[y+4] output[x+3] = input[y+6] type convertRGBA = proc(output: var cstring, input: cstring, numPixels: int, mode: PNGColorMode) convertRGBA8 = proc(p: var RGBA8, input: cstring, px: int, mode: PNGColorMode) convertRGBA16 = proc(p: var RGBA16, input: cstring, px: int, mode: PNGColorMode) pixelRGBA8 = proc(p: RGBA8, output: var cstring, px: int, mode: PNGColorMode, ct: ColorTree8) pixelRGBA16 = proc(p: RGBA16, output: var cstring, px: int, mode: PNGColorMode) proc hash*(c: RGBA8): THash = var h: THash = 0 h = h !& ord(c.r) h = h !& ord(c.g) h = h !& ord(c.b) h = h !& ord(c.a) proc RGBA8FromGrey8(p: var RGBA8, input: cstring, px: int, mode: PNGColorMode) = p.r = input[px] p.g = input[px] p.b = input[px] if mode.keyDefined and (ord(p.r) == mode.keyR): p.a = chr(0) else: p.a = chr(255) proc RGBA8FromGrey16(p: var RGBA8, input: cstring, px: int, mode: PNGColorMode) = let i = px * 2 let keyR = 256 * ord(input[i]) + ord(input[i + 1]) p.r = input[i] p.g = input[i] p.b = input[i] if mode.keyDefined and (keyR == mode.keyR): p.a = chr(0) else: p.a = chr(255) proc RGBA8FromGrey124(p: var RGBA8, input: cstring, px: int, mode: PNGColorMode) = let highest = ((1 shl mode.bitDepth) - 1) #highest possible value for this bit depth var obp = px * mode.bitDepth let val = readBitsFromReversedStream(obp, input, mode.bitDepth) let value = chr((val * 255) div highest) p.r = value p.g = value p.b = value if mode.keyDefined and (ord(val) == mode.keyR): p.a = chr(0) else: p.a = chr(255) proc RGBA8FromRGB8(p: var RGBA8, input: cstring, px: int, mode: PNGColorMode) = let y = px * 3 p.r = input[y] p.g = input[y+1] p.b = input[y+2] if mode.keyDefined and (mode.keyR == ord(input[y])) and (mode.keyG == ord(input[y+1])) and (mode.keyB == ord(input[y+2])): p.a = chr(0) else: p.a = chr(255) proc RGBA8FromRGB16(p: var RGBA8, input: cstring, px: int, mode: PNGColorMode) = let y = px * 6 p.r = input[y] p.g = input[y+2] p.b = input[y+4] let keyR = 256 * ord(input[y]) + ord(input[y+1]) let keyG = 256 * ord(input[y+2]) + ord(input[y+3]) let keyB = 256 * ord(input[y+4]) + ord(input[y+5]) if mode.keyDefined and (mode.keyR == keyR) and (mode.keyG == keyG) and (mode.keyB == keyB): p.a = chr(0) else: p.a = chr(255) proc RGBA8FromPalette8(p: var RGBA8, input: cstring, px: int, mode: PNGColorMode) = let index = ord(input[px]) if index >= mode.paletteSize: # This is an error according to the PNG spec, # but common PNG decoders make it black instead. # Done here too, slightly faster due to no error handling needed. p.r = chr(0) p.g = chr(0) p.b = chr(0) p.a = chr(255) else: p.r = mode.palette[index].r p.g = mode.palette[index].g p.b = mode.palette[index].b p.a = mode.palette[index].a proc RGBA8FromPalette124(p: var RGBA8, input: cstring, px: int, mode: PNGColorMode) = var obp = px * mode.bitDepth let index = readBitsFromReversedStream(obp, input, mode.bitDepth) if index >= mode.paletteSize: # This is an error according to the PNG spec, # but common PNG decoders make it black instead. # Done here too, slightly faster due to no error handling needed. p.r = chr(0) p.g = chr(0) p.b = chr(0) p.a = chr(255) else: p.r = mode.palette[index].r p.g = mode.palette[index].g p.b = mode.palette[index].b p.a = mode.palette[index].a proc RGBA8FromGreyAlpha8(p: var RGBA8, input: cstring, px: int, mode: PNGColorMode) = let i = px * 2 let val = input[i] p.r = val p.g = val p.b = val p.a = input[i+1] proc RGBA8FromGreyAlpha16(p: var RGBA8, input: cstring, px: int, mode: PNGColorMode) = let i = px * 4 let val = input[i] p.r = val p.g = val p.b = val p.a = input[i+2] proc RGBA8FromRGBA8(p: var RGBA8, input: cstring, px: int, mode: PNGColorMode) = let i = px * 4 p.r = input[i] p.g = input[i+1] p.b = input[i+2] p.a = input[i+3] proc RGBA8FromRGBA16(p: var RGBA8, input: cstring, px: int, mode: PNGColorMode) = let i = px * 8 p.r = input[i] p.g = input[i+2] p.b = input[i+4] p.a = input[i+6] proc RGBA16FromGrey(p: var RGBA16, input: cstring, px: int, mode: PNGColorMode) = let i = px * 2 let val = 256 * ord(input[i]) + ord(input[i + 1]) p.r = val p.g = val p.b = val if mode.keyDefined and (val == mode.keyR): p.a = 0 else: p.a = 65535 proc RGBA16FromRGB(p: var RGBA16, input: cstring, px: int, mode: PNGColorMode) = let i = px * 6 p.r = 256 * ord(input[i]) + ord(input[i+1]) p.g = 256 * ord(input[i+2]) + ord(input[i+3]) p.b = 256 * ord(input[i+4]) + ord(input[i+5]) if mode.keyDefined and (int(p.r) == mode.keyR) and (int(p.g) == mode.keyG) and (int(p.b) == mode.keyB): p.a = 0 else: p.a = 65535 proc RGBA16FromGreyAlpha(p: var RGBA16, input: cstring, px: int, mode: PNGColorMode) = let i = px * 4 let val = 256 * ord(input[i]) + ord(input[i + 1]) p.r = val p.g = val p.b = val p.a = 256 * ord(input[i + 2]) + ord(input[i + 3]) proc RGBA16FromRGBA(p: var RGBA16, input: cstring, px: int, mode: PNGColorMode) = let i = px * 8 p.r = 256 * ord(input[i]) + ord(input[i+1]) p.g = 256 * ord(input[i+2]) + ord(input[i+3]) p.b = 256 * ord(input[i+4]) + ord(input[i+5]) p.a = 256 * ord(input[i+6]) + ord(input[i+7]) proc RGBA8ToGrey8(p: RGBA8, output: var cstring, px: int, mode: PNGColorMode, ct: ColorTree8) = output[px] = p.r proc RGBA8ToGrey16(p: RGBA8, output: var cstring, px: int, mode: PNGColorMode, ct: ColorTree8) = let i = px * 2 output[i] = p.r output[i+1] = p.r proc RGBA8ToGrey124(p: RGBA8, output: var cstring, px: int, mode: PNGColorMode, ct: ColorTree8) = # take the most significant bits of grey let grey = (ord(p.r) shr (8 - mode.bitDepth)) and ((1 shl mode.bitDepth) - 1) addColorBits(output, px, mode.bitDepth, grey) proc RGBA8ToRGB8(p: RGBA8, output: var cstring, px: int, mode: PNGColorMode, ct: ColorTree8) = let i = px * 3 output[i] = p.r output[i+1] = p.g output[i+2] = p.b proc RGBA8ToRGB16(p: RGBA8, output: var cstring, px: int, mode: PNGColorMode, ct: ColorTree8) = let i = px * 6 output[i] = p.r output[i+2] = p.g output[i+4] = p.b output[i+1] = p.r output[i+3] = p.g output[i+5] = p.b proc RGBA8ToPalette8(p: RGBA8, output: var cstring, px: int, mode: PNGColorMode, ct: ColorTree8) = output[px] = chr(ct[p]) proc RGBA8ToPalette124(p: RGBA8, output: var cstring, px: int, mode: PNGColorMode, ct: ColorTree8) = addColorBits(output, px, mode.bitDepth, ct[p]) proc RGBA8ToGreyAlpha8(p: RGBA8, output: var cstring, px: int, mode: PNGColorMode, ct: ColorTree8) = let i = px * 2 output[i] = p.r output[i+1] = p.a proc RGBA8ToGreyAlpha16(p: RGBA8, output: var cstring, px: int, mode: PNGColorMode, ct: ColorTree8) = let i = px * 4 output[i] = p.r output[i+1] = p.r output[i+2] = p.a output[i+3] = p.a proc RGBA8ToRGBA8(p: RGBA8, output: var cstring, px: int, mode: PNGColorMode, ct: ColorTree8) = let i = px * 4 output[i] = p.r output[i+1] = p.g output[i+2] = p.b output[i+3] = p.a proc RGBA8ToRGBA16(p: RGBA8, output: var cstring, px: int, mode: PNGColorMode, ct: ColorTree8) = let i = px * 8 output[i] = p.r output[i+2] = p.g output[i+4] = p.b output[i+6] = p.a output[i+1] = p.r output[i+3] = p.g output[i+5] = p.b output[i+7] = p.a proc RGBA16ToGrey(p: RGBA16, output: var cstring, px: int, mode: PNGColorMode) = let i = px * 2 output[i] = chr((ord(p.r) shr 8) and 255) output[i+1] = chr(ord(p.r) and 255) proc RGBA16ToRGB(p: RGBA16, output: var cstring, px: int, mode: PNGColorMode) = let i = px * 6 output[i] = chr((ord(p.r) shr 8) and 255) output[i+1] = chr(ord(p.r) and 255) output[i+2] = chr((ord(p.g) shr 8) and 255) output[i+3] = chr(ord(p.g) and 255) output[i+4] = chr((ord(p.b) shr 8) and 255) output[i+5] = chr(ord(p.b) and 255) proc RGBA16ToGreyAlpha(p: RGBA16, output: var cstring, px: int, mode: PNGColorMode) = let i = px * 4 output[i] = chr((ord(p.r) shr 8) and 255) output[i+1] = chr(ord(p.r) and 255) output[i+2] = chr((ord(p.a) shr 8) and 255) output[i+3] = chr(ord(p.a) and 255) proc RGBA16ToRGBA(p: RGBA16, output: var cstring, px: int, mode: PNGColorMode) = let i = px * 8 output[i] = chr((ord(p.r) shr 8) and 255) output[i+1] = chr(ord(p.r) and 255) output[i+2] = chr((ord(p.g) shr 8) and 255) output[i+3] = chr(ord(p.g) and 255) output[i+4] = chr((ord(p.b) shr 8) and 255) output[i+5] = chr(ord(p.b) and 255) output[i+6] = chr((ord(p.a) shr 8) and 255) output[i+7] = chr(ord(p.a) and 255) proc getColorRGBA16(mode: PNGColorMode): convertRGBA16 = if mode.colorType == LCT_GREY: return RGBA16FromGrey elif mode.colorType == LCT_RGB: return RGBA16FromRGB elif mode.colorType == LCT_GREY_ALPHA: return RGBA16FromGreyAlpha elif mode.colorType == LCT_RGBA: return RGBA16FromRGBA else: raise PNGError("unsupported converter16") proc getPixelRGBA16(mode: PNGColorMode): pixelRGBA16 = if mode.colorType == LCT_GREY: return RGBA16ToGrey elif mode.colorType == LCT_RGB: return RGBA16ToRGB elif mode.colorType == LCT_GREY_ALPHA: return RGBA16ToGreyAlpha elif mode.colorType == LCT_RGBA: return RGBA16ToRGBA else: raise PNGError("unsupported pixel16 converter") proc getColorRGBA8(mode: PNGColorMode): convertRGBA8 = if mode.colorType == LCT_GREY: if mode.bitDepth == 8: return RGBA8FromGrey8 elif mode.bitDepth == 16: return RGBA8FromGrey16 else: return RGBA8FromGrey124 elif mode.colorType == LCT_RGB: if mode.bitDepth == 8: return RGBA8FromRGB8 else: return RGBA8FromRGB16 elif mode.colorType == LCT_PALETTE: if mode.bitDepth == 8: return RGBA8FromPalette8 else: return RGBA8FromPalette124 elif mode.colorType == LCT_GREY_ALPHA: if mode.bitDepth == 8: return RGBA8FromGreyAlpha8 else: return RGBA8FromGreyAlpha16 elif mode.colorType == LCT_RGBA: if mode.bitDepth == 8: return RGBA8FromRGBA8 else: return RGBA8FromRGBA16 else: raise PNGError("unsupported converter8") proc getPixelRGBA8(mode: PNGColorMode): pixelRGBA8 = if mode.colorType == LCT_GREY: if mode.bitDepth == 8: return RGBA8ToGrey8 elif mode.bitDepth == 16: return RGBA8ToGrey16 else: return RGBA8ToGrey124 elif mode.colorType == LCT_RGB: if mode.bitDepth == 8: return RGBA8ToRGB8 else: return RGBA8ToRGB16 elif mode.colorType == LCT_PALETTE: if mode.bitDepth == 8: return RGBA8ToPalette8 else: return RGBA8ToPalette124 elif mode.colorType == LCT_GREY_ALPHA: if mode.bitDepth == 8: return RGBA8ToGreyAlpha8 else: return RGBA8ToGreyAlpha16 elif mode.colorType == LCT_RGBA: if mode.bitDepth == 8: return RGBA8ToRGBA8 else: return RGBA8ToRGBA16 else: raise PNGError("unsupported pixel8 converter") proc getConverterRGB(mode: PNGColorMode): convertRGBA = if mode.colorType == LCT_GREY: if mode.bitDepth == 8: return RGBFromGrey8 elif mode.bitDepth == 16: return RGBFromGrey16 else: return RGBFromGrey124 elif mode.colorType == LCT_RGB: if mode.bitDepth == 8: return RGBFromRGB8 else: return RGBFromRGB16 elif mode.colorType == LCT_PALETTE: if mode.bitDepth == 8: return RGBFromPalette8 else: return RGBFromPalette124 elif mode.colorType == LCT_GREY_ALPHA: if mode.bitDepth == 8: return RGBFromGreyAlpha8 else: return RGBFromGreyAlpha16 elif mode.colorType == LCT_RGBA: if mode.bitDepth == 8: return RGBFromRGBA8 else: return RGBFromRGBA16 else: raise PNGError("unsupported RGB converter") proc getConverterRGBA(mode: PNGColorMode): convertRGBA = if mode.colorType == LCT_GREY: if mode.bitDepth == 8: return RGBAFromGrey8 elif mode.bitDepth == 16: return RGBAFromGrey16 else: return RGBAFromGrey124 elif mode.colorType == LCT_RGB: if mode.bitDepth == 8: return RGBAFromRGB8 else: return RGBAFromRGB16 elif mode.colorType == LCT_PALETTE: if mode.bitDepth == 8: return RGBAFromPalette8 else: return RGBAFromPalette124 elif mode.colorType == LCT_GREY_ALPHA: if mode.bitDepth == 8: return RGBAFromGreyAlpha8 else: return RGBAFromGreyAlpha16 elif mode.colorType == LCT_RGBA: if mode.bitDepth == 8: return RGBAFromRGBA8 else: return RGBAFromRGBA16 else: raise PNGError("unsupported RGBA converter") proc convert*(output: var cstring, input: cstring, modeOut, modeIn: PNGColorMode, numPixels: int) = var tree: ColorTree8 if modeOut.colorType == LCT_PALETTE: let palSize = min(1 shl modeOut.bitDepth, modeOut.paletteSize) tree = initTable[RGBA8, int]() for i in 0..palSize-1: tree[modeOut.palette[i]] = i if(modeIn.bitDepth == 16) and (modeOut.bitDepth == 16): let cvt = getColorRGBA16(modeIn) let pxl = getPixelRGBA16(modeOut) for px in 0..numPixels-1: var p = RGBA16(r:0, g:0, b:0, a:0) cvt(p, input, px, modeIn) pxl(p, output, px, modeOut) elif(modeOut.bitDepth == 8) and (modeOut.colorType == LCT_RGBA): let cvt = getConverterRGBA(modeIn) cvt(output, input, numPixels, modeIn) elif(modeOut.bitDepth == 8) and (modeOut.colorType == LCT_RGB): let cvt = getConverterRGB(modeIn) cvt(output, input, numPixels, modeIn) else: let cvt = getColorRGBA8(modeIn) let pxl = getPixelRGBA8(modeOut) for px in 0..numPixels-1: var p = RGBA8(r:chr(0), g:chr(0), b:chr(0), a:chr(0)) cvt(p, input, px, modeIn) pxl(p, output, px, modeOut, tree) proc convert*(png: PNG, colorType: PNGcolorType, bitDepth: int): PNGResult = #TODO: check if this works according to the statement in the documentation: "The converter can convert # from greyscale input color type, to 8-bit greyscale or greyscale with alpha" #if(colorType notin {LCT_RGB, LCT_RGBA}) and (bitDepth != 8): #raise PNGError("unsupported color mode conversion") let header = PNGHeader(png.getChunk(IHDR)) let modeIn = png.getColorMode() let modeOut = newColorMode(colorType, bitDepth) let size = getRawSize(header.width, header.height, modeOut) let numPixels = header.width * header.height let input = cstring(png.pixels) new(result) result.width = header.width result.height = header.height result.data = newString(size) var output = cstring(result.data) if modeOut == modeIn: copyMem(output, input, size) return result convert(output, input, modeOut, modeIn, numPixels) proc decodePNG*(s: Stream, colorType: PNGcolorType, bitDepth: int, settings = PNGDecoder(nil)): PNGResult = if not bitDepthAllowed(colorType, bitDepth): raise PNGError("colorType and bitDepth combination not allowed") var png = s.parsePNG(settings) png.postProcessscanLines() if PNGDecoder(png.settings).colorConvert: result = png.convert(colorType, bitDepth) else: let header = PNGHeader(png.getChunk(IHDR)) new(result) result.width = header.width result.height = header.height result.data = png.pixels proc decodePNG*(s: Stream, settings = PNGDecoder(nil)): PNG = var png = s.parsePNG(settings) png.postProcessscanLines() result = png proc loadPNG*(fileName: string, colorType: PNGcolorType, bitDepth: int, settings: PNGDecoder): PNGResult = try: var s = newFileStream(fileName, fmRead) if s == nil: return nil result = s.decodePNG(colorType, bitDepth, settings) s.close() except: debugEcho getCurrentExceptionMsg() result = nil proc loadPNG32*(fileName: string, settings = PNGDecoder(nil)): PNGResult = result = loadPNG(fileName, LCT_RGBA, 8, settings) proc loadPNG24*(fileName: string, settings = PNGDecoder(nil)): PNGResult = result = loadPNG(fileName, LCT_RGB, 8, settings) proc decodePNG32*(input: string, settings = PNGDecoder(nil)): PNGResult = try: var s = newStringStream(input) if s == nil: return nil result = s.decodePNG(LCT_RGBA, 8, settings) except: debugEcho getCurrentExceptionMsg() result = nil proc decodePNG24*(input: string, settings = PNGDecoder(nil)): PNGResult = try: var s = newStringStream(input) if s == nil: return nil result = s.decodePNG(LCT_RGB, 8, settings) except: debugEcho getCurrentExceptionMsg() result = nil #Encoder/Decoder demarcation line----------------------------- type PNGFilterStrategy* = enum #every filter at zero LFS_ZERO, #Use filter that gives minimum sum, as described in the official PNG filter heuristic. LFS_MINSUM, #Use the filter type that gives smallest Shannon entropy for this scanLine. Depending #on the image, this is better or worse than minsum. LFS_ENTROPY, #Brute-force-search PNG filters by compressing each filter for each scanLine. #Experimental, very slow, and only rarely gives better compression than MINSUM. LFS_BRUTE_FORCE, #use predefined_filters buffer: you specify the filter type for each scanLine LFS_PREDEFINED PNGKeyText = object keyword, text: string PNGIText = object keyword: string text: string languageTag: string translatedKeyword: string PNGUnknown = ref object of PNGChunk PNGEnd = ref object of PNGChunk PNGEncoder* = ref object of PNGSettings #automatically choose output PNG color type. Default: true autoConvert*: bool modeIn*: PNGColorMode modeOut*: PNGColorMode #If true, follows the official PNG heuristic: if the PNG uses a palette or lower than #8 bit depth, set all filters to zero. Otherwise use the filter_strategy. Note that to #completely follow the official PNG heuristic, filter_palette_zero must be true and #filter_strategy must be LFS_MINSUM filterPaletteZero*: bool #Which filter strategy to use when not using zeroes due to filter_palette_zero. #Set filter_palette_zero to 0 to ensure always using your chosen strategy. Default: LFS_MINSUM filterStrategy*: PNGFilterStrategy #used if filter_strategy is LFS_PREDEFINED. In that case, this must point to a buffer with #the same length as the amount of scanLines in the image, and each value must <= 5. #Don't forget that filter_palette_zero must be set to false to ensure this is also used on palette or low bitdepth images. predefinedFilters*: string #force creating a PLTE chunk if colorType is 2 or 6 (= a suggested palette). #If colorType is 3, PLTE is _always_ created. forcePalette*: bool #add nimPNG identifier and version as a text chunk, for debugging addID*: bool #encode text chunks as zTXt chunks instead of tEXt chunks, and use compression in iTXt chunks textCompression*: bool textList*: seq[PNGKeyText] itextList*: seq[PNGIText] interlaceMethod*: PNGInterlace backgroundDefined*: bool backgroundR*, backgroundG*, backgroundB*: int physDefined*: bool physX*, physY*, physUnit*: int timeDefined*: bool year*: range[0..65535] month*: range[1..12] day*: range[1..31] hour*: range[0..23] minute*: range[0..59] second*: range[0..60] #to allow for leap seconds unknown*: seq[PNGUnknown] PNGColorProfile = ref object colored: bool #not greyscale key: bool #if true, image is not opaque. Only if true and alpha is false, color key is possible. keyR, keyG, keyB: int #these values are always in 16-bit bitdepth in the profile alpha: bool #alpha channel or alpha palette required numColors: int #amount of colors, up to 257. Not valid if bits == 16. palette: seq[RGBA8] #Remembers up to the first 256 RGBA colors, in no particular order bits: int #bits per channel (not for palette). 1,2 or 4 for greyscale only. 16 if 16-bit per channel required. proc makePNGEncoder*(): PNGEncoder = var s: PNGEncoder new(s) s.filterPaletteZero = true s.filterStrategy = LFS_MINSUM s.autoConvert = true s.modeIn = newColorMode() s.modeOut = newColorMode() s.forcePalette = false s.predefinedFilters = nil s.addID = false s.textCompression = true s.interlaceMethod = IM_NONE s.backgroundDefined = false s.backgroundR = 0 s.backgroundG = 0 s.backgroundB = 0 s.physDefined = false s.physX = 0 s.physY = 0 s.physUnit = 0 s.timeDefined = false s.textList = @[] s.itextList = @[] s.unknown = @[] result = s proc addText*(state: PNGEncoder, keyword, text: string) = state.textList.add PNGKeyText(keyword: keyword, text: text) proc addIText*(state: PNGEncoder, keyword, langtag, transkey, text: string) = var itext: PNGIText itext.keyword = keyword itext.text = text itext.languageTag = langtag itext.translatedKeyword = transkey state.itextList.add itext proc make[T](chunkType: PNGChunkType, estimateSize: int): T = new(result) result.chunkType = chunkType if estimateSize > 0: result.data = newStringOfCap(estimateSize) else: result.data = "" proc addUnknownChunk*(state: PNGEncoder, chunkType, data: string) = assert chunkType.len == 4 var chunk = make[PNGUnknown](makeChunkType(chunkType), 0) chunk.data = data state.unknown.add chunk proc makeColorProfile(): PNGColorProfile = new(result) result.colored = false result.key = false result.alpha = false result.keyR = 0 result.keyG = 0 result.keyB = 0 result.numcolors = 0 result.bits = 1 result.palette = @[] proc writeByte(s: PNGChunk, val: int) = s.data.add chr(val) proc writeString(s: PNGChunk, val: string) = s.data.add val proc writeInt32(s: PNGChunk, val: int) = s.writeByte((val shr 24) and 0xff) s.writeByte((val shr 16) and 0xff) s.writeByte((val shr 8) and 0xff) s.writeByte(val and 0xff) proc writeInt16(s: PNGChunk, val: int) = s.writeByte((val shr 8) and 0xff) s.writeByte(val and 0xff) proc writeInt32BE(s: Stream, value: int) = var val = cast[int32](value) var tmp: int32 bigEndian32(addr(tmp), addr(val)) s.write(tmp) method writeChunk(chunk: PNGChunk, png: PNG): bool = true method writeChunk(chunk: PNGHeader, png: PNG): bool = #estimate 13 bytes chunk.writeInt32(chunk.width) chunk.writeInt32(chunk.height) chunk.writeByte(chunk.bitDepth) chunk.writeByte(int(chunk.colorType)) chunk.writeByte(chunk.compressionMethod) chunk.writeByte(chunk.filterMethod) chunk.writeByte(int(chunk.interlaceMethod)) result = true method writeChunk(chunk: PNGPalette, png: PNG): bool = #estimate 3 * palette.len for px in chunk.palette: chunk.writeByte(int(px.r)) chunk.writeByte(int(px.g)) chunk.writeByte(int(px.b)) result = true method writeChunk(chunk: PNGData, png: PNG): bool = var nz = nzDeflateInit(chunk.idat) chunk.data = zlib_compress(nz) result = true method writeChunk(chunk: PNGTrans, png: PNG): bool = var header = PNGHeader(png.getChunk(IHDR)) if header.colorType == LCT_PALETTE: #estimate plte.palette.len var plte = PNGPalette(png.getChunk(PLTE)) #the tail of palette values that all have 255 as alpha, does not have to be encoded var amount = plte.palette.len for i in countdown(amount-1, 0): if plte.palette[i].a == chr(255): dec amount else: break for i in 0..amount-1: chunk.writeByte(int(plte.palette[i].a)) elif header.colorType == LCT_GREY: #estimate 2 bytes if chunk.keyR != -1: chunk.writeInt16(chunk.keyR) elif header.colorType == LCT_RGB: #estimate 6 bytes if chunk.keyR != -1: chunk.writeInt16(chunk.keyR) chunk.writeInt16(chunk.keyG) chunk.writeInt16(chunk.keyB) else: raise PNGError("tRNS chunk not allowed for other color models") result = true method writeChunk(chunk: PNGBackground, png: PNG): bool = var header = PNGHeader(png.getChunk(IHDR)) if header.colorType == LCT_PALETTE: #estimate 1 bytes chunk.writeByte(chunk.bkgdR) if header.colorType in {LCT_GREY, LCT_GREY_ALPHA}: #estimate 2 bytes chunk.writeInt16(chunk.bkgdR) elif header.colorType in {LCT_RGB, LCT_RGBA}: #estimate 6 bytes chunk.writeInt16(chunk.bkgdR) chunk.writeInt16(chunk.bkgdG) chunk.writeInt16(chunk.bkgdB) result = true method writeChunk(chunk: PNGTime, png: PNG): bool = #estimate 7 bytes chunk.writeInt16(chunk.year) chunk.writeByte(chunk.month) chunk.writeByte(chunk.day) chunk.writeByte(chunk.hour) chunk.writeByte(chunk.minute) chunk.writeByte(chunk.second) result = true method writeChunk(chunk: PNGPhys, png: PNG): bool = #estimate 9 bytes chunk.writeInt32(chunk.physX) chunk.writeInt32(chunk.physY) chunk.writeByte(chunk.unit) result = true method writeChunk(chunk: PNGText, png: PNG): bool = #estimate chunk.keyword.len + chunk.text.len + 1 chunk.writeString chunk.keyword chunk.writeByte 0 #null separator chunk.writeString chunk.text result = true method writeChunk(chunk: PNGZtxt, png: PNG): bool = #estimate chunk.keyword.len + 2 chunk.writeString chunk.keyword chunk.writeByte 0 #null separator chunk.writeByte 0 #compression method(0: deflate) var nz = nzDeflateInit(chunk.text) chunk.writeString zlib_compress(nz) result = true method writeChunk(chunk: PNGItxt, png: PNG): bool = #estimate chunk.keyword.len + 2 # + chunk.languageTag.len + chunk.translatedKeyword.len let state = PNGEncoder(png.settings) var compressed: int var text: string if state.textCompression: var nz = nzDeflateInit(chunk.text) var zz = zlib_compress(nz) if zz.len >= chunk.text.len: compressed = 0 text = chunk.text else: compressed = 1 text = zz else: compressed = 0 text = chunk.text chunk.writeString chunk.keyword chunk.writeByte 0 #null separator chunk.writeByte compressed #compression flag(0: uncompressed, 1: compressed) chunk.writeByte 0 #compression method(0: deflate) chunk.writeString chunk.languageTag chunk.writeByte 0 #null separator chunk.writeString chunk.translatedKeyword chunk.writeByte 0 #null separator chunk.writeString text result = true method writeChunk(chunk: PNGGamma, png: PNG): bool = #estimate 4 bytes chunk.writeInt32(chunk.gamma) result = true method writeChunk(chunk: PNGChroma, png: PNG): bool = #estimate 8 * 4 bytes chunk.writeInt32(chunk.whitePointX) chunk.writeInt32(chunk.whitePointY) chunk.writeInt32(chunk.redX) chunk.writeInt32(chunk.redY) chunk.writeInt32(chunk.greenX) chunk.writeInt32(chunk.greenY) chunk.writeInt32(chunk.blueX) chunk.writeInt32(chunk.blueY) result = true method writeChunk(chunk: PNGStandarRGB, png: PNG): bool = #estimate 1 byte chunk.writeByte(chunk.renderingIntent) result = true method writeChunk(chunk: PNGICCProfile, png: PNG): bool = #estimate chunk.profileName.len + 2 chunk.writeString chunk.profileName chunk.writeByte 0 #null separator chunk.writeByte 0 #compression method(0: deflate) var nz = nzDeflateInit(chunk.profile) chunk.writeString zlib_compress(nz) result = true method writeChunk(chunk: PNGSPalette, png: PNG): bool = #estimate chunk.paletteName.len + 2 #if sampleDepth == 8: estimate += chunk.palette.len * 6 #else: estimate += chunk.palette.len * 10 chunk.writeString chunk.paletteName chunk.writeByte 0 #null separator if chunk.sampleDepth notin {8, 16}: raise PNGError("palette sample depth error") chunk.writeByte chunk.sampleDepth if chunk.sampleDepth == 8: for p in chunk.palette: chunk.writeByte(p.red) chunk.writeByte(p.green) chunk.writeByte(p.blue) chunk.writeByte(p.alpha) chunk.writeInt16(p.frequency) else: # chunk.sampleDepth == 16: for p in chunk.palette: chunk.writeInt16(p.red) chunk.writeInt16(p.green) chunk.writeInt16(p.blue) chunk.writeInt16(p.alpha) chunk.writeInt16(p.frequency) result = true method writeChunk(chunk: PNGHist, png: PNG): bool = #estimate chunk.histogram.len * 2 for c in chunk.histogram: chunk.writeInt16 c result = true proc isGreyscaleType(mode: PNGColorMode): bool = result = mode.colorType in {LCT_GREY, LCT_GREY_ALPHA} proc isAlphaType(mode: PNGColorMode): bool = result = mode.colorType in {LCT_RGBA, LCT_GREY_ALPHA} #proc isPaletteType(mode: PNGColorMode): bool = # result = mode.colorType == LCT_PALETTE proc hasPaletteAlpha(mode: PNGColorMode): bool = for p in mode.palette: if ord(p.a) < 255: return true result = false proc canHaveAlpha(mode: PNGColorMode): bool = result = mode.keyDefined or isAlphaType(mode) or hasPaletteAlpha(mode) #Returns how many bits needed to represent given value (max 8 bit)*/ proc getValueRequiredBits(value: int): int = if(value == 0) or (value == 255): return 1 #The scaling of 2-bit and 4-bit values uses multiples of 85 and 17 if(value mod 17) == 0: if (value mod 85) == 0: return 2 else: return 4 result = 8 proc differ(p: RGBA16): bool = # first and second byte differ if (p.r and 255) != ((p.r shr 8) and 255): return true if (p.g and 255) != ((p.g shr 8) and 255): return true if (p.b and 255) != ((p.b shr 8) and 255): return true if (p.a and 255) != ((p.a shr 8) and 255): return true result = false proc getColorProfile(input: string, w, h: int, mode: PNGColorMode): PNGColorProfile = var prof = makeColorProfile() let numPixels = w * h bpp = getBPP(mode) var coloredDone = isGreyscaleType(mode) alphaDone = not canHaveAlpha(mode) bitsDone = bpp == 1 numColorsDone = false sixteen = false maxNumColors = 257 tree = initTable[RGBA8, int]() if bpp <= 8: case bpp of 1: maxNumColors = 2 of 2: maxNumColors = 4 of 4: maxNumColors = 16 else: maxNumColors = 256 #Check if the 16-bit input is truly 16-bit if mode.bitDepth == 16: let cvt = getColorRGBA16(mode) var p = RGBA16(r:0, g:0, b:0, a:0) for px in 0..numPixels-1: cvt(p, cstring(input), px, mode) if p.differ(): sixteen = true break if sixteen: let cvt = getColorRGBA16(mode) var p = RGBA16(r:0, g:0, b:0, a:0) prof.bits = 16 #counting colors no longer useful, palette doesn't support 16-bit bitsDone = true numColorsDone = true for px in 0..numPixels-1: cvt(p, cstring(input), px, mode) if not coloredDone and ((p.r != p.g) or (p.r != p.b)): prof.colored = true coloredDone = true if not alphaDone: let matchKey = (int(p.r) == prof.keyR and int(p.g) == prof.keyG and int(p.b) == prof.keyB) if(p.a != 65535) and (p.a != 0 or (prof.key and not matchKey)): prof.alpha = true alphaDone = true if prof.bits < 8: prof.bits = 8 #PNG has no alphachannel modes with less than 8-bit per channel elif(p.a == 0) and not prof.alpha and not prof.key: prof.key = true prof.keyR = int(p.r) prof.keyG = int(p.g) prof.keyB = int(p.b) elif(p.a == 65535) and prof.key and matchKey: # Color key cannot be used if an opaque pixel also has that RGB color. prof.alpha = true alphaDone = true if alphaDone and numColorsDone and coloredDone and bitsDone: break else: # < 16-bit let cvt = getColorRGBA8(mode) for px in 0..numPixels-1: var p = RGBA8(r:chr(0), g:chr(0), b:chr(0), a:chr(0)) cvt(p, cstring(input), px, mode) if (not bitsDone) and (prof.bits < 8): #only r is checked, < 8 bits is only relevant for greyscale let bits = getValueRequiredBits(int(p.r)) if bits > prof.bits: prof.bits = bits bitsDone = prof.bits >= bpp if (not coloredDone) and ((p.r != p.g) or (p.r != p.b)): prof.colored = true coloredDone = true if prof.bits < 8: prof.bits = 8 #PNG has no colored modes with less than 8-bit per channel if not alphaDone: let matchKey = ((int(p.r) == prof.keyR) and (int(p.g) == prof.keyG) and (int(p.b) == prof.keyB)) if(p.a != chr(255)) and (p.a != chr(0) or (prof.key and (not matchKey))): prof.alpha = true alphaDone = true if prof.bits < 8: prof.bits = 8 #PNG has no alphachannel modes with less than 8-bit per channel elif(p.a == chr(0)) and not prof.alpha and not prof.key: prof.key = true prof.keyR = int(p.r) prof.keyG = int(p.g) prof.keyB = int(p.b) elif(p.a == chr(255)) and prof.key and matchKey: #Color key cannot be used if an opaque pixel also has that RGB color. prof.alpha = true alphaDone = true if prof.bits < 8: prof.bits = 8 #PNG has no alphachannel modes with less than 8-bit per channel if not numColorsDone: if not tree.hasKey(p): tree[p] = prof.numColors if prof.numColors < 256: prof.palette.add p inc prof.numColors numColorsDone = prof.numColors >= maxNumColors if alphaDone and numColorsDone and coloredDone and bitsDone: break # make the profile's key always 16-bit for consistency - repeat each byte twice prof.keyR += prof.keyR shl 8 prof.keyG += prof.keyG shl 8 prof.keyB += prof.keyB shl 8 result = prof #Automatically chooses color type that gives smallest amount of bits in the #output image, e.g. grey if there are only greyscale pixels, palette if there #are less than 256 colors, ... #Updates values of mode with a potentially smaller color model. mode_out should #contain the user chosen color model, but will be overwritten with the new chosen one. proc autoChooseColor(modeOut: PNGColorMode, input: string, w, h: int, modeIn: PNGColorMode) = var prof = getColorProfile(input, w, h, modeIn) modeOut.keyDefined = false if prof.key and ((w * h) <= 16): prof.alpha = true #too few pixels to justify tRNS chunk overhead if prof.bits < 8: prof.bits = 8 #PNG has no alphachannel modes with less than 8-bit per channel #grey without alpha, with potentially low bits let greyOk = not prof.colored and not prof.alpha let n = prof.numColors var paletteBits = 0 if n <= 2: paletteBits = 1 elif n <= 4: paletteBits = 2 elif n <= 16: paletteBits = 4 else: paletteBits = 8 var paletteOk = (n <= 256) and ((n * 2) < (w * h)) and prof.bits <= 8 #don't add palette overhead if image has only a few pixels if (w * h) < (n * 2): paletteOk = false #grey is less overhead if greyOk and (prof.bits <= palettebits): paletteOk = false if paletteOk: modeOut.paletteSize = prof.palette.len modeOut.palette = prof.palette modeOut.colorType = LCT_PALETTE modeOut.bitDepth = paletteBits if(modeIn.colorType == LCT_PALETTE) and (modeIn.palettesize >= modeOut.palettesize) and (modeIn.bitdepth == modeOut.bitdepth): #If input should have same palette colors, keep original to preserve its order and prevent conversion modeIn.copyTo(modeOut) else: #8-bit or 16-bit per channel modeOut.bitDepth = prof.bits if prof.alpha: if prof.colored: modeOut.colorType = LCT_RGBA else: modeOut.colorType = LCT_GREY_ALPHA else: if prof.colored: modeOut.colorType = LCT_RGB else: modeOut.colorType = LCT_GREY if prof.key and not prof.alpha: #profile always uses 16-bit, mask converts it let mask = (1 shl modeOut.bitDepth) - 1 modeOut.keyR = prof.keyR and mask modeOut.keyG = prof.keyG and mask modeOut.keyB = prof.keyB and mask modeOut.keyDefined = true proc addPaddingBits(output: var cstring, input: cstring, olinebits, ilinebits, h: int) = #The opposite of the removePaddingBits function #olinebits must be >= ilinebits let diff = olinebits - ilinebits var obp = 0 ibp = 0 #bit pointers for y in 0..h-1: for x in 0..ilinebits-1: let bit = readBitFromReversedStream(ibp, input) setBitOfReversedStream(obp, output, bit) for x in 0..diff-1: setBitOfReversedStream(obp, output, 0) proc filterScanLine(output: var cstring, scanLine, prevLine: cstring, len, byteWidth: int, filterType: PNGFilter0) = case filterType of FLT_NONE: for i in 0..len-1: output[i] = scanLine[i] of FLT_SUB: for i in 0..byteWidth-1: output[i] = scanLine[i] for i in byteWidth..len-1: output[i] = chr(scanLine[i].uint8 - scanLine[i - byteWidth].uint8) of FLT_UP: if prevLine != nil: for i in 0..len-1: output[i] = chr(scanLine[i].uint8 - prevLine[i].uint8) else: for i in 0..len-1: output[i] = scanLine[i] of FLT_AVERAGE: if prevLine != nil: for i in 0..byteWidth-1: output[i] = chr(scanLine[i].uint8 - (prevLine[i].uint8 div 2)) for i in byteWidth..len-1: output[i] = chr(scanLine[i].uint8 - ((scanLine[i - byteWidth].uint8 + prevLine[i].uint8) div 2)) else: for i in 0..byteWidth-1: output[i] = scanLine[i] for i in byteWidth..len-1: output[i] = chr(scanLine[i].uint8 - (scanLine[i - byteWidth].uint8 div 2)) of FLT_PAETH: if prevLine != nil: #paethPredictor(0, prevLine[i], 0) is always prevLine[i] for i in 0..byteWidth-1: output[i] = chr(scanLine[i].uint8 - prevLine[i].uint8) for i in byteWidth..len-1: output[i] = chr(scanLine[i].uint8 - paethPredictor(ord(scanLine[i - byteWidth]), ord(prevLine[i]), ord(prevLine[i - byteWidth])).uint8) else: for i in 0..byteWidth-1: output[i] = scanLine[i] #paethPredictor(scanLine[i - byteWidth], 0, 0) is always scanLine[i - byteWidth] for i in byteWidth..len-1: output[i] = chr(scanLine[i].uint8 - scanLine[i - byteWidth].uint8) else: raise PNGError("unsupported fitler type") proc filterZero(output: var cstring, input: cstring, w, h, bpp: int) = #the width of a scanline in bytes, not including the filter type let lineBytes = (w * bpp + 7) div 8 #byteWidth is used for filtering, is 1 when bpp < 8, number of bytes per pixel otherwise let byteWidth = (bpp + 7) div 8 var prevLine: cstring = nil var inp = input for y in 0..h-1: let outindex = (1 + lineBytes) * y #the extra filterbyte added to each row let inindex = lineBytes * y output[outindex] = chr(int(FLT_NONE)) #filter type byte var outp: cstring = addr(output[outindex + 1]) let scanLine: cstring = addr(inp[inindex]) filterScanLine(outp, scanLine, prevLine, lineBytes, byteWidth, FLT_NONE) prevLine = addr(inp[inindex]) proc filterMinsum(output: var cstring, input: cstring, w, h, bpp: int) = let lineBytes = (w * bpp + 7) div 8 let byteWidth = (bpp + 7) div 8 #adaptive filtering var sum = [0, 0, 0, 0, 0] var smallest = 0 #five filtering attempts, one for each filter type var attempt: array[0..4, string] var bestType = 0 var inp = input var prevLine: cstring = nil for i in 0..attempt.high: attempt[i] = newString(lineBytes) for y in 0..h-1: #try the 5 filter types for fType in 0..4: var outp = cstring(attempt[fType]) filterScanLine(outp, addr(inp[y * lineBytes]), prevLine, lineBytes, byteWidth, PNGFilter0(fType)) #calculate the sum of the result sum[fType] = 0 if fType == 0: for x in 0..lineBytes-1: sum[fType] += ord(attempt[fType][x]) else: for x in 0..lineBytes-1: #For differences, each byte should be treated as signed, values above 127 are negative #(converted to signed char). Filtertype 0 isn't a difference though, so use unsigned there. #This means filtertype 0 is almost never chosen, but that is justified. let s = ord(attempt[fType][x]) if s < 128: sum[fType] += s else: sum[fType] += (255 - s) #check if this is smallest sum (or if type == 0 it's the first case so always store the values)*/ if(fType == 0) or (sum[fType] < smallest): bestType = fType smallest = sum[fType] prevLine = addr(inp[y * lineBytes]) #now fill the out values #the first byte of a scanline will be the filter type output[y * (lineBytes + 1)] = chr(bestType) for x in 0..lineBytes-1: output[y * (lineBytes + 1) + 1 + x] = attempt[bestType][x] proc filterEntropy(output: var cstring, input: cstring, w, h, bpp: int) = let lineBytes = (w * bpp + 7) div 8 let byteWidth = (bpp + 7) div 8 var inp = input var prevLine: cstring = nil var sum: array[0..4, float] var smallest = 0.0 var bestType = 0 var attempt: array[0..4, string] var count: array[0..255, int] for i in 0..attempt.high: attempt[i] = newString(lineBytes) for y in 0..h-1: #try the 5 filter types for fType in 0..4: var outp = cstring(attempt[fType]) filterScanLine(outp, addr(inp[y * lineBytes]), prevLine, lineBytes, byteWidth, PNGFilter0(fType)) for x in 0..255: count[x] = 0 for x in 0..lineBytes-1: inc count[ord(attempt[fType][x])] inc count[fType] #the filter type itself is part of the scanline sum[fType] = 0 for x in 0..255: let p = float(count[x]) / float(lineBytes + 1) if count[x] != 0: sum[fType] += log2(1 / p) * p #check if this is smallest sum (or if type == 0 it's the first case so always store the values) if (fType == 0) or (sum[fType] < smallest): bestType = fType smallest = sum[fType] prevLine = addr(inp[y * lineBytes]) #now fill the out values*/ #the first byte of a scanline will be the filter type output[y * (lineBytes + 1)] = chr(bestType) for x in 0..lineBytes-1: output[y * (lineBytes + 1) + 1 + x] = attempt[bestType][x] proc filterPredefined(output: var cstring, input: cstring, w, h, bpp: int, state: PNGEncoder) = let lineBytes = (w * bpp + 7) div 8 let byteWidth = (bpp + 7) div 8 var inp = input var prevLine: cstring = nil for y in 0..h-1: let outindex = (1 + lineBytes) * y #the extra filterbyte added to each row let inindex = lineBytes * y let fType = ord(state.predefinedFilters[y]) output[outindex] = chr(fType) #filter type byte var outp: cstring = addr(output[outindex + 1]) filterScanLine(outp, addr(inp[inindex]), prevLine, lineBytes, byteWidth, PNGFilter0(fType)) prevLine = addr(inp[inindex]) proc filterBruteForce(output: var cstring, input: cstring, w, h, bpp: int) = let lineBytes = (w * bpp + 7) div 8 let byteWidth = (bpp + 7) div 8 var inp = input var prevLine: cstring = nil #brute force filter chooser. #deflate the scanline after every filter attempt to see which one deflates best. #This is very slow and gives only slightly smaller, sometimes even larger, result*/ var size: array[0..4, int] var attempt: array[0..4, string] #five filtering attempts, one for each filter type var smallest = 0 var bestType = 0 #use fixed tree on the attempts so that the tree is not adapted to the filtertype on purpose, #to simulate the true case where the tree is the same for the whole image. Sometimes it gives #better result with dynamic tree anyway. Using the fixed tree sometimes gives worse, but in rare #cases better compression. It does make this a bit less slow, so it's worth doing this. for i in 0..attempt.high: attempt[i] = newString(lineBytes) for y in 0..h-1: #try the 5 filter types for fType in 0..4: #let testSize = attempt[fType].len var outp = cstring(attempt[fType]) filterScanline(outp, addr(inp[y * lineBytes]), prevLine, lineBytes, byteWidth, PNGFilter0(fType)) size[fType] = 0 var nz = nzDeflateInit(attempt[fType]) let data = zlib_compress(nz) size[fType] = data.len #check if this is smallest size (or if type == 0 it's the first case so always store the values) if(fType == 0) or (size[fType] < smallest): bestType = fType smallest = size[fType] prevLine = addr(inp[y * lineBytes]) output[y * (lineBytes + 1)] = chr(bestType) #the first byte of a scanline will be the filter type for x in 0..lineBytes-1: output[y * (lineBytes + 1) + 1 + x] = attempt[bestType][x] proc filter(output: var cstring, input: cstring, w, h: int, modeOut: PNGColorMode, state: PNGEncoder) = #For PNG filter method 0 #out must be a buffer with as size: h + (w * h * bpp + 7) / 8, because there are #the scanlines with 1 extra byte per scanline let bpp = getBPP(modeOut) var strategy = state.filterStrategy #There is a heuristic called the minimum sum of absolute differences heuristic, suggested by the PNG standard: # * If the image type is Palette, or the bit depth is smaller than 8, then do not filter the image (i.e. # use fixed filtering, with the filter None). # * (The other case) If the image type is Grayscale or RGB (with or without Alpha), and the bit depth is # not smaller than 8, then use adaptive filtering heuristic as follows: independently for each row, apply # all five filters and select the filter that produces the smallest sum of absolute values per row. #This heuristic is used if filter strategy is LFS_MINSUM and filter_palette_zero is true. #If filter_palette_zero is true and filter_strategy is not LFS_MINSUM, the above heuristic is followed, #but for "the other case", whatever strategy filter_strategy is set to instead of the minimum sum #heuristic is used. if state.filterPaletteZero and (modeOut.colorType == LCT_PALETTE or modeOut.bitDepth < 8): strategy = LFS_ZERO if bpp == 0: raise PNGError("invalid color type") case strategy of LFS_ZERO: filterZero(output, input, w, h, bpp) of LFS_MINSUM: filterMinsum(output, input, w, h, bpp) of LFS_ENTROPY: filterEntropy(output, input, w, h, bpp) of LFS_BRUTE_FORCE: filterBruteForce(output, input, w, h, bpp) of LFS_PREDEFINED: filterPredefined(output, input, w, h, bpp, state) #input: non-interlaced image with size w*h #output: the same pixels, but re-ordered according to PNG's Adam7 interlacing, with # no padding bits between scanlines, but between reduced images so that each # reduced image starts at a byte. #bpp: bits per pixel #there are no padding bits, not between scanlines, not between reduced images #in has the following size in bits: w * h * bpp. #output is possibly bigger due to padding bits between reduced images #NOTE: comments about padding bits are only relevant if bpp < 8 proc Adam7Interlace(output: var cstring, input: cstring, w, h, bpp: int) = var pass: PNGPass Adam7PassValues(pass, w, h, bpp) if bpp >= 8: for i in 0..6: let byteWidth = bpp div 8 for y in 0..pass.h[i]-1: for x in 0..pass.w[i]-1: let inStart = ((ADAM7_IY[i] + y * ADAM7_DY[i]) * w + ADAM7_IX[i] + x * ADAM7_DX[i]) * byteWidth let outStart = pass.start[i] + (y * pass.w[i] + x) * byteWidth for b in 0..byteWidth-1: output[outStart + b] = input[inStart + b] else: #bpp < 8: Adam7 with pixels < 8 bit is a bit trickier: with bit pointers for i in 0..6: let ilinebits = bpp * pass.w[i] let olinebits = bpp * w var obp, ibp: int #bit pointers (for out and in buffer) for y in 0..pass.h[i]-1: for x in 0..pass.w[i]-1: ibp = (ADAM7_IY[i] + y * ADAM7_DY[i]) * olinebits + (ADAM7_IX[i] + x * ADAM7_DX[i]) * bpp obp = (8 * pass.start[i]) + (y * ilinebits + x * bpp) for b in 0..bpp-1: let bit = readBitFromReversedStream(ibp, input) setBitOfReversedStream(obp, output, bit) proc preProcessScanLines(png: PNG, input: cstring, w, h: int, modeOut: PNGColorMode, state: PNGEncoder) = #This function converts the pure 2D image with the PNG's colorType, into filtered-padded-interlaced data. Steps: # if no Adam7: 1) add padding bits (= posible extra bits per scanLine if bpp < 8) 2) filter # if adam7: 1) Adam7_interlace 2) 7x add padding bits 3) 7x filter let bpp = getBPP(modeOut) if state.interlaceMethod == IM_NONE: #image size plus an extra byte per scanLine + possible padding bits let scanLen = (w * bpp + 7) div 8 let outSize = h + (h * scanLen) png.pixels = newString(outSize) var output = cstring(png.pixels) #non multiple of 8 bits per scanLine, padding bits needed per scanLine if(bpp < 8) and ((w * bpp) != (scanLen * 8)): var padded = newString(h * scanLen) var padding = cstring(padded) addPaddingBits(padding, input, scanLen * 8, w * bpp, h) filter(output, padding, w, h, modeOut, state) else: #we can immediatly filter into the out buffer, no other steps needed filter(output, input, w, h, modeOut, state) else: #interlaceMethod is 1 (Adam7) var pass: PNGPass Adam7PassValues(pass, w, h, bpp) let outSize = pass.filterStart[7] png.pixels = newString(outSize) var adam7buf = newString(pass.start[7]) var adam7 = cstring(adam7buf) var output = cstring(png.pixels) Adam7Interlace(adam7, input, w, h, bpp) for i in 0..6: if bpp < 8: var padded = newString(pass.paddedStart[i + 1] - pass.paddedStart[i]) var padding = cstring(padded) addPaddingBits(padding, addr(adam7[pass.start[i]]), ((pass.w[i] * bpp + 7) div 8) * 8, pass.w[i] * bpp, pass.h[i]) var outp:cstring = addr(output[pass.filterStart[i]]) filter(outp, padding, pass.w[i], pass.h[i], modeOut, state) else: var outp:cstring = addr(output[pass.filterStart[i]]) filter(outp, addr(adam7[pass.paddedStart[i]]), pass.w[i], pass.h[i], modeOut, state) #palette must have 4 * palettesize bytes allocated, and given in format RGBARGBARGBARGBA... #returns 0 if the palette is opaque, #returns 1 if the palette has a single color with alpha 0 ==> color key #returns 2 if the palette is semi-translucent. proc getPaletteTranslucency(modeOut: PNGColorMode): int = var key = 0 #the value of the color with alpha 0, so long as color keying is possible var p: RGBA8 var i = 0 while i < modeOut.paletteSize: let x = modeOut.palette[i] if (key == 0) and (x.a == chr(0)): p = x key = 1 i = -1 #restart from beginning, to detect earlier opaque colors with key's value elif x.a != chr(255): return 2 #when key, no opaque RGB may have key's RGB*/ elif(key != 0) and (p.r == x.r) and (p.g == x.g) and (p.b == x.g): return 2 inc i result = key proc addChunkIHDR(png: PNG, w,h: int, modeOut: PNGColorMode, state: PNGEncoder) = var chunk = make[PNGHeader](IHDR, 13) chunk.width = w chunk.height = h chunk.bitDepth = modeOut.bitDepth chunk.colorType = modeOut.colorType chunk.compressionMethod = 0 chunk.filterMethod = 0 chunk.interlaceMethod = state.interlaceMethod png.chunks.add chunk proc addChunkPLTE(png: PNG, modeOut: PNGColorMode) = if modeOut.paletteSize == 0: return var chunk = make[PNGPalette](PLTE, 3 * modeOut.paletteSize) chunk.palette = modeOut.palette png.chunks.add chunk proc addChunktRNS(png: PNG, modeOut: PNGColorMode) = var chunk = make[PNGTrans](tRNS, 2) if modeOut.colorType == LCT_PALETTE: var plte = png.getChunk(PLTE) doAssert plte != nil elif modeOut.colorType == LCT_GREY: if modeOut.keyDefined: chunk.keyR = modeOut.keyR else: chunk.keyR = -1 elif modeOut.colorType == LCT_RGB: if modeOut.keyDefined: chunk.keyR = modeOut.keyR chunk.keyG = modeOut.keyG chunk.keyB = modeOut.keyB else: chunk.keyR = -1 png.chunks.add chunk proc addChunkbKGD(png: PNG, modeOut: PNGColorMode, state: PNGEncoder) = var chunk = make[PNGBackground](bKGD, 6) if modeOut.colorType == LCT_PALETTE: #estimate 1 bytes chunk.bkgdR = state.backgroundR if modeOut.colorType in {LCT_GREY, LCT_GREY_ALPHA}: #estimate 2 bytes chunk.bkgdR = state.backgroundR elif modeOut.colorType in {LCT_RGB, LCT_RGBA}: #estimate 6 bytes chunk.bkgdR = state.backgroundR chunk.bkgdG = state.backgroundG chunk.bkgdB = state.backgroundB png.chunks.add chunk proc addChunkpHYs(png: PNG, state: PNGEncoder) = var chunk = make[PNGPhys](pHYs, 9) chunk.physX = state.physX chunk.physY = state.physY chunk.unit = state.physUnit png.chunks.add chunk proc addChunkIDAT(png: PNG, state: PNGEncoder) = var chunk = make[PNGData](IDAT, 0) chunk.idat = png.pixels png.chunks.add chunk proc addChunktIME(png: PNG, state: PNGEncoder) = var chunk = make[PNGTime](tIME, 0) chunk.year = state.year chunk.month = state.month chunk.day = state.day chunk.hour = state.hour chunk.minute = state.minute chunk.second = state.second png.chunks.add chunk proc addChunktEXt(png: PNG, txt: PNGKeyText) = var chunk = make[PNGText](tEXt, txt.keyword.len + txt.text.len + 1) chunk.keyword = txt.keyword chunk.text = txt.text png.chunks.add chunk proc addChunkzTXt(png: PNG, txt: PNGKeyText) = var chunk = make[PNGZtxt](zTXt, txt.keyword.len + txt.text.len + 1) chunk.keyword = txt.keyword chunk.text = txt.text png.chunks.add chunk proc addChunkiTXt(png: PNG, txt: PNGIText) = var chunk = make[PNGItxt](iTXt, txt.keyword.len + txt.text.len + 1) chunk.keyword = txt.keyword chunk.translatedKeyword = txt.translatedKeyword chunk.languageTag = txt.languageTag chunk.text = txt.text png.chunks.add chunk proc addChunkIEND(png: PNG) = var chunk = make[PNGEnd](IEND, 0) png.chunks.add chunk proc encodePNG*(input: string, w, h: int, settings = PNGEncoder(nil)): PNG = var png: PNG new(png) png.chunks = @[] if settings == nil: png.settings = makePNGEncoder() else: png.settings = settings let state = PNGEncoder(png.settings) var modeIn = newColorMode(state.modeIn) var modeOut = newColorMode(state.modeOut) if not bitDepthAllowed(modeIn.colorType, modeIn.bitDepth): raise PNGError("modeIn colorType and bitDepth combination not allowed") if not bitDepthAllowed(modeOut.colorType, modeOut.bitDepth): raise PNGError("modeOut colorType and bitDepth combination not allowed") if(modeOut.colorType == LCT_PALETTE or state.forcePalette) and (modeOut.paletteSize == 0 or modeOut.paletteSize > 256): raise PNGError("invalid palette size, it is only allowed to be 1-256") let inputSize = getRawSize(w, h, modeIn) if input.len < inputSize: raise PNGError("not enough input to encode") if state.autoConvert: autoChooseColor(modeOut, input, w, h, modeIn) if state.interlaceMethod notin {IM_NONE, IM_INTERLACED}: raise PNGError("unexisting interlace mode") if not bitDepthAllowed(modeOut.colorType, modeOut.bitDepth): raise PNGError("colorType and bitDepth combination not allowed") if modeIn != modeOut: let size = (w * h * getBPP(modeOut) + 7) div 8 let numPixels = w * h var converted = newString(size) var output = cstring(converted) convert(output, cstring(input), modeOut, modeIn, numPixels) preProcessScanLines(png, cstring(converted), w, h, modeOut, state) else: preProcessScanLines(png, cstring(input), w, h, modeOut, state) png.addChunkIHDR(w, h, modeOut, state) #unknown chunks between IHDR and PLTE if state.unknown.len > 0: png.chunks.add state.unknown[0] if modeOut.colorType == LCT_PALETTE: png.addChunkPLTE(modeOut) if state.forcePalette and modeOut.colorType in {LCT_RGB, LCT_RGBA}: png.addChunkPLTE(modeOut) if(modeOut.colorType == LCT_PALETTE) and (getPaletteTranslucency(modeOut) != 0): png.addChunktRNS(modeOut) if modeOut.colorType in {LCT_GREY, LCT_RGB} and modeOut.keyDefined: png.addChunktRNS(modeOut) #bKGD (must come between PLTE and the IDAt chunks if state.backgroundDefined: png.addChunkbKGD(modeOut, state) #pHYs (must come before the IDAT chunks) if state.physDefined: png.addChunkpHYs(state) #unknown chunks between PLTE and IDAT if state.unknown.len > 1: png.chunks.add state.unknown[1] #IDAT (multiple IDAT chunks must be consecutive) png.addChunkIDAT(state) if state.timeDefined: png.addChunktIME(state) for txt in state.textList: if state.textCompression: png.addChunkzTXt(txt) else: png.addChunktEXt(txt) if state.addID: var txt = PNGKeyText(keyword: "nimPNG", text: NIM_PNG_VERSION) png.addChunktEXt(txt) for txt in state.itextList: png.addChunkiTXt(txt) #unknown chunks between IDAT and IEND if state.unknown.len > 2: png.chunks.add state.unknown[2] png.addChunkIEND() result = png proc encodePNG*(input: string, colorType: PNGcolorType, bitDepth, w, h: int, settings = PNGEncoder(nil)): PNG = if not bitDepthAllowed(colorType, bitDepth): raise PNGError("colorType and bitDepth combination not allowed") var state: PNGEncoder if settings == nil: state = makePNGEncoder() else: state = settings state.modeIn.colorType = colorType state.modeIn.bitDepth = bitDepth result = encodePNG(input, w, h, state) proc encodePNG32*(input: string, w, h: int): PNG = result = encodePNG(input, LCT_RGBA, 8, w, h) proc encodePNG24*(input: string, w, h: int): PNG = result = encodePNG(input, LCT_RGB, 8, w, h) proc writeChunks*(png: PNG, s: Stream) = s.write PNGSignature for chunk in png.chunks: if not chunk.validateChunk(png): raise PNGError("combine chunk validation error") if not chunk.writeChunk(png): raise PNGError("combine chunk write error") chunk.length = chunk.data.len chunk.crc = crc32(crc32(0, $chunk.chunkType), chunk.data) s.writeInt32BE chunk.length s.writeInt32BE int(chunk.chunkType) s.write chunk.data s.writeInt32BE cast[int](chunk.crc) proc savePNG*(fileName, input: string, colorType: PNGcolorType, bitDepth, w, h: int): bool = try: var png = encodePNG(input, colorType, bitDepth, w, h) var s = newFileStream(fileName, fmWrite) png.writeChunks s s.close() result = true except: debugEcho getCurrentExceptionMsg() result = false proc savePNG32*(fileName, input: string, w, h: int): bool = result = savePNG(fileName, input, LCT_RGBA, 8, w, h) proc savePNG24*(fileName, input: string, w, h: int): bool = result = savePNG(fileName, input, LCT_RGB, 8, w, h) proc getFilterTypesInterlaced(png: PNG): seq[string] = var header = PNGHeader(png.getChunk(IHDR)) var idat = PNGData(png.getChunk(IDAT)) if header.interlaceMethod == IM_NONE: result = newSeq[string](1) result[0] = "" #A line is 1 filter byte + all pixels let lineBytes = 1 + idatRawSize(header.width, 1, header) var i = 0 while i < idat.idat.len: result[0].add idat.idat[i] inc(i, lineBytes) else: result = newSeq[string](7) for j in 0..6: result[j] = "" var w2 = (header.width - ADAM7_IX[j] + ADAM7_DX[j] - 1) div ADAM7_DX[j] var h2 = (header.height - ADAM7_IY[j] + ADAM7_DY[j] - 1) div ADAM7_DY[j] if(ADAM7_IX[j] >= header.width) or (ADAM7_IY[j] >= header.height): w2 = 0 h2 = 0 let lineBytes = 1 + idatRawSize(w2, 1, header) var pos = 0 for i in 0..h2-1: result[j].add idat.idat[pos] inc(pos, linebytes) proc getFilterTypes*(png: PNG): string = var passes = getFilterTypesInterlaced(png) if passes.len == 1: result = passes[0] else: var header = PNGHeader(png.getChunk(IHDR)) #Interlaced. Simplify it: put pass 6 and 7 alternating in the one vector so #that one filter per scanline of the uninterlaced image is given, with that #filter corresponding the closest to what it would be for non-interlaced image. result = "" for i in 0..header.height-1: if (i mod 2) == 0: result.add passes[5][i div 2] else: result.add passes[6][i div 2]