content: /*
   * Copyright (C) 2013 The Android Open Source Project
   *
   * 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 com.android.photos.views;
  
  import android.content.Context;
  import android.graphics.Bitmap;
  import android.graphics.Rect;
  import android.graphics.RectF;
  import android.support.v4.util.LongSparseArray;
  import android.util.DisplayMetrics;
  import android.util.Log;
  import android.util.Pools.Pool;
  import android.util.Pools.SynchronizedPool;
  import android.view.View;
  import android.view.WindowManager;
  
  import com.android.gallery3d.common.Utils;
  import com.android.gallery3d.glrenderer.BasicTexture;
  import com.android.gallery3d.glrenderer.GLCanvas;
  import com.android.gallery3d.glrenderer.UploadedTexture;
  
  /**
   * Handles laying out, decoding, and drawing of tiles in GL
   */
  public class TiledImageRenderer {
      public static final int SIZE_UNKNOWN = -1;
  
      private static final String TAG = "TiledImageRenderer";
      private static final int UPLOAD_LIMIT = 1;
  
      /*
       *  This is the tile state in the CPU side.
       *  Life of a Tile:
       *      ACTIVATED (initial state)
       *              --> IN_QUEUE - by queueForDecode()
       *              --> RECYCLED - by recycleTile()
       *      IN_QUEUE --> DECODING - by decodeTile()
       *               --> RECYCLED - by recycleTile)
       *      DECODING --> RECYCLING - by recycleTile()
       *               --> DECODED  - by decodeTile()
       *               --> DECODE_FAIL - by decodeTile()
       *      RECYCLING --> RECYCLED - by decodeTile()
       *      DECODED --> ACTIVATED - (after the decoded bitmap is uploaded)
       *      DECODED --> RECYCLED - by recycleTile()
       *      DECODE_FAIL -> RECYCLED - by recycleTile()
       *      RECYCLED --> ACTIVATED - by obtainTile()
       */
      private static final int STATE_ACTIVATED = 0x01;
      private static final int STATE_IN_QUEUE = 0x02;
      private static final int STATE_DECODING = 0x04;
      private static final int STATE_DECODED = 0x08;
      private static final int STATE_DECODE_FAIL = 0x10;
      private static final int STATE_RECYCLING = 0x20;
      private static final int STATE_RECYCLED = 0x40;
  
      private static Pool<Bitmap> sTilePool = new SynchronizedPool<Bitmap>(64);
  
      // TILE_SIZE must be 2^N
      private int mTileSize;
  
      private TileSource mModel;
      private BasicTexture mPreview;
      protected int mLevelCount;  // cache the value of mScaledBitmaps.length
  
      // The mLevel variable indicates which level of bitmap we should use.
      // Level 0 means the original full-sized bitmap, and a larger value means
      // a smaller scaled bitmap (The width and height of each scaled bitmap is
      // half size of the previous one). If the value is in [0, mLevelCount), we
      // use the bitmap in mScaledBitmaps[mLevel] for display, otherwise the value
      // is mLevelCount
      private int mLevel = 0;
  
      private int mOffsetX;
      private int mOffsetY;
  
      private int mUploadQuota;
      private boolean mRenderComplete;
  
      private final RectF mSourceRect = new RectF();
      private final RectF mTargetRect = new RectF();
  
      private final LongSparseArray<Tile> mActiveTiles = new LongSparseArray<Tile>();
  
      // The following three queue are guarded by mQueueLock
      private final Object mQueueLock = new Object();
      private final TileQueue mRecycledQueue = new TileQueue();
      private final TileQueue mUploadQueue = new TileQueue();
      private final TileQueue mDecodeQueue = new TileQueue();
  
      // The width and height of the full-sized bitmap
      protected int mImageWidth = SIZE_UNKNOWN;
      protected int mImageHeight = SIZE_UNKNOWN;
  
      protected int mCenterX;
      protected int mCenterY;
      protected float mScale;
      protected int mRotation;
  
      private boolean mLayoutTiles;
  
      // Temp variables to avoid memory allocation
      private final Rect mTileRange = new Rect();
      private final Rect mActiveRange[] = {new Rect(), new Rect()};
  
      private TileDecoder mTileDecoder;
      private boolean mBackgroundTileUploaded;
  
      private int mViewWidth, mViewHeight;
      private View mParent;
  
      /**
       * Interface for providing tiles to a {@link TiledImageRenderer}
       */
      public static interface TileSource {
  
          /**
           * If the source does not care about the tile size, it should use
           * {@link TiledImageRenderer#suggestedTileSize(Context)}
           */
          public int getTileSize();
          public int getImageWidth();
          public int getImageHeight();
          public int getRotation();
  
          /**
           * Return a Preview image if available. This will be used as the base layer
           * if higher res tiles are not yet available
           */
          public BasicTexture getPreview();
  
          /**
           * The tile returned by this method can be specified this way: Assuming
           * the image size is (width, height), first take the intersection of (0,
           * 0) - (width, height) and (x, y) - (x + tileSize, y + tileSize). If
           * in extending the region, we found some part of the region is outside
           * the image, those pixels are filled with black.
           *
           * If level > 0, it does the same operation on a down-scaled version of
           * the original image (down-scaled by a factor of 2^level), but (x, y)
           * still refers to the coordinate on the original image.
           *
           * The method would be called by the decoder thread.
           */
          public Bitmap getTile(int level, int x, int y, Bitmap reuse);
      }
  
      public static int suggestedTileSize(Context context) {
          return isHighResolution(context) ? 512 : 256;
      }
  
      private static boolean isHighResolution(Context context) {
          DisplayMetrics metrics = new DisplayMetrics();
          WindowManager wm = (WindowManager)
                  context.getSystemService(Context.WINDOW_SERVICE);
          wm.getDefaultDisplay().getMetrics(metrics);
          return metrics.heightPixels > 2048 ||  metrics.widthPixels > 2048;
      }
  
      public TiledImageRenderer(View parent) {
          mParent = parent;
          mTileDecoder = new TileDecoder();
          mTileDecoder.start();
      }
  
      public int getViewWidth() {
          return mViewWidth;
      }
  
      public int getViewHeight() {
          return mViewHeight;
      }
  
      private void invalidate() {
          mParent.postInvalidate();
      }
  
      public void setModel(TileSource model, int rotation) {
          if (mModel != model) {
              mModel = model;
              notifyModelInvalidated();
          }
          if (mRotation != rotation) {
              mRotation = rotation;
              mLayoutTiles = true;
          }
      }
  
      private void calculateLevelCount() {
          if (mPreview != null) {
              mLevelCount = Math.max(0, Utils.ceilLog2(
                  mImageWidth / (float) mPreview.getWidth()));
          } else {
              int levels = 1;
              int maxDim = Math.max(mImageWidth, mImageHeight);
              int t = mTileSize;
              while (t < maxDim) {
                  t <<= 1;
                  levels++;
              }
              mLevelCount = levels;
          }
      }
  
      public void notifyModelInvalidated() {
          invalidateTiles();
          if (mModel == null) {
              mImageWidth = 0;
              mImageHeight = 0;
              mLevelCount = 0;
              mPreview = null;
          } else {
              mImageWidth = mModel.getImageWidth();
              mImageHeight = mModel.getImageHeight();
              mPreview = mModel.getPreview();
              mTileSize = mModel.getTileSize();
              calculateLevelCount();
          }
          mLayoutTiles = true;
      }
  
      public void setViewSize(int width, int height) {
          mViewWidth = width;
          mViewHeight = height;
      }
  
      public void setPosition(int centerX, int centerY, float scale) {
          if (mCenterX == centerX && mCenterY == centerY
                  && mScale == scale) {
              return;
          }
          mCenterX = centerX;
          mCenterY = centerY;
          mScale = scale;
          mLayoutTiles = true;
      }
  
      // Prepare the tiles we want to use for display.
      //
      // 1. Decide the tile level we want to use for display.
      // 2. Decide the tile levels we want to keep as texture (in addition to
      //    the one we use for display).
      // 3. Recycle unused tiles.
      // 4. Activate the tiles we want.
      private void layoutTiles() {
          if (mViewWidth == 0 || mViewHeight == 0 || !mLayoutTiles) {
              return;
          }
          mLayoutTiles = false;
  
          // The tile levels we want to keep as texture is in the range
          // [fromLevel, endLevel).
          int fromLevel;
          int endLevel;
  
          // We want to use a texture larger than or equal to the display size.
          mLevel = Utils.clamp(Utils.floorLog2(1f / mScale), 0, mLevelCount);
  
          // We want to keep one more tile level as texture in addition to what
          // we use for display. So it can be faster when the scale moves to the
          // next level. We choose the level closest to the current scale.
          if (mLevel != mLevelCount) {
              Rect range = mTileRange;
              getRange(range, mCenterX, mCenterY, mLevel, mScale, mRotation);
              mOffsetX = Math.round(mViewWidth / 2f + (range.left - mCenterX) * mScale);
              mOffsetY = Math.round(mViewHeight / 2f + (range.top - mCenterY) * mScale);
              fromLevel = mScale * (1 << mLevel) > 0.75f ? mLevel - 1 : mLevel;
          } else {
              // Activate the tiles of the smallest two levels.
              fromLevel = mLevel - 2;
              mOffsetX = Math.round(mViewWidth / 2f - mCenterX * mScale);
              mOffsetY = Math.round(mViewHeight / 2f - mCenterY * mScale);
          }
  
          fromLevel = Math.max(0, Math.min(fromLevel, mLevelCount - 2));
          endLevel = Math.min(fromLevel + 2, mLevelCount);
  
          Rect range[] = mActiveRange;
          for (int i = fromLevel; i < endLevel; ++i) {
              getRange(range[i - fromLevel], mCenterX, mCenterY, i, mRotation);
          }
  
          // If rotation is transient, don't update the tile.
          if (mRotation % 90 != 0) {
              return;
          }
  
          synchronized (mQueueLock) {
              mDecodeQueue.clean();
              mUploadQueue.clean();
              mBackgroundTileUploaded = false;
  
              // Recycle unused tiles: if the level of the active tile is outside the
              // range [fromLevel, endLevel) or not in the visible range.
              int n = mActiveTiles.size();
              for (int i = 0; i < n; i++) {
                  Tile tile = mActiveTiles.valueAt(i);
                  int level = tile.mTileLevel;
                  if (level < fromLevel || level >= endLevel
                          || !range[level - fromLevel].contains(tile.mX, tile.mY)) {
                      mActiveTiles.removeAt(i);
                      i--;
                      n--;
                      recycleTile(tile);
                  }
              }
          }
  
          for (int i = fromLevel; i < endLevel; ++i) {
              int size = mTileSize << i;
              Rect r = range[i - fromLevel];
              for (int y = r.top, bottom = r.bottom; y < bottom; y += size) {
                  for (int x = r.left, right = r.right; x < right; x += size) {
                      activateTile(x, y, i);
                  }
              }
          }
          invalidate();
      }
  
      private void invalidateTiles() {
          synchronized (mQueueLock) {
              mDecodeQueue.clean();
              mUploadQueue.clean();
  
              // TODO(xx): disable decoder
              int n = mActiveTiles.size();
              for (int i = 0; i < n; i++) {
                  Tile tile = mActiveTiles.valueAt(i);
                  recycleTile(tile);
              }
              mActiveTiles.clear();
          }
      }
  
      private void getRange(Rect out, int cX, int cY, int level, int rotation) {
          getRange(out, cX, cY, level, 1f / (1 << (level + 1)), rotation);
      }
  
      // If the bitmap is scaled by the given factor "scale", return the
      // rectangle containing visible range. The left-top coordinate returned is
      // aligned to the tile boundary.
      //
      // (cX, cY) is the point on the original bitmap which will be put in the
      // center of the ImageViewer.
      private void getRange(Rect out,
              int cX, int cY, int level, float scale, int rotation) {
  
          double radians = Math.toRadians(-rotation);
          double w = mViewWidth;
          double h = mViewHeight;
  
          double cos = Math.cos(radians);
          double sin = Math.sin(radians);
          int width = (int) Math.ceil(Math.max(
                  Math.abs(cos * w - sin * h), Math.abs(cos * w + sin * h)));
          int height = (int) Math.ceil(Math.max(
                  Math.abs(sin * w + cos * h), Math.abs(sin * w - cos * h)));
  
          int left = (int) Math.floor(cX - width / (2f * scale));
          int top = (int) Math.floor(cY - height / (2f * scale));
          int right = (int) Math.ceil(left + width / scale);
          int bottom = (int) Math.ceil(top + height / scale);
  
          // align the rectangle to tile boundary
          int size = mTileSize << level;
          left = Math.max(0, size * (left / size));
          top = Math.max(0, size * (top / size));
          right = Math.min(mImageWidth, right);
          bottom = Math.min(mImageHeight, bottom);
  
          out.set(left, top, right, bottom);
      }
  
      public void freeTextures() {
          mLayoutTiles = true;
  
          mTileDecoder.finishAndWait();
          synchronized (mQueueLock) {
              mUploadQueue.clean();
              mDecodeQueue.clean();
              Tile tile = mRecycledQueue.pop();
              while (tile != null) {
                  tile.recycle();
                  tile = mRecycledQueue.pop();
              }
          }
  
          int n = mActiveTiles.size();
          for (int i = 0; i < n; i++) {
              Tile texture = mActiveTiles.valueAt(i);
              texture.recycle();
          }
          mActiveTiles.clear();
          mTileRange.set(0, 0, 0, 0);
  
          while (sTilePool.acquire() != null) {}
      }
  
      public boolean draw(GLCanvas canvas) {
          layoutTiles();
          uploadTiles(canvas);
  
          mUploadQuota = UPLOAD_LIMIT;
          mRenderComplete = true;
  
          int level = mLevel;
          int rotation = mRotation;
          int flags = 0;
          if (rotation != 0) {
              flags |= GLCanvas.SAVE_FLAG_MATRIX;
          }
  
          if (flags != 0) {
              canvas.save(flags);
              if (rotation != 0) {
                  int centerX = mViewWidth / 2, centerY = mViewHeight / 2;
                  canvas.translate(centerX, centerY);
                  canvas.rotate(rotation, 0, 0, 1);
                  canvas.translate(-centerX, -centerY);
              }
          }
          try {
              if (level != mLevelCount) {
                  int size = (mTileSize << level);
                  float length = size * mScale;
                  Rect r = mTileRange;
  
                  for (int ty = r.top, i = 0; ty < r.bottom; ty += size, i++) {
                      float y = mOffsetY + i * length;
                      for (int tx = r.left, j = 0; tx < r.right; tx += size, j++) {
                          float x = mOffsetX + j * length;
                          drawTile(canvas, tx, ty, level, x, y, length);
                      }
                  }
              } else if (mPreview != null) {
                  mPreview.draw(canvas, mOffsetX, mOffsetY,
                          Math.round(mImageWidth * mScale),
                          Math.round(mImageHeight * mScale));
              }
          } finally {
              if (flags != 0) {
                  canvas.restore();
              }
          }
  
          if (mRenderComplete) {
              if (!mBackgroundTileUploaded) {
                  uploadBackgroundTiles(canvas);
              }
          } else {
              invalidate();
          }
          return mRenderComplete || mPreview != null;
      }
  
      private void uploadBackgroundTiles(GLCanvas canvas) {
          mBackgroundTileUploaded = true;
          int n = mActiveTiles.size();
          for (int i = 0; i < n; i++) {
              Tile tile = mActiveTiles.valueAt(i);
              if (!tile.isContentValid()) {
                  queueForDecode(tile);
              }
          }
      }
  
     private void queueForDecode(Tile tile) {
         synchronized (mQueueLock) {
             if (tile.mTileState == STATE_ACTIVATED) {
                 tile.mTileState = STATE_IN_QUEUE;
                 if (mDecodeQueue.push(tile)) {
                     mQueueLock.notifyAll();
                 }
             }
         }
      }
  
      private void decodeTile(Tile tile) {
          synchronized (mQueueLock) {
              if (tile.mTileState != STATE_IN_QUEUE) {
                  return;
              }
              tile.mTileState = STATE_DECODING;
          }
          boolean decodeComplete = tile.decode();
          synchronized (mQueueLock) {
              if (tile.mTileState == STATE_RECYCLING) {
                  tile.mTileState = STATE_RECYCLED;
                  if (tile.mDecodedTile != null) {
                      sTilePool.release(tile.mDecodedTile);
                      tile.mDecodedTile = null;
                  }
                  mRecycledQueue.push(tile);
                  return;
              }
              tile.mTileState = decodeComplete ? STATE_DECODED : STATE_DECODE_FAIL;
              if (!decodeComplete) {
                  return;
              }
              mUploadQueue.push(tile);
          }
          invalidate();
      }
  
      private Tile obtainTile(int x, int y, int level) {
          synchronized (mQueueLock) {
              Tile tile = mRecycledQueue.pop();
              if (tile != null) {
                  tile.mTileState = STATE_ACTIVATED;
                  tile.update(x, y, level);
                  return tile;
              }
              return new Tile(x, y, level);
          }
      }
  
      private void recycleTile(Tile tile) {
          synchronized (mQueueLock) {
              if (tile.mTileState == STATE_DECODING) {
                  tile.mTileState = STATE_RECYCLING;
                  return;
              }
              tile.mTileState = STATE_RECYCLED;
              if (tile.mDecodedTile != null) {
                  sTilePool.release(tile.mDecodedTile);
                  tile.mDecodedTile = null;
              }
              mRecycledQueue.push(tile);
          }
      }
  
      private void activateTile(int x, int y, int level) {
          long key = makeTileKey(x, y, level);
          Tile tile = mActiveTiles.get(key);
          if (tile != null) {
              if (tile.mTileState == STATE_IN_QUEUE) {
                  tile.mTileState = STATE_ACTIVATED;
              }
              return;
          }
          tile = obtainTile(x, y, level);
          mActiveTiles.put(key, tile);
      }
  
      private Tile getTile(int x, int y, int level) {
          return mActiveTiles.get(makeTileKey(x, y, level));
      }
  
      private static long makeTileKey(int x, int y, int level) {
          long result = x;
          result = (result << 16) | y;
          result = (result << 16) | level;
          return result;
      }
  
      private void uploadTiles(GLCanvas canvas) {
          int quota = UPLOAD_LIMIT;
          Tile tile = null;
          while (quota > 0) {
              synchronized (mQueueLock) {
                  tile = mUploadQueue.pop();
              }
              if (tile == null) {
                  break;
              }
              if (!tile.isContentValid()) {
                  if (tile.mTileState == STATE_DECODED) {
                      tile.updateContent(canvas);
                      --quota;
                  } else {
                      Log.w(TAG, "Tile in upload queue has invalid state: " + tile.mTileState);
                  }
              }
          }
          if (tile != null) {
              invalidate();
          }
      }
  
      // Draw the tile to a square at canvas that locates at (x, y) and
      // has a side length of length.
      private void drawTile(GLCanvas canvas,
              int tx, int ty, int level, float x, float y, float length) {
          RectF source = mSourceRect;
          RectF target = mTargetRect;
          target.set(x, y, x + length, y + length);
          source.set(0, 0, mTileSize, mTileSize);
  
          Tile tile = getTile(tx, ty, level);
          if (tile != null) {
              if (!tile.isContentValid()) {
                  if (tile.mTileState == STATE_DECODED) {
                      if (mUploadQuota > 0) {
                          --mUploadQuota;
                          tile.updateContent(canvas);
                      } else {
                          mRenderComplete = false;
                      }
                  } else if (tile.mTileState != STATE_DECODE_FAIL){
                      mRenderComplete = false;
                      queueForDecode(tile);
                  }
              }
              if (drawTile(tile, canvas, source, target)) {
                  return;
              }
          }
          if (mPreview != null) {
              int size = mTileSize << level;
              float scaleX = (float) mPreview.getWidth() / mImageWidth;
              float scaleY = (float) mPreview.getHeight() / mImageHeight;
              source.set(tx * scaleX, ty * scaleY, (tx + size) * scaleX,
                      (ty + size) * scaleY);
              canvas.drawTexture(mPreview, source, target);
          }
      }
  
      private boolean drawTile(
              Tile tile, GLCanvas canvas, RectF source, RectF target) {
          while (true) {
              if (tile.isContentValid()) {
                  canvas.drawTexture(tile, source, target);
                  return true;
              }
  
              // Parent can be divided to four quads and tile is one of the four.
              Tile parent = tile.getParentTile();
              if (parent == null) {
                  return false;
              }
              if (tile.mX == parent.mX) {
                  source.left /= 2f;
                  source.right /= 2f;
              } else {
                  source.left = (mTileSize + source.left) / 2f;
                  source.right = (mTileSize + source.right) / 2f;
              }
              if (tile.mY == parent.mY) {
                  source.top /= 2f;
                  source.bottom /= 2f;
              } else {
                  source.top = (mTileSize + source.top) / 2f;
                  source.bottom = (mTileSize + source.bottom) / 2f;
              }
              tile = parent;
          }
      }
  
      private class Tile extends UploadedTexture {
          public int mX;
          public int mY;
          public int mTileLevel;
          public Tile mNext;
          public Bitmap mDecodedTile;
          public volatile int mTileState = STATE_ACTIVATED;
  
          public Tile(int x, int y, int level) {
              mX = x;
              mY = y;
              mTileLevel = level;
          }
  
          @Override
          protected void onFreeBitmap(Bitmap bitmap) {
              sTilePool.release(bitmap);
          }
  
          boolean decode() {
              // Get a tile from the original image. The tile is down-scaled
              // by (1 << mTilelevel) from a region in the original image.
              try {
                  Bitmap reuse = sTilePool.acquire();
                  if (reuse != null && reuse.getWidth() != mTileSize) {
                      reuse = null;
                  }
                  mDecodedTile = mModel.getTile(mTileLevel, mX, mY, reuse);
              } catch (Throwable t) {
                  Log.w(TAG, "fail to decode tile", t);
              }
              return mDecodedTile != null;
          }
  
          @Override
          protected Bitmap onGetBitmap() {
              Utils.assertTrue(mTileState == STATE_DECODED);
  
              // We need to override the width and height, so that we won't
              // draw beyond the boundaries.
              int rightEdge = ((mImageWidth - mX) >> mTileLevel);
              int bottomEdge = ((mImageHeight - mY) >> mTileLevel);
              setSize(Math.min(mTileSize, rightEdge), Math.min(mTileSize, bottomEdge));
  
              Bitmap bitmap = mDecodedTile;
              mDecodedTile = null;
              mTileState = STATE_ACTIVATED;
              return bitmap;
          }
  
          // We override getTextureWidth() and getTextureHeight() here, so the
          // texture can be re-used for different tiles regardless of the actual
          // size of the tile (which may be small because it is a tile at the
          // boundary).
          @Override
          public int getTextureWidth() {
              return mTileSize;
          }
  
          @Override
          public int getTextureHeight() {
              return mTileSize;
          }
  
          public void update(int x, int y, int level) {
              mX = x;
              mY = y;
              mTileLevel = level;
              invalidateContent();
          }
  
          public Tile getParentTile() {
              if (mTileLevel + 1 == mLevelCount) {
                  return null;
              }
              int size = mTileSize << (mTileLevel + 1);
              int x = size * (mX / size);
              int y = size * (mY / size);
              return getTile(x, y, mTileLevel + 1);
          }
  
          @Override
          public String toString() {
              return String.format("tile(%s, %s, %s / %s)",
                      mX / mTileSize, mY / mTileSize, mLevel, mLevelCount);
          }
      }
  
      private static class TileQueue {
          private Tile mHead;
  
          public Tile pop() {
              Tile tile = mHead;
              if (tile != null) {
                  mHead = tile.mNext;
              }
              return tile;
          }
  
          public boolean push(Tile tile) {
              if (contains(tile)) {
                  Log.w(TAG, "Attempting to add a tile already in the queue!");
                  return false;
              }
              boolean wasEmpty = mHead == null;
              tile.mNext = mHead;
              mHead = tile;
              return wasEmpty;
          }
  
          private boolean contains(Tile tile) {
              Tile other = mHead;
              while (other != null) {
                  if (other == tile) {
                      return true;
                  }
                  other = other.mNext;
              }
              return false;
          }
  
          public void clean() {
              mHead = null;
          }
      }
  
      private class TileDecoder extends Thread {
  
          public void finishAndWait() {
              interrupt();
              try {
                  join();
              } catch (InterruptedException e) {
                  Log.w(TAG, "Interrupted while waiting for TileDecoder thread to finish!");
              }
          }
  
          private Tile waitForTile() throws InterruptedException {
              synchronized (mQueueLock) {
                  while (true) {
                      Tile tile = mDecodeQueue.pop();
                      if (tile != null) {
                          return tile;
                      }
                      mQueueLock.wait();
                  }
              }
          }
  
          @Override
          public void run() {
              try {
                  while (!isInterrupted()) {
                      Tile tile = waitForTile();
                      decodeTile(tile);
                  }
              } catch (InterruptedException ex) {
                  // We were finished
              }
          }
  
      }
  }
  