Add support for rendering APNGs.

2026-04-24 02:39:55 +01:00 · 2020-09-01 19:13:35 -04:00
parent 1d2ffe56fb
commit 250402e9b9
44 changed files with 2822 additions and 108 deletions
--- a/app/src/main/java/org/signal/glide/common/FrameAnimationDrawable.java
+++ b/app/src/main/java/org/signal/glide/common/FrameAnimationDrawable.java
@@ -0,0 +1,253 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.DrawFilter;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.PaintFlagsDrawFilter;
+import android.graphics.PixelFormat;
+import android.graphics.drawable.Drawable;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+
+import androidx.annotation.NonNull;
+import androidx.vectordrawable.graphics.drawable.Animatable2Compat;
+
+import org.signal.glide.Log;
+import org.signal.glide.common.decode.FrameSeqDecoder;
+import org.signal.glide.common.loader.Loader;
+
+import java.nio.ByteBuffer;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * @Description: Frame animation drawable
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019/3/27
+ */
+public abstract class FrameAnimationDrawable<Decoder extends FrameSeqDecoder> extends Drawable implements Animatable2Compat, FrameSeqDecoder.RenderListener {
+    private static final String TAG = FrameAnimationDrawable.class.getSimpleName();
+    private final Paint paint = new Paint();
+    private final Decoder frameSeqDecoder;
+    private DrawFilter drawFilter = new PaintFlagsDrawFilter(0, Paint.ANTI_ALIAS_FLAG | Paint.FILTER_BITMAP_FLAG);
+    private Matrix matrix = new Matrix();
+    private Set<AnimationCallback> animationCallbacks = new HashSet<>();
+    private Bitmap bitmap;
+    private static final int MSG_ANIMATION_START = 1;
+    private static final int MSG_ANIMATION_END = 2;
+    private Handler uiHandler = new Handler(Looper.getMainLooper()) {
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case MSG_ANIMATION_START:
+                    for (AnimationCallback animationCallback : animationCallbacks) {
+                        animationCallback.onAnimationStart(FrameAnimationDrawable.this);
+                    }
+                    break;
+                case MSG_ANIMATION_END:
+                    for (AnimationCallback animationCallback : animationCallbacks) {
+                        animationCallback.onAnimationEnd(FrameAnimationDrawable.this);
+                    }
+                    break;
+            }
+        }
+    };
+    private Runnable invalidateRunnable = new Runnable() {
+        @Override
+        public void run() {
+            invalidateSelf();
+        }
+    };
+    private boolean autoPlay = true;
+
+    public FrameAnimationDrawable(Decoder frameSeqDecoder) {
+        paint.setAntiAlias(true);
+        this.frameSeqDecoder = frameSeqDecoder;
+    }
+
+    public FrameAnimationDrawable(Loader provider) {
+        paint.setAntiAlias(true);
+        this.frameSeqDecoder = createFrameSeqDecoder(provider, this);
+    }
+
+    public void setAutoPlay(boolean autoPlay) {
+        this.autoPlay = autoPlay;
+    }
+
+    protected abstract Decoder createFrameSeqDecoder(Loader streamLoader, FrameSeqDecoder.RenderListener listener);
+
+    /**
+     * @param loopLimit <=0为无限播放,>0为实际播放次数
+     */
+    public void setLoopLimit(int loopLimit) {
+        frameSeqDecoder.setLoopLimit(loopLimit);
+    }
+
+    public void reset() {
+        frameSeqDecoder.reset();
+    }
+
+    public void pause() {
+        frameSeqDecoder.pause();
+    }
+
+    public void resume() {
+        frameSeqDecoder.resume();
+    }
+
+    public boolean isPaused() {
+        return frameSeqDecoder.isPaused();
+    }
+
+    @Override
+    public void start() {
+        if (autoPlay) {
+            frameSeqDecoder.start();
+        } else {
+            this.frameSeqDecoder.addRenderListener(this);
+            if (!this.frameSeqDecoder.isRunning()) {
+                this.frameSeqDecoder.start();
+            }
+        }
+    }
+
+    @Override
+    public void stop() {
+        if (autoPlay) {
+            frameSeqDecoder.stop();
+        } else {
+            this.frameSeqDecoder.removeRenderListener(this);
+            this.frameSeqDecoder.stopIfNeeded();
+        }
+    }
+
+    @Override
+    public boolean isRunning() {
+        return frameSeqDecoder.isRunning();
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+        if (bitmap == null || bitmap.isRecycled()) {
+            return;
+        }
+        canvas.setDrawFilter(drawFilter);
+        canvas.drawBitmap(bitmap, matrix, paint);
+    }
+
+    @Override
+    public void setBounds(int left, int top, int right, int bottom) {
+        super.setBounds(left, top, right, bottom);
+        boolean sampleSizeChanged = frameSeqDecoder.setDesiredSize(getBounds().width(), getBounds().height());
+        matrix.setScale(
+                1.0f * getBounds().width() * frameSeqDecoder.getSampleSize() / frameSeqDecoder.getBounds().width(),
+                1.0f * getBounds().height() * frameSeqDecoder.getSampleSize() / frameSeqDecoder.getBounds().height());
+
+        if (sampleSizeChanged)
+            this.bitmap = Bitmap.createBitmap(
+                    frameSeqDecoder.getBounds().width() / frameSeqDecoder.getSampleSize(),
+                    frameSeqDecoder.getBounds().height() / frameSeqDecoder.getSampleSize(),
+                    Bitmap.Config.ARGB_8888);
+    }
+
+    @Override
+    public void setAlpha(int alpha) {
+        paint.setAlpha(alpha);
+    }
+
+    @Override
+    public void setColorFilter(ColorFilter colorFilter) {
+        paint.setColorFilter(colorFilter);
+    }
+
+    @Override
+    public int getOpacity() {
+        return PixelFormat.TRANSLUCENT;
+    }
+
+    @Override
+    public void onStart() {
+        Message.obtain(uiHandler, MSG_ANIMATION_START).sendToTarget();
+    }
+
+    @Override
+    public void onRender(ByteBuffer byteBuffer) {
+        if (!isRunning()) {
+            return;
+        }
+        if (this.bitmap == null || this.bitmap.isRecycled()) {
+            this.bitmap = Bitmap.createBitmap(
+                    frameSeqDecoder.getBounds().width() / frameSeqDecoder.getSampleSize(),
+                    frameSeqDecoder.getBounds().height() / frameSeqDecoder.getSampleSize(),
+                    Bitmap.Config.ARGB_8888);
+        }
+        byteBuffer.rewind();
+        if (byteBuffer.remaining() < this.bitmap.getByteCount()) {
+            Log.e(TAG, "onRender:Buffer not large enough for pixels");
+            return;
+        }
+        this.bitmap.copyPixelsFromBuffer(byteBuffer);
+        uiHandler.post(invalidateRunnable);
+    }
+
+    @Override
+    public void onEnd() {
+        Message.obtain(uiHandler, MSG_ANIMATION_END).sendToTarget();
+    }
+
+    @Override
+    public boolean setVisible(boolean visible, boolean restart) {
+        if (this.autoPlay) {
+            if (visible) {
+                if (!isRunning()) {
+                    start();
+                }
+            } else if (isRunning()) {
+                stop();
+            }
+        }
+        return super.setVisible(visible, restart);
+    }
+
+    @Override
+    public int getIntrinsicWidth() {
+        try {
+            return frameSeqDecoder.getBounds().width();
+        } catch (Exception exception) {
+            return 0;
+        }
+    }
+
+    @Override
+    public int getIntrinsicHeight() {
+        try {
+            return frameSeqDecoder.getBounds().height();
+        } catch (Exception exception) {
+            return 0;
+        }
+    }
+
+    @Override
+    public void registerAnimationCallback(@NonNull AnimationCallback animationCallback) {
+        this.animationCallbacks.add(animationCallback);
+    }
+
+    @Override
+    public boolean unregisterAnimationCallback(@NonNull AnimationCallback animationCallback) {
+        return this.animationCallbacks.remove(animationCallback);
+    }
+
+    @Override
+    public void clearAnimationCallbacks() {
+        this.animationCallbacks.clear();
+    }
+}
--- a/app/src/main/java/org/signal/glide/common/decode/Frame.java
+++ b/app/src/main/java/org/signal/glide/common/decode/Frame.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.decode;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+
+import org.signal.glide.common.io.Reader;
+import org.signal.glide.common.io.Writer;
+
+/**
+ * @Description: One frame in an animation
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019-05-13
+ */
+public abstract class Frame<R extends Reader, W extends Writer> {
+    protected final R reader;
+    public int frameWidth;
+    public int frameHeight;
+    public int frameX;
+    public int frameY;
+    public int frameDuration;
+
+    public Frame(R reader) {
+        this.reader = reader;
+    }
+
+    public abstract Bitmap draw(Canvas canvas, Paint paint, int sampleSize, Bitmap reusedBitmap, W writer);
+}
--- a/app/src/main/java/org/signal/glide/common/decode/FrameSeqDecoder.java
+++ b/app/src/main/java/org/signal/glide/common/decode/FrameSeqDecoder.java
@@ -0,0 +1,539 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.decode;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.WorkerThread;
+
+import org.signal.glide.Log;
+import org.signal.glide.common.executor.FrameDecoderExecutor;
+import org.signal.glide.common.io.Reader;
+import org.signal.glide.common.io.Writer;
+import org.signal.glide.common.loader.Loader;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.LockSupport;
+
+/**
+ * @Description: Abstract Frame Animation Decoder
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019/3/27
+ */
+public abstract class FrameSeqDecoder<R extends Reader, W extends Writer> {
+    private static final String TAG = FrameSeqDecoder.class.getSimpleName();
+    private final int taskId;
+
+    private final Loader mLoader;
+    private final Handler workerHandler;
+    protected List<Frame> frames = new ArrayList<>();
+    protected int frameIndex = -1;
+    private int playCount;
+    private Integer loopLimit = null;
+    private Set<RenderListener> renderListeners = new HashSet<>();
+    private AtomicBoolean paused = new AtomicBoolean(true);
+    private static final Rect RECT_EMPTY = new Rect();
+    private Runnable renderTask = new Runnable() {
+        @Override
+        public void run() {
+            if (paused.get()) {
+                return;
+            }
+            if (canStep()) {
+                long start = System.currentTimeMillis();
+                long delay = step();
+                long cost = System.currentTimeMillis() - start;
+                workerHandler.postDelayed(this, Math.max(0, delay - cost));
+                for (RenderListener renderListener : renderListeners) {
+                    renderListener.onRender(frameBuffer);
+                }
+            } else {
+                stop();
+            }
+        }
+    };
+    protected int sampleSize = 1;
+
+    private Set<Bitmap> cacheBitmaps = new HashSet<>();
+    protected Map<Bitmap, Canvas> cachedCanvas = new WeakHashMap<>();
+    protected ByteBuffer frameBuffer;
+    protected volatile Rect fullRect;
+    private W mWriter = getWriter();
+    private R mReader = null;
+
+    /**
+     * If played all the needed
+     */
+    private boolean finished = false;
+
+    private enum State {
+        IDLE,
+        RUNNING,
+        INITIALIZING,
+        FINISHING,
+    }
+
+    private volatile State mState = State.IDLE;
+
+    public Loader getLoader() {
+        return mLoader;
+    }
+
+    protected abstract W getWriter();
+
+    protected abstract R getReader(Reader reader);
+
+    protected Bitmap obtainBitmap(int width, int height) {
+        Bitmap ret = null;
+        Iterator<Bitmap> iterator = cacheBitmaps.iterator();
+        while (iterator.hasNext()) {
+            int reuseSize = width * height * 4;
+            ret = iterator.next();
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+                if (ret != null && ret.getAllocationByteCount() >= reuseSize) {
+                    iterator.remove();
+                    if (ret.getWidth() != width || ret.getHeight() != height) {
+                        ret.reconfigure(width, height, Bitmap.Config.ARGB_8888);
+                    }
+                    ret.eraseColor(0);
+                    return ret;
+                }
+            } else {
+                if (ret != null && ret.getByteCount() >= reuseSize) {
+                    if (ret.getWidth() == width && ret.getHeight() == height) {
+                        iterator.remove();
+                        ret.eraseColor(0);
+                    }
+                    return ret;
+                }
+            }
+        }
+
+        try {
+            Bitmap.Config config = Bitmap.Config.ARGB_8888;
+            ret = Bitmap.createBitmap(width, height, config);
+        } catch (OutOfMemoryError e) {
+            e.printStackTrace();
+        }
+        return ret;
+    }
+
+    protected void recycleBitmap(Bitmap bitmap) {
+        if (bitmap != null && !cacheBitmaps.contains(bitmap)) {
+            cacheBitmaps.add(bitmap);
+        }
+    }
+
+    /**
+     * 解码器的渲染回调
+     */
+    public interface RenderListener {
+        /**
+         * 播放开始
+         */
+        void onStart();
+
+        /**
+         * 帧播放
+         */
+        void onRender(ByteBuffer byteBuffer);
+
+        /**
+         * 播放结束
+         */
+        void onEnd();
+    }
+
+
+    /**
+     * @param loader         webp的reader
+     * @param renderListener 渲染的回调
+     */
+    public FrameSeqDecoder(Loader loader, @Nullable RenderListener renderListener) {
+        this.mLoader = loader;
+        if (renderListener != null) {
+            this.renderListeners.add(renderListener);
+        }
+        this.taskId = FrameDecoderExecutor.getInstance().generateTaskId();
+        this.workerHandler = new Handler(FrameDecoderExecutor.getInstance().getLooper(taskId));
+    }
+
+
+    public void addRenderListener(final RenderListener renderListener) {
+        this.workerHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                renderListeners.add(renderListener);
+            }
+        });
+    }
+
+    public void removeRenderListener(final RenderListener renderListener) {
+        this.workerHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                renderListeners.remove(renderListener);
+            }
+        });
+    }
+
+    public void stopIfNeeded() {
+        this.workerHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                if (renderListeners.size() == 0) {
+                    stop();
+                }
+            }
+        });
+    }
+
+    public Rect getBounds() {
+        if (fullRect == null) {
+            if (mState == State.FINISHING) {
+                Log.e(TAG, "In finishing,do not interrupt");
+            }
+            final Thread thread = Thread.currentThread();
+            workerHandler.post(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        if (fullRect == null) {
+                            if (mReader == null) {
+                                mReader = getReader(mLoader.obtain());
+                            } else {
+                                mReader.reset();
+                            }
+                            initCanvasBounds(read(mReader));
+                        }
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                        fullRect = RECT_EMPTY;
+                    } finally {
+                        LockSupport.unpark(thread);
+                    }
+                }
+            });
+            LockSupport.park(thread);
+        }
+        return fullRect;
+    }
+
+    private void initCanvasBounds(Rect rect) {
+        fullRect = rect;
+        frameBuffer = ByteBuffer.allocate((rect.width() * rect.height() / (sampleSize * sampleSize) + 1) * 4);
+        if (mWriter == null) {
+            mWriter = getWriter();
+        }
+    }
+
+
+    private int getFrameCount() {
+        return this.frames.size();
+    }
+
+    /**
+     * @return Loop Count defined in file
+     */
+    protected abstract int getLoopCount();
+
+    public void start() {
+        if (fullRect == RECT_EMPTY) {
+            return;
+        }
+        if (mState == State.RUNNING || mState == State.INITIALIZING) {
+            Log.i(TAG, debugInfo() + " Already started");
+            return;
+        }
+        if (mState == State.FINISHING) {
+            Log.e(TAG, debugInfo() + " Processing,wait for finish at " + mState);
+        }
+        mState = State.INITIALIZING;
+        if (Looper.myLooper() == workerHandler.getLooper()) {
+            innerStart();
+        } else {
+            workerHandler.post(new Runnable() {
+                @Override
+                public void run() {
+                    innerStart();
+                }
+            });
+        }
+    }
+
+    @WorkerThread
+    private void innerStart() {
+        paused.compareAndSet(true, false);
+
+        final long start = System.currentTimeMillis();
+        try {
+            if (frames.size() == 0) {
+                try {
+                    if (mReader == null) {
+                        mReader = getReader(mLoader.obtain());
+                    } else {
+                        mReader.reset();
+                    }
+                    initCanvasBounds(read(mReader));
+                } catch (Throwable e) {
+                    e.printStackTrace();
+                }
+            }
+        } finally {
+            Log.i(TAG, debugInfo() + " Set state to RUNNING,cost " + (System.currentTimeMillis() - start));
+            mState = State.RUNNING;
+        }
+        if (getNumPlays() == 0 || !finished) {
+            this.frameIndex = -1;
+            renderTask.run();
+            for (RenderListener renderListener : renderListeners) {
+                renderListener.onStart();
+            }
+        } else {
+            Log.i(TAG, debugInfo() + " No need to started");
+        }
+    }
+
+    @WorkerThread
+    private void innerStop() {
+        workerHandler.removeCallbacks(renderTask);
+        frames.clear();
+        for (Bitmap bitmap : cacheBitmaps) {
+            if (bitmap != null && !bitmap.isRecycled()) {
+                bitmap.recycle();
+            }
+        }
+        cacheBitmaps.clear();
+        if (frameBuffer != null) {
+            frameBuffer = null;
+        }
+        cachedCanvas.clear();
+        try {
+            if (mReader != null) {
+                mReader.close();
+                mReader = null;
+            }
+            if (mWriter != null) {
+                mWriter.close();
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        release();
+        mState = State.IDLE;
+        for (RenderListener renderListener : renderListeners) {
+            renderListener.onEnd();
+        }
+    }
+
+    public void stop() {
+        if (fullRect == RECT_EMPTY) {
+            return;
+        }
+        if (mState == State.FINISHING || mState == State.IDLE) {
+            Log.i(TAG, debugInfo() + "No need to stop");
+            return;
+        }
+        if (mState == State.INITIALIZING) {
+            Log.e(TAG, debugInfo() + "Processing,wait for finish at " + mState);
+        }
+        mState = State.FINISHING;
+        if (Looper.myLooper() == workerHandler.getLooper()) {
+            innerStop();
+        } else {
+            workerHandler.post(new Runnable() {
+                @Override
+                public void run() {
+                    innerStop();
+                }
+            });
+        }
+    }
+
+    private String debugInfo() {
+        return "";
+    }
+
+    protected abstract void release();
+
+    public boolean isRunning() {
+        return mState == State.RUNNING || mState == State.INITIALIZING;
+    }
+
+    public boolean isPaused() {
+        return paused.get();
+    }
+
+    public void setLoopLimit(int limit) {
+        this.loopLimit = limit;
+    }
+
+    public void reset() {
+        this.playCount = 0;
+        this.frameIndex = -1;
+        this.finished = false;
+    }
+
+    public void pause() {
+        workerHandler.removeCallbacks(renderTask);
+        paused.compareAndSet(false, true);
+    }
+
+    public void resume() {
+        paused.compareAndSet(true, false);
+        workerHandler.removeCallbacks(renderTask);
+        workerHandler.post(renderTask);
+    }
+
+
+    public int getSampleSize() {
+        return sampleSize;
+    }
+
+    public boolean setDesiredSize(int width, int height) {
+        boolean sampleSizeChanged = false;
+        int sample = getDesiredSample(width, height);
+        if (sample != this.sampleSize) {
+            this.sampleSize = sample;
+            sampleSizeChanged = true;
+            final boolean tempRunning = isRunning();
+            workerHandler.removeCallbacks(renderTask);
+            workerHandler.post(new Runnable() {
+                @Override
+                public void run() {
+                    innerStop();
+                    try {
+                        initCanvasBounds(read(getReader(mLoader.obtain())));
+                        if (tempRunning) {
+                            innerStart();
+                        }
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            });
+        }
+        return sampleSizeChanged;
+    }
+
+    protected int getDesiredSample(int desiredWidth, int desiredHeight) {
+        if (desiredWidth == 0 || desiredHeight == 0) {
+            return 1;
+        }
+        int radio = Math.min(getBounds().width() / desiredWidth, getBounds().height() / desiredHeight);
+        int sample = 1;
+        while ((sample * 2) <= radio) {
+            sample *= 2;
+        }
+        return sample;
+    }
+
+    protected abstract Rect read(R reader) throws IOException;
+
+    private int getNumPlays() {
+        return this.loopLimit != null ? this.loopLimit : this.getLoopCount();
+    }
+
+    private boolean canStep() {
+        if (!isRunning()) {
+            return false;
+        }
+        if (frames.size() == 0) {
+            return false;
+        }
+        if (getNumPlays() <= 0) {
+            return true;
+        }
+        if (this.playCount < getNumPlays() - 1) {
+            return true;
+        } else if (this.playCount == getNumPlays() - 1 && this.frameIndex < this.getFrameCount() - 1) {
+            return true;
+        }
+        finished = true;
+        return false;
+    }
+
+    @WorkerThread
+    private long step() {
+        this.frameIndex++;
+        if (this.frameIndex >= this.getFrameCount()) {
+            this.frameIndex = 0;
+            this.playCount++;
+        }
+        Frame frame = getFrame(this.frameIndex);
+        if (frame == null) {
+            return 0;
+        }
+        renderFrame(frame);
+        return frame.frameDuration;
+    }
+
+    protected abstract void renderFrame(Frame frame);
+
+    private Frame getFrame(int index) {
+        if (index < 0 || index >= frames.size()) {
+            return null;
+        }
+        return frames.get(index);
+    }
+
+    /**
+     * Get Indexed frame
+     *
+     * @param index <0 means reverse from last index
+     */
+    public Bitmap getFrameBitmap(int index) throws IOException {
+        if (mState != State.IDLE) {
+            Log.e(TAG, debugInfo() + ",stop first");
+            return null;
+        }
+        mState = State.RUNNING;
+        paused.compareAndSet(true, false);
+        if (frames.size() == 0) {
+            if (mReader == null) {
+                mReader = getReader(mLoader.obtain());
+            } else {
+                mReader.reset();
+            }
+            initCanvasBounds(read(mReader));
+        }
+        if (index < 0) {
+            index += this.frames.size();
+        }
+        if (index < 0) {
+            index = 0;
+        }
+        frameIndex = -1;
+        while (frameIndex < index) {
+            if (canStep()) {
+                step();
+            } else {
+                break;
+            }
+        }
+        frameBuffer.rewind();
+        Bitmap bitmap = Bitmap.createBitmap(getBounds().width() / getSampleSize(), getBounds().height() / getSampleSize(), Bitmap.Config.ARGB_8888);
+        bitmap.copyPixelsFromBuffer(frameBuffer);
+        innerStop();
+        return bitmap;
+    }
+}
--- a/app/src/main/java/org/signal/glide/common/executor/FrameDecoderExecutor.java
+++ b/app/src/main/java/org/signal/glide/common/executor/FrameDecoderExecutor.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.executor;
+
+import android.os.HandlerThread;
+import android.os.Looper;
+
+import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * @Description: com.github.penfeizhou.animation.executor
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019-11-21
+ */
+public class FrameDecoderExecutor {
+    private static int sPoolNumber = 4;
+    private ArrayList<HandlerThread> mHandlerThreadGroup = new ArrayList<>();
+    private AtomicInteger counter = new AtomicInteger(0);
+
+    private FrameDecoderExecutor() {
+    }
+
+    static class Inner {
+        static final FrameDecoderExecutor sInstance = new FrameDecoderExecutor();
+    }
+
+    public void setPoolSize(int size) {
+        sPoolNumber = size;
+    }
+
+    public static FrameDecoderExecutor getInstance() {
+        return Inner.sInstance;
+    }
+
+    public Looper getLooper(int taskId) {
+        int idx = taskId % sPoolNumber;
+        if (idx >= mHandlerThreadGroup.size()) {
+            HandlerThread handlerThread = new HandlerThread("FrameDecoderExecutor-" + idx);
+            handlerThread.start();
+
+            mHandlerThreadGroup.add(handlerThread);
+            Looper looper = handlerThread.getLooper();
+            if (looper != null) {
+                return looper;
+            } else {
+                return Looper.getMainLooper();
+            }
+        } else {
+            if (mHandlerThreadGroup.get(idx) != null) {
+                Looper looper = mHandlerThreadGroup.get(idx).getLooper();
+                if (looper != null) {
+                    return looper;
+                } else {
+                    return Looper.getMainLooper();
+                }
+            } else {
+                return Looper.getMainLooper();
+            }
+        }
+    }
+
+    public int generateTaskId() {
+        return counter.getAndIncrement();
+    }
+}
+
--- a/app/src/main/java/org/signal/glide/common/io/ByteBufferReader.java
+++ b/app/src/main/java/org/signal/glide/common/io/ByteBufferReader.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.io;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+
+/**
+ * @Description: APNG4Android
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019-05-14
+ */
+public class ByteBufferReader implements Reader {
+
+    private final ByteBuffer byteBuffer;
+
+    public ByteBufferReader(ByteBuffer byteBuffer) {
+        this.byteBuffer = byteBuffer;
+        byteBuffer.position(0);
+    }
+
+    @Override
+    public long skip(long total) throws IOException {
+        byteBuffer.position((int) (byteBuffer.position() + total));
+        return total;
+    }
+
+    @Override
+    public byte peek() throws IOException {
+        return byteBuffer.get();
+    }
+
+    @Override
+    public void reset() throws IOException {
+        byteBuffer.position(0);
+    }
+
+    @Override
+    public int position() {
+        return byteBuffer.position();
+    }
+
+    @Override
+    public int read(byte[] buffer, int start, int byteCount) throws IOException {
+        byteBuffer.get(buffer, start, byteCount);
+        return byteCount;
+    }
+
+    @Override
+    public int available() throws IOException {
+        return byteBuffer.limit() - byteBuffer.position();
+    }
+
+    @Override
+    public void close() throws IOException {
+    }
+
+    @Override
+    public InputStream toInputStream() throws IOException {
+        return new ByteArrayInputStream(byteBuffer.array());
+    }
+}
--- a/app/src/main/java/org/signal/glide/common/io/ByteBufferWriter.java
+++ b/app/src/main/java/org/signal/glide/common/io/ByteBufferWriter.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.io;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * @Description: ByteBufferWriter
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019-05-12
+ */
+public class ByteBufferWriter implements Writer {
+
+    protected ByteBuffer byteBuffer;
+
+    public ByteBufferWriter() {
+        reset(10 * 1024);
+    }
+
+    @Override
+    public void putByte(byte b) {
+        byteBuffer.put(b);
+    }
+
+    @Override
+    public void putBytes(byte[] b) {
+        byteBuffer.put(b);
+    }
+
+    @Override
+    public int position() {
+        return byteBuffer.position();
+    }
+
+    @Override
+    public void skip(int length) {
+        byteBuffer.position(length + position());
+    }
+
+    @Override
+    public byte[] toByteArray() {
+        return byteBuffer.array();
+    }
+
+    @Override
+    public void close() {
+    }
+
+    @Override
+    public void reset(int size) {
+        if (byteBuffer == null || size > byteBuffer.capacity()) {
+            byteBuffer = ByteBuffer.allocate(size);
+            this.byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
+        }
+        byteBuffer.clear();
+    }
+}
--- a/app/src/main/java/org/signal/glide/common/io/FileReader.java
+++ b/app/src/main/java/org/signal/glide/common/io/FileReader.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.io;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+/**
+ * @Description: FileReader
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019-05-23
+ */
+public class FileReader extends FilterReader {
+    private final File mFile;
+
+    public FileReader(File file) throws IOException {
+        super(new StreamReader(new FileInputStream(file)));
+        mFile = file;
+    }
+
+    @Override
+    public void reset() throws IOException {
+        reader.close();
+        reader = new StreamReader(new FileInputStream(mFile));
+    }
+}
--- a/app/src/main/java/org/signal/glide/common/io/FilterReader.java
+++ b/app/src/main/java/org/signal/glide/common/io/FilterReader.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.io;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * @Description: FilterReader
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019-05-23
+ */
+public class FilterReader implements Reader {
+    protected Reader reader;
+
+    public FilterReader(Reader in) {
+        this.reader = in;
+    }
+
+    @Override
+    public long skip(long total) throws IOException {
+        return reader.skip(total);
+    }
+
+    @Override
+    public byte peek() throws IOException {
+        return reader.peek();
+    }
+
+    @Override
+    public void reset() throws IOException {
+        reader.reset();
+    }
+
+    @Override
+    public int position() {
+        return reader.position();
+    }
+
+    @Override
+    public int read(byte[] buffer, int start, int byteCount) throws IOException {
+        return reader.read(buffer, start, byteCount);
+    }
+
+    @Override
+    public int available() throws IOException {
+        return reader.available();
+    }
+
+    @Override
+    public void close() throws IOException {
+        reader.close();
+    }
+
+    @Override
+    public InputStream toInputStream() throws IOException {
+        reset();
+        return reader.toInputStream();
+    }
+}
--- a/app/src/main/java/org/signal/glide/common/io/Reader.java
+++ b/app/src/main/java/org/signal/glide/common/io/Reader.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.io;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * @link {https://developers.google.com/speed/webp/docs/riff_container#terminology_basics}
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019-05-11
+ */
+public interface Reader {
+    long skip(long total) throws IOException;
+
+    byte peek() throws IOException;
+
+    void reset() throws IOException;
+
+    int position();
+
+    int read(byte[] buffer, int start, int byteCount) throws IOException;
+
+    int available() throws IOException;
+
+    /**
+     * close io
+     */
+    void close() throws IOException;
+
+    InputStream toInputStream() throws IOException;
+}
--- a/app/src/main/java/org/signal/glide/common/io/StreamReader.java
+++ b/app/src/main/java/org/signal/glide/common/io/StreamReader.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.io;
+
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019-05-11
+ */
+public class StreamReader extends FilterInputStream implements Reader {
+    private int position;
+
+    public StreamReader(InputStream in) {
+        super(in);
+        try {
+            in.reset();
+        } catch (IOException e) {
+            // e.printStackTrace();
+        }
+    }
+
+    @Override
+    public byte peek() throws IOException {
+        byte ret = (byte) read();
+        position++;
+        return ret;
+    }
+
+    @Override
+    public int read(byte[] b, int off, int len) throws IOException {
+        int ret = super.read(b, off, len);
+        position += Math.max(0, ret);
+        return ret;
+    }
+
+    @Override
+    public synchronized void reset() throws IOException {
+        super.reset();
+        position = 0;
+    }
+
+    @Override
+    public long skip(long n) throws IOException {
+        long ret = super.skip(n);
+        position += ret;
+        return ret;
+    }
+
+    @Override
+    public int position() {
+        return position;
+    }
+
+    @Override
+    public InputStream toInputStream() throws IOException {
+        return this;
+    }
+}
--- a/app/src/main/java/org/signal/glide/common/io/Writer.java
+++ b/app/src/main/java/org/signal/glide/common/io/Writer.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.io;
+
+import java.io.IOException;
+
+/**
+ * @Description: APNG4Android
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019-05-12
+ */
+public interface Writer {
+    void reset(int size);
+
+    void putByte(byte b);
+
+    void putBytes(byte[] b);
+
+    int position();
+
+    void skip(int length);
+
+    byte[] toByteArray();
+
+    void close() throws IOException;
+}
--- a/app/src/main/java/org/signal/glide/common/loader/AssetStreamLoader.java
+++ b/app/src/main/java/org/signal/glide/common/loader/AssetStreamLoader.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.loader;
+
+import android.content.Context;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * @Description: 从Asset中读取流
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019/3/28
+ */
+public class AssetStreamLoader extends StreamLoader {
+
+    private final Context mContext;
+    private final String mAssetName;
+
+    public AssetStreamLoader(Context context, String assetName) {
+        mContext = context.getApplicationContext();
+        mAssetName = assetName;
+    }
+
+    @Override
+    protected InputStream getInputStream() throws IOException {
+        return mContext.getAssets().open(mAssetName);
+    }
+}
--- a/app/src/main/java/org/signal/glide/common/loader/ByteBufferLoader.java
+++ b/app/src/main/java/org/signal/glide/common/loader/ByteBufferLoader.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.loader;
+
+import org.signal.glide.common.io.ByteBufferReader;
+import org.signal.glide.common.io.Reader;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+/**
+ * @Description: ByteBufferLoader
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019-05-15
+ */
+public abstract class ByteBufferLoader implements Loader {
+    public abstract ByteBuffer getByteBuffer();
+
+    @Override
+    public Reader obtain() throws IOException {
+        return new ByteBufferReader(getByteBuffer());
+    }
+}
--- a/app/src/main/java/org/signal/glide/common/loader/FileLoader.java
+++ b/app/src/main/java/org/signal/glide/common/loader/FileLoader.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.loader;
+
+import org.signal.glide.common.io.FileReader;
+import org.signal.glide.common.io.Reader;
+
+import java.io.File;
+import java.io.IOException;
+
+/**
+ * @Description: 从文件加载流
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019/3/28
+ */
+public class FileLoader implements Loader {
+
+    private final File mFile;
+    private Reader mReader;
+
+    public FileLoader(String path) {
+        mFile = new File(path);
+    }
+
+    @Override
+    public synchronized Reader obtain() throws IOException {
+        return new FileReader(mFile);
+    }
+}
--- a/app/src/main/java/org/signal/glide/common/loader/Loader.java
+++ b/app/src/main/java/org/signal/glide/common/loader/Loader.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.loader;
+
+import org.signal.glide.common.io.Reader;
+
+import java.io.IOException;
+
+/**
+ * @Description: Loader
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019-05-14
+ */
+public interface Loader {
+    Reader obtain() throws IOException;
+}
--- a/app/src/main/java/org/signal/glide/common/loader/ResourceStreamLoader.java
+++ b/app/src/main/java/org/signal/glide/common/loader/ResourceStreamLoader.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.loader;
+
+import android.content.Context;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * @Description: 从资源加载流
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019/3/28
+ */
+public class ResourceStreamLoader extends StreamLoader {
+    private final Context mContext;
+    private final int mResId;
+
+
+    public ResourceStreamLoader(Context context, int resId) {
+        mContext = context.getApplicationContext();
+        mResId = resId;
+    }
+
+    @Override
+    protected InputStream getInputStream() throws IOException {
+        return mContext.getResources().openRawResource(mResId);
+    }
+}
--- a/app/src/main/java/org/signal/glide/common/loader/StreamLoader.java
+++ b/app/src/main/java/org/signal/glide/common/loader/StreamLoader.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2019 Zhou Pengfei
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.signal.glide.common.loader;
+
+import org.signal.glide.common.io.Reader;
+import org.signal.glide.common.io.StreamReader;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * @Author: pengfei.zhou
+ * @CreateDate: 2019/3/28
+ */
+public abstract class StreamLoader implements Loader {
+    protected abstract InputStream getInputStream() throws IOException;
+
+
+    public final synchronized Reader obtain() throws IOException {
+        return new StreamReader(getInputStream());
+    }
+}