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 4385746f..00000000
Binary files a/app/libs/japng-0.5.1.jar and /dev/null differ
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'