react-native-ensys-camera-x 1.0.7

package/android/src/main/java/com/customcamera/gif/GifDecoder.kt

@@ -0,0 +1,690 @@
+package com.customcamera.gif
+
+import android.graphics.Bitmap
+
+/**
+ * Dependency-free decoder for animated (and static) GIF87a / GIF89a images.
+ *
+ * This is a faithful Kotlin port of the canonical public-domain animated-GIF decoder in the
+ * Kevin Weiner / `com.bumptech.glide.gifdecoder` lineage, itself derived from the GIF89a
+ * specification. It parses an entire GIF held in memory and produces fully-composited
+ * ARGB_8888 [Bitmap] frames, honouring per-frame delays, transparency, interlacing and all four
+ * GIF disposal methods.
+ *
+ * Only [android.graphics.Bitmap] and the standard Kotlin/Java runtime are used, so there are no
+ * third-party dependencies. Target: minSdk 24. Malformed input yields a non-OK status / `null`
+ * rather than throwing.
+ *
+ * One-shot usage:
+ * ```
+ * val gif = GifDecoder.decodeAll(bytes, maxDimension = 1024) ?: return
+ * // gif.frames, gif.delaysMs, gif.loopCount, gif.width, gif.height
+ * ```
+ * Manual usage:
+ * ```
+ * val decoder = GifDecoder()
+ * if (decoder.read(bytes) == GifDecoder.STATUS_OK) {
+ *   val first = decoder.getFrame(0)
+ * }
+ * ```
+ */
+class GifDecoder {
+
+  /** Logical screen width in pixels (valid after a successful [read]). */
+  var width: Int = 0
+    private set
+
+  /** Logical screen height in pixels (valid after a successful [read]). */
+  var height: Int = 0
+    private set
+
+  /** Number of frames successfully decoded from the current stream. */
+  var frameCount: Int = 0
+    private set
+
+  /**
+   * Netscape/Animexts loop count. `0` means "loop forever" and is also the default when the
+   * extension is absent.
+   */
+  var loopCount: Int = 0
+    private set
+
+  /** Current read status; one of [STATUS_OK], [STATUS_FORMAT_ERROR], [STATUS_OPEN_ERROR]. */
+  private var status: Int = STATUS_OK
+
+  // --- Raw input ------------------------------------------------------------
+  private var rawData: ByteArray = ByteArray(0)
+  private var rawPos: Int = 0
+
+  // --- Global (logical screen) descriptor -----------------------------------
+  private var gctFlag: Boolean = false
+  private var gctSize: Int = 0
+  private var gct: IntArray? = null
+  private var bgIndex: Int = 0
+  private var bgColor: Int = 0
+
+  // --- Current frame descriptor ---------------------------------------------
+  private var lctFlag: Boolean = false
+  private var interlace: Boolean = false
+  private var lctSize: Int = 0
+  private var lct: IntArray? = null
+  private var act: IntArray? = null
+  private var ix: Int = 0
+  private var iy: Int = 0
+  private var iw: Int = 0
+  private var ih: Int = 0
+  private var dispose: Int = 0
+  private var transparency: Boolean = false
+  private var transIndex: Int = 0
+  private var delay: Int = 0
+
+  // --- Previous frame tracking (for disposal) -------------------------------
+  private var lastDispose: Int = 0
+  private var lrx: Int = 0
+  private var lry: Int = 0
+  private var lrw: Int = 0
+  private var lrh: Int = 0
+  private var hasPreviousFrame: Boolean = false
+
+  // --- Composition buffers --------------------------------------------------
+  /** Persistent ARGB canvas reused across frames; each frame is composited here. */
+  private var mainScratch: IntArray = IntArray(0)
+
+  /** Snapshot of the last "leave in place" canvas, used to service DISPOSAL_PREVIOUS restores. */
+  private var previousImage: IntArray? = null
+
+  /** Decoded colour-table indices for the current frame. */
+  private var pixels: ByteArray? = null
+
+  // --- LZW working storage --------------------------------------------------
+  private var prefix: ShortArray? = null
+  private var suffix: ByteArray? = null
+  private var pixelStack: ByteArray? = null
+  private val block: ByteArray = ByteArray(256)
+  private var blockSize: Int = 0
+
+  // --- Decoded results ------------------------------------------------------
+  private val framesList: MutableList<Bitmap> = ArrayList()
+  private val delaysList: MutableList<Int> = ArrayList()
+
+  /**
+   * Parses an entire GIF from an in-memory byte array.
+   *
+   * @param data the complete GIF file bytes, or `null`.
+   * @return [STATUS_OK] on success, [STATUS_OPEN_ERROR] if [data] is null, or [STATUS_FORMAT_ERROR]
+   *   if the bytes are not a decodable GIF.
+   */
+  fun read(data: ByteArray?): Int {
+    init()
+    if (data == null) {
+      status = STATUS_OPEN_ERROR
+      return status
+    }
+    rawData = data
+    rawPos = 0
+    try {
+      readHeader()
+      if (!err()) {
+        if (width <= 0 || height <= 0 ||
+          width.toLong() * height.toLong() > Int.MAX_VALUE.toLong()) {
+          status = STATUS_FORMAT_ERROR
+        } else {
+          mainScratch = IntArray(width * height)
+          readContents()
+          if (frameCount < 0) status = STATUS_FORMAT_ERROR
+        }
+      }
+    } catch (e: Exception) {
+      status = STATUS_FORMAT_ERROR
+    }
+    return status
+  }
+
+  /**
+   * Returns the fully-composited ARGB_8888 bitmap for frame [n] (0-based), with all preceding
+   * frames' disposal methods already applied, or `null` if [n] is out of range.
+   */
+  fun getFrame(n: Int): Bitmap? {
+    return if (n in 0 until frameCount && n < framesList.size) framesList[n] else null
+  }
+
+  /**
+   * Returns the display delay for frame [n] in milliseconds. Frames that specify a zero/absent
+   * delay report [DEFAULT_FRAME_DELAY_MS] (100 ms).
+   */
+  fun getDelay(n: Int): Int {
+    return if (n in 0 until frameCount && n < delaysList.size) delaysList[n] else DEFAULT_FRAME_DELAY_MS
+  }
+
+  // ---------------------------------------------------------------------------
+  // Parsing
+  // ---------------------------------------------------------------------------
+
+  private fun init() {
+    status = STATUS_OK
+    frameCount = 0
+    loopCount = 0
+    framesList.clear()
+    delaysList.clear()
+    gct = null
+    lct = null
+    act = null
+    previousImage = null
+    pixels = null
+    hasPreviousFrame = false
+    dispose = 0
+    lastDispose = 0
+    transparency = false
+    delay = 0
+    bgColor = 0
+    bgIndex = 0
+  }
+
+  private fun err(): Boolean = status != STATUS_OK
+
+  /** Reads the 6-byte signature, then the logical screen descriptor + global colour table. */
+  private fun readHeader() {
+    val id = StringBuilder()
+    for (i in 0 until 6) {
+      id.append((readByte() and 0xff).toChar())
+    }
+    if (!id.toString().startsWith("GIF")) {
+      status = STATUS_FORMAT_ERROR
+      return
+    }
+    readLSD()
+    if (gctFlag && !err()) {
+      gct = readColorTable(gctSize)
+      val table = gct
+      bgColor = if (table != null && bgIndex < table.size) table[bgIndex] else 0
+    }
+  }
+
+  /** Logical Screen Descriptor: screen size, global colour table flags, background index. */
+  private fun readLSD() {
+    width = readShort()
+    height = readShort()
+    val packed = readByte()
+    gctFlag = (packed and 0x80) != 0
+    gctSize = 2 shl (packed and 7) // 2^(N+1)
+    bgIndex = readByte()
+    readByte() // pixel aspect ratio (unused)
+  }
+
+  /** Reads a colour table of [ncolors] RGB triples into a 256-entry opaque-ARGB array. */
+  private fun readColorTable(ncolors: Int): IntArray? {
+    val nbytes = 3 * ncolors
+    if (ncolors <= 0 || rawPos + nbytes > rawData.size) {
+      status = STATUS_FORMAT_ERROR
+      return null
+    }
+    val tab = IntArray(256) // full size to avoid index bounds checks on lookup
+    var i = 0
+    var j = rawPos
+    while (i < ncolors) {
+      val r = rawData[j++].toInt() and 0xff
+      val g = rawData[j++].toInt() and 0xff
+      val b = rawData[j++].toInt() and 0xff
+      tab[i++] = 0xFF000000.toInt() or (r shl 16) or (g shl 8) or b
+    }
+    rawPos += nbytes
+    return tab
+  }
+
+  /** Main block loop: images, extensions and the trailer. */
+  private fun readContents() {
+    var done = false
+    while (!done && !err()) {
+      when (readByte()) {
+        0x2C -> readImage() // image separator
+        0x21 -> { // extension introducer
+          when (readByte()) {
+            0xF9 -> readGraphicControlExt()
+            0xFF -> { // application extension
+              readBlock()
+              val app = StringBuilder()
+              for (i in 0 until 11) {
+                app.append((block[i].toInt() and 0xff).toChar())
+              }
+              if (app.toString() == "NETSCAPE2.0") readNetscapeExt() else skip()
+            }
+            else -> skip() // comment / plain-text / unknown extension
+          }
+        }
+        0x3B -> done = true // trailer
+        0x00 -> { /* stray byte: tolerate and continue */ }
+        else -> status = STATUS_FORMAT_ERROR
+      }
+    }
+  }
+
+  /** Graphic Control Extension: disposal method, transparency flag/index and frame delay. */
+  private fun readGraphicControlExt() {
+    readByte() // block size (always 4)
+    val packed = readByte()
+    dispose = (packed and 0x1C) shr 2 // 0=unspecified 1=none 2=background 3=previous
+    transparency = (packed and 1) != 0
+    delay = readShort() * 10 // centiseconds -> milliseconds
+    transIndex = readByte()
+    readByte() // block terminator
+  }
+
+  /** Netscape 2.0 application extension: the animation loop count (0 = forever). */
+  private fun readNetscapeExt() {
+    do {
+      readBlock()
+      if (blockSize >= 3 && block[0].toInt() == 1) {
+        val b1 = block[1].toInt() and 0xff
+        val b2 = block[2].toInt() and 0xff
+        loopCount = (b2 shl 8) or b1
+      }
+    } while (blockSize > 0 && !err())
+  }
+
+  /** Image Descriptor + optional local colour table + LZW pixel data for one frame. */
+  private fun readImage() {
+    ix = readShort()
+    iy = readShort()
+    iw = readShort()
+    ih = readShort()
+
+    val packed = readByte()
+    lctFlag = (packed and 0x80) != 0
+    interlace = (packed and 0x40) != 0
+    lctSize = 2 shl (packed and 7)
+
+    if (lctFlag) {
+      lct = readColorTable(lctSize)
+      act = lct
+    } else {
+      act = gct
+    }
+
+    var save = 0
+    val active = act
+    if (transparency && active != null && transIndex < active.size) {
+      save = active[transIndex]
+      active[transIndex] = 0 // render the transparent index as fully transparent
+    }
+
+    if (act == null) {
+      status = STATUS_FORMAT_ERROR
+      return
+    }
+    if (err()) return
+
+    decodeImageData()
+    skip()
+    if (err()) return
+
+    setPixels()
+    framesList.add(Bitmap.createBitmap(mainScratch, width, height, Bitmap.Config.ARGB_8888))
+    delaysList.add(if (delay > 0) delay else DEFAULT_FRAME_DELAY_MS)
+    frameCount++
+
+    val active2 = act
+    if (transparency && active2 != null && transIndex < active2.size) {
+      active2[transIndex] = save // restore the shared colour-table entry
+    }
+    resetFrame()
+  }
+
+  /** Carries the just-drawn frame's disposal state forward as the "previous" state. */
+  private fun resetFrame() {
+    lastDispose = dispose
+    lrx = ix
+    lry = iy
+    lrw = iw
+    lrh = ih
+    hasPreviousFrame = true
+    dispose = 0
+    transparency = false
+    delay = 0
+    lct = null
+  }
+
+  // ---------------------------------------------------------------------------
+  // Compositing
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Composites the freshly-decoded [pixels] onto [mainScratch]. First the *previous* frame's
+   * disposal method is applied to the persistent canvas, then this frame's sub-rectangle is
+   * blitted (de-interlacing and skipping transparent pixels). Finally the canvas is snapshotted
+   * when this frame "leaves in place", so a later DISPOSAL_PREVIOUS frame can restore it.
+   */
+  private fun setPixels() {
+    val dest = mainScratch
+    val size = dest.size
+
+    // First frame starts from a clean, fully-transparent canvas.
+    if (!hasPreviousFrame) {
+      previousImage = null
+      java.util.Arrays.fill(dest, 0)
+    }
+
+    // DISPOSAL_PREVIOUS with nothing saved to restore to -> clear.
+    if (hasPreviousFrame && lastDispose == DISPOSAL_PREVIOUS && previousImage == null) {
+      java.util.Arrays.fill(dest, 0)
+    }
+
+    // Apply the previous frame's disposal to the canvas before drawing this frame.
+    if (hasPreviousFrame && lastDispose > DISPOSAL_UNSPECIFIED) {
+      if (lastDispose == DISPOSAL_BACKGROUND) {
+        var c = 0
+        if (!transparency) {
+          c = bgColor
+          if (lct != null && bgIndex == transIndex) c = 0
+        }
+        val topLeft = lry * width + lrx
+        val bottomLeft = topLeft + lrh * width
+        var left = topLeft
+        while (left < bottomLeft) {
+          val right = left + lrw
+          var p = left
+          while (p < right) {
+            if (p in 0 until size) dest[p] = c
+            p++
+          }
+          left += width
+        }
+      } else if (lastDispose == DISPOSAL_PREVIOUS) {
+        val prev = previousImage
+        if (prev != null && prev.size == size) System.arraycopy(prev, 0, dest, 0, size)
+      }
+    }
+
+    // Blit this frame's sub-rectangle onto the canvas, de-interlacing as required.
+    val px = pixels ?: return
+    val actLocal = act ?: return
+    var pass = 1
+    var inc = 8
+    var iline = 0
+    var i = 0
+    while (i < ih) {
+      var line = i
+      if (interlace) {
+        if (iline >= ih) {
+          pass++
+          when (pass) {
+            2 -> iline = 4
+            3 -> { iline = 2; inc = 4 }
+            4 -> { iline = 1; inc = 2 }
+          }
+        }
+        line = iline
+        iline += inc
+      }
+      line += iy
+      if (line < height) {
+        val k = line * width
+        var dx = k + ix
+        var dlim = dx + iw
+        if (k + width < dlim) dlim = k + width // clamp to the logical screen edge
+        var sx = i * iw
+        while (dx < dlim) {
+          if (sx < px.size) {
+            val index = px[sx].toInt() and 0xff
+            if (index < actLocal.size) {
+              val c = actLocal[index]
+              if (c != 0 && dx >= 0 && dx < size) dest[dx] = c // c == 0 means transparent
+            }
+          }
+          sx++
+          dx++
+        }
+      }
+      i++
+    }
+
+    // Snapshot the canvas so a later DISPOSAL_PREVIOUS frame can restore this state.
+    if (dispose == DISPOSAL_UNSPECIFIED || dispose == DISPOSAL_NONE) {
+      var prev = previousImage
+      if (prev == null || prev.size != size) {
+        prev = IntArray(size)
+        previousImage = prev
+      }
+      System.arraycopy(dest, 0, prev, 0, size)
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // LZW decompression
+  // ---------------------------------------------------------------------------
+
+  /** Classic table-based LZW decode of the image data sub-blocks into [pixels]. */
+  private fun decodeImageData() {
+    val nullCode = -1
+    if (iw <= 0 || ih <= 0 || iw.toLong() * ih.toLong() > Int.MAX_VALUE.toLong()) {
+      status = STATUS_FORMAT_ERROR
+      return
+    }
+    val npix = iw * ih
+
+    var pxArr = pixels
+    if (pxArr == null || pxArr.size < npix) {
+      pxArr = ByteArray(npix)
+      pixels = pxArr
+    }
+    var pfx = prefix
+    if (pfx == null) { pfx = ShortArray(MAX_STACK_SIZE); prefix = pfx }
+    var sfx = suffix
+    if (sfx == null) { sfx = ByteArray(MAX_STACK_SIZE); suffix = sfx }
+    var pst = pixelStack
+    if (pst == null) { pst = ByteArray(MAX_STACK_SIZE + 1); pixelStack = pst }
+
+    val dataSize = readByte()
+    if (dataSize < 1 || dataSize > 8) { // guard the code-size shift against malformed input
+      status = STATUS_FORMAT_ERROR
+      return
+    }
+    val clear = 1 shl dataSize
+    val endOfInformation = clear + 1
+    var available = clear + 2
+    var oldCode = nullCode
+    var codeSize = dataSize + 1
+    var codeMask = (1 shl codeSize) - 1
+
+    var code = 0
+    while (code < clear) {
+      pfx[code] = 0
+      sfx[code] = code.toByte()
+      code++
+    }
+
+    var datum = 0
+    var bits = 0
+    var count = 0
+    var first = 0
+    var top = 0
+    var pi = 0
+    var bi = 0
+    var i = 0
+
+    while (i < npix) {
+      if (top == 0) {
+        if (bits < codeSize) {
+          if (count == 0) {
+            // Read the next data sub-block.
+            count = readBlock()
+            if (count <= 0) break
+            bi = 0
+          }
+          datum += (block[bi].toInt() and 0xff) shl bits
+          bits += 8
+          bi++
+          count--
+          continue
+        }
+
+        // Get the next code.
+        code = datum and codeMask
+        datum = datum shr codeSize
+        bits -= codeSize
+
+        // Interpret the code.
+        if (code > available || code == endOfInformation) break
+        if (code == clear) {
+          // Reset the decoder.
+          codeSize = dataSize + 1
+          codeMask = (1 shl codeSize) - 1
+          available = clear + 2
+          oldCode = nullCode
+          continue
+        }
+        if (oldCode == nullCode) {
+          pst[top++] = sfx[code]
+          oldCode = code
+          first = code
+          continue
+        }
+        val inCode = code
+        if (code == available) {
+          pst[top++] = first.toByte()
+          code = oldCode
+        }
+        while (code > clear) {
+          pst[top++] = sfx[code]
+          code = pfx[code].toInt()
+        }
+        first = sfx[code].toInt() and 0xff
+
+        // Add a new string to the table.
+        if (available >= MAX_STACK_SIZE) break
+        pst[top++] = first.toByte()
+        pfx[available] = oldCode.toShort()
+        sfx[available] = first.toByte()
+        available++
+        if ((available and codeMask) == 0 && available < MAX_STACK_SIZE) {
+          codeSize++
+          codeMask += available
+        }
+        oldCode = inCode
+      }
+      // Pop a pixel off the pixel stack into the output.
+      top--
+      pxArr[pi++] = pst[top]
+      i++
+    }
+
+    // Zero any pixels a truncated stream failed to produce.
+    while (pi < npix) {
+      pxArr[pi++] = 0
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Low-level byte / block reads
+  // ---------------------------------------------------------------------------
+
+  /** Reads one length-prefixed sub-block into [block]; returns the number of bytes read. */
+  private fun readBlock(): Int {
+    blockSize = readByte()
+    var n = 0
+    if (blockSize > 0) {
+      while (n < blockSize) {
+        val remaining = rawData.size - rawPos
+        if (remaining <= 0) break
+        val count = if (blockSize - n < remaining) blockSize - n else remaining
+        System.arraycopy(rawData, rawPos, block, n, count)
+        rawPos += count
+        n += count
+      }
+      if (n < blockSize) status = STATUS_FORMAT_ERROR
+    }
+    return n
+  }
+
+  /** Consumes sub-blocks until the block terminator (a zero-length block). */
+  private fun skip() {
+    do {
+      readBlock()
+    } while (blockSize > 0 && !err())
+  }
+
+  /** Reads a single unsigned byte, flagging a format error past end-of-data. */
+  private fun readByte(): Int {
+    if (rawPos >= rawData.size) {
+      status = STATUS_FORMAT_ERROR
+      return 0
+    }
+    return rawData[rawPos++].toInt() and 0xff
+  }
+
+  /** Reads a little-endian unsigned 16-bit value. */
+  private fun readShort(): Int = readByte() or (readByte() shl 8)
+
+  companion object {
+    /** [read] status: success. */
+    const val STATUS_OK = 0
+
+    /** [read] status: the data could not be parsed as a GIF. */
+    const val STATUS_FORMAT_ERROR = 1
+
+    /** [read] status: no input was supplied. */
+    const val STATUS_OPEN_ERROR = 2
+
+    /** Maximum number of LZW codes (12-bit code space). */
+    private const val MAX_STACK_SIZE = 4096
+
+    /** Fallback per-frame delay when a GIF specifies a zero / absent delay. */
+    private const val DEFAULT_FRAME_DELAY_MS = 100
+
+    // GIF89a disposal methods.
+    private const val DISPOSAL_UNSPECIFIED = 0
+    private const val DISPOSAL_NONE = 1
+    private const val DISPOSAL_BACKGROUND = 2
+    private const val DISPOSAL_PREVIOUS = 3
+
+    /**
+     * Convenience one-shot decode of every frame.
+     *
+     * @param data the complete GIF bytes.
+     * @param maxDimension when > 0, any composited frame whose larger side exceeds this value is
+     *   proportionally down-scaled (and the full-size frame recycled) so its larger side equals
+     *   [maxDimension].
+     * @return a [DecodedGif], or `null` on decode failure or if there are no frames.
+     */
+    fun decodeAll(data: ByteArray, maxDimension: Int = 0): DecodedGif? {
+      return try {
+        val decoder = GifDecoder()
+        decoder.read(data)
+        if (decoder.frameCount <= 0) return null
+        val frames = ArrayList<Bitmap>(decoder.frameCount)
+        val delays = ArrayList<Int>(decoder.frameCount)
+        for (i in 0 until decoder.frameCount) {
+          var frame = decoder.getFrame(i) ?: continue
+          if (maxDimension > 0) {
+            val larger = if (frame.width > frame.height) frame.width else frame.height
+            if (larger > maxDimension) {
+              val scale = maxDimension.toFloat() / larger.toFloat()
+              val newW = Math.max(1, Math.round(frame.width * scale))
+              val newH = Math.max(1, Math.round(frame.height * scale))
+              val scaled = Bitmap.createScaledBitmap(frame, newW, newH, true)
+              if (scaled != frame) frame.recycle()
+              frame = scaled
+            }
+          }
+          frames.add(frame)
+          delays.add(decoder.getDelay(i))
+        }
+        if (frames.isEmpty()) null
+        else DecodedGif(frames, delays, decoder.loopCount, decoder.width, decoder.height)
+      } catch (e: Exception) {
+        null
+      }
+    }
+  }
+
+  /**
+   * Result of [decodeAll]: the composited [frames], their per-frame [delaysMs], the animation
+   * [loopCount] (0 = loop forever) and the logical [width] / [height] of the GIF.
+   */
+  data class DecodedGif(
+    val frames: List<Bitmap>,
+    val delaysMs: List<Int>,
+    val loopCount: Int,
+    val width: Int,
+    val height: Int
+  )
+}