Merge origin/master into imagesuite

Author: treeform

bindings/bindings.nim

@@ -112,6 +112,7 @@ exportRefObject Image:
     newImage(int, int)
   procs:
     writeFile(Image, string)
+    encodeBase64
     copy(Image)
     getColor
     setColor
@@ -291,6 +292,7 @@ exportRefObject Context:
     isPointInStroke(Context, Path, float32, float32)
 
 exportProcs:
+  decodeBase64
   decodeImage
   decodeImageDimensions
   readImage

src/pixie.nim

@@ -1,10 +1,11 @@
-import bumpy, chroma, flatty/binny, os, pixie/common, pixie/contexts,
-    pixie/fileformats/bmp, pixie/fileformats/gif, pixie/fileformats/jpeg,
-    pixie/fileformats/png, pixie/fileformats/ppm, pixie/fileformats/qoi,
-    pixie/fileformats/svg, pixie/fonts, pixie/images, pixie/internal,
-    pixie/paints, pixie/paths, strutils, vmath
+import
+  std/[os, strutils],
+  bumpy, chroma, flatty/binny, vmath,
+  pixie/[common, contexts, fonts, imagebase64, images, internal, paints, paths],
+  pixie/fileformats/[bmp, gif, jpeg, png, ppm, qoi, svg]
 
-export bumpy, chroma, common, contexts, fonts, images, paints, paths, vmath
+export bumpy, chroma, common, contexts, fonts, imagebase64, images, paints,
+    paths, vmath
 
 type
   FileFormat* = enum
@@ -85,7 +86,9 @@ proc readImage*(filePath: string): Image {.inline, raises: [PixieError].} =
   except IOError as e:
     raise newException(PixieError, e.msg, e)
 
-proc encodeImage*(image: Image, fileFormat: FileFormat): string {.raises: [PixieError].} =
+proc encodeImage*(
+  image: Image, fileFormat: FileFormat
+): string {.raises: [PixieError].} =
   ## Encodes an image into memory.
   case fileFormat:
   of PngFormat:

src/pixie/fileformats/ppm.nim

@@ -53,15 +53,20 @@ proc decodeHeader(
 
     result.dataOffset = i
 
-proc decodeP6Data(data: string, maxVal: int): seq[ColorRGBX] {.raises: [].} =
+proc decodeP6Data(
+  data: string, maxVal: int
+): seq[ColorRGBX] {.raises: [PixieError].} =
   let needsUint16 = maxVal > 0xFF
-
-  result = newSeq[ColorRGBX](
+  let bytesPerPixel =
     if needsUint16:
-      data.len div 6
+      6
     else:
-      data.len div 3
-  )
+      3
+
+  if data.len mod bytesPerPixel != 0:
+    failInvalid()
+
+  result = newSeq[ColorRGBX](data.len div bytesPerPixel)
 
   # Let's calculate the real maximum value multiplier.
   # rgbx() accepts a maximum value of 255. Most of the time,
@@ -129,15 +134,18 @@ proc decodePpm*(data: string): Image {.raises: [PixieError].} =
   if not (header.version in ppmSignatures):
     failInvalid()
 
-  if 0 > header.maxVal or header.maxVal > 0xFFFF:
+  if header.maxVal <= 0 or header.maxVal > 0xFFFF:
     failInvalid()
 
   result = newImage(header.width, header.height)
-  result.data =
+  let pixels =
     if header.version == "P3":
       decodeP3Data(data[header.dataOffset .. ^1], header.maxVal)
     else:
       decodeP6Data(data[header.dataOffset .. ^1], header.maxVal)
+  if pixels.len != result.data.len:
+    failInvalid()
+  result.data = pixels
 
 proc decodePpmDimensions*(
   data: pointer, len: int

src/pixie/fontformats/opentype.nim

@@ -394,6 +394,8 @@ type
 when defined(release):
   {.push checks: off.}
 
+const maxCompositeGlyphRecursion = 64
+
 template eofCheck(buf: string, readTo: int) =
   if readTo > buf.len:
     raise newException(PixieError, "Unexpected error reading font data, EOF")
@@ -2180,7 +2182,7 @@ proc hasGlyph*(opentype: OpenType, rune: Rune): bool =
   rune in opentype.cmap.runeToGlyphId
 
 proc parseGlyfGlyph(
-  opentype: OpenType, glyphId: uint16
+  opentype: OpenType, glyphId: uint16, recursionDepth = 0
 ): Path {.raises: [PixieError], gcsafe.}
 
 proc parseGlyphPath(
@@ -2318,7 +2320,9 @@ proc parseGlyphPath(
 
     result.closePath()
 
-proc parseCompositeGlyph(opentype: OpenType, offset: int): Path =
+proc parseCompositeGlyph(
+  opentype: OpenType, offset, recursionDepth: int
+): Path =
   result = newPath()
 
   var
@@ -2402,7 +2406,10 @@ proc parseCompositeGlyph(opentype: OpenType, offset: int): Path =
     # elif (flags and 0b1000000000000) != 0: # UNSCALED_COMPONENT_OFFSET
     #   discard
 
-    var subPath = opentype.parseGlyfGlyph(component.glyphId)
+    var subPath = opentype.parseGlyfGlyph(
+      component.glyphId,
+      recursionDepth + 1
+    )
     subPath.transform(mat3(
       component.xScale, component.scale10, 0.0,
       component.scale01, component.yScale, 0.0,
@@ -2413,7 +2420,11 @@ proc parseCompositeGlyph(opentype: OpenType, offset: int): Path =
 
     moreComponents = (flags and 0b100000) != 0
 
-proc parseGlyfGlyph(opentype: OpenType, glyphId: uint16): Path =
+proc parseGlyfGlyph(
+  opentype: OpenType, glyphId: uint16, recursionDepth: int
+): Path =
+  if recursionDepth > maxCompositeGlyphRecursion:
+    raise newException(PixieError, "Invalid composite glyph recursion")
 
   if glyphId.int >= opentype.glyf.offsets.len:
     raise newException(PixieError, "Invalid glyph ID " & $glyphId)
@@ -2434,7 +2445,7 @@ proc parseGlyfGlyph(opentype: OpenType, glyphId: uint16): Path =
   i += 10
 
   if numberOfContours < 0:
-    opentype.parseCompositeGlyph(i)
+    opentype.parseCompositeGlyph(i, recursionDepth)
   else:
     parseGlyphPath(opentype.buf, i, numberOfContours)
 

src/pixie/imagebase64.nim

@@ -0,0 +1,52 @@
+import
+  std/base64 as stdbase64,
+  std/strutils,
+  flatty/binny,
+  common,
+  fileformats/[bmp, gif, jpeg, png, ppm, qoi, svg]
+
+proc decodeImageData(data: string): Image {.raises: [PixieError].} =
+  ## Decodes supported image bytes into an image.
+  if data.len > 8 and data.readUint64(0) == cast[uint64](pngSignature):
+    decodePng(data).convertToImage()
+  elif data.len > 2 and data.readUint16(0) == cast[uint16](jpegStartOfImage):
+    decodeJpeg(data)
+  elif data.len > 2 and data.readStr(0, 2) == bmpSignature:
+    decodeBmp(data)
+  elif data.len > 5 and (
+    data.readStr(0, 5) == xmlSignature or
+    data.readStr(0, 4) == svgSignature
+  ):
+    newImage(parseSvg(data))
+  elif data.len > 6 and data.readStr(0, 6) in gifSignatures:
+    newImage(decodeGif(data))
+  elif data.len > (14 + 8) and data.readStr(0, 4) == qoiSignature:
+    decodeQoi(data).convertToImage()
+  elif data.len > 9 and data.readStr(0, 2) in ppmSignatures:
+    decodePpm(data)
+  else:
+    raise newException(PixieError, "Unsupported image file format")
+
+proc getPayload(data: string): string {.raises: [PixieError].} =
+  ## Gets the base64 payload from plain base64 data or a data URL.
+  if data.startsWith("data:"):
+    let comma = data.find(',')
+    if comma == -1:
+      raise newException(PixieError, "Invalid data URL")
+    if comma + 1 < data.len:
+      data[comma + 1 .. ^1]
+    else:
+      ""
+  else:
+    data
+
+proc encodeBase64*(image: Image): string {.raises: [PixieError].} =
+  ## Encodes an image into PNG format and returns it as base64.
+  stdbase64.encode(image.encodePng())
+
+proc decodeBase64*(data: string): Image {.raises: [PixieError].} =
+  ## Decodes a base64 image string into an image.
+  try:
+    decodeImageData(stdbase64.decode(data.getPayload()))
+  except ValueError as e:
+    raise newException(PixieError, e.msg, e)

tests/test_base64.nim

@@ -0,0 +1,35 @@
+import
+  std/base64,
+  chroma, pixie, pixie/fileformats/png
+
+block:
+  let image = newImage(2, 1)
+  image[0, 0] = rgba(255, 0, 0, 255)
+  image[1, 0] = rgba(0, 0, 255, 128)
+
+  let encoded = image.encodeBase64()
+  doAssert encoded == base64.encode(image.encodePng())
+
+  let decoded = decodeBase64(encoded)
+  doAssert decoded.width == image.width
+  doAssert decoded.height == image.height
+  doAssert decoded.data == image.data
+
+block:
+  let image = newImage(1, 1)
+  image[0, 0] = rgba(0, 255, 0, 255)
+
+  let
+    encoded = image.encodeBase64()
+    decoded = decodeBase64("data:image/png;base64," & encoded)
+
+  doAssert decoded.width == image.width
+  doAssert decoded.height == image.height
+  doAssert decoded.data == image.data
+
+block:
+  try:
+    discard decodeBase64("nope")
+    doAssert false
+  except PixieError:
+    discard

tests/test_fonts.nim

@@ -1,4 +1,4 @@
-import os, pixie, strformat, unicode, xrays
+import os, pixie, pixie/fontformats/opentype, strformat, tables, unicode, xrays
 
 proc wh(image: Image): Vec2 =
   ## Return with and height as a size vector.
@@ -1048,6 +1048,52 @@ block:
   var typeface = readTypeface("tests/fonts/Roboto-Regular_1.ttf")
   doAssert typeface.getKerningAdjustment('T'.Rune, 'e'.Rune) == -99.0
 
+block:
+  proc writeBe16(data: var string, offset, value: int) =
+    data[offset] = char((value shr 8) and 0xff)
+    data[offset + 1] = char(value and 0xff)
+
+  let originalData = readFile("tests/fonts/Roboto-Regular_1.ttf")
+  let original = parseOpenType(originalData)
+
+  var
+    targetRune: Rune
+    targetGlyphId = -1
+    glyphOffset = -1
+
+  for rune, glyphId in original.cmap.runeToGlyphId.pairs:
+    let glyphIndex = glyphId.int
+    if glyphIndex == 0 or glyphIndex + 1 >= original.glyf.offsets.len:
+      continue
+
+    let
+      startOffset = original.glyf.offsets[glyphIndex].int
+      endOffset = original.glyf.offsets[glyphIndex + 1].int
+      glyphLen = endOffset - startOffset
+
+    if glyphLen >= 16:
+      targetRune = rune
+      targetGlyphId = glyphIndex
+      glyphOffset = startOffset
+      break
+
+  doAssert targetGlyphId >= 0
+
+  var mutated = originalData
+  writeBe16(mutated, glyphOffset + 0, 0xffff) # Composite glyph.
+  writeBe16(mutated, glyphOffset + 2, 0)
+  writeBe16(mutated, glyphOffset + 4, 0)
+  writeBe16(mutated, glyphOffset + 6, 0)
+  writeBe16(mutated, glyphOffset + 8, 0)
+  writeBe16(mutated, glyphOffset + 10, 0x0002) # ARGS_ARE_XY_VALUES.
+  writeBe16(mutated, glyphOffset + 12, targetGlyphId)
+  mutated[glyphOffset + 14] = '\0'
+  mutated[glyphOffset + 15] = '\0'
+
+  let font = parseOpenType(mutated)
+  doAssertRaises PixieError:
+    discard font.getGlyphPath(targetRune)
+
 block:
   var font = readFont("tests/fonts/Inter-Regular.ttf")
   font.size = 26

tests/test_ppm.nim

@@ -1,4 +1,4 @@
-import pixie/fileformats/ppm
+import pixie, pixie/fileformats/ppm
 
 block:
   for format in @["p3", "p6"]:
@@ -23,3 +23,9 @@ block:
   let p6Master = readFile("tests/fileformats/ppm/feep.p6.master.ppm")
   for image in @["p3", "p6", "p3.hidepth"]:
     doAssert readFile("tests/fileformats/ppm/feep." & $image & ".ppm") == p6Master
+
+block:
+  let payload = "P6\n10 10\n255\n" & "\x12\x34\x56"
+
+  doAssertRaises PixieError:
+    discard decodeImage(payload)

tests/test_tiff.nim

@@ -1,4 +1,4 @@
-import pixie/fileformats/tiff
+import pixie/common, pixie/fileformats/tiff
 
 let
   data = readFile("tests/fileformats/tiff/pc260001.tif")
@@ -50,3 +50,52 @@ doAssert grayInt16Image.data[2].r == 255
 doAssert floatImage.width == 1
 doAssert floatImage.height == 1
 doAssert floatImage.data[0].r == 128
+
+block:
+  proc addLe16(data: var string, value: int) =
+    data.add(char(value and 0xff))
+    data.add(char((value shr 8) and 0xff))
+
+  proc addLe32(data: var string, value: int) =
+    data.add(char(value and 0xff))
+    data.add(char((value shr 8) and 0xff))
+    data.add(char((value shr 16) and 0xff))
+    data.add(char((value shr 24) and 0xff))
+
+  proc addIfdEntry(
+    data: var string,
+    tag, fieldType, numValues, valueOrOffset: int
+  ) =
+    data.addLe16(tag)
+    data.addLe16(fieldType)
+    data.addLe32(numValues)
+    data.addLe32(valueOrOffset)
+
+  const
+    ifdOffset = 8
+    entryCount = 9
+    colorMapOffset = ifdOffset + 2 + entryCount * 12 + 4
+    pixelDataOffset = colorMapOffset + 6
+
+  var payload = ""
+  payload.add("II")
+  payload.addLe16(42)
+  payload.addLe32(ifdOffset)
+  payload.addLe16(entryCount)
+  payload.addIfdEntry(0x0100, 4, 1, 1) # ImageWidth
+  payload.addIfdEntry(0x0101, 4, 1, 1) # ImageLength
+  payload.addIfdEntry(0x0102, 3, 1, 8) # BitsPerSample
+  payload.addIfdEntry(0x0103, 3, 1, 1) # Compression = none
+  payload.addIfdEntry(0x0106, 3, 1, 3) # PhotometricInterpretation = palette
+  payload.addIfdEntry(0x0111, 4, 1, pixelDataOffset)
+  payload.addIfdEntry(0x0116, 4, 1, 1) # RowsPerStrip
+  payload.addIfdEntry(0x0117, 4, 1, 1) # StripByteCounts
+  payload.addIfdEntry(0x0140, 3, 3, colorMapOffset)
+  payload.addLe32(0)
+  payload.addLe16(0)
+  payload.addLe16(0)
+  payload.addLe16(0)
+  payload.add(char(0x01))
+
+  doAssertRaises PixieError:
+    discard decodeTiff(payload)

tests/tests.nim

@@ -1,4 +1,5 @@
 import
+  test_base64,
   test_bmp,
   test_contexts,
   test_fonts,