From 6fada3fb936f89f0b85626a8e5c32ee2746128ac Mon Sep 17 00:00:00 2001
From: tateisu <tateisu@gmail.com>
Date: Sat, 27 Jan 2018 20:00:44 +0900
Subject: [PATCH] =?UTF-8?q?APNG=E3=83=87=E3=82=B3=E3=83=BC=E3=83=80?=
 =?UTF-8?q?=E3=81=ABjapng=E3=82=92=E5=88=A9=E7=94=A8=E3=81=99=E3=82=8B?=
 =?UTF-8?q?=E3=81=AE=E3=82=92=E3=82=84=E3=82=81=E3=81=A6=E3=80=81=E3=83=95?=
 =?UTF-8?q?=E3=83=AB=E3=82=B9=E3=82=AF=E3=83=A9=E3=83=83=E3=83=81=E3=81=A7?=
 =?UTF-8?q?=E6=9B=B8=E3=81=8D=E8=B5=B7=E3=81=93=E3=81=97=E3=81=9F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .idea/gradle.xml                              |   1 +
 .idea/modules.xml                             |   1 +
 apng/.gitignore                               |   1 +
 apng/build.gradle                             |  12 +
 apng/src/main/java/jp/juggler/apng/Apng.kt    |   9 +
 .../jp/juggler/apng/ApngAnimationControl.kt   |  32 +
 .../java/jp/juggler/apng/ApngBackground.kt    |  37 +
 .../main/java/jp/juggler/apng/ApngBitmap.kt   |  35 +
 .../main/java/jp/juggler/apng/ApngChunk.kt    |  39 +
 .../main/java/jp/juggler/apng/ApngDecoder.kt  | 147 +++
 .../jp/juggler/apng/ApngDecoderCallback.kt    |   9 +
 .../main/java/jp/juggler/apng/ApngEnums.kt    |  46 +
 .../java/jp/juggler/apng/ApngFrameControl.kt  |  43 +
 .../java/jp/juggler/apng/ApngImageHeader.kt   |  39 +
 .../main/java/jp/juggler/apng/ApngPalette.kt  |  29 +
 .../jp/juggler/apng/ApngTransparentColor.kt   |  24 +
 .../main/java/jp/juggler/apng/IdatDecoder.kt  | 612 +++++++++++
 .../main/java/jp/juggler/apng/ParseError.kt   |   3 +
 .../java/jp/juggler/apng/util/BufferPool.kt   |  15 +
 .../jp/juggler/apng/util/ByteArrayQueue.kt    |  40 +
 .../jp/juggler/apng/util/ByteArrayRange.kt    |   7 +
 .../juggler/apng/util/ByteArrayTokenizer.kt   |  55 +
 .../jp/juggler/apng/util/StreamTokenizer.kt   |  66 ++
 app/build.gradle                              |   2 +
 app/libs/japng-0.5.1.jar                      | Bin 67635 -> 0 bytes
 .../subwaytooter/span/NetworkEmojiSpan.kt     |   4 +-
 .../juggler/subwaytooter/util/APNGFrames.kt   | 966 ++++++++++++------
 .../subwaytooter/util/CustomEmojiCache.kt     |  18 +-
 .../subwaytooter/view/NetworkEmojiView.kt     |   4 +-
 settings.gradle                               |   2 +-
 30 files changed, 1983 insertions(+), 315 deletions(-)
 create mode 100644 apng/.gitignore
 create mode 100644 apng/build.gradle
 create mode 100644 apng/src/main/java/jp/juggler/apng/Apng.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/ApngAnimationControl.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/ApngBackground.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/ApngBitmap.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/ApngChunk.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/ApngDecoder.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/ApngDecoderCallback.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/ApngEnums.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/ApngFrameControl.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/ApngImageHeader.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/ApngPalette.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/ApngTransparentColor.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/IdatDecoder.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/ParseError.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/util/BufferPool.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/util/ByteArrayQueue.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/util/ByteArrayRange.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/util/ByteArrayTokenizer.kt
 create mode 100644 apng/src/main/java/jp/juggler/apng/util/StreamTokenizer.kt
 delete mode 100644 app/libs/japng-0.5.1.jar

diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 4f58a394..76bada1a 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -8,6 +8,7 @@
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />
+            <option value="$PROJECT_DIR$/apng" />
             <option value="$PROJECT_DIR$/app" />
             <option value="$PROJECT_DIR$/colorpicker" />
             <option value="$PROJECT_DIR$/emoji" />
diff --git a/.idea/modules.xml b/.idea/modules.xml
index 56dce11c..02444022 100644
--- a/.idea/modules.xml
+++ b/.idea/modules.xml
@@ -3,6 +3,7 @@
   <component name="ProjectModuleManager">
     <modules>
       <module fileurl="file://$PROJECT_DIR$/SubwayTooter.iml" filepath="$PROJECT_DIR$/SubwayTooter.iml" />
+      <module fileurl="file://$PROJECT_DIR$/apng/apng.iml" filepath="$PROJECT_DIR$/apng/apng.iml" />
       <module fileurl="file://$PROJECT_DIR$/app/app.iml" filepath="$PROJECT_DIR$/app/app.iml" />
       <module fileurl="file://$PROJECT_DIR$/colorpicker/colorpicker.iml" filepath="$PROJECT_DIR$/colorpicker/colorpicker.iml" />
       <module fileurl="file://$PROJECT_DIR$/emoji/emoji.iml" filepath="$PROJECT_DIR$/emoji/emoji.iml" />
diff --git a/apng/.gitignore b/apng/.gitignore
new file mode 100644
index 00000000..3543521e
--- /dev/null
+++ b/apng/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/apng/build.gradle b/apng/build.gradle
new file mode 100644
index 00000000..b467a0a5
--- /dev/null
+++ b/apng/build.gradle
@@ -0,0 +1,12 @@
+apply plugin: 'java-library'
+apply plugin: 'kotlin'
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
+}
+
+sourceCompatibility = "1.7"
+targetCompatibility = "1.7"
+
+
diff --git a/apng/src/main/java/jp/juggler/apng/Apng.kt b/apng/src/main/java/jp/juggler/apng/Apng.kt
new file mode 100644
index 00000000..c65c3b24
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/Apng.kt
@@ -0,0 +1,9 @@
+package jp.juggler.apng
+
+class Apng {
+    var header: ApngImageHeader? = null
+    var background: ApngBackground? = null
+    var animationControl: ApngAnimationControl? = null
+    internal var palette: ApngPalette? = null
+    internal var transparentColor: ApngTransparentColor? = null
+}
diff --git a/apng/src/main/java/jp/juggler/apng/ApngAnimationControl.kt b/apng/src/main/java/jp/juggler/apng/ApngAnimationControl.kt
new file mode 100644
index 00000000..15790e79
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/ApngAnimationControl.kt
@@ -0,0 +1,32 @@
+@file:Suppress("JoinDeclarationAndAssignment", "MemberVisibilityCanBePrivate")
+
+package jp.juggler.apng
+
+import jp.juggler.apng.util.ByteArrayTokenizer
+
+
+class ApngAnimationControl internal constructor(bat: ByteArrayTokenizer) {
+
+    companion object {
+        const val PLAY_INDEFINITELY =0
+    }
+
+    // This must equal the number of `fcTL` chunks.
+    // 0 is not a valid value.
+    // 1 is a valid value for a single-frame APNG.
+    val numFrames: Int
+
+    //  if it is 0, the animation should play indefinitely.
+    // If nonzero, the animation should come to rest on the final frame at the end of the last play.
+    val numPlays: Int
+
+    init {
+        numFrames = bat.readInt32()
+        numPlays = bat.readInt32()
+    }
+
+    override fun toString() ="ApngAnimationControl(numFrames=$numFrames,numPlays=$numPlays)"
+    
+    val isPlayIndefinitely :Boolean
+        get() = numPlays == PLAY_INDEFINITELY
+}
diff --git a/apng/src/main/java/jp/juggler/apng/ApngBackground.kt b/apng/src/main/java/jp/juggler/apng/ApngBackground.kt
new file mode 100644
index 00000000..58c12128
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/ApngBackground.kt
@@ -0,0 +1,37 @@
+@file:Suppress("JoinDeclarationAndAssignment", "MemberVisibilityCanBePrivate")
+
+package jp.juggler.apng
+
+import jp.juggler.apng.util.ByteArrayTokenizer
+
+class ApngBackground internal constructor(colorType: ColorType, bat: ByteArrayTokenizer) {
+
+    val red: Int
+    val green: Int
+    val blue: Int
+    val index: Int
+
+    init {
+        when (colorType) {
+            ColorType.GREY, ColorType.GREY_ALPHA -> {
+                val v = bat.readUInt16()
+                red = v
+                green = v
+                blue = v
+                index = -1
+            }
+            ColorType.RGB, ColorType.RGBA -> {
+                red = bat.readUInt16()
+                green = bat.readUInt16()
+                blue = bat.readUInt16()
+                index = -1
+            }
+            ColorType.INDEX -> {
+                red = -1
+                green = -1
+                blue = -1
+                index = bat.readUInt8()
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/apng/src/main/java/jp/juggler/apng/ApngBitmap.kt b/apng/src/main/java/jp/juggler/apng/ApngBitmap.kt
new file mode 100644
index 00000000..912137a5
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/ApngBitmap.kt
@@ -0,0 +1,35 @@
+package jp.juggler.apng
+
+class ApngBitmap(var width: Int, var height: Int) {
+
+    val colors = IntArray( width * height)
+
+    fun reset(width: Int, height: Int) {
+        val newSize = width * height
+        if( newSize > colors.size )
+            throw ParseError("can't resize to ${width}x${height} , it's greater than initial size")
+        this.width = width
+        this.height = height
+        colors.fill( 0,fromIndex = 0,toIndex = newSize)
+    }
+
+    inner class Pointer(private var pos: Int) {
+
+        fun plusX(x: Int): Pointer {
+            pos += x
+            return this
+        }
+
+        fun setPixel(a: Int, r: Int, g: Int, b: Int): Pointer {
+            colors[pos] = ((a and 255) shl 24) or ((r and 255) shl 16) or ((g and 255) shl 8) or (b and 255)
+            return this
+        }
+
+        fun setPixel(a: Byte, r: Byte, g: Byte, b: Byte): Pointer {
+            colors[pos] = ((a.toInt() and 255) shl 24) or ((r.toInt() and 255) shl 16) or ((g.toInt() and 255) shl 8) or (b.toInt() and 255)
+            return this
+        }
+    }
+
+    fun pointer(x: Int, y: Int) = Pointer( x + y * width )
+}
diff --git a/apng/src/main/java/jp/juggler/apng/ApngChunk.kt b/apng/src/main/java/jp/juggler/apng/ApngChunk.kt
new file mode 100644
index 00000000..e1d33f9b
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/ApngChunk.kt
@@ -0,0 +1,39 @@
+@file:Suppress("JoinDeclarationAndAssignment")
+
+package jp.juggler.apng
+
+import jp.juggler.apng.util.StreamTokenizer
+import java.util.zip.CRC32
+
+internal class ApngChunk(crc32:CRC32,tokenizer: StreamTokenizer) {
+    val size: Int
+    val type: String
+
+    init {
+        size = tokenizer.readInt32()
+        val typeBytes = tokenizer.readBytes(4)
+        type = typeBytes.toString(Charsets.UTF_8)
+
+        crc32.update(typeBytes)
+    }
+
+    fun readBody(crc32:CRC32,tokenizer: StreamTokenizer): ByteArray {
+        val bytes = tokenizer.readBytes(size)
+        val crcExpect = tokenizer.readUInt32()
+
+        crc32.update(bytes, 0, size)
+        val crcActual = crc32.value
+        if (crcActual != crcExpect) throw ParseError("CRC not match.")
+
+        return bytes
+    }
+
+    fun skipBody(tokenizer: StreamTokenizer) {
+        tokenizer.skipBytes((size + 4).toLong())
+    }
+
+    fun checkCRC(tokenizer: StreamTokenizer, crcActual: Long) {
+        val crcExpect = tokenizer.readUInt32()
+        if (crcActual != crcExpect) throw ParseError("CRC not match.")
+    }
+}
diff --git a/apng/src/main/java/jp/juggler/apng/ApngDecoder.kt b/apng/src/main/java/jp/juggler/apng/ApngDecoder.kt
new file mode 100644
index 00000000..cab1d065
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/ApngDecoder.kt
@@ -0,0 +1,147 @@
+@file:Suppress("JoinDeclarationAndAssignment")
+
+package jp.juggler.apng
+
+import jp.juggler.apng.util.BufferPool
+import jp.juggler.apng.util.ByteArrayTokenizer
+import jp.juggler.apng.util.StreamTokenizer
+import java.io.InputStream
+import java.util.zip.CRC32
+
+object ApngDecoder {
+
+    private val PNG_SIGNATURE = byteArrayOf(0x89.toByte(), 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0a)
+
+    fun parseStream(
+            _inStream: InputStream,
+            callback: ApngDecoderCallback
+    ) {
+        val apng = Apng()
+        val tokenizer = StreamTokenizer(_inStream)
+
+        val pngHeader = tokenizer.readBytes(8)
+        if (!pngHeader.contentEquals(PNG_SIGNATURE)) {
+            throw ParseError("header not match")
+        }
+
+        var lastSequenceNumber: Int? = null
+        fun checkSequenceNumber(n: Int) {
+            val last = lastSequenceNumber
+            if (last != null && n <= last) {
+                throw ParseError("incorrect sequenceNumber. last=$lastSequenceNumber,current=$n")
+            }
+            lastSequenceNumber = n
+        }
+
+        val inBuffer = ByteArray(4096)
+        val inflateBufferPool = BufferPool(8192)
+        var idatDecoder: IdatDecoder? = null
+        var fdatDecoder: IdatDecoder? = null
+        val crc32 = CRC32()
+        var lastFctl: ApngFrameControl? = null
+        var bitmap: ApngBitmap? = null
+
+        loop@ while (true) {
+            crc32.reset()
+            val chunk = ApngChunk(crc32, tokenizer)
+            when (chunk.type) {
+
+                "IEND" -> break@loop
+
+                "IHDR" -> {
+                    val header = ApngImageHeader(ByteArrayTokenizer(chunk.readBody(crc32, tokenizer)))
+                    bitmap = ApngBitmap(header.width, header.height)
+                    apng.header = header
+                    callback.onHeader(apng, header)
+                }
+
+                "PLTE" -> apng.palette = ApngPalette(chunk.readBody(crc32, tokenizer))
+
+                "bKGD" -> {
+                    val header = apng.header ?: throw ParseError("missing IHDR")
+                    apng.background = ApngBackground(header.colorType, ByteArrayTokenizer(chunk.readBody(crc32, tokenizer)))
+                }
+
+                "tRNS" -> {
+                    val header = apng.header ?: throw ParseError("missing IHDR")
+                    val body = chunk.readBody(crc32, tokenizer)
+                    when (header.colorType) {
+                        ColorType.GREY -> apng.transparentColor = ApngTransparentColor(true, ByteArrayTokenizer(body))
+                        ColorType.RGB -> apng.transparentColor = ApngTransparentColor(false, ByteArrayTokenizer(body))
+                        ColorType.INDEX -> apng.palette?.parseTRNS(body) ?: throw ParseError("missing palette")
+                        else -> callback.log("tRNS ignored. colorType =${header.colorType}")
+                    }
+                }
+
+                "IDAT" -> {
+                    val header = apng.header ?: throw ParseError("missing IHDR")
+                    if (idatDecoder == null) {
+                        bitmap ?: throw ParseError("missing bitmap")
+                        bitmap.reset(header.width, header.height)
+                        idatDecoder = IdatDecoder(apng, bitmap, inflateBufferPool) {
+                            callback.onDefaultImage(apng, bitmap)
+                            val fctl = lastFctl
+                            if (fctl != null) {
+                                // IDATより前にfcTLが登場しているなら、そのfcTLの画像はIDATと同じ
+                                callback.onAnimationFrame(apng, fctl, bitmap)
+                            }
+                        }
+                    }
+                    idatDecoder.addData(
+                            tokenizer.inStream,
+                            chunk.size,
+                            inBuffer,
+                            crc32
+                    )
+                    chunk.checkCRC(tokenizer, crc32.value)
+                }
+
+                "acTL" -> {
+                    val animationControl = ApngAnimationControl(ByteArrayTokenizer(chunk.readBody(crc32, tokenizer)))
+                    apng.animationControl = animationControl
+                    callback.onAnimationInfo(apng, animationControl)
+                }
+
+                "fcTL" -> {
+                    val bat = ByteArrayTokenizer(chunk.readBody(crc32, tokenizer))
+                    checkSequenceNumber(bat.readInt32())
+                    lastFctl = ApngFrameControl(bat)
+                    fdatDecoder = null
+                }
+
+                "fdAT" -> {
+                    val fctl = lastFctl ?: throw ParseError("missing fCTL before fdAT")
+                    if (fdatDecoder == null) {
+                        bitmap ?: throw ParseError("missing bitmap")
+                        bitmap.reset(fctl.width, fctl.height)
+                        fdatDecoder = IdatDecoder(apng, bitmap, inflateBufferPool) {
+                            callback.onAnimationFrame(apng, fctl, bitmap)
+                        }
+                    }
+                    checkSequenceNumber(tokenizer.readInt32(crc32))
+                    fdatDecoder.addData(
+                            tokenizer.inStream,
+                            chunk.size - 4,
+                            inBuffer,
+                            crc32
+                    )
+                    chunk.checkCRC(tokenizer, crc32.value)
+                }
+
+            // 無視するチャンク
+                "cHRM", "gAMA", "iCCP", "sBIT", "sRGB", // color space information
+                "tEXt", "zTXt", "iTXt", // text information
+                "tIME", // timestamp
+                "hIST", // histogram
+                "pHYs", // Physical pixel dimensions
+                "sPLT" //  Suggested palette (おそらく減色用?)
+                -> chunk.skipBody(tokenizer)
+
+                else -> {
+                    callback.log("unknown chunk: type=%s,size=0x%x".format(chunk.type, chunk.size))
+                    chunk.skipBody(tokenizer)
+                }
+            }
+        }
+    }
+}
diff --git a/apng/src/main/java/jp/juggler/apng/ApngDecoderCallback.kt b/apng/src/main/java/jp/juggler/apng/ApngDecoderCallback.kt
new file mode 100644
index 00000000..4a3b2d95
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/ApngDecoderCallback.kt
@@ -0,0 +1,9 @@
+package jp.juggler.apng
+
+interface ApngDecoderCallback{
+    fun onHeader(apng: Apng, header: ApngImageHeader)
+    fun onAnimationInfo(apng: Apng, animationControl: ApngAnimationControl)
+    fun onDefaultImage(apng: Apng, bitmap: ApngBitmap)
+    fun onAnimationFrame(apng: Apng, frameControl: ApngFrameControl, bitmap: ApngBitmap)
+    fun log(message:String)
+}
diff --git a/apng/src/main/java/jp/juggler/apng/ApngEnums.kt b/apng/src/main/java/jp/juggler/apng/ApngEnums.kt
new file mode 100644
index 00000000..c8b46829
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/ApngEnums.kt
@@ -0,0 +1,46 @@
+package jp.juggler.apng
+
+enum class ColorType(val num:Int ){
+    GREY(0),
+    RGB ( 2),
+    INDEX( 3),
+    GREY_ALPHA ( 4),
+    RGBA ( 6),
+}
+
+enum class CompressionMethod(val num:Int ){
+    Standard(0)
+}
+
+enum class FilterMethod(val num:Int ){
+    Standard(0)
+}
+
+enum class InterlaceMethod(val num:Int ){
+    None(0),
+    Standard(1)
+}
+
+enum class FilterType(val num:Int ){
+    None(0),
+    Sub(1),
+    Up(2),
+    Average(3),
+    Paeth(4)
+}
+
+enum class DisposeOp(val num :Int){
+    //no disposal is done on this frame before rendering the next; the contents of the output buffer are left as is.
+    None(0),
+    // the frame's region of the output buffer is to be cleared to fully transparent black before rendering the next frame.
+    Background(1),
+    // the frame's region of the output buffer is to be reverted to the previous contents before rendering the next frame.
+    Previous(2)
+}
+
+enum class BlendOp(val num :Int){
+    // all color components of the frame, including alpha, overwrite the current contents of the frame's output buffer region.
+    Source(0),
+    //  the frame should be composited onto the output buffer based on its alpha, using a simple OVER operation as described in the "Alpha Channel Processing" section of the PNG specification [PNG-1.2].
+    Over(1)
+}
diff --git a/apng/src/main/java/jp/juggler/apng/ApngFrameControl.kt b/apng/src/main/java/jp/juggler/apng/ApngFrameControl.kt
new file mode 100644
index 00000000..cfc60d77
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/ApngFrameControl.kt
@@ -0,0 +1,43 @@
+@file:Suppress("JoinDeclarationAndAssignment", "MemberVisibilityCanBePrivate")
+
+package jp.juggler.apng
+
+import jp.juggler.apng.util.ByteArrayTokenizer
+
+
+class ApngFrameControl internal constructor(bat: ByteArrayTokenizer) {
+
+    val width: Int
+    val height: Int
+    val xOffset: Int
+    val yOffset: Int
+    val delayNum: Int
+    val delayDen: Int
+    val disposeOp: DisposeOp
+    val blendOp: BlendOp
+
+    init {
+        width = bat.readInt32()
+        height = bat.readInt32()
+        xOffset = bat.readInt32()
+        yOffset = bat.readInt32()
+        delayNum = bat.readUInt16()
+        delayDen = bat.readUInt16().let{ if(it==0) 100 else it}
+
+        var num:Int
+
+        num = bat.readUInt8()
+        disposeOp = DisposeOp.values().first{it.num==num}
+
+        num = bat.readUInt8()
+        blendOp = BlendOp.values().first{it.num==num}
+    }
+
+    override fun toString() ="ApngFrameControl(width=$width,height=$height,x=$xOffset,y=$yOffset,delayNum=$delayNum,delayDen=$delayDen,disposeOp=$disposeOp,blendOp=$blendOp)"
+    
+    val delayMilliseconds : Long
+        get() = when(delayDen) {
+	        1000 -> delayNum.toLong()
+	        else -> (1000f * delayNum.toFloat() / delayDen.toFloat() + 0.5f).toLong()
+        }
+}
\ No newline at end of file
diff --git a/apng/src/main/java/jp/juggler/apng/ApngImageHeader.kt b/apng/src/main/java/jp/juggler/apng/ApngImageHeader.kt
new file mode 100644
index 00000000..ae737292
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/ApngImageHeader.kt
@@ -0,0 +1,39 @@
+@file:Suppress("JoinDeclarationAndAssignment", "MemberVisibilityCanBePrivate")
+
+package jp.juggler.apng
+
+import jp.juggler.apng.util.ByteArrayTokenizer
+
+
+class ApngImageHeader internal constructor(bat: ByteArrayTokenizer) {
+    val width: Int
+    val height: Int
+    val bitDepth: Int
+    val colorType: ColorType
+    val compressionMethod: CompressionMethod
+    val filterMethod: FilterMethod
+    val interlaceMethod: InterlaceMethod
+
+    init {
+
+        width = bat.readInt32()
+        height = bat.readInt32()
+        bitDepth = bat.readUInt8()
+
+        var num:Int
+        //
+        num =bat.readUInt8()
+        colorType = ColorType.values().first { it.num==num }
+        //
+        num =bat.readUInt8()
+        compressionMethod = CompressionMethod.values().first { it.num==num }
+        //
+        num =bat.readUInt8()
+        filterMethod = FilterMethod.values().first { it.num==num }
+        //
+        num =bat.readUInt8()
+        interlaceMethod = InterlaceMethod.values().first { it.num==num }
+    }
+
+    override fun toString() = "ApngImageHeader(w=$width,h=$height,bits=$bitDepth,color=$colorType,interlace=$interlaceMethod)"
+}
diff --git a/apng/src/main/java/jp/juggler/apng/ApngPalette.kt b/apng/src/main/java/jp/juggler/apng/ApngPalette.kt
new file mode 100644
index 00000000..8ca82b16
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/ApngPalette.kt
@@ -0,0 +1,29 @@
+@file:Suppress("JoinDeclarationAndAssignment", "MemberVisibilityCanBePrivate")
+
+package jp.juggler.apng
+
+
+class ApngPalette(rgb: ByteArray) {
+    val list: ByteArray
+    var hasAlpha: Boolean = false
+
+    init {
+        val entryCount = rgb.size / 3
+        list = ByteArray(4 * entryCount)
+        for (i in 0 until entryCount) {
+            list[i * 4] = 255.toByte()
+            list[i * 4 + 1] = rgb[i * 3 + 0]
+            list[i * 4 + 2] = rgb[i * 3 + 1]
+            list[i * 4 + 3] = rgb[i * 3 + 2]
+        }
+    }
+
+    override fun toString() = "palette(${list.size} entries,hasAlpha=$hasAlpha)"
+
+    fun parseTRNS(ba: ByteArray) {
+        hasAlpha = true
+        for (i in 0 until Math.min(list.size, ba.size)) {
+            list[i * 4] = ba[i]
+        }
+    }
+}
diff --git a/apng/src/main/java/jp/juggler/apng/ApngTransparentColor.kt b/apng/src/main/java/jp/juggler/apng/ApngTransparentColor.kt
new file mode 100644
index 00000000..042db12b
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/ApngTransparentColor.kt
@@ -0,0 +1,24 @@
+package jp.juggler.apng
+
+import jp.juggler.apng.util.ByteArrayTokenizer
+
+class ApngTransparentColor internal constructor(isGreyScale:Boolean, bat: ByteArrayTokenizer) {
+    val red:Int
+    val green:Int
+    val blue:Int
+    init{
+        if( isGreyScale){
+            val v = bat.readUInt16()
+            red =v
+            green =v
+            blue =v
+        }else{
+            red =bat.readUInt16()
+            green =bat.readUInt16()
+            blue =bat.readUInt16()
+        }
+    }
+
+    fun match(grey:Int) = red == grey
+    fun match(r:Int,g:Int,b:Int) = (r==red && g == green && b == blue)
+}
\ No newline at end of file
diff --git a/apng/src/main/java/jp/juggler/apng/IdatDecoder.kt b/apng/src/main/java/jp/juggler/apng/IdatDecoder.kt
new file mode 100644
index 00000000..9d41e7c6
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/IdatDecoder.kt
@@ -0,0 +1,612 @@
+@file:Suppress("JoinDeclarationAndAssignment")
+
+package jp.juggler.apng
+
+import jp.juggler.apng.util.BufferPool
+import jp.juggler.apng.util.ByteArrayQueue
+import jp.juggler.apng.util.ByteArrayRange
+import java.io.InputStream
+import java.util.*
+import java.util.zip.CRC32
+import java.util.zip.Inflater
+
+internal class IdatDecoder(
+        apng: Apng,
+        private val bitmap: ApngBitmap,
+        private val inflateBufferPool: BufferPool,
+        private val onCompleted: () -> Unit
+) {
+
+    class PassInfo(val xStep: Int, val xStart: Int, val yStep: Int, val yStart: Int)
+
+    companion object {
+
+        private val passInfoList = listOf(
+                PassInfo(1, 0, 1, 0), // [0]:no interlacing
+                PassInfo(8, 0, 8, 0), // Adam7 pass 1
+                PassInfo(8, 4, 8, 0), // Adam7 pass 2
+                PassInfo(4, 0, 8, 4), // Adam7 pass 3
+                PassInfo(4, 2, 4, 0), // Adam7 pass 4
+                PassInfo(2, 0, 4, 2), // Adam7 pass 5
+                PassInfo(2, 1, 2, 0), // Adam7 pass 6
+                PassInfo(1, 0, 2, 1) // Adam7 pass 7
+
+        )
+
+        private fun abs(v: Int) = if (v >= 0) v else -v
+
+        private val dummyPaletteData = ByteArray(0)
+
+        // a = left, b = above, c = upper left
+        private fun paeth(a: Int, b: Int, c: Int): Int {
+            val p = a + b - c
+            val pa = abs(p - a)
+            val pb = abs(p - b)
+            val pc = abs(p - c)
+            return when {
+                (pa <= pb && pa <= pc) -> a
+                (pb <= pc) -> b
+                else -> c
+            }
+        }
+
+        private inline fun scanLine1(baLine: ByteArray, pass_w: Int, block: (v: Int) -> Unit) {
+            var pos = 1
+            var x = 0
+            while (pass_w - x >= 8) {
+                val v = baLine[pos++].toInt()
+                block((v shr 7) and 1)
+                block((v shr 6) and 1)
+                block((v shr 5) and 1)
+                block((v shr 4) and 1)
+                block((v shr 3) and 1)
+                block((v shr 2) and 1)
+                block((v shr 1) and 1)
+                block(v and 1)
+                x += 8
+            }
+            val remain = pass_w - x
+            if (remain > 0) {
+                val v = baLine[pos].toInt()
+                block((v shr 7) and 1)
+                if (remain > 1) block((v shr 6) and 1)
+                if (remain > 2) block((v shr 5) and 1)
+                if (remain > 3) block((v shr 4) and 1)
+                if (remain > 4) block((v shr 3) and 1)
+                if (remain > 5) block((v shr 2) and 1)
+                if (remain > 6) block((v shr 1) and 1)
+            }
+        }
+
+        private inline fun scanLine2(baLine: ByteArray, pass_w: Int, block: (v: Int) -> Unit) {
+            var pos = 1
+            var x = 0
+            while (pass_w - x >= 4) {
+                val v = baLine[pos++].toInt()
+                block((v shr 6) and 3)
+                block((v shr 4) and 3)
+                block((v shr 2) and 3)
+                block(v and 3)
+                x += 4
+            }
+            val remain = pass_w - x
+            if (remain > 0) {
+                val v = baLine[pos].toInt()
+                block((v shr 6) and 3)
+                if (remain > 1) block((v shr 4) and 3)
+                if (remain > 2) block((v shr 2) and 3)
+            }
+        }
+
+        private inline fun scanLine4(baLine: ByteArray, pass_w: Int, block: (v: Int) -> Unit) {
+            var pos = 1
+            var x = 0
+            while (pass_w - x >= 2) {
+                val v = baLine[pos++].toInt()
+                block((v shr 4) and 15)
+                block(v and 15)
+                x += 2
+            }
+            val remain = pass_w - x
+            if (remain > 0) {
+                val v = baLine[pos].toInt()
+                block((v shr 4) and 15)
+            }
+        }
+
+        private inline fun scanLine8(baLine: ByteArray, pass_w: Int, block: (v: Int) -> Unit) {
+            var pos = 1
+            var x = 0
+            while (x < pass_w) {
+                val v = baLine[pos++].toInt()
+                block(v and 255)
+                ++x
+            }
+        }
+
+        private fun parseUInt16(ba: ByteArray, pos: Int): Int {
+            val b0 = ba[pos].toInt() and 255
+            val b1 = ba[pos].toInt() and 255
+            return (b0 shl 8) or b1
+        }
+
+        private inline fun scanLine16(baLine: ByteArray, pass_w: Int, block: (v: Int) -> Unit) {
+            var pos = 1
+            var x = 0
+            while (x < pass_w) {
+                val v = parseUInt16(baLine, pos)
+                pos += 2
+                block(v)
+                ++x
+            }
+        }
+
+        private inline fun scanLineRGB8(baLine: ByteArray, pass_w: Int, block: (r: Int, g: Int, b: Int) -> Unit) {
+            var pos = 1
+            var x = 0
+            while (x < pass_w) {
+                val r = baLine[pos].toInt() and 255
+                val g = baLine[pos + 1].toInt() and 255
+                val b = baLine[pos + 2].toInt() and 255
+                pos += 3
+                block(r, g, b)
+                ++x
+            }
+        }
+
+        private inline fun scanLineRGB16(baLine: ByteArray, pass_w: Int, block: (r: Int, g: Int, b: Int) -> Unit) {
+            var pos = 1
+            var x = 0
+            while (x < pass_w) {
+                val r = parseUInt16(baLine, pos)
+                val g = parseUInt16(baLine, pos + 2)
+                val b = parseUInt16(baLine, pos + 4)
+                pos += 6
+                block(r, g, b)
+                ++x
+            }
+        }
+
+        private inline fun scanLineRGBA8(baLine: ByteArray, pass_w: Int, block: (r: Int, g: Int, b: Int, a: Int) -> Unit) {
+            var pos = 1
+            var x = 0
+            while (x < pass_w) {
+                val r = baLine[pos].toInt() and 255
+                val g = baLine[pos + 1].toInt() and 255
+                val b = baLine[pos + 2].toInt() and 255
+                val a = baLine[pos + 3].toInt() and 255
+                pos += 4
+                block(r, g, b, a)
+                ++x
+            }
+        }
+
+        private inline fun scanLineRGBA16(baLine: ByteArray, pass_w: Int, block: (r: Int, g: Int, b: Int, a: Int) -> Unit) {
+            var pos = 1
+            var x = 0
+            while (x < pass_w) {
+                val r = parseUInt16(baLine, pos)
+                val g = parseUInt16(baLine, pos + 2)
+                val b = parseUInt16(baLine, pos + 4)
+                val a = parseUInt16(baLine, pos + 6)
+                pos += 8
+                block(r, g, b, a)
+                ++x
+            }
+        }
+
+        private inline fun scanLineGA8(baLine: ByteArray, pass_w: Int, block: (g: Int, a: Int) -> Unit) {
+            var pos = 1
+            var x = 0
+            while (x < pass_w) {
+                val g = baLine[pos].toInt() and 255
+                val a = baLine[pos + 1].toInt() and 255
+                pos += 2
+                block(g, a)
+                ++x
+            }
+        }
+
+        private inline fun scanLineGA16(baLine: ByteArray, pass_w: Int, block: (g: Int, a: Int) -> Unit) {
+            var pos = 1
+            var x = 0
+            while (x < pass_w) {
+                val g = parseUInt16(baLine, pos)
+                val a = parseUInt16(baLine, pos + 2)
+                pos += 4
+                block(g, a)
+                ++x
+            }
+        }
+    }
+
+    private val inflater = Inflater()
+    private val bytesQueue = ByteArrayQueue { inflateBufferPool.recycle(it.array) }
+    private val colorType: ColorType
+    private val bitDepth: Int
+    private val plteData: ByteArray
+    private val sampleBits: Int
+    private val sampleBytes: Int
+    private val scanLineBytesMax: Int
+    private val linePool = LinkedList<ByteArray>()
+    private val transparentCheckerGrey: (v: Int) -> Int
+    private val transparentCheckerRGB: (r: Int, g: Int, b: Int) -> Int
+    private val renderScanLineFunc: (baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) -> Unit
+
+    private var pass: Int
+    private lateinit var passInfo: PassInfo
+    private var passWidth: Int = 0
+    private var passHeight: Int = 0
+    private var passY: Int = 0
+    private var scanLineBytes: Int = 0
+    private var baPreviousLine: ByteArray? = null
+    private var isCompleted = false
+
+    init {
+        val header = requireNotNull(apng.header)
+        this.colorType = header.colorType
+        this.bitDepth = header.bitDepth
+
+        this.plteData = if (colorType == ColorType.INDEX) {
+            apng.palette?.list
+                    ?: throw ParseError("missing ApngPalette for index color")
+        } else {
+            dummyPaletteData
+        }
+
+        sampleBits = when (colorType) {
+            ColorType.GREY,ColorType.INDEX -> bitDepth
+            ColorType.GREY_ALPHA -> bitDepth * 2
+            ColorType.RGB -> bitDepth * 3
+            ColorType.RGBA -> bitDepth * 4
+        }
+
+        sampleBytes = (sampleBits + 7) / 8
+        scanLineBytesMax = 1 + (bitmap.width * sampleBits + 7) / 8
+
+        linePool.add(ByteArray(scanLineBytesMax))
+        linePool.add(ByteArray(scanLineBytesMax))
+
+        this.pass = when (header.interlaceMethod) {
+            InterlaceMethod.None -> 0
+            InterlaceMethod.Standard -> 1
+        }
+
+        val transparentColor = apng.transparentColor
+        transparentCheckerGrey = if (transparentColor != null) {
+            { v: Int -> if (transparentColor.match(v)) 0 else 255 }
+        } else {
+            { _: Int -> 255 }
+        }
+
+        transparentCheckerRGB = if (transparentColor != null) {
+            { r: Int, g: Int, b: Int -> if (transparentColor.match(r,g,b)) 0 else 255 }
+        } else {
+            { _: Int, _: Int, _: Int -> 255 }
+        }
+
+        renderScanLineFunc = selectRenderFunc()
+
+        initializePass()
+    }
+
+    private fun renderGrey1(baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) {
+        scanLine1(baLine, passWidth) { v ->
+            val g8 = if (v == 0) 0 else 255
+            val a8 = transparentCheckerGrey(v)
+            bitmapPointer.setPixel(a8, g8, g8, g8)
+                    .plusX(xStep)
+        }
+    }
+
+    private fun renderGrey2(baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) {
+        scanLine2(baLine, passWidth) { v ->
+            val g8 = v or (v shl 2) or (v shl 4) or (v shl 6)
+            val a8 = transparentCheckerGrey(v)
+            bitmapPointer.setPixel(a8, g8, g8, g8)
+                    .plusX(xStep)
+        }
+    }
+
+    private fun renderGrey4(baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) {
+        scanLine4(baLine, passWidth) { v ->
+            val g8 = v or (v shl 4)
+            val a8 = transparentCheckerGrey(v)
+            bitmapPointer.setPixel(a8, g8, g8, g8)
+                    .plusX(xStep)
+        }
+    }
+
+    private fun renderGrey8(baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) {
+        scanLine8(baLine, passWidth) { v ->
+            val a8 = transparentCheckerGrey(v)
+            bitmapPointer.setPixel(a8, v, v, v)
+                    .plusX(xStep)
+        }
+    }
+
+    private fun renderGrey16(baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) {
+        scanLine16(baLine, passWidth) { v ->
+            val g8 = v shr 8
+            val a8 = transparentCheckerGrey(v)
+            bitmapPointer.setPixel(a8, g8, g8, g8)
+                    .plusX(xStep)
+        }
+    }
+
+    private fun renderRGB8(baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) {
+        scanLineRGB8(baLine, passWidth) { r, g, b ->
+            val a8 = transparentCheckerRGB(r, g, b)
+            bitmapPointer.setPixel(a8, r, g, b)
+                    .plusX(xStep)
+        }
+    }
+
+    private fun renderRGB16(baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) {
+        scanLineRGB16(baLine, passWidth) { r, g, b ->
+            val a8 = transparentCheckerRGB(r, g, b)
+            bitmapPointer.setPixel(a8, r shr 8, g shr 8, b shr 8)
+                    .plusX(xStep)
+        }
+    }
+
+    private fun renderIndex1(baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) {
+        scanLine1(baLine, passWidth) { v ->
+            val plteOffset = v * 4
+            bitmapPointer.setPixel(
+                    plteData[plteOffset],
+                    plteData[plteOffset + 1],
+                    plteData[plteOffset + 2],
+                    plteData[plteOffset + 3]
+            )
+                    .plusX(xStep)
+        }
+    }
+
+    private fun renderIndex2(baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) {
+        scanLine2(baLine, passWidth) { v ->
+            val plteOffset = v * 4
+            bitmapPointer.setPixel(
+                    plteData[plteOffset],
+                    plteData[plteOffset + 1],
+                    plteData[plteOffset + 2],
+                    plteData[plteOffset + 3]
+            )
+                    .plusX(xStep)
+        }
+    }
+
+    private fun renderIndex4(baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) {
+        scanLine4(baLine, passWidth) { v ->
+            val plteOffset = v * 4
+            bitmapPointer.setPixel(
+                    plteData[plteOffset],
+                    plteData[plteOffset + 1],
+                    plteData[plteOffset + 2],
+                    plteData[plteOffset + 3]
+            )
+                    .plusX(xStep)
+        }
+    }
+
+    private fun renderIndex8(baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) {
+        scanLine8(baLine, passWidth) { v ->
+            val plteOffset = v * 4
+            bitmapPointer.setPixel(
+                    plteData[plteOffset],
+                    plteData[plteOffset + 1],
+                    plteData[plteOffset + 2],
+                    plteData[plteOffset + 3]
+            )
+                    .plusX(xStep)
+        }
+    }
+
+    private fun renderGA8(baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) {
+        scanLineGA8(baLine, passWidth) { g, a ->
+            bitmapPointer.setPixel(a, g, g, g)
+                    .plusX(xStep)
+        }
+    }
+
+    private fun renderGA16(baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) {
+        scanLineGA16(baLine, passWidth) { g, a ->
+            val g8 = g shr 8
+            bitmapPointer.setPixel(a shr 8, g8, g8, g8)
+                    .plusX(xStep)
+        }
+    }
+
+    private fun renderRGBA8(baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) {
+        scanLineRGBA8(baLine, passWidth) { r, g, b, a ->
+            bitmapPointer.setPixel(a, r, g, b)
+                    .plusX(xStep)
+        }
+    }
+
+    private fun renderRGBA16(baLine: ByteArray, bitmapPointer: ApngBitmap.Pointer, xStep: Int) {
+        scanLineRGBA16(baLine, passWidth) { r, g, b, a ->
+            bitmapPointer.setPixel(a shr 8, r shr 8, g shr 8, b shr 8)
+                    .plusX(xStep)
+        }
+    }
+
+    private fun colorBitsNotSupported(): Nothing {
+        throw ParseError("bitDepth $bitDepth is not supported for $colorType")
+    }
+
+    private fun selectRenderFunc() = when (colorType) {
+        ColorType.GREY -> when (bitDepth) {
+            1 -> ::renderGrey1
+            2 -> ::renderGrey2
+            4 -> ::renderGrey4
+            8 -> ::renderGrey8
+            16 -> ::renderGrey16
+            else -> colorBitsNotSupported()
+        }
+        ColorType.RGB -> when (bitDepth) {
+            8 -> ::renderRGB8
+            16 -> ::renderRGB16
+            else -> colorBitsNotSupported()
+        }
+        ColorType.INDEX -> when (bitDepth) {
+            1 -> ::renderIndex1
+            2 -> ::renderIndex2
+            4 -> ::renderIndex4
+            8 -> ::renderIndex8
+            else -> colorBitsNotSupported()
+        }
+        ColorType.GREY_ALPHA -> when (bitDepth) {
+            8 -> ::renderGA8
+            16 -> ::renderGA16
+            else -> colorBitsNotSupported()
+        }
+        ColorType.RGBA -> when (bitDepth) {
+            8 -> ::renderRGBA8
+            16 -> ::renderRGBA16
+            else -> colorBitsNotSupported()
+        }
+    }
+
+    private fun initializePass() {
+        passInfo = passInfoList[pass]
+        passWidth = (bitmap.width + passInfo.xStep - passInfo.xStart - 1) / passInfo.xStep
+        passHeight = (bitmap.height + passInfo.yStep - passInfo.yStart - 1) / passInfo.yStep
+        passY = 0
+        scanLineBytes = 1 + (passWidth * sampleBits + 7) / 8
+
+        baPreviousLine?.let { linePool.add(it) }
+        baPreviousLine = null
+
+        if (passWidth <= 0 || passHeight <= 0) {
+            incrementPassOrComplete()
+        }
+    }
+
+    private fun incrementPassOrComplete(){
+        if (pass in 1..6) {
+            ++pass
+            initializePass()
+        } else if (!isCompleted) {
+            isCompleted = true
+            onCompleted()
+        }
+    }
+
+
+    private fun readScanLine(): Boolean {
+        if (bytesQueue.remain < scanLineBytes) return false
+
+        val baLine = linePool.removeFirst()
+        bytesQueue.readBytes(baLine, 0, scanLineBytes)
+
+        val filterNum = baLine[0].toInt() and 255
+        val filterType = FilterType.values().first { it.num == filterNum }
+
+        when (filterType) {
+            FilterType.None -> {
+            }
+            FilterType.Sub -> {
+                for (pos in 1 until scanLineBytes) {
+                    val vLeft = if (pos <= sampleBytes) 0 else baLine[pos - sampleBytes].toInt() and 255
+                    val vCur = baLine[pos].toInt() and 255
+                    baLine[pos] = (vCur + vLeft).toByte()
+                }
+            }
+            FilterType.Up -> {
+                for (pos in 1 until scanLineBytes) {
+                    val vUp = (baPreviousLine?.get(pos)?.toInt() ?: 0) and 255
+                    val vCur = baLine[pos].toInt() and 255
+                    baLine[pos] = (vCur + vUp).toByte()
+                }
+            }
+            FilterType.Average -> {
+                for (pos in 1 until scanLineBytes) {
+                    val vLeft = if (pos <= sampleBytes) 0 else baLine[pos - sampleBytes].toInt() and 255
+                    val vUp = (baPreviousLine?.get(pos)?.toInt() ?: 0) and 255
+                    val vCur = baLine[pos].toInt() and 255
+                    baLine[pos] = (vCur + ((vLeft + vUp) shr 1)).toByte()
+                }
+            }
+            FilterType.Paeth -> {
+                for (pos in 1 until scanLineBytes) {
+                    val vLeft = if (pos <= sampleBytes) 0 else baLine[pos - sampleBytes].toInt() and 255
+                    val vUp = (baPreviousLine?.get(pos)?.toInt() ?: 0) and 255
+                    val vUpperLeft = if (pos <= sampleBytes) 0 else (baPreviousLine?.get(pos - sampleBytes)?.toInt()
+                            ?: 0) and 255
+                    val vCur = baLine[pos].toInt() and 255
+                    baLine[pos] = (vCur + paeth(vLeft, vUp, vUpperLeft)).toByte()
+                }
+            }
+        }
+
+        // render scanline
+        renderScanLineFunc(
+                baLine,
+                bitmap.pointer(
+                        passInfo.xStart,
+                        passInfo.yStart + passInfo.yStep * passY
+                ),
+                passInfo.xStep
+        )
+        // save previous line
+        baPreviousLine?.let { linePool.add(it) }
+        baPreviousLine = baLine
+
+        // complete pass?
+        if (++passY >= passHeight) {
+            incrementPassOrComplete()
+        }
+
+        return true
+    }
+
+
+    // returns CRC32 value
+    fun addData(
+            inStream: InputStream,
+            size: Int,
+            inBuffer: ByteArray,
+            crc32: CRC32
+    ){
+        var foundEnd = false
+        var inRemain = size
+        while (inRemain > 0 && !foundEnd) {
+            // read from inStream( max 4096 byte)
+            var nRead = 0
+            val nReadMax = Math.min(inBuffer.size, inRemain)
+            while (nRead < nReadMax) {
+                val delta = inStream.read(inBuffer, nRead, nReadMax - nRead)
+                if (delta < 0) {
+                    foundEnd = true
+                    break
+                }
+                nRead += delta
+            }
+            if (nRead > 0) {
+                inRemain -= nRead
+                crc32.update(inBuffer, 0, nRead)
+
+                // inflate
+                inflater.setInput(inBuffer, 0, nRead)
+                while (!inflater.needsInput()) {
+                    val inflateBuffer = inflateBufferPool.obtain()
+                    val delta = inflater.inflate(inflateBuffer)
+                    if (delta > 0) {
+                        bytesQueue.add(ByteArrayRange(inflateBuffer, 0, delta))
+                    } else {
+                        inflateBufferPool.recycle(inflateBuffer)
+                    }
+                }
+
+                // read scanLine
+                while (!isCompleted && readScanLine()) {
+                }
+
+                if (isCompleted) {
+                    bytesQueue.clear()
+                }
+            }
+        }
+    }
+}
diff --git a/apng/src/main/java/jp/juggler/apng/ParseError.kt b/apng/src/main/java/jp/juggler/apng/ParseError.kt
new file mode 100644
index 00000000..7b569c73
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/ParseError.kt
@@ -0,0 +1,3 @@
+package jp.juggler.apng
+
+class ParseError(message: String) : IllegalArgumentException(message)
diff --git a/apng/src/main/java/jp/juggler/apng/util/BufferPool.kt b/apng/src/main/java/jp/juggler/apng/util/BufferPool.kt
new file mode 100644
index 00000000..a358ffd8
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/util/BufferPool.kt
@@ -0,0 +1,15 @@
+package jp.juggler.apng.util
+
+import java.util.*
+
+internal class BufferPool(private val arraySize:Int){
+    private val list =LinkedList<ByteArray>()
+
+    fun recycle(array: ByteArray) {
+        list.add( array)
+    }
+
+    fun obtain(): ByteArray {
+        return if( list.isEmpty() ) ByteArray(arraySize) else list.removeFirst()
+    }
+}
\ No newline at end of file
diff --git a/apng/src/main/java/jp/juggler/apng/util/ByteArrayQueue.kt b/apng/src/main/java/jp/juggler/apng/util/ByteArrayQueue.kt
new file mode 100644
index 00000000..935ed554
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/util/ByteArrayQueue.kt
@@ -0,0 +1,40 @@
+package jp.juggler.apng.util
+
+import java.util.*
+
+internal class ByteArrayQueue(private val bufferRecycler :(ByteArrayRange)->Unit) {
+
+    private val list = LinkedList<ByteArrayRange>()
+
+    val remain: Int
+        get() = list.sumBy { it.remain }
+
+    fun add(range: ByteArrayRange) {
+        list.add(range)
+    }
+
+    fun clear() {
+        for( item in list ){
+            bufferRecycler(item)
+        }
+        list.clear()
+    }
+
+    fun readBytes(dst: ByteArray, offset: Int, length: Int): Int {
+        var nRead = 0
+        while (nRead < length && list.isNotEmpty()) {
+            val item = list.first()
+            if (item.remain <= 0) {
+                bufferRecycler(item)
+                list.removeFirst()
+            } else {
+                val delta = Math.min(item.remain, length - nRead)
+                System.arraycopy(item.array, item.start, dst, offset + nRead, delta)
+                item.start += delta
+                item.remain -= delta
+                nRead += delta
+            }
+        }
+        return nRead
+    }
+}
diff --git a/apng/src/main/java/jp/juggler/apng/util/ByteArrayRange.kt b/apng/src/main/java/jp/juggler/apng/util/ByteArrayRange.kt
new file mode 100644
index 00000000..e4125e5f
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/util/ByteArrayRange.kt
@@ -0,0 +1,7 @@
+package jp.juggler.apng.util
+
+internal class ByteArrayRange(
+        val array: ByteArray,
+        var start: Int,
+        var remain: Int
+)
diff --git a/apng/src/main/java/jp/juggler/apng/util/ByteArrayTokenizer.kt b/apng/src/main/java/jp/juggler/apng/util/ByteArrayTokenizer.kt
new file mode 100644
index 00000000..18c76dc8
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/util/ByteArrayTokenizer.kt
@@ -0,0 +1,55 @@
+package jp.juggler.apng.util
+
+import jp.juggler.apng.ParseError
+
+
+internal class ByteArrayTokenizer(ba: ByteArray) {
+    private val array: ByteArray = ba
+    private val arraySize: Int = ba.size
+    private var pos = 0
+
+    val size: Int
+        get()= arraySize
+
+    val remain: Int
+        get()= arraySize -pos
+
+    fun skipBytes(size: Int) {
+        pos += size
+    }
+
+    fun readBytes(size: Int): ByteArrayRange {
+        if (pos + size > arraySize) {
+            throw ParseError("readBytes: unexpected EoS")
+        }
+        val result = ByteArrayRange(array, pos, size)
+        pos+=size
+        return result
+    }
+
+    private fun readByte(): Int {
+        if (pos >=  arraySize) {
+            throw ParseError("readBytes: unexpected EoS")
+        }
+        return array[pos++].toInt() and 0xff
+    }
+
+    fun readInt32(): Int {
+        val b0 = readByte()
+        val b1 = readByte()
+        val b2 = readByte()
+        val b3 = readByte()
+
+        return (b0 shl 24) or (b1 shl 16) or (b2 shl 8) or b3
+    }
+
+    fun readUInt16(): Int {
+        val b0 = readByte()
+        val b1 = readByte()
+        return (b0 shl 8) or b1
+    }
+
+    fun readUInt8() = readByte()
+
+
+}
\ No newline at end of file
diff --git a/apng/src/main/java/jp/juggler/apng/util/StreamTokenizer.kt b/apng/src/main/java/jp/juggler/apng/util/StreamTokenizer.kt
new file mode 100644
index 00000000..c5e45500
--- /dev/null
+++ b/apng/src/main/java/jp/juggler/apng/util/StreamTokenizer.kt
@@ -0,0 +1,66 @@
+package jp.juggler.apng.util
+
+import jp.juggler.apng.ParseError
+import java.io.InputStream
+import java.util.zip.CRC32
+
+internal class StreamTokenizer(val inStream: InputStream) {
+
+    fun skipBytes(size: Long) {
+        var nRead = 0L
+        while (true) {
+            val remain = size - nRead
+            if (remain <= 0) break
+            val delta = inStream.skip(size - nRead)
+            if (delta <= 0) throw ParseError("skipBytes: unexpected EoS")
+            nRead += delta
+        }
+    }
+
+    fun readBytes(size: Int): ByteArray {
+        val dst = ByteArray(size)
+        var nRead = 0
+        while (true) {
+            val remain = size - nRead
+            if (remain <= 0) break
+            val delta = inStream.read(dst, nRead, size - nRead)
+            if (delta < 0) throw ParseError("readBytes: unexpected EoS")
+            nRead += delta
+        }
+        return dst
+    }
+
+    private fun readByte(): Int {
+        val b = inStream.read()
+        if( b == -1 ) throw ParseError("readBytes: unexpected EoS")
+        return b and 0xff
+    }
+
+    fun readInt32(): Int {
+        val b0 = readByte()
+        val b1 = readByte()
+        val b2 = readByte()
+        val b3 = readByte()
+
+        return (b0 shl 24) or (b1 shl 16) or (b2 shl 8) or b3
+    }
+
+    fun readInt32(crc32: CRC32): Int {
+        val ba = readBytes(4)
+        crc32.update(ba)
+        val b0 = ba[0].toInt() and 255
+        val b1 = ba[1].toInt() and 255
+        val b2 = ba[2].toInt() and 255
+        val b3 = ba[3].toInt() and 255
+
+        return (b0 shl 24) or (b1 shl 16) or (b2 shl 8) or b3
+    }
+
+    fun readUInt32(): Long {
+        val b0 = readByte()
+        val b1 = readByte()
+        val b2 = readByte()
+        val b3 = readByte()
+        return (b0.toLong() shl 24) or ((b1 shl 16) or (b2 shl 8) or b3).toLong()
+    }
+}
\ No newline at end of file
diff --git a/app/build.gradle b/app/build.gradle
index 63118ee4..097bbb08 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -67,6 +67,7 @@ dependencies {
     compile project(':exif')
     compile project(':colorpicker')
     compile project(':emoji')
+    compile project(':apng')
 
     compile 'com.android.support:support-v4:27.0.2'
     compile 'com.android.support:appcompat-v7:27.0.2'
@@ -82,6 +83,7 @@ dependencies {
     testCompile "org.jetbrains.kotlin:kotlin-test:$kotlin_version"
     testCompile 'junit:junit:4.12' // しばらくはjunitと併用
 
+    // compile 'org.jetbrains.kotlinx:kotlinx-coroutines-core:0.21.2'
 
     compile 'uk.co.chrisjenx:calligraphy:2.3.0'
     compile 'com.github.woxthebox:draglistview:1.5.1'
diff --git a/app/libs/japng-0.5.1.jar b/app/libs/japng-0.5.1.jar
deleted file mode 100644
index 4385746f780260717586641d113f7689b2c953a1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 67635
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

diff --git a/app/src/main/java/jp/juggler/subwaytooter/span/NetworkEmojiSpan.kt b/app/src/main/java/jp/juggler/subwaytooter/span/NetworkEmojiSpan.kt
index 6c03c3a1..3a1aed11 100644
--- a/app/src/main/java/jp/juggler/subwaytooter/span/NetworkEmojiSpan.kt
+++ b/app/src/main/java/jp/juggler/subwaytooter/span/NetworkEmojiSpan.kt
@@ -9,7 +9,7 @@ import android.text.style.ReplacementSpan
 
 import jp.juggler.subwaytooter.App1
 import jp.juggler.subwaytooter.Pref
-import jp.juggler.subwaytooter.util.APNGFrames
+import jp.juggler.subwaytooter.util.ApngFrames
 import jp.juggler.subwaytooter.util.LogCategory
 import java.lang.ref.WeakReference
 
@@ -31,7 +31,7 @@ class NetworkEmojiSpan internal constructor(private val url : String) : Replacem
 	private var refDrawTarget : WeakReference<Any>? = null
 	
 	// フレーム探索結果を格納する構造体を確保しておく
-	private val mFrameFindResult = APNGFrames.FindFrameResult()
+	private val mFrameFindResult = ApngFrames.FindFrameResult()
 	
 	init {
 		mPaint.isFilterBitmap = true
diff --git a/app/src/main/java/jp/juggler/subwaytooter/util/APNGFrames.kt b/app/src/main/java/jp/juggler/subwaytooter/util/APNGFrames.kt
index 9e52114e..77ac2ae8 100644
--- a/app/src/main/java/jp/juggler/subwaytooter/util/APNGFrames.kt
+++ b/app/src/main/java/jp/juggler/subwaytooter/util/APNGFrames.kt
@@ -6,152 +6,130 @@ import android.graphics.Paint
 import android.graphics.PorterDuff
 import android.graphics.PorterDuffXfermode
 import android.graphics.Rect
-
-import net.ellerton.japng.PngScanlineBuffer
-import net.ellerton.japng.argb8888.Argb8888Bitmap
-import net.ellerton.japng.argb8888.Argb8888Processor
-import net.ellerton.japng.argb8888.Argb8888Processors
-import net.ellerton.japng.argb8888.Argb8888ScanlineProcessor
-import net.ellerton.japng.argb8888.BasicArgb8888Director
-import net.ellerton.japng.chunks.PngAnimationControl
-import net.ellerton.japng.chunks.PngFrameControl
-import net.ellerton.japng.chunks.PngHeader
-import net.ellerton.japng.error.PngException
-import net.ellerton.japng.reader.DefaultPngChunkReader
-import net.ellerton.japng.reader.PngReadHelper
+import android.util.Log
+import jp.juggler.apng.*
 
 import java.io.InputStream
 import java.util.ArrayList
 
-// APNGを解釈した結果を保持する
-// (フレーム数分のbitmapと時間情報)
-
-class APNGFrames {
+class ApngFrames(private val pixelSizeMax : Int = 0) : ApngDecoderCallback {
 	
 	companion object {
 		
-		internal val log = LogCategory("APNGFrames")
+		private const val TAG = "ApngFrames"
 		
 		// ループしない画像の場合は3秒でまたループさせる
 		private const val DELAY_AFTER_END = 3000L
 		
-		/**
-		 * Keep a 1x1 transparent image around as reference for creating a scaled starting bitmap.
-		 * Considering this because of some reported OutOfMemory errors, and this post:
-		 *
-		 *
-		 * http://stackoverflow.com/a/8527745/963195
-		 *
-		 *
-		 * Specifically: "NEVER use Bitmap.createBitmap(width, height, Config.ARGB_8888). I mean NEVER!"
-		 *
-		 *
-		 * Instead the 1x1 image (68 bytes of resources) is scaled up to the needed size.
-		 * Whether or not this fixes the OOM problems is TBD...
-		 */
-		//static Bitmap sOnePxTransparent;
-		internal val sSrcModePaint : Paint by lazy{
+		// アニメーションフレームの描画に使う
+		private val sSrcModePaint : Paint by lazy {
 			val paint = Paint()
 			paint.xfermode = PorterDuffXfermode(PorterDuff.Mode.SRC)
 			paint.isFilterBitmap = true
 			paint
 		}
 		
-		internal fun createBlankBitmap(w : Int, h : Int) : Bitmap {
+		private fun createBlankBitmap(w : Int, h : Int) : Bitmap {
 			return Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
 		}
 		
 		// WARNING: ownership of "src" will be moved or recycled.
-		internal fun scaleBitmap(src : Bitmap?, size_max : Int) : Bitmap? {
+		private fun scaleBitmap(src : Bitmap?, size_max : Int) : Bitmap? {
 			if(src == null) return null
 			
-			val src_w = src.width
-			val src_h = src.height
-			if(src_w <= size_max && src_h <= size_max) return src
+			if(size_max <= 0) return src
 			
-			var dst_w : Int
-			var dst_h : Int
-			if(src_w >= src_h) {
-				dst_w = size_max
-				dst_h = (0.5f + src_h * size_max / src_w.toFloat()).toInt()
-				if(dst_h < 1) dst_h = 1
+			val wSrc = src.width
+			val hSrc = src.height
+			if(wSrc <= size_max && hSrc <= size_max) return src
+			
+			val wDst : Int
+			val hDst : Int
+			if(wSrc >= hSrc) {
+				wDst = size_max
+				hDst = Math.max(
+					1,
+					(size_max.toFloat() * hSrc.toFloat() / wSrc.toFloat() + 0.5f).toInt()
+				)
 			} else {
-				dst_h = size_max
-				dst_w = (0.5f + src_w * size_max / src_h.toFloat()).toInt()
-				if(dst_w < 1) dst_w = 1
+				hDst = size_max
+				wDst = Math.max(
+					1,
+					(size_max.toFloat() * wSrc.toFloat() / hSrc.toFloat() + 0.5f).toInt()
+				)
 			}
 			
-			// この方法だとリークがあるらしい？？？
-			// http://stackoverflow.com/a/8527745/963195
-			// return Bitmap.createScaledBitmap( src, dst_w , dst_h , true );
-			
-			val b2 = createBlankBitmap(dst_w, dst_h)
+			val b2 = createBlankBitmap(wDst, hDst)
 			val canvas = Canvas(b2)
-			val rect_src = Rect(0, 0, src_w, src_h)
-			val rect_dst = Rect(0, 0, dst_w, dst_h)
-			canvas.drawBitmap(src, rect_src, rect_dst, sSrcModePaint)
+			val rectSrc = Rect(0, 0, wSrc, hSrc)
+			val rectDst = Rect(0, 0, wDst, hDst)
+			canvas.drawBitmap(src, rectSrc, rectDst, sSrcModePaint)
 			src.recycle()
 			return b2
 		}
 		
-		internal fun toBitmap(src : Argb8888Bitmap) : Bitmap {
-			val offset = 0
-			val stride = src.width
-			return Bitmap.createBitmap(src.pixelArray, offset, stride, src.width, src.height, Bitmap.Config.ARGB_8888)
+		private fun toBitmap(src : ApngBitmap) : Bitmap {
+			return Bitmap.createBitmap(
+				src.colors, // int[] 配列
+				0, // offset
+				src.width, //stride
+				src.width, // width
+				src.height, //height
+				Bitmap.Config.ARGB_8888
+			)
 		}
 		
-		internal fun toBitmap(src : Argb8888Bitmap, size_max : Int) : Bitmap? {
+		private fun toBitmap(src : ApngBitmap, size_max : Int) : Bitmap? {
 			return scaleBitmap(toBitmap(src), size_max)
 		}
 		
-		/////////////////////////////////////////////////////////////////////
-		
-		// entry point is here
-		@Throws(PngException::class)
-		internal fun parseAPNG( inStream : InputStream, size_max : Int) : APNGFrames? {
-			val handler = APNGParseEventHandler(size_max)
+		@Suppress("unused")
+		fun parseApng(inStream : InputStream, size_max : Int) : ApngFrames {
+			val result = ApngFrames(size_max)
 			try {
-				val processor = Argb8888Processor(handler)
-				val reader = DefaultPngChunkReader(processor)
-				val result = PngReadHelper.read(inStream, reader)
-				result?.onParseComplete()
-				return result
+				ApngDecoder.parseStream(inStream, result)
+				result.onParseComplete()
+				return if( result.defaultImage != null || result.frames?.isNotEmpty() == true ){
+					result
+				}else{
+					throw RuntimeException("APNG has no image")
+				}
 			} catch(ex : Throwable) {
-				handler.dispose()
+				result.dispose()
 				throw ex
 			}
 			
 		}
 	}
 	
-	// ピクセルサイズ制限
-	private var mPixelSizeMax : Int = 0
+	private var header : ApngImageHeader? = null
+	private var animationControl : ApngAnimationControl? = null
 	
-	// APNGじゃなかった場合に使われる
-	private var mBitmapNonAnimation : Bitmap? = null
+	val width : Int
+		get() = header?.width ?: 0
+	
+	val height : Int
+		get() = header?.height ?: 0
+	
+	@Suppress("MemberVisibilityCanBePrivate")
+	val numFrames : Int
+		get() = animationControl?.numFrames ?: 1
+	
+	@Suppress("unused")
+	val hasMultipleFrame : Boolean
+		get() = numFrames > 1
+	
+	private var timeTotal = 0L
 	
-	private lateinit var header : PngHeader
-	private lateinit var scanlineProcessor : Argb8888ScanlineProcessor
 	private lateinit var canvas : Canvas
 	
 	private var canvasBitmap : Bitmap? = null
-	private var currentFrame : PngFrameControl? = null
-	private var animationControl : PngAnimationControl? = null
-	
-	private var time_total = 0L
-	
-	private var frames : ArrayList<Frame>? = null
-	
-	///////////////////////////////////////////////////////////////
 	
 	// 再生速度の調整
 	private var durationScale = 1f
 	
-	private val numFrames : Int
-		get() = animationControl?.numFrames ?: 1
-	
-	val hasMultipleFrame : Boolean
-		get() = numFrames > 1
+	// APNGじゃなかった場合に使われる
+	private var defaultImage : Bitmap? = null
 	
 	private class Frame(
 		internal val bitmap : Bitmap,
@@ -159,39 +137,32 @@ class APNGFrames {
 		internal val time_width : Long
 	)
 	
-	///////////////////////////////////////////////////////////////
+	private var frames : ArrayList<Frame>? = null
 	
-	internal constructor(bitmap : Bitmap) {
-		this.mBitmapNonAnimation = bitmap
+	@Suppress("unused")
+	constructor(bitmap : Bitmap) : this() {
+		this.defaultImage = bitmap
 	}
 	
-	internal constructor(
-		header : PngHeader, scanlineProcessor : Argb8888ScanlineProcessor, animationControl : PngAnimationControl, size_max : Int
-	) {
-		this.header = header
-		this.scanlineProcessor = scanlineProcessor
-		this.animationControl = animationControl
-		this.mPixelSizeMax = size_max
-		
-		this.canvasBitmap = createBlankBitmap(header.width, header.height)
-		this.canvas = Canvas(this.canvasBitmap)
-		this.frames = ArrayList(animationControl.numFrames)
-		
-	}
-	
-	internal fun onParseComplete() {
-		val frames = this.frames
-		
-		if(frames != null && frames.size <= 1) {
-			mBitmapNonAnimation = toBitmap(scanlineProcessor.bitmap, mPixelSizeMax)
-		}
-		
+	private fun onParseComplete() {
 		canvasBitmap?.recycle()
 		canvasBitmap = null
+		
+		val frames = this.frames
+		if( frames != null ){
+			if( frames.size > 1){
+				defaultImage?.recycle()
+				defaultImage = null
+			}else if( frames.size == 1){
+				defaultImage?.recycle()
+				defaultImage = frames.first().bitmap
+				frames.clear()
+			}
+		}
 	}
 	
-	internal fun dispose() {
-		mBitmapNonAnimation?.recycle()
+	fun dispose() {
+		defaultImage?.recycle()
 		canvasBitmap?.recycle()
 		
 		val frames = this.frames
@@ -202,73 +173,177 @@ class APNGFrames {
 		}
 	}
 	
-	// フレームが追加される
-	internal fun beginFrame(frameControl : PngFrameControl) : Argb8888ScanlineProcessor {
-		currentFrame = frameControl
-		return scanlineProcessor.cloneWithSharedBitmap(header.adjustFor(currentFrame))
+	class FindFrameResult {
+		var bitmap : Bitmap? = null // may null
+		var delay : Long = 0 // 再描画が必要ない場合は Long.MAX_VALUE
 	}
 	
-	// フレームが追加される
-	internal fun completeFrame(frameImage : Argb8888Bitmap) {
+	// シーク位置に応じたコマ画像と次のコマまでの残り時間をresultに格納する
+	@Suppress("unused")
+	fun findFrame(result : FindFrameResult, t : Long) {
 		
+		if(defaultImage != null) {
+			result.bitmap = defaultImage
+			result.delay = Long.MAX_VALUE
+			return
+		}
+		
+		val animationControl = this.animationControl
+		val frames = this.frames
+		if(animationControl == null || frames == null) {
+			// この場合は既に mBitmapNonAnimation が用意されてるはずだ
+			result.bitmap = null
+			result.delay = Long.MAX_VALUE
+			return
+		}
+		
+		val frameCount = frames.size
+		
+		val isFinite = ! animationControl.isPlayIndefinitely
+		val repeatSequenceCount = if(isFinite) animationControl.numPlays else 1
+		val endWait = if(isFinite) DELAY_AFTER_END else 0L
+		val timeTotalLoop = Math.max(1,timeTotal * repeatSequenceCount + endWait)
+		
+		val tf = (if(0.5f + t < 0f) 0f else t / durationScale).toLong()
+		
+		// 全体の繰り返し時刻で余りを計算
+		val tl = tf % timeTotalLoop
+		if(tl >= timeTotalLoop - endWait) {
+			// 終端で待機状態
+			result.bitmap = frames[frameCount - 1].bitmap
+			result.delay = (0.5f + (timeTotalLoop - tl) * durationScale).toLong()
+			return
+		}
+		// １ループの繰り返し時刻で余りを計算
+		val tt = tl % timeTotal
+		
+		// フレームリストを時刻で二分探索
+		var s = 0
+		var e = frameCount
+		while(e - s > 1) {
+			val mid = s + e shr 1
+			val frame = frames[mid]
+			// log.d("s=%d,m=%d,e=%d tt=%d,fs=%s,fe=%d",s,mid,e,tt,frame.time_start,frame.time_start+frame.time_width );
+			if(tt < frame.time_start) {
+				e = mid
+			} else if(tt >= frame.time_start + frame.time_width) {
+				s = mid + 1
+			} else {
+				s = mid
+				break
+			}
+		}
+		s = if(s < 0) 0 else if(s >= frameCount - 1) frameCount - 1 else s
+		val frame = frames[s]
+		val delay = frame.time_start + frame.time_width - tt
+		result.bitmap = frames[s].bitmap
+		result.delay = (0.5f + durationScale * Math.max(0f, delay.toFloat())).toLong()
+		
+		// log.d("findFrame tf=%d,tl=%d/%d,tt=%d/%d,s=%d,w=%d,delay=%d",tf,tl,loop_total,tt,timeTotal,s,frame.time_width,result.delay);
+	}
+	
+	/////////////////////////////////////////////////////
+	// implements ApngDecoderCallback
+	
+	override fun log(message : String) {
+		Log.d(ApngFrames.TAG, message)
+	}
+	
+	override fun onHeader(apng : Apng, header : ApngImageHeader) {
+		this.header = header
+	}
+	
+	override fun onAnimationInfo(
+		apng : Apng,
+		animationControl : ApngAnimationControl
+	) {
+		this.animationControl = animationControl
+		
+		val canvasBitmap = ApngFrames.createBlankBitmap(width, height)
+		this.canvasBitmap = canvasBitmap
+		this.canvas = Canvas(canvasBitmap)
+		this.frames = ArrayList(animationControl.numFrames)
+	}
+	
+	override fun onDefaultImage(apng : Apng, bitmap : ApngBitmap) {
+		defaultImage?.recycle()
+		defaultImage = ApngFrames.toBitmap(bitmap, pixelSizeMax)
+	}
+	
+	override fun onAnimationFrame(
+		apng : Apng,
+		frameControl : ApngFrameControl,
+		bitmap : ApngBitmap
+	) {
 		val frames = this.frames ?: return
-		
 		val canvasBitmap = this.canvasBitmap ?: return
 		
-		val currentFrame = this.currentFrame ?: return
-		this.currentFrame = null
+		// APNGのフレーム画像をAndroidの形式に変換する。この段階ではリサイズしない
+		val bitmapNative = ApngFrames.toBitmap(bitmap)
 		
-		// APNGのフレーム画像をAndroidの形式に変換する
-		val frame = toBitmap(frameImage)
-		
-		var previous : Bitmap? = null
-		// Capture the current bitmap region IF it needs to be reverted after rendering
-		if(2 == currentFrame.disposeOp.toInt()) {
-			previous = Bitmap.createBitmap(canvasBitmap, currentFrame.xOffset, currentFrame.yOffset, currentFrame.width, currentFrame.height) // or could use from frames?
-			//System.out.println(String.format("Captured previous %d x %d", previous.getWidth(), previous.getHeight()));
+		val previous : Bitmap? = if(frameControl.disposeOp == DisposeOp.Previous) {
+			// Capture the current bitmap region IF it needs to be reverted after rendering
+			Bitmap.createBitmap(
+				canvasBitmap,
+				frameControl.xOffset,
+				frameControl.yOffset,
+				frameControl.width,
+				frameControl.height
+			)
+		} else {
+			null
 		}
 		
-		var paint : Paint? = null // (for blend, leave paint null)
-		if(0 == currentFrame.blendOp.toInt()) { // SRC_OVER, not blend
-			paint = sSrcModePaint
+		val paint = if(frameControl.blendOp == BlendOp.Source) {
+			ApngFrames.sSrcModePaint  // SRC_OVER, not blend
+		} else {
+			null // (for blend, leave paint null)
 		}
 		
-		// boolean isFull = currentFrame.height == header.height && currentFrame.width == header.width;
-		
 		// Draw the new frame into place
-		canvas.drawBitmap(frame, currentFrame.xOffset.toFloat(), currentFrame.yOffset.toFloat(), paint)
+		canvas.drawBitmap(
+			bitmapNative,
+			frameControl.xOffset.toFloat(),
+			frameControl.yOffset.toFloat(),
+			paint
+		)
 		
 		// Extract a drawable from the canvas. Have to copy the current bitmap.
 		// Store the drawable in the sequence of frames
-		val time_start = time_total
-		var time_width = currentFrame.delayMilliseconds.toLong()
-		if(time_width <= 0L) time_width = 1L
-		time_total = time_start + time_width
+		val timeStart = timeTotal
+		val timeWidth = Math.max(1L, frameControl.delayMilliseconds)
+		timeTotal += timeWidth
 		
-		val scaledBitmap = scaleBitmap(canvasBitmap.copy(Bitmap.Config.ARGB_8888, false), mPixelSizeMax)
+		val scaledBitmap =
+			scaleBitmap(canvasBitmap.copy(Bitmap.Config.ARGB_8888, false), pixelSizeMax)
 		if(scaledBitmap != null) {
-			frames.add(Frame(scaledBitmap, time_start, time_width))
+			frames.add(Frame(scaledBitmap, timeStart, timeWidth))
 		}
 		
 		// Now "dispose" of the frame in preparation for the next.
 		// https://wiki.mozilla.org/APNG_Specification#.60fcTL.60:_The_Frame_Control_Chunk
 		
-		when(currentFrame.disposeOp.toInt()) {
+		when(frameControl.disposeOp) {
+			DisposeOp.None -> {
+			}
 			
-			1 ->
+			DisposeOp.Background ->
 				// APNG_DISPOSE_OP_BACKGROUND: the frame's region of the output buffer is to be cleared to fully transparent black before rendering the next frame.
 				//System.out.println(String.format("Frame %d clear background (full=%s, x=%d y=%d w=%d h=%d) previous=%s", currentFrame.sequenceNumber,
 				//        isFull, currentFrame.xOffset, currentFrame.yOffset, currentFrame.width, currentFrame.height, previous));
 				//if (true || isFull) {
 				canvas.drawColor(0, PorterDuff.Mode.CLEAR) // Clear to fully transparent black
 			
-			2 ->
+			DisposeOp.Previous ->
 				// APNG_DISPOSE_OP_PREVIOUS: the frame's region of the output buffer is to be reverted to the previous contents before rendering the next frame.
 				//System.out.println(String.format("Frame %d restore previous (full=%s, x=%d y=%d w=%d h=%d) previous=%s", currentFrame.sequenceNumber,
 				//        isFull, currentFrame.xOffset, currentFrame.yOffset, currentFrame.width, currentFrame.height, previous));
 				// Put the original section back
 				if(previous != null) {
-					canvas.drawBitmap(previous, currentFrame.xOffset.toFloat(), currentFrame.yOffset.toFloat(), sSrcModePaint)
+					canvas.drawBitmap(
+						previous, frameControl.xOffset.toFloat(), frameControl.yOffset.toFloat(),
+						ApngFrames.sSrcModePaint
+					)
 					previous.recycle()
 				}
 			
@@ -290,151 +365,446 @@ class APNGFrames {
 		}
 	}
 	
-	class FindFrameResult {
-		var bitmap : Bitmap? = null // may null
-		var delay : Long = 0 // 再描画が必要ない場合は Long.MAX_VALUE
-	}
-	
-	// シーク位置に応じたコマ画像と次のコマまでの残り時間をresultに格納する
-	fun findFrame(result : FindFrameResult, t : Long) {
-		
-		if(mBitmapNonAnimation != null) {
-			result.bitmap = mBitmapNonAnimation
-			result.delay = Long.MAX_VALUE
-			return
-		}
-		
-		val animationControl = this.animationControl
-		val frames = this.frames
-		if(animationControl == null || frames == null) {
-			// この場合は既に mBitmapNonAnimation が用意されてるはずだ
-			result.bitmap = null
-			result.delay = Long.MAX_VALUE
-			return
-		}
-		
-		val frame_count = frames.size
-		
-		val isFinite = ! animationControl.loopForever()
-		val repeatSequenceCount = if(isFinite) animationControl.numPlays else 1
-		val end_wait = if(isFinite) DELAY_AFTER_END else 0L
-		var loop_total = time_total * repeatSequenceCount + end_wait
-		if(loop_total <= 0) loop_total = 1
-		
-		val tf = (if(0.5f + t < 0f) 0f else t / durationScale).toLong()
-		
-		// 全体の繰り返し時刻で余りを計算
-		val tl = tf % loop_total
-		if(tl >= loop_total - end_wait) {
-			// 終端で待機状態
-			result.bitmap = frames[frame_count - 1].bitmap
-			result.delay = (0.5f + (loop_total - tl) * durationScale).toLong()
-			return
-		}
-		// １ループの繰り返し時刻で余りを計算
-		val tt = tl % time_total
-		
-		// フレームリストを時刻で二分探索
-		var s = 0
-		var e = frame_count
-		while(e - s > 1) {
-			val mid = s + e shr 1
-			val frame = frames[mid]
-			// log.d("s=%d,m=%d,e=%d tt=%d,fs=%s,fe=%d",s,mid,e,tt,frame.time_start,frame.time_start+frame.time_width );
-			if(tt < frame.time_start) {
-				e = mid
-			} else if(tt >= frame.time_start + frame.time_width) {
-				s = mid + 1
-			} else {
-				s = mid
-				break
-			}
-		}
-		s = if(s < 0) 0 else if(s >= frame_count - 1) frame_count - 1 else s
-		val frame = frames[s]
-		val delay = frame.time_start + frame.time_width - tt
-		result.bitmap = frames[s].bitmap
-		result.delay = (0.5f + durationScale * Math.max(0f, delay.toFloat())).toLong()
-		
-		// log.d("findFrame tf=%d,tl=%d/%d,tt=%d/%d,s=%d,w=%d,delay=%d",tf,tl,loop_total,tt,time_total,s,frame.time_width,result.delay);
-	}
-	
-	/////////////////////////////////////////////////////////////////////
-	
-	// APNGのパース中に随時呼び出される
-	internal class APNGParseEventHandler(
-		private val size_max : Int
-	) : BasicArgb8888Director<APNGFrames>() {
-		
-		private lateinit var header : PngHeader
-		
-		private var frames : APNGFrames? = null
-		
-		private val isAnimated : Boolean
-			get() = frames != null
-		
-		// ヘッダが分かった
-		@Throws(PngException::class)
-		override fun receiveHeader(header : PngHeader, buffer : PngScanlineBuffer) {
-			this.header = header
-			
-			// 親クラスのprotectedフィールドを更新する
-			val pngBitmap = Argb8888Bitmap(header.width, header.height)
-			this.scanlineProcessor = Argb8888Processors.from(header, buffer, pngBitmap)
-		}
-		
-		// デフォルト画像の手前で呼ばれる
-		override fun beforeDefaultImage() : Argb8888ScanlineProcessor {
-			return scanlineProcessor
-		}
-		
-		// デフォルト画像が分かった
-		// おそらく receiveAnimationControl より先に呼ばれる
-		override fun receiveDefaultImage(defaultImage : Argb8888Bitmap) {
-			// japng ライブラリの返すデフォルトイメージはあまり信用できないので使わない
-		}
-		
-		// アニメーション制御情報が分かった
-		override fun receiveAnimationControl(animationControl : PngAnimationControl) {
-			this.frames = APNGFrames(header , scanlineProcessor, animationControl, size_max)
-		}
-		
-		override fun wantDefaultImage() : Boolean {
-			return ! isAnimated
-		}
-		
-		override fun wantAnimationFrames() : Boolean {
-			return true // isAnimated;
-		}
-		
-		// フレーム制御情報が分かった
-		override fun receiveFrameControl(frameControl : PngFrameControl) : Argb8888ScanlineProcessor {
-			val frames = this.frames ?: throw RuntimeException("not animation image")
-			return frames.beginFrame(frameControl)
-		}
-		
-		// フレーム画像が分かった
-		override fun receiveFrameImage(frameImage : Argb8888Bitmap) {
-			val frames = this.frames ?: throw RuntimeException("not animation image")
-			frames.completeFrame(frameImage)
-		}
-		
-		// 結果を取得する
-		override fun getResult() : APNGFrames? {
-			val frames = this.frames
-			return if( frames?.hasMultipleFrame == true ){
-				frames
-			}else {
-				dispose()
-				return null
-			}
-		}
-		
-		// 処理中に例外が起きた場合、Bitmapリソースを解放する
-		fun dispose() {
-			frames?.dispose()
-			frames = null
-		}
-	}
-	
 }
+
+
+//package jp.juggler.subwaytooter.util
+//
+//import android.graphics.Bitmap
+//import android.graphics.Canvas
+//import android.graphics.Paint
+//import android.graphics.PorterDuff
+//import android.graphics.PorterDuffXfermode
+//import android.graphics.Rect
+//
+//import net.ellerton.japng.PngScanlineBuffer
+//import net.ellerton.japng.argb8888.Argb8888Bitmap
+//import net.ellerton.japng.argb8888.Argb8888Processor
+//import net.ellerton.japng.argb8888.Argb8888Processors
+//import net.ellerton.japng.argb8888.Argb8888ScanlineProcessor
+//import net.ellerton.japng.argb8888.BasicArgb8888Director
+//import net.ellerton.japng.chunks.PngAnimationControl
+//import net.ellerton.japng.chunks.PngFrameControl
+//import net.ellerton.japng.chunks.PngHeader
+//import net.ellerton.japng.error.PngException
+//import net.ellerton.japng.reader.DefaultPngChunkReader
+//import net.ellerton.japng.reader.PngReadHelper
+//
+//import java.io.InputStream
+//import java.util.ArrayList
+//
+//// APNGを解釈した結果を保持する
+//// (フレーム数分のbitmapと時間情報)
+//
+//class APNGFrames {
+//
+//	companion object {
+//
+//		internal val log = LogCategory("APNGFrames")
+//
+//		// ループしない画像の場合は3秒でまたループさせる
+//		private const val DELAY_AFTER_END = 3000L
+//
+//		/**
+//		 * Keep a 1x1 transparent image around as reference for creating a scaled starting bitmap.
+//		 * Considering this because of some reported OutOfMemory errors, and this post:
+//		 *
+//		 *
+//		 * http://stackoverflow.com/a/8527745/963195
+//		 *
+//		 *
+//		 * Specifically: "NEVER use Bitmap.createBitmap(width, height, Config.ARGB_8888). I mean NEVER!"
+//		 *
+//		 *
+//		 * Instead the 1x1 image (68 bytes of resources) is scaled up to the needed size.
+//		 * Whether or not this fixes the OOM problems is TBD...
+//		 */
+//		//static Bitmap sOnePxTransparent;
+//		internal val sSrcModePaint : Paint by lazy{
+//			val paint = Paint()
+//			paint.xfermode = PorterDuffXfermode(PorterDuff.Mode.SRC)
+//			paint.isFilterBitmap = true
+//			paint
+//		}
+//
+//		internal fun createBlankBitmap(w : Int, h : Int) : Bitmap {
+//			return Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
+//		}
+//
+//		// WARNING: ownership of "src" will be moved or recycled.
+//		internal fun scaleBitmap(src : Bitmap?, size_max : Int) : Bitmap? {
+//			if(src == null) return null
+//
+//			val src_w = src.width
+//			val src_h = src.height
+//			if(src_w <= size_max && src_h <= size_max) return src
+//
+//			var dst_w : Int
+//			var dst_h : Int
+//			if(src_w >= src_h) {
+//				dst_w = size_max
+//				dst_h = (0.5f + src_h * size_max / src_w.toFloat()).toInt()
+//				if(dst_h < 1) dst_h = 1
+//			} else {
+//				dst_h = size_max
+//				dst_w = (0.5f + src_w * size_max / src_h.toFloat()).toInt()
+//				if(dst_w < 1) dst_w = 1
+//			}
+//
+//			// この方法だとリークがあるらしい？？？
+//			// http://stackoverflow.com/a/8527745/963195
+//			// return Bitmap.createScaledBitmap( src, dst_w , dst_h , true );
+//
+//			val b2 = createBlankBitmap(dst_w, dst_h)
+//			val canvas = Canvas(b2)
+//			val rect_src = Rect(0, 0, src_w, src_h)
+//			val rect_dst = Rect(0, 0, dst_w, dst_h)
+//			canvas.drawBitmap(src, rect_src, rect_dst, sSrcModePaint)
+//			src.recycle()
+//			return b2
+//		}
+//
+//		internal fun toBitmap(src : Argb8888Bitmap) : Bitmap {
+//			val offset = 0
+//			val stride = src.width
+//			return Bitmap.createBitmap(src.pixelArray, offset, stride, src.width, src.height, Bitmap.Config.ARGB_8888)
+//		}
+//
+//		internal fun toBitmap(src : Argb8888Bitmap, size_max : Int) : Bitmap? {
+//			return scaleBitmap(toBitmap(src), size_max)
+//		}
+//
+//		/////////////////////////////////////////////////////////////////////
+//
+//		// entry point is here
+//		@Throws(PngException::class)
+//		internal fun parseAPNG( inStream : InputStream, size_max : Int) : APNGFrames? {
+//			val handler = APNGParseEventHandler(size_max)
+//			try {
+//				val processor = Argb8888Processor(handler)
+//				val reader = DefaultPngChunkReader(processor)
+//				val result = PngReadHelper.read(inStream, reader)
+//				result?.onParseComplete()
+//				return result
+//			} catch(ex : Throwable) {
+//				handler.dispose()
+//				throw ex
+//			}
+//
+//		}
+//	}
+//
+//	// ピクセルサイズ制限
+//	private var mPixelSizeMax : Int = 0
+//
+//	// APNGじゃなかった場合に使われる
+//	private var mBitmapNonAnimation : Bitmap? = null
+//
+//	private lateinit var header : PngHeader
+//	private lateinit var scanlineProcessor : Argb8888ScanlineProcessor
+//	private lateinit var canvas : Canvas
+//
+//	private var canvasBitmap : Bitmap? = null
+//	private var currentFrame : PngFrameControl? = null
+//	private var animationControl : PngAnimationControl? = null
+//
+//	private var time_total = 0L
+//
+//	private var frames : ArrayList<Frame>? = null
+//
+//	///////////////////////////////////////////////////////////////
+//
+//	// 再生速度の調整
+//	private var durationScale = 1f
+//
+//	private val numFrames : Int
+//		get() = animationControl?.numFrames ?: 1
+//
+//	val hasMultipleFrame : Boolean
+//		get() = numFrames > 1
+//
+//	private class Frame(
+//		internal val bitmap : Bitmap,
+//		internal val time_start : Long,
+//		internal val time_width : Long
+//	)
+//
+//	///////////////////////////////////////////////////////////////
+//
+//	internal constructor(bitmap : Bitmap) {
+//		this.mBitmapNonAnimation = bitmap
+//	}
+//
+//	internal constructor(
+//		header : PngHeader, scanlineProcessor : Argb8888ScanlineProcessor, animationControl : PngAnimationControl, size_max : Int
+//	) {
+//		this.header = header
+//		this.scanlineProcessor = scanlineProcessor
+//		this.animationControl = animationControl
+//		this.mPixelSizeMax = size_max
+//
+//		this.canvasBitmap = createBlankBitmap(header.width, header.height)
+//		this.canvas = Canvas(this.canvasBitmap)
+//		this.frames = ArrayList(animationControl.numFrames)
+//
+//	}
+//
+//	internal fun onParseComplete() {
+//		val frames = this.frames
+//
+//		if(frames != null && frames.size <= 1) {
+//			mBitmapNonAnimation = toBitmap(scanlineProcessor.bitmap, mPixelSizeMax)
+//		}
+//
+//		canvasBitmap?.recycle()
+//		canvasBitmap = null
+//	}
+//
+//	internal fun dispose() {
+//		mBitmapNonAnimation?.recycle()
+//		canvasBitmap?.recycle()
+//
+//		val frames = this.frames
+//		if(frames != null) {
+//			for(f in frames) {
+//				f.bitmap.recycle()
+//			}
+//		}
+//	}
+//
+//	// フレームが追加される
+//	internal fun beginFrame(frameControl : PngFrameControl) : Argb8888ScanlineProcessor {
+//		currentFrame = frameControl
+//		return scanlineProcessor.cloneWithSharedBitmap(header.adjustFor(currentFrame))
+//	}
+//
+//	// フレームが追加される
+//	internal fun completeFrame(frameImage : Argb8888Bitmap) {
+//
+//		val frames = this.frames ?: return
+//
+//		val canvasBitmap = this.canvasBitmap ?: return
+//
+//		val currentFrame = this.currentFrame ?: return
+//		this.currentFrame = null
+//
+//		// APNGのフレーム画像をAndroidの形式に変換する
+//		val frame = toBitmap(frameImage)
+//
+//		var previous : Bitmap? = null
+//		// Capture the current bitmap region IF it needs to be reverted after rendering
+//		if(2 == currentFrame.disposeOp.toInt()) {
+//			previous = Bitmap.createBitmap(canvasBitmap, currentFrame.xOffset, currentFrame.yOffset, currentFrame.width, currentFrame.height) // or could use from frames?
+//			//System.out.println(String.format("Captured previous %d x %d", previous.getWidth(), previous.getHeight()));
+//		}
+//
+//		var paint : Paint? = null // (for blend, leave paint null)
+//		if(0 == currentFrame.blendOp.toInt()) { // SRC_OVER, not blend
+//			paint = sSrcModePaint
+//		}
+//
+//		// boolean isFull = currentFrame.height == header.height && currentFrame.width == header.width;
+//
+//		// Draw the new frame into place
+//		canvas.drawBitmap(frame, currentFrame.xOffset.toFloat(), currentFrame.yOffset.toFloat(), paint)
+//
+//		// Extract a drawable from the canvas. Have to copy the current bitmap.
+//		// Store the drawable in the sequence of frames
+//		val time_start = time_total
+//		var time_width = currentFrame.delayMilliseconds.toLong()
+//		if(time_width <= 0L) time_width = 1L
+//		time_total = time_start + time_width
+//
+//		val scaledBitmap = scaleBitmap(canvasBitmap.copy(Bitmap.Config.ARGB_8888, false), mPixelSizeMax)
+//		if(scaledBitmap != null) {
+//			frames.add(Frame(scaledBitmap, time_start, time_width))
+//		}
+//
+//		// Now "dispose" of the frame in preparation for the next.
+//		// https://wiki.mozilla.org/APNG_Specification#.60fcTL.60:_The_Frame_Control_Chunk
+//
+//		when(currentFrame.disposeOp.toInt()) {
+//
+//			1 ->
+//				// APNG_DISPOSE_OP_BACKGROUND: the frame's region of the output buffer is to be cleared to fully transparent black before rendering the next frame.
+//				//System.out.println(String.format("Frame %d clear background (full=%s, x=%d y=%d w=%d h=%d) previous=%s", currentFrame.sequenceNumber,
+//				//        isFull, currentFrame.xOffset, currentFrame.yOffset, currentFrame.width, currentFrame.height, previous));
+//				//if (true || isFull) {
+//				canvas.drawColor(0, PorterDuff.Mode.CLEAR) // Clear to fully transparent black
+//
+//			2 ->
+//				// APNG_DISPOSE_OP_PREVIOUS: the frame's region of the output buffer is to be reverted to the previous contents before rendering the next frame.
+//				//System.out.println(String.format("Frame %d restore previous (full=%s, x=%d y=%d w=%d h=%d) previous=%s", currentFrame.sequenceNumber,
+//				//        isFull, currentFrame.xOffset, currentFrame.yOffset, currentFrame.width, currentFrame.height, previous));
+//				// Put the original section back
+//				if(previous != null) {
+//					canvas.drawBitmap(previous, currentFrame.xOffset.toFloat(), currentFrame.yOffset.toFloat(), sSrcModePaint)
+//					previous.recycle()
+//				}
+//
+//			else -> {
+//				// 0: Default should never happen
+//
+//				// APNG_DISPOSE_OP_NONE: no disposal is done on this frame before rendering the next; the contents of the output buffer are left as is.
+//				//System.out.println("Frame "+currentFrame.sequenceNumber+" do nothing dispose");
+//				// do nothing
+//				//                } else {
+//				//                    Rect rt = new Rect(currentFrame.xOffset, currentFrame.yOffset, currentFrame.width+currentFrame.xOffset, currentFrame.height+currentFrame.yOffset);
+//				//                    paint = new Paint();
+//				//                    paint.setColor(0);
+//				//                    paint.setStyle(Paint.Style.FILL);
+//				//                    canvas.drawRect(rt, paint);
+//				//                }
+//
+//			}
+//		}
+//	}
+//
+//	class FindFrameResult {
+//		var bitmap : Bitmap? = null // may null
+//		var delay : Long = 0 // 再描画が必要ない場合は Long.MAX_VALUE
+//	}
+//
+//	// シーク位置に応じたコマ画像と次のコマまでの残り時間をresultに格納する
+//	fun findFrame(result : FindFrameResult, t : Long) {
+//
+//		if(mBitmapNonAnimation != null) {
+//			result.bitmap = mBitmapNonAnimation
+//			result.delay = Long.MAX_VALUE
+//			return
+//		}
+//
+//		val animationControl = this.animationControl
+//		val frames = this.frames
+//		if(animationControl == null || frames == null) {
+//			// この場合は既に mBitmapNonAnimation が用意されてるはずだ
+//			result.bitmap = null
+//			result.delay = Long.MAX_VALUE
+//			return
+//		}
+//
+//		val frame_count = frames.size
+//
+//		val isFinite = ! animationControl.loopForever()
+//		val repeatSequenceCount = if(isFinite) animationControl.numPlays else 1
+//		val end_wait = if(isFinite) DELAY_AFTER_END else 0L
+//		var loop_total = time_total * repeatSequenceCount + end_wait
+//		if(loop_total <= 0) loop_total = 1
+//
+//		val tf = (if(0.5f + t < 0f) 0f else t / durationScale).toLong()
+//
+//		// 全体の繰り返し時刻で余りを計算
+//		val tl = tf % loop_total
+//		if(tl >= loop_total - end_wait) {
+//			// 終端で待機状態
+//			result.bitmap = frames[frame_count - 1].bitmap
+//			result.delay = (0.5f + (loop_total - tl) * durationScale).toLong()
+//			return
+//		}
+//		// １ループの繰り返し時刻で余りを計算
+//		val tt = tl % time_total
+//
+//		// フレームリストを時刻で二分探索
+//		var s = 0
+//		var e = frame_count
+//		while(e - s > 1) {
+//			val mid = s + e shr 1
+//			val frame = frames[mid]
+//			// log.d("s=%d,m=%d,e=%d tt=%d,fs=%s,fe=%d",s,mid,e,tt,frame.time_start,frame.time_start+frame.time_width );
+//			if(tt < frame.time_start) {
+//				e = mid
+//			} else if(tt >= frame.time_start + frame.time_width) {
+//				s = mid + 1
+//			} else {
+//				s = mid
+//				break
+//			}
+//		}
+//		s = if(s < 0) 0 else if(s >= frame_count - 1) frame_count - 1 else s
+//		val frame = frames[s]
+//		val delay = frame.time_start + frame.time_width - tt
+//		result.bitmap = frames[s].bitmap
+//		result.delay = (0.5f + durationScale * Math.max(0f, delay.toFloat())).toLong()
+//
+//		// log.d("findFrame tf=%d,tl=%d/%d,tt=%d/%d,s=%d,w=%d,delay=%d",tf,tl,loop_total,tt,time_total,s,frame.time_width,result.delay);
+//	}
+//
+//	/////////////////////////////////////////////////////////////////////
+//
+//	// APNGのパース中に随時呼び出される
+//	internal class APNGParseEventHandler(
+//		private val size_max : Int
+//	) : BasicArgb8888Director<APNGFrames>() {
+//
+//		private lateinit var header : PngHeader
+//
+//		private var frames : APNGFrames? = null
+//
+//		private val isAnimated : Boolean
+//			get() = frames != null
+//
+//		// ヘッダが分かった
+//		@Throws(PngException::class)
+//		override fun receiveHeader(header : PngHeader, buffer : PngScanlineBuffer) {
+//			this.header = header
+//
+//			// 親クラスのprotectedフィールドを更新する
+//			val pngBitmap = Argb8888Bitmap(header.width, header.height)
+//			this.scanlineProcessor = Argb8888Processors.from(header, buffer, pngBitmap)
+//		}
+//
+//		// デフォルト画像の手前で呼ばれる
+//		override fun beforeDefaultImage() : Argb8888ScanlineProcessor {
+//			return scanlineProcessor
+//		}
+//
+//		// デフォルト画像が分かった
+//		// おそらく receiveAnimationControl より先に呼ばれる
+//		override fun receiveDefaultImage(defaultImage : Argb8888Bitmap) {
+//			// japng ライブラリの返すデフォルトイメージはあまり信用できないので使わない
+//		}
+//
+//		// アニメーション制御情報が分かった
+//		override fun receiveAnimationControl(animationControl : PngAnimationControl) {
+//			this.frames = APNGFrames(header , scanlineProcessor, animationControl, size_max)
+//		}
+//
+//		override fun wantDefaultImage() : Boolean {
+//			return ! isAnimated
+//		}
+//
+//		override fun wantAnimationFrames() : Boolean {
+//			return true // isAnimated;
+//		}
+//
+//		// フレーム制御情報が分かった
+//		override fun receiveFrameControl(frameControl : PngFrameControl) : Argb8888ScanlineProcessor {
+//			val frames = this.frames ?: throw RuntimeException("not animation image")
+//			return frames.beginFrame(frameControl)
+//		}
+//
+//		// フレーム画像が分かった
+//		override fun receiveFrameImage(frameImage : Argb8888Bitmap) {
+//			val frames = this.frames ?: throw RuntimeException("not animation image")
+//			frames.completeFrame(frameImage)
+//		}
+//
+//		// 結果を取得する
+//		override fun getResult() : APNGFrames? {
+//			val frames = this.frames
+//			return if( frames?.hasMultipleFrame == true ){
+//				frames
+//			}else {
+//				dispose()
+//				return null
+//			}
+//		}
+//
+//		// 処理中に例外が起きた場合、Bitmapリソースを解放する
+//		fun dispose() {
+//			frames?.dispose()
+//			frames = null
+//		}
+//	}
+//
+//}
diff --git a/app/src/main/java/jp/juggler/subwaytooter/util/CustomEmojiCache.kt b/app/src/main/java/jp/juggler/subwaytooter/util/CustomEmojiCache.kt
index 24453924..d6c1aa27 100644
--- a/app/src/main/java/jp/juggler/subwaytooter/util/CustomEmojiCache.kt
+++ b/app/src/main/java/jp/juggler/subwaytooter/util/CustomEmojiCache.kt
@@ -30,7 +30,7 @@ class CustomEmojiCache(internal val context : Context) {
 			get() = SystemClock.elapsedRealtime()
 	}
 	
-	private class CacheItem(val url : String, var frames : APNGFrames?) {
+	private class CacheItem(val url : String, var frames : ApngFrames?) {
 		var time_used : Long = elapsedTime
 	}
 	
@@ -100,7 +100,7 @@ class CustomEmojiCache(internal val context : Context) {
 		return null
 	}
 	
-	fun getFrames(refDrawTarget: WeakReference<Any>?, url : String, onLoadComplete :  ()->Unit) : APNGFrames? {
+	fun getFrames(refDrawTarget: WeakReference<Any>?, url : String, onLoadComplete :  ()->Unit) : ApngFrames? {
 		try {
 			if( refDrawTarget?.get() == null ){
 				NetworkEmojiSpan.log.e("draw: DrawTarget is null ")
@@ -169,7 +169,7 @@ class CustomEmojiCache(internal val context : Context) {
 					if(DEBUG)
 						log.d("start get image. queue_size=%d, cache_size=%d url=%s", queue_size, cache_size, request.url)
 					
-					var frames : APNGFrames? = null
+					var frames : ApngFrames? = null
 					try {
 						val data = App1.getHttpCached(request.url)
 						if(data == null) {
@@ -241,7 +241,7 @@ class CustomEmojiCache(internal val context : Context) {
 			}
 		}
 		
-		private fun decodeAPNG(data : ByteArray, url : String) : APNGFrames? {
+		private fun decodeAPNG(data : ByteArray, url : String) : ApngFrames? {
 			try {
 				// PNGヘッダを確認
 				if( data.size >= 8
@@ -249,19 +249,13 @@ class CustomEmojiCache(internal val context : Context) {
 					&& (data[1].toInt() and 0xff) ==  0x50
 				){
 					// APNGをデコード
-					val frames = APNGFrames.parseAPNG(ByteArrayInputStream(data), 64)
-					if(frames?.hasMultipleFrame == true) return frames
-					frames?.dispose()
-					
-					// mastodonのstatic_urlが返すPNG画像はAPNGだと透明になってる場合がある。BitmapFactoryでデコードしなおすべき
-					if(DEBUG) log.d("parseAPNG returns null or single frame.")
+					return ApngFrames.parseApng(ByteArrayInputStream(data), 64)
 				}
 
 				// fall thru
 			} catch(ex : Throwable) {
 				if(DEBUG) log.trace(ex)
 				log.e(ex, "PNG decode failed. %s ", url)
-				// PngFeatureException Interlaced images are not yet supported
 			}
 			
 			// 通常のビットマップでのロードを試みる
@@ -269,7 +263,7 @@ class CustomEmojiCache(internal val context : Context) {
 				val b = decodeBitmap(data, 128)
 				if(b != null) {
 					if(DEBUG) log.d("bitmap decoded.")
-					return APNGFrames(b)
+					return ApngFrames(b)
 				} else {
 					log.e("Bitmap decode returns null. %s", url)
 				}
diff --git a/app/src/main/java/jp/juggler/subwaytooter/view/NetworkEmojiView.kt b/app/src/main/java/jp/juggler/subwaytooter/view/NetworkEmojiView.kt
index d59736fa..80e0234f 100644
--- a/app/src/main/java/jp/juggler/subwaytooter/view/NetworkEmojiView.kt
+++ b/app/src/main/java/jp/juggler/subwaytooter/view/NetworkEmojiView.kt
@@ -10,7 +10,7 @@ import android.util.AttributeSet
 import android.view.View
 
 import jp.juggler.subwaytooter.App1
-import jp.juggler.subwaytooter.util.APNGFrames
+import jp.juggler.subwaytooter.util.ApngFrames
 import java.lang.ref.WeakReference
 
 class NetworkEmojiView : View {
@@ -26,7 +26,7 @@ class NetworkEmojiView : View {
 	private val tagDrawTarget : WeakReference<Any>
 	
 	// フレーム探索結果を格納する構造体を確保しておく
-	private val mFrameFindResult = APNGFrames.FindFrameResult()
+	private val mFrameFindResult = ApngFrames.FindFrameResult()
 	
 	// 最後に描画した時刻
 	private var t_last_draw : Long = 0
diff --git a/settings.gradle b/settings.gradle
index 42e7f3b2..9f8d0af2 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1 +1 @@
-include ':app', ':exif', ':colorpicker', ':emoji'
+include ':app', ':exif', ':colorpicker', ':emoji', ':apng'