react-native-ensys-camera-x 1.0.7

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

@@ -0,0 +1,473 @@
+package com.customcamera.gif
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import java.io.BufferedOutputStream
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.OutputStream
+
+/**
+ * Encodes one or more [Bitmap] frames into an animated GIF89a.
+ *
+ * Faithful Kotlin/Android port of Kevin Weiner's public-domain AnimatedGifEncoder (v1.03,
+ * November 2003), which uses [NeuQuant] for 256-colour quantization and [LZWEncoder] for the
+ * GIF-variant LZW pixel compression. It emits a GIF89a with a Netscape 2.0 looping application
+ * extension when the repeat count is >= 0, a per-frame 256-colour palette, optional transparency,
+ * and per-frame disposal codes.
+ *
+ * Typical use:
+ * ```
+ * val e = AnimatedGifEncoder()
+ * e.start(outputStream)
+ * e.setRepeat(0)   // loop forever
+ * e.setDelay(100)  // 100 ms between frames
+ * e.addFrame(bitmap1)
+ * e.addFrame(bitmap2)
+ * e.finish()
+ * ```
+ *
+ * This is a syntax-only translation to idiomatic Kotlin; the emitted bytes are intended to be
+ * equivalent to the canonical Java implementation. The only Android-specific part is
+ * [getImagePixels], which reads pixels from a [Bitmap] instead of an AWT BufferedImage.
+ */
+class AnimatedGifEncoder {
+
+  private var width = 0 // image size
+  private var height = 0
+  private var transparent = -1 // transparent color if given
+  private var transIndex = 0 // transparent index in color table
+  private var repeat = -1 // -1 = no repeat, 0 = forever
+  private var delay = 0 // frame delay (hundredths)
+  private var started = false // ready to output frames
+  private var out: OutputStream? = null
+  private var image: Bitmap? = null // current frame
+  private var pixels: ByteArray? = null // BGR byte array from frame
+  private var indexedPixels: ByteArray? = null // converted frame indexed to palette
+  private var colorDepth = 0 // number of bit planes
+  private var colorTab: ByteArray? = null // RGB palette
+  private val usedEntry = BooleanArray(256) // active palette entries
+  private var palSize = 7 // color table size (bits - 1)
+  private var dispose = -1 // disposal code (-1 = use default)
+  private var closeStream = false // close stream when finished
+  private var firstFrame = true
+  private var sizeSet = false // if false, get size from first frame
+  private var sample = 10 // default sample interval for quantizer
+
+  /**
+   * Sets the delay between frames (applies to the last frame added and subsequent frames).
+   * @param ms delay in milliseconds
+   */
+  fun setDelay(ms: Int) {
+    delay = Math.round(ms / 10.0f)
+  }
+
+  /**
+   * Sets the GIF frame disposal code for the last added frame and any subsequent frames.
+   */
+  fun setDispose(code: Int) {
+    if (code >= 0) {
+      dispose = code
+    }
+  }
+
+  /**
+   * Sets the number of times the frame set should be played. 0 means loop forever. Must be called
+   * before the first frame is added.
+   */
+  fun setRepeat(iter: Int) {
+    if (iter >= 0) {
+      repeat = iter
+    }
+  }
+
+  /**
+   * Sets the transparent colour (an RRGGBB value) for the last added frame and subsequent frames.
+   */
+  fun setTransparent(c: Int) {
+    transparent = c
+  }
+
+  /**
+   * Adds the next GIF frame. The frame is preprocessed immediately (quantized and indexed) and the
+   * corresponding GIF blocks are written. On the first frame the logical screen descriptor, global
+   * palette and (if looping) the Netscape extension are written first. Returns true on success.
+   */
+  fun addFrame(im: Bitmap?): Boolean {
+    if (im == null || !started) {
+      return false
+    }
+    var ok = true
+    try {
+      if (!sizeSet) {
+        // use first frame's size
+        setSize(im.width, im.height)
+      }
+      image = im
+      getImagePixels() // convert to correct format if necessary
+      analyzePixels() // build color table & map pixels
+      if (firstFrame) {
+        writeLSD() // logical screen descriptor
+        writePalette() // global color table
+        if (repeat >= 0) {
+          // use NS app extension to indicate reps
+          writeNetscapeExt()
+        }
+      }
+      writeGraphicCtrlExt() // write graphic control extension
+      writeImageDesc() // image descriptor
+      if (!firstFrame) {
+        writePalette() // local color table
+      }
+      writePixels() // encode and write pixel data
+      firstFrame = false
+    } catch (e: IOException) {
+      ok = false
+    }
+    return ok
+  }
+
+  /**
+   * Flushes any pending data and writes the GIF trailer. Closes the stream only when it was opened
+   * by [start] with a file name. Resets internal state so the encoder can be reused. Returns false
+   * if the encoder was never started.
+   */
+  fun finish(): Boolean {
+    if (!started) return false
+    var ok = true
+    started = false
+    try {
+      out!!.write(0x3b) // gif trailer
+      out!!.flush()
+      if (closeStream) {
+        out!!.close()
+      }
+    } catch (e: IOException) {
+      ok = false
+    }
+
+    // reset for subsequent use
+    transIndex = 0
+    out = null
+    image = null
+    pixels = null
+    indexedPixels = null
+    colorTab = null
+    closeStream = false
+    firstFrame = true
+
+    return ok
+  }
+
+  /**
+   * Sets the frame rate in frames per second. Equivalent to a delay of 1000/fps milliseconds.
+   */
+  fun setFrameRate(fps: Float) {
+    if (fps != 0f) {
+      delay = Math.round(100f / fps)
+    }
+  }
+
+  /**
+   * Sets the quantization quality (1 = best/slowest). Values below 1 are clamped to 1. Higher
+   * values sample fewer pixels, trading quality for speed. Takes effect on the next added frame.
+   */
+  fun setQuality(quality: Int) {
+    var q = quality
+    if (q < 1) q = 1
+    sample = q
+  }
+
+  /**
+   * Sets the fixed GIF frame size. Ignored once the first frame has been written; if never called,
+   * the size of the first frame is used.
+   */
+  fun setSize(w: Int, h: Int) {
+    if (started && !firstFrame) return
+    width = w
+    height = h
+    if (width < 1) width = 320
+    if (height < 1) height = 240
+    sizeSet = true
+  }
+
+  /**
+   * Initiates GIF creation on the given output stream. The caller retains ownership of the stream
+   * (it is not closed by [finish]). Returns true on success.
+   */
+  fun start(os: OutputStream?): Boolean {
+    if (os == null) return false
+    var ok = true
+    closeStream = false
+    out = os
+    try {
+      writeString("GIF89a") // header
+    } catch (e: IOException) {
+      ok = false
+    }
+    started = ok
+    return started
+  }
+
+  /**
+   * Initiates writing of a GIF file with the specified name. The stream is created and owned by the
+   * encoder and will be closed by [finish]. Returns true on success.
+   */
+  fun start(file: String): Boolean {
+    var ok = true
+    try {
+      out = BufferedOutputStream(FileOutputStream(file))
+      ok = start(out)
+      closeStream = true
+    } catch (e: IOException) {
+      ok = false
+    }
+    started = ok
+    return started
+  }
+
+  /**
+   * Analyzes the current frame's colours with [NeuQuant] and creates the palette plus the indexed
+   * pixel data. The NeuQuant palette is produced in BGR order and swapped to RGB here.
+   */
+  private fun analyzePixels() {
+    val pix = pixels!!
+    val len = pix.size
+    val nPix = len / 3
+    val indexed = ByteArray(nPix)
+    val nq = NeuQuant(pix, len, sample)
+    // initialize quantizer, create reduced palette
+    val tab = nq.process()
+    // convert map from BGR to RGB
+    var i = 0
+    while (i < tab.size) {
+      val temp = tab[i]
+      tab[i] = tab[i + 2]
+      tab[i + 2] = temp
+      usedEntry[i / 3] = false
+      i += 3
+    }
+    // map image pixels to new palette
+    var k = 0
+    for (j in 0 until nPix) {
+      val index = nq.map(
+        pix[k++].toInt() and 0xff,
+        pix[k++].toInt() and 0xff,
+        pix[k++].toInt() and 0xff
+      )
+      usedEntry[index] = true
+      indexed[j] = index.toByte()
+    }
+    colorTab = tab
+    indexedPixels = indexed
+    pixels = null
+    colorDepth = 8
+    palSize = 7
+    // get closest match to transparent color if specified
+    if (transparent != -1) {
+      transIndex = findClosest(transparent)
+    }
+  }
+
+  /**
+   * Returns the index of the palette colour closest to [c] (an RRGGBB value), considering only
+   * palette entries actually used by the current frame. Returns -1 if there is no palette yet.
+   */
+  private fun findClosest(c: Int): Int {
+    val tab = colorTab ?: return -1
+    val r = (c shr 16) and 0xff
+    val g = (c shr 8) and 0xff
+    val b = (c shr 0) and 0xff
+    var minpos = 0
+    var dmin = 256 * 256 * 256
+    val len = tab.size
+    var i = 0
+    while (i < len) {
+      val dr = r - (tab[i++].toInt() and 0xff)
+      val dg = g - (tab[i++].toInt() and 0xff)
+      val db = b - (tab[i].toInt() and 0xff)
+      val d = dr * dr + dg * dg + db * db
+      val index = i / 3
+      if (usedEntry[index] && d < dmin) {
+        dmin = d
+        minpos = index
+      }
+      i++
+    }
+    return minpos
+  }
+
+  /**
+   * Extracts the current frame's pixels into [pixels] in BGR order (blue first), matching the
+   * channel order [NeuQuant] expects. The bitmap is redrawn onto a correctly sized ARGB_8888
+   * canvas first when its dimensions differ from the target GIF size.
+   */
+  private fun getImagePixels() {
+    val src = image!!
+    var bmp = src
+    val w = src.width
+    val h = src.height
+    if (w != width || h != height) {
+      // create a new image with the right size
+      val temp = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+      val canvas = Canvas(temp)
+      canvas.drawBitmap(src, 0f, 0f, null)
+      bmp = temp
+      image = temp
+    }
+    val count = width * height
+    val intPixels = IntArray(count)
+    bmp.getPixels(intPixels, 0, width, 0, 0, width, height)
+    val bgr = ByteArray(count * 3)
+    for (i in 0 until count) {
+      val pixel = intPixels[i]
+      bgr[i * 3 + 0] = (pixel and 0xff).toByte() // blue
+      bgr[i * 3 + 1] = ((pixel shr 8) and 0xff).toByte() // green
+      bgr[i * 3 + 2] = ((pixel shr 16) and 0xff).toByte() // red
+    }
+    pixels = bgr
+  }
+
+  /**
+   * Writes the Graphic Control Extension: frame delay, disposal method and transparency flag.
+   */
+  @Throws(IOException::class)
+  private fun writeGraphicCtrlExt() {
+    val o = out!!
+    o.write(0x21) // extension introducer
+    o.write(0xf9) // GCE label
+    o.write(4) // data block size
+    val transp: Int
+    var disp: Int
+    if (transparent == -1) {
+      transp = 0
+      disp = 0 // dispose = no action
+    } else {
+      transp = 1
+      disp = 2 // force clear if using transparent color
+    }
+    if (dispose >= 0) {
+      disp = dispose and 7 // user override
+    }
+    disp = disp shl 2
+
+    // packed fields
+    o.write(
+      0 or // 1:3 reserved
+        disp or // 4:6 disposal
+        0 or // 7 user input - 0 = none
+        transp // 8 transparency flag
+    )
+
+    writeShort(delay) // delay x 1/100 sec
+    o.write(transIndex) // transparent color index
+    o.write(0) // block terminator
+  }
+
+  /**
+   * Writes the Image Descriptor. The first frame relies on the global colour table; later frames
+   * flag a local colour table.
+   */
+  @Throws(IOException::class)
+  private fun writeImageDesc() {
+    val o = out!!
+    o.write(0x2c) // image separator
+    writeShort(0) // image position x,y = 0,0
+    writeShort(0)
+    writeShort(width) // image size
+    writeShort(height)
+    // packed fields
+    if (firstFrame) {
+      // no LCT - GCT is used for first (or only) frame
+      o.write(0)
+    } else {
+      // specify normal LCT
+      o.write(
+        0x80 or // 1 local color table  1=yes
+          0 or // 2 interlace - 0=no
+          0 or // 3 sorted - 0=no
+          0 or // 4-5 reserved
+          palSize // 6-8 size of color table
+      )
+    }
+  }
+
+  /**
+   * Writes the Logical Screen Descriptor (canvas size and global colour table flags).
+   */
+  @Throws(IOException::class)
+  private fun writeLSD() {
+    val o = out!!
+    // logical screen size
+    writeShort(width)
+    writeShort(height)
+    // packed fields
+    o.write(
+      0x80 or // 1   : global color table flag = 1 (gct used)
+        0x70 or // 2-4 : color resolution = 7
+        0x00 or // 5   : gct sort flag = 0
+        palSize // 6-8 : gct size
+    )
+    o.write(0) // background color index
+    o.write(0) // pixel aspect ratio - assume 1:1
+  }
+
+  /**
+   * Writes the Netscape 2.0 application extension that defines the loop/repeat count.
+   */
+  @Throws(IOException::class)
+  private fun writeNetscapeExt() {
+    val o = out!!
+    o.write(0x21) // extension introducer
+    o.write(0xff) // app extension label
+    o.write(11) // block size
+    writeString("NETSCAPE" + "2.0") // app id + auth code
+    o.write(3) // sub-block size
+    o.write(1) // loop sub-block id
+    writeShort(repeat) // loop count (extra iterations, 0 = repeat forever)
+    o.write(0) // block terminator
+  }
+
+  /**
+   * Writes the colour table, padded with zeros to a full 256 entries (768 bytes).
+   */
+  @Throws(IOException::class)
+  private fun writePalette() {
+    val o = out!!
+    val tab = colorTab!!
+    o.write(tab, 0, tab.size)
+    val n = 3 * 256 - tab.size
+    for (i in 0 until n) {
+      o.write(0)
+    }
+  }
+
+  /**
+   * Encodes and writes the indexed pixel data via [LZWEncoder].
+   */
+  @Throws(IOException::class)
+  private fun writePixels() {
+    val encoder = LZWEncoder(width, height, indexedPixels!!, colorDepth)
+    encoder.encode(out!!)
+  }
+  /**
+   * Writes a 16-bit value to the output stream, least-significant byte first.
+   */
+  @Throws(IOException::class)
+  private fun writeShort(value: Int) {
+    val o = out!!
+    o.write(value and 0xff)
+    o.write((value shr 8) and 0xff)
+  }
+
+  /**
+   * Writes each character of [s] to the output stream as a single (low) byte.
+   */
+  @Throws(IOException::class)
+  private fun writeString(s: String) {
+    val o = out!!
+    for (i in 0 until s.length) {
+      o.write(s[i].code)
+    }
+  }
+}