| /* |
| * Copyright (C) 2015 The Gifplayer Authors. All Rights Reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package jp.tomorrowkey.android.gifplayer; |
| |
| import android.graphics.Bitmap; |
| import android.graphics.Canvas; |
| import android.graphics.ColorFilter; |
| import android.graphics.Paint; |
| import android.graphics.PixelFormat; |
| import android.graphics.Rect; |
| import android.graphics.drawable.Animatable; |
| import android.graphics.drawable.Drawable; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.SystemClock; |
| import android.util.Log; |
| |
| /** |
| * A base GIF Drawable with support for animations. |
| * |
| * Inspired by http://code.google.com/p/android-gifview/ |
| */ |
| public class BaseGifDrawable extends Drawable implements Runnable, Animatable, |
| android.os.Handler.Callback { |
| |
| private static final String TAG = "GifDrawable"; |
| |
| // Max decoder pixel stack size |
| private static final int MAX_STACK_SIZE = 4096; |
| private static final int MAX_BITS = 4097; |
| |
| // Frame disposal methods |
| private static final int DISPOSAL_METHOD_UNKNOWN = 0; |
| private static final int DISPOSAL_METHOD_LEAVE = 1; |
| private static final int DISPOSAL_METHOD_BACKGROUND = 2; |
| private static final int DISPOSAL_METHOD_RESTORE = 3; |
| |
| // Message types |
| private static final int READ_FRAME_REQ = 10; |
| private static final int READ_FRAME_RESP = 11; |
| private static final int RESET_DECODER = 12; |
| |
| // Specifies the minimum amount of time before a subsequent frame will be rendered. |
| private static final int MIN_FRAME_SCHEDULE_DELAY_MS = 5; |
| |
| private static final byte[] NETSCAPE2_0 = "NETSCAPE2.0".getBytes(); |
| |
| private static Paint sPaint; |
| private static Paint sScalePaint; |
| |
| protected final BaseGifImage mGifImage; |
| private final byte[] mData; |
| |
| private int mPosition; |
| protected int mIntrinsicWidth; |
| protected int mIntrinsicHeight; |
| |
| private int mWidth; |
| private int mHeight; |
| |
| protected Bitmap mBitmap; |
| protected int[] mColors; |
| private boolean mScale; |
| private float mScaleFactor; |
| |
| // The following are marked volatile because they are read/written in the background decoder |
| // thread and read from the UI thread. No further synchronization is needed because their |
| // values will only ever change from at most once, and it is safe to lazily detect the change |
| // in the UI thread. |
| private volatile boolean mError; |
| private volatile boolean mDone; |
| private volatile boolean mAnimateOnLoad = true; |
| |
| private int mBackgroundColor; |
| private boolean mLocalColorTableUsed; |
| private int mLocalColorTableSize; |
| private int[] mLocalColorTable; |
| private int[] mActiveColorTable; |
| private boolean mInterlace; |
| |
| // Each frame specifies a sub-region of the image that should be updated. The values are |
| // clamped to the GIF dimensions if they exceed the intrinsic dimensions. |
| private int mFrameX, mFrameY, mFrameWidth, mFrameHeight; |
| |
| // This specifies the width of the actual data within a GIF frame. It will be equal to |
| // mFrameWidth unless the frame sub-region was clamped to prevent exceeding the intrinsic |
| // dimensions. |
| private int mFrameStep; |
| |
| private byte[] mBlock = new byte[256]; |
| private int mDisposalMethod = DISPOSAL_METHOD_BACKGROUND; |
| private boolean mTransparency; |
| private int mTransparentColorIndex; |
| |
| // LZW decoder working arrays |
| private short[] mPrefix = new short[MAX_STACK_SIZE]; |
| private byte[] mSuffix = new byte[MAX_STACK_SIZE]; |
| private byte[] mPixelStack = new byte[MAX_STACK_SIZE + 1]; |
| private byte[] mPixels; |
| |
| private boolean mBackupSaved; |
| private int[] mBackup; |
| |
| private int mFrameCount; |
| |
| private long mLastFrameTime; |
| |
| private boolean mRunning; |
| protected int mFrameDelay; |
| private int mNextFrameDelay; |
| protected boolean mScheduled; |
| private boolean mAnimationEnabled = true; |
| private final Handler mHandler = new Handler(Looper.getMainLooper(), this); |
| private static DecoderThread sDecoderThread; |
| private static Handler sDecoderHandler; |
| |
| private boolean mRecycled; |
| protected boolean mFirstFrameReady; |
| private boolean mEndOfFile; |
| private int mLoopCount = 0; // 0 to repeat endlessly. |
| private int mLoopIndex = 0; |
| |
| private final Bitmap.Config mBitmapConfig; |
| private boolean mFirstFrame = true; |
| |
| public BaseGifDrawable(BaseGifImage gifImage, Bitmap.Config bitmapConfig) { |
| this.mBitmapConfig = bitmapConfig; |
| |
| // Create the background decoder thread, if necessary. |
| if (sDecoderThread == null) { |
| sDecoderThread = new DecoderThread(); |
| sDecoderThread.start(); |
| sDecoderHandler = new Handler(sDecoderThread.getLooper(), sDecoderThread); |
| } |
| |
| if (sPaint == null) { |
| sPaint = new Paint(Paint.FILTER_BITMAP_FLAG); |
| sScalePaint = new Paint(Paint.FILTER_BITMAP_FLAG); |
| sScalePaint.setFilterBitmap(true); |
| } |
| |
| mGifImage = gifImage; |
| mData = gifImage.getData(); |
| mPosition = mGifImage.mHeaderSize; |
| mFrameWidth = mFrameStep = mIntrinsicWidth = gifImage.getWidth(); |
| mFrameHeight = mIntrinsicHeight = gifImage.getHeight(); |
| mBackgroundColor = mGifImage.mBackgroundColor; |
| mError = mGifImage.mError; |
| |
| if (!mError) { |
| try { |
| mBitmap = Bitmap.createBitmap(mIntrinsicWidth, mIntrinsicHeight, mBitmapConfig); |
| if (mBitmap == null) { |
| throw new OutOfMemoryError("Cannot allocate bitmap"); |
| } |
| |
| int pixelCount = mIntrinsicWidth * mIntrinsicHeight; |
| mColors = new int[pixelCount]; |
| mPixels = new byte[pixelCount]; |
| |
| mWidth = mIntrinsicHeight; |
| mHeight = mIntrinsicHeight; |
| |
| // Read the first frame |
| sDecoderHandler.sendMessage(sDecoderHandler.obtainMessage(READ_FRAME_REQ, this)); |
| } catch (OutOfMemoryError e) { |
| mError = true; |
| } |
| } |
| } |
| |
| /** |
| * Sets the loop count for multi-frame animation. |
| */ |
| public void setLoopCount(int loopCount) { |
| mLoopCount = loopCount; |
| } |
| |
| /** |
| * Returns the loop count for multi-frame animation. |
| */ |
| public int getLoopCount() { |
| return mLoopCount; |
| } |
| |
| /** |
| * Sets whether to start animation on load or not. |
| */ |
| public void setAnimateOnLoad(boolean animateOnLoad) { |
| mAnimateOnLoad = animateOnLoad; |
| } |
| |
| /** |
| * Returns {@code true} if the GIF is valid and {@code false} otherwise. |
| */ |
| public boolean isValid() { |
| return !mError && mFirstFrameReady; |
| } |
| |
| public void onRecycle() { |
| if (mBitmap != null) { |
| mBitmap.recycle(); |
| } |
| mBitmap = null; |
| mRecycled = true; |
| } |
| |
| /** |
| * Enables or disables the GIF from animating. GIF animations are enabled by default. |
| */ |
| public void setAnimationEnabled(boolean animationEnabled) { |
| if (mAnimationEnabled == animationEnabled) { |
| return; |
| } |
| |
| mAnimationEnabled = animationEnabled; |
| if (mAnimationEnabled) { |
| start(); |
| } else { |
| stop(); |
| } |
| } |
| |
| @Override |
| protected void onBoundsChange(Rect bounds) { |
| super.onBoundsChange(bounds); |
| mWidth = bounds.width(); |
| mHeight = bounds.height(); |
| mScale = mWidth != mIntrinsicWidth && mHeight != mIntrinsicHeight; |
| if (mScale) { |
| mScaleFactor = Math.max((float) mWidth / mIntrinsicWidth, |
| (float) mHeight / mIntrinsicHeight); |
| } |
| |
| if (!mError && !mRecycled) { |
| // Request that the decoder reset itself |
| sDecoderHandler.sendMessage(sDecoderHandler.obtainMessage(RESET_DECODER, this)); |
| } |
| } |
| |
| @Override |
| public boolean setVisible(boolean visible, boolean restart) { |
| boolean changed = super.setVisible(visible, restart); |
| if (visible) { |
| if (changed || restart) { |
| start(); |
| } |
| } else { |
| stop(); |
| } |
| return changed; |
| } |
| |
| @Override |
| public void draw(Canvas canvas) { |
| if (mError || mWidth == 0 || mHeight == 0 || mRecycled || !mFirstFrameReady) { |
| return; |
| } |
| |
| if (mScale) { |
| canvas.save(); |
| canvas.scale(mScaleFactor, mScaleFactor, 0, 0); |
| canvas.drawBitmap(mBitmap, 0, 0, sScalePaint); |
| canvas.restore(); |
| } else { |
| canvas.drawBitmap(mBitmap, 0, 0, sPaint); |
| } |
| |
| if (mRunning) { |
| if (!mScheduled) { |
| // Schedule the next frame at mFrameDelay milliseconds from the previous frame or |
| // the minimum sceduling delay from now, whichever is later. |
| mLastFrameTime = Math.max( |
| mLastFrameTime + mFrameDelay, |
| SystemClock.uptimeMillis() + MIN_FRAME_SCHEDULE_DELAY_MS); |
| scheduleSelf(this, mLastFrameTime); |
| } |
| } else if (!mDone) { |
| start(); |
| } else { |
| unscheduleSelf(this); |
| } |
| } |
| |
| @Override |
| public int getIntrinsicWidth() { |
| return mIntrinsicWidth; |
| } |
| |
| @Override |
| public int getIntrinsicHeight() { |
| return mIntrinsicHeight; |
| } |
| |
| @Override |
| public int getOpacity() { |
| return PixelFormat.UNKNOWN; |
| } |
| |
| @Override |
| public void setAlpha(int alpha) { |
| } |
| |
| @Override |
| public void setColorFilter(ColorFilter cf) { |
| } |
| |
| @Override |
| public boolean isRunning() { |
| return mRunning; |
| } |
| |
| @Override |
| public void start() { |
| if (!isRunning()) { |
| mRunning = true; |
| if (!mAnimateOnLoad) { |
| mDone = true; |
| } |
| mLastFrameTime = SystemClock.uptimeMillis(); |
| run(); |
| } |
| } |
| |
| @Override |
| public void stop() { |
| if (isRunning()) { |
| unscheduleSelf(this); |
| } |
| } |
| |
| @Override |
| public void scheduleSelf(Runnable what, long when) { |
| if (mAnimationEnabled) { |
| super.scheduleSelf(what, when); |
| mScheduled = true; |
| } |
| } |
| |
| @Override |
| public void unscheduleSelf(Runnable what) { |
| super.unscheduleSelf(what); |
| mRunning = false; |
| } |
| |
| /** |
| * Moves to the next frame. |
| */ |
| @Override |
| public void run() { |
| if (mRecycled) { |
| return; |
| } |
| |
| // Send request to decoder to read the next frame |
| if (!mDone) { |
| sDecoderHandler.sendMessage(sDecoderHandler.obtainMessage(READ_FRAME_REQ, this)); |
| } |
| } |
| |
| /** |
| * Restarts decoding the image from the beginning. Called from the background thread. |
| */ |
| private void reset() { |
| // Return to the position of the first image frame in the stream. |
| mPosition = mGifImage.mHeaderSize; |
| mBackupSaved = false; |
| mFrameCount = 0; |
| mDisposalMethod = DISPOSAL_METHOD_UNKNOWN; |
| } |
| |
| /** |
| * Restarts animation if a limited number of loops of animation have been previously done. |
| */ |
| public void restartAnimation() { |
| if (mDone && mLoopCount > 0) { |
| reset(); |
| mDone = false; |
| mLoopIndex = 0; |
| run(); |
| } |
| } |
| |
| /** |
| * Reads color table as 256 RGB integer values. Called from the background thread. |
| * |
| * @param ncolors int number of colors to read |
| */ |
| private void readColorTable(int[] colorTable, int ncolors) { |
| for (int i = 0; i < ncolors; i++) { |
| int r = mData[mPosition++] & 0xff; |
| int g = mData[mPosition++] & 0xff; |
| int b = mData[mPosition++] & 0xff; |
| colorTable[i] = 0xff000000 | (r << 16) | (g << 8) | b; |
| } |
| } |
| |
| /** |
| * Reads GIF content blocks. Called from the background thread. |
| * |
| * @return true if the next frame has been parsed successfully, false if EOF |
| * has been reached |
| */ |
| private void readNextFrame() { |
| // Don't clear the image if it is a terminator. |
| if ((mData[mPosition] & 0xff) == 0x3b) { |
| mEndOfFile = true; |
| return; |
| } |
| disposeOfLastFrame(); |
| |
| mDisposalMethod = DISPOSAL_METHOD_UNKNOWN; |
| mTransparency = false; |
| |
| mEndOfFile = false; |
| mNextFrameDelay = 100; |
| mLocalColorTable = null; |
| |
| while (true) { |
| int code = mData[mPosition++] & 0xff; |
| switch (code) { |
| case 0: // Empty block, ignore |
| break; |
| case 0x21: // Extension. Extensions precede the corresponding image. |
| code = mData[mPosition++] & 0xff; |
| switch (code) { |
| case 0xf9: // graphics control extension |
| readGraphicControlExt(); |
| break; |
| case 0xff: // application extension |
| readBlock(); |
| boolean netscape = true; |
| for (int i = 0; i < NETSCAPE2_0.length; i++) { |
| if (mBlock[i] != NETSCAPE2_0[i]) { |
| netscape = false; |
| break; |
| } |
| } |
| if (netscape) { |
| readNetscapeExtension(); |
| } else { |
| skip(); // don't care |
| } |
| break; |
| case 0xfe:// comment extension |
| skip(); |
| break; |
| case 0x01:// plain text extension |
| skip(); |
| break; |
| default: // uninteresting extension |
| skip(); |
| } |
| break; |
| |
| case 0x2C: // Image separator |
| readBitmap(); |
| return; |
| |
| case 0x3b: // Terminator |
| mEndOfFile = true; |
| return; |
| |
| default: // We don't know what this is. Just skip it. |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Disposes of the previous frame. Called from the background thread. |
| */ |
| private void disposeOfLastFrame() { |
| if (mFirstFrame) { |
| mFirstFrame = false; |
| return; |
| } |
| switch (mDisposalMethod) { |
| case DISPOSAL_METHOD_UNKNOWN: |
| case DISPOSAL_METHOD_LEAVE: { |
| mBackupSaved = false; |
| break; |
| } |
| case DISPOSAL_METHOD_RESTORE: { |
| if (mBackupSaved) { |
| System.arraycopy(mBackup, 0, mColors, 0, mBackup.length); |
| } |
| break; |
| } |
| case DISPOSAL_METHOD_BACKGROUND: { |
| mBackupSaved = false; |
| |
| // Fill last image rect area with background color |
| int color = 0; |
| if (!mTransparency) { |
| color = mBackgroundColor; |
| } |
| for (int i = 0; i < mFrameHeight; i++) { |
| int n1 = (mFrameY + i) * mIntrinsicWidth + mFrameX; |
| int n2 = n1 + mFrameWidth; |
| for (int k = n1; k < n2; k++) { |
| mColors[k] = color; |
| } |
| } |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Reads Graphics Control Extension values. Called from the background thread. |
| */ |
| private void readGraphicControlExt() { |
| mPosition++; // Block size, fixed |
| |
| int packed = mData[mPosition++] & 0xff; // Packed fields |
| |
| mDisposalMethod = (packed & 0x1c) >> 2; // Disposal method |
| mTransparency = (packed & 1) != 0; |
| mNextFrameDelay = readShort() * 10; // Delay in milliseconds |
| |
| // It seems that there are broken tools out there that set a 0ms or 10ms |
| // timeout when they really want a "default" one. |
| // Following WebKit's lead (http://trac.webkit.org/changeset/73295) |
| // we use 10 frames per second as the default frame rate. |
| if (mNextFrameDelay <= 10) { |
| mNextFrameDelay = 100; |
| } |
| |
| mTransparentColorIndex = mData[mPosition++] & 0xff; |
| |
| mPosition++; // Block terminator - ignore |
| } |
| |
| /** |
| * Reads Netscape extension to obtain iteration count. Called from the background thread. |
| */ |
| private void readNetscapeExtension() { |
| int count; |
| do { |
| count = readBlock(); |
| } while ((count > 0) && !mError); |
| } |
| |
| /** |
| * Reads next frame image. Called from the background thread. |
| */ |
| private void readBitmap() { |
| mFrameX = readShort(); // (sub)image position & size |
| mFrameY = readShort(); |
| |
| int width = readShort(); |
| int height = readShort(); |
| |
| // Clamp the frame dimensions to the intrinsic dimensions. |
| mFrameWidth = Math.min(width, mIntrinsicWidth - mFrameX); |
| mFrameHeight = Math.min(height, mIntrinsicHeight - mFrameY); |
| |
| // The frame step is set to the specfied frame width before clamping. |
| mFrameStep = width; |
| |
| // Increase the size of the decoding buffer if necessary. |
| int framePixelCount = width * height; |
| if (framePixelCount > mPixels.length) { |
| mPixels = new byte[framePixelCount]; |
| } |
| |
| int packed = mData[mPosition++] & 0xff; |
| // 3 - sort flag |
| // 4-5 - reserved lctSize = 2 << (packed & 7); |
| // 6-8 - local color table size |
| mInterlace = (packed & 0x40) != 0; |
| mLocalColorTableUsed = (packed & 0x80) != 0; // 1 - local color table flag interlace |
| mLocalColorTableSize = (int) Math.pow(2, (packed & 0x07) + 1); |
| |
| if (mLocalColorTableUsed) { |
| if (mLocalColorTable == null) { |
| mLocalColorTable = new int[256]; |
| } |
| readColorTable(mLocalColorTable, mLocalColorTableSize); |
| mActiveColorTable = mLocalColorTable; |
| } else { |
| mActiveColorTable = mGifImage.mGlobalColorTable; |
| if (mGifImage.mBackgroundIndex == mTransparentColorIndex) { |
| mBackgroundColor = 0; |
| } |
| } |
| int savedColor = 0; |
| if (mTransparency) { |
| savedColor = mActiveColorTable[mTransparentColorIndex]; |
| mActiveColorTable[mTransparentColorIndex] = 0; |
| } |
| |
| if (mActiveColorTable == null) { |
| mError = true; |
| } |
| |
| if (mError) { |
| return; |
| } |
| |
| decodeBitmapData(); |
| |
| skip(); |
| |
| if (mError) { |
| return; |
| } |
| |
| if (mDisposalMethod == DISPOSAL_METHOD_RESTORE) { |
| backupFrame(); |
| } |
| |
| populateImageData(); |
| |
| if (mTransparency) { |
| mActiveColorTable[mTransparentColorIndex] = savedColor; |
| } |
| |
| mFrameCount++; |
| } |
| |
| /** |
| * Stores the relevant portion of the current frame so that it can be restored |
| * before the next frame is rendered. Called from the background thread. |
| */ |
| private void backupFrame() { |
| if (mBackupSaved) { |
| return; |
| } |
| |
| if (mBackup == null) { |
| mBackup = null; |
| try { |
| mBackup = new int[mColors.length]; |
| } catch (OutOfMemoryError e) { |
| Log.e(TAG, "GifDrawable.backupFrame threw an OOME", e); |
| } |
| } |
| |
| if (mBackup != null) { |
| System.arraycopy(mColors, 0, mBackup, 0, mColors.length); |
| mBackupSaved = true; |
| } |
| } |
| |
| /** |
| * Decodes LZW image data into pixel array. Called from the background thread. |
| */ |
| private void decodeBitmapData() { |
| int npix = mFrameWidth * mFrameHeight; |
| |
| // Initialize GIF data stream decoder. |
| int dataSize = mData[mPosition++] & 0xff; |
| int clear = 1 << dataSize; |
| int endOfInformation = clear + 1; |
| int available = clear + 2; |
| int oldCode = -1; |
| int codeSize = dataSize + 1; |
| int codeMask = (1 << codeSize) - 1; |
| for (int code = 0; code < clear; code++) { |
| mPrefix[code] = 0; // XXX ArrayIndexOutOfBoundsException |
| mSuffix[code] = (byte) code; |
| } |
| |
| // Decode GIF pixel stream. |
| int datum = 0; |
| int bits = 0; |
| int first = 0; |
| int top = 0; |
| int pi = 0; |
| while (pi < npix) { |
| int blockSize = mData[mPosition++] & 0xff; |
| if (blockSize == 0) { |
| break; |
| } |
| |
| int blockEnd = mPosition + blockSize; |
| while (mPosition < blockEnd) { |
| datum += (mData[mPosition++] & 0xff) << bits; |
| bits += 8; |
| |
| while (bits >= codeSize) { |
| // Get the next code. |
| int code = datum & codeMask; |
| datum >>= codeSize; |
| bits -= codeSize; |
| |
| // Interpret the code |
| if (code == clear) { |
| // Reset decoder. |
| codeSize = dataSize + 1; |
| codeMask = (1 << codeSize) - 1; |
| available = clear + 2; |
| oldCode = -1; |
| continue; |
| } |
| |
| // Check for explicit end-of-stream |
| if (code == endOfInformation) { |
| mPosition = blockEnd; |
| return; |
| } |
| |
| if (oldCode == -1) { |
| mPixels[pi++] = mSuffix[code]; |
| oldCode = code; |
| first = code; |
| continue; |
| } |
| |
| int inCode = code; |
| if (code >= available) { |
| mPixelStack[top++] = (byte) first; |
| code = oldCode; |
| if (top == MAX_BITS) { |
| mError = true; |
| return; |
| } |
| } |
| |
| while (code >= clear) { |
| if (code >= MAX_BITS || code == mPrefix[code]) { |
| mError = true; |
| return; |
| } |
| |
| mPixelStack[top++] = mSuffix[code]; |
| code = mPrefix[code]; |
| |
| if (top == MAX_BITS) { |
| mError = true; |
| return; |
| } |
| } |
| |
| first = mSuffix[code]; |
| mPixelStack[top++] = (byte) first; |
| |
| // Add new code to the dictionary |
| if (available < MAX_STACK_SIZE) { |
| mPrefix[available] = (short) oldCode; |
| mSuffix[available] = (byte) first; |
| available++; |
| |
| if (((available & codeMask) == 0) && (available < MAX_STACK_SIZE)) { |
| codeSize++; |
| codeMask += available; |
| } |
| } |
| |
| oldCode = inCode; |
| |
| // Drain the pixel stack. |
| do { |
| mPixels[pi++] = mPixelStack[--top]; |
| } while (top > 0); |
| } |
| } |
| } |
| |
| while (pi < npix) { |
| mPixels[pi++] = 0; // clear missing pixels |
| } |
| } |
| |
| /** |
| * Populates the color array with pixels for the next frame. |
| */ |
| private void populateImageData() { |
| |
| // Copy each source line to the appropriate place in the destination |
| int pass = 1; |
| int inc = 8; |
| int iline = 0; |
| for (int i = 0; i < mFrameHeight; i++) { |
| int line = i; |
| if (mInterlace) { |
| if (iline >= mFrameHeight) { |
| pass++; |
| switch (pass) { |
| case 2: |
| iline = 4; |
| break; |
| case 3: |
| iline = 2; |
| inc = 4; |
| break; |
| case 4: |
| iline = 1; |
| inc = 2; |
| break; |
| default: |
| break; |
| } |
| } |
| line = iline; |
| iline += inc; |
| } |
| line += mFrameY; |
| if (line < mIntrinsicHeight) { |
| int k = line * mIntrinsicWidth; |
| int dx = k + mFrameX; // start of line in dest |
| int dlim = dx + mFrameWidth; // end of dest line |
| |
| // It is unnecesary to test if dlim is beyond the edge of the destination line, |
| // since mFrameWidth is clamped to a maximum of mIntrinsicWidth - mFrameX. |
| |
| int sx = i * mFrameStep; // start of line in source |
| while (dx < dlim) { |
| // map color and insert in destination |
| int index = mPixels[sx++] & 0xff; |
| int c = mActiveColorTable[index]; |
| if (c != 0) { |
| mColors[dx] = c; |
| } |
| dx++; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Reads next variable length block from input. Called from the background thread. |
| * |
| * @return number of bytes stored in "buffer" |
| */ |
| private int readBlock() { |
| int blockSize = mData[mPosition++] & 0xff; |
| if (blockSize > 0) { |
| System.arraycopy(mData, mPosition, mBlock, 0, blockSize); |
| mPosition += blockSize; |
| } |
| return blockSize; |
| } |
| |
| /** |
| * Reads next 16-bit value, LSB first. Called from the background thread. |
| */ |
| private int readShort() { |
| // read 16-bit value, LSB first |
| int byte1 = mData[mPosition++] & 0xff; |
| int byte2 = mData[mPosition++] & 0xff; |
| return byte1 | (byte2 << 8); |
| } |
| |
| /** |
| * Skips variable length blocks up to and including next zero length block. |
| * Called from the background thread. |
| */ |
| private void skip() { |
| int blockSize; |
| do { |
| blockSize = mData[mPosition++] & 0xff; |
| mPosition += blockSize; |
| } while (blockSize > 0); |
| } |
| |
| @Override |
| public boolean handleMessage(Message msg) { |
| if (msg.what == BaseGifDrawable.READ_FRAME_RESP) { |
| mFrameDelay = msg.arg1; |
| if (mBitmap != null) { |
| mBitmap.setPixels(mColors, 0, mIntrinsicWidth, |
| 0, 0, mIntrinsicWidth, mIntrinsicHeight); |
| postProcessFrame(mBitmap); |
| mFirstFrameReady = true; |
| mScheduled = false; |
| invalidateSelf(); |
| } |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Gives a subclass a chance to apply changes to the mutable bitmap |
| * before showing the frame. |
| */ |
| protected void postProcessFrame(Bitmap bitmap) { |
| } |
| |
| /** |
| * Background thread that handles reading and decoding frames of GIF images. |
| */ |
| private static class DecoderThread extends HandlerThread |
| implements android.os.Handler.Callback { |
| private static final String DECODER_THREAD_NAME = "GifDecoder"; |
| |
| public DecoderThread() { |
| super(DECODER_THREAD_NAME); |
| } |
| |
| @Override |
| public boolean handleMessage(Message msg) { |
| BaseGifDrawable gif = (BaseGifDrawable) msg.obj; |
| if (gif == null || gif.mBitmap == null || gif.mRecycled) { |
| return true; |
| } |
| |
| switch (msg.what) { |
| |
| case READ_FRAME_REQ: |
| // Processed on background thread |
| do { |
| try { |
| gif.readNextFrame(); |
| } catch (ArrayIndexOutOfBoundsException e) { |
| gif.mEndOfFile = true; |
| } |
| |
| // Check for EOF |
| if (gif.mEndOfFile) { |
| if (gif.mFrameCount == 0) { |
| // could not read first frame |
| gif.mError = true; |
| } else if (gif.mFrameCount > 1) { |
| if (gif.mLoopCount == 0 || ++gif.mLoopIndex < gif.mLoopCount) { |
| // Repeat the animation |
| gif.reset(); |
| } else { |
| gif.mDone = true; |
| } |
| } else { |
| // Only one frame. Mark as done. |
| gif.mDone = true; |
| } |
| } |
| } while (gif.mEndOfFile && !gif.mError && !gif.mDone); |
| gif.mHandler.sendMessage(gif.mHandler.obtainMessage(READ_FRAME_RESP, |
| gif.mNextFrameDelay, 0)); |
| return true; |
| |
| case RESET_DECODER: |
| gif.reset(); |
| return true; |
| } |
| |
| return false; |
| } |
| } |
| } |
