src/com/android/photos/views/TiledImageRenderer.java

   1 /*
   2  * Copyright (C) 2013 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.photos.views;
  18
  19 import android.content.Context;
  20 import android.graphics.Bitmap;
  21 import android.graphics.Rect;
  22 import android.graphics.RectF;
  23 import android.support.v4.util.LongSparseArray;
  24 import android.util.DisplayMetrics;
  25 import android.util.Log;
  26 import android.view.View;
  27 import android.view.WindowManager;
  28
  29 import com.android.gallery3d.common.Utils;
  30 import com.android.gallery3d.glrenderer.GLCanvas;
  31 import com.android.gallery3d.glrenderer.UploadedTexture;
  32 import com.android.photos.data.GalleryBitmapPool;
  33
  34 public class TiledImageRenderer {
  35     public static final int SIZE_UNKNOWN = -1;
  36
  37     private static final String TAG = "TiledImageRenderer";
  38     private static final int UPLOAD_LIMIT = 1;
  39
  40     /*
  41      *  This is the tile state in the CPU side.
  42      *  Life of a Tile:
  43      *      ACTIVATED (initial state)
  44      *              --> IN_QUEUE - by queueForDecode()
  45      *              --> RECYCLED - by recycleTile()
  46      *      IN_QUEUE --> DECODING - by decodeTile()
  47      *               --> RECYCLED - by recycleTile)
  48      *      DECODING --> RECYCLING - by recycleTile()
  49      *               --> DECODED  - by decodeTile()
  50      *               --> DECODE_FAIL - by decodeTile()
  51      *      RECYCLING --> RECYCLED - by decodeTile()
  52      *      DECODED --> ACTIVATED - (after the decoded bitmap is uploaded)
  53      *      DECODED --> RECYCLED - by recycleTile()
  54      *      DECODE_FAIL -> RECYCLED - by recycleTile()
  55      *      RECYCLED --> ACTIVATED - by obtainTile()
  56      */
  57     private static final int STATE_ACTIVATED = 0x01;
  58     private static final int STATE_IN_QUEUE = 0x02;
  59     private static final int STATE_DECODING = 0x04;
  60     private static final int STATE_DECODED = 0x08;
  61     private static final int STATE_DECODE_FAIL = 0x10;
  62     private static final int STATE_RECYCLING = 0x20;
  63     private static final int STATE_RECYCLED = 0x40;
  64
  65     private static GalleryBitmapPool sTilePool = GalleryBitmapPool.getInstance();
  66
  67     // TILE_SIZE must be 2^N
  68     private int mTileSize;
  69
  70     private TileSource mModel;
  71     protected int mLevelCount;  // cache the value of mScaledBitmaps.length
  72
  73     // The mLevel variable indicates which level of bitmap we should use.
  74     // Level 0 means the original full-sized bitmap, and a larger value means
  75     // a smaller scaled bitmap (The width and height of each scaled bitmap is
  76     // half size of the previous one). If the value is in [0, mLevelCount), we
  77     // use the bitmap in mScaledBitmaps[mLevel] for display, otherwise the value
  78     // is mLevelCount
  79     private int mLevel = 0;
  80
  81     private int mOffsetX;
  82     private int mOffsetY;
  83
  84     private int mUploadQuota;
  85     private boolean mRenderComplete;
  86
  87     private final RectF mSourceRect = new RectF();
  88     private final RectF mTargetRect = new RectF();
  89
  90     private final LongSparseArray<Tile> mActiveTiles = new LongSparseArray<Tile>();
  91
  92     // The following three queue are guarded by mQueueLock
  93     private final Object mQueueLock = new Object();
  94     private final TileQueue mRecycledQueue = new TileQueue();
  95     private final TileQueue mUploadQueue = new TileQueue();
  96     private final TileQueue mDecodeQueue = new TileQueue();
  97
  98     // The width and height of the full-sized bitmap
  99     protected int mImageWidth = SIZE_UNKNOWN;
 100     protected int mImageHeight = SIZE_UNKNOWN;
 101
 102     protected int mCenterX;
 103     protected int mCenterY;
 104     protected float mScale;
 105     protected int mRotation;
 106
 107     private boolean mLayoutTiles;
 108
 109     // Temp variables to avoid memory allocation
 110     private final Rect mTileRange = new Rect();
 111     private final Rect mActiveRange[] = {new Rect(), new Rect()};
 112
 113     private TileDecoder mTileDecoder;
 114     private boolean mBackgroundTileUploaded;
 115
 116     private int mViewWidth, mViewHeight;
 117     private View mParent;
 118
 119     public static interface TileSource {
 120         public int getTileSize();
 121         public int getImageWidth();
 122         public int getImageHeight();
 123
 124         // The tile returned by this method can be specified this way: Assuming
 125         // the image size is (width, height), first take the intersection of (0,
 126         // 0) - (width, height) and (x, y) - (x + tileSize, y + tileSize). If
 127         // in extending the region, we found some part of the region is outside
 128         // the image, those pixels are filled with black.
 129         //
 130         // If level > 0, it does the same operation on a down-scaled version of
 131         // the original image (down-scaled by a factor of 2^level), but (x, y)
 132         // still refers to the coordinate on the original image.
 133         //
 134         // The method would be called by the decoder thread.
 135         public Bitmap getTile(int level, int x, int y, Bitmap reuse);
 136     }
 137
 138     public static int suggestedTileSize(Context context) {
 139         return isHighResolution(context) ? 512 : 256;
 140     }
 141
 142     private static boolean isHighResolution(Context context) {
 143         DisplayMetrics metrics = new DisplayMetrics();
 144         WindowManager wm = (WindowManager)
 145                 context.getSystemService(Context.WINDOW_SERVICE);
 146         wm.getDefaultDisplay().getMetrics(metrics);
 147         return metrics.heightPixels > 2048 ||  metrics.widthPixels > 2048;
 148     }
 149
 150     public TiledImageRenderer(View parent) {
 151         mParent = parent;
 152         mTileDecoder = new TileDecoder();
 153         mTileDecoder.start();
 154     }
 155
 156     public int getViewWidth() {
 157         return mViewWidth;
 158     }
 159
 160     public int getViewHeight() {
 161         return mViewHeight;
 162     }
 163
 164     private void invalidate() {
 165         mParent.postInvalidate();
 166     }
 167
 168     public void setModel(TileSource model, int rotation) {
 169         if (mModel != model) {
 170             mModel = model;
 171             notifyModelInvalidated();
 172         }
 173         if (mRotation != rotation) {
 174             mRotation = rotation;
 175             mLayoutTiles = true;
 176             invalidate();
 177         }
 178     }
 179
 180     private static int calulateLevelCount(TileSource source) {
 181         int levels = 1;
 182         int maxDim = Math.max(source.getImageWidth(), source.getImageHeight());
 183         int t = source.getTileSize();
 184         while (t < maxDim) {
 185             t <<= 1;
 186             levels++;
 187         }
 188         return levels;
 189     }
 190
 191     public void notifyModelInvalidated() {
 192         invalidateTiles();
 193         if (mModel == null) {
 194             mImageWidth = 0;
 195             mImageHeight = 0;
 196             mLevelCount = 0;
 197         } else {
 198             mImageWidth = mModel.getImageWidth();
 199             mImageHeight = mModel.getImageHeight();
 200             mLevelCount = calulateLevelCount(mModel);
 201             mTileSize = mModel.getTileSize();
 202         }
 203         mLayoutTiles = true;
 204         invalidate();
 205     }
 206
 207     public void setViewSize(int width, int height) {
 208         mViewWidth = width;
 209         mViewHeight = height;
 210     }
 211
 212     public void setPosition(int centerX, int centerY, float scale) {
 213         if (mCenterX == centerX && mCenterY == centerY
 214                 && mScale == scale) return;
 215         mCenterX = centerX;
 216         mCenterY = centerY;
 217         mScale = scale;
 218         mLayoutTiles = true;
 219         invalidate();
 220     }
 221
 222     // Prepare the tiles we want to use for display.
 223     //
 224     // 1. Decide the tile level we want to use for display.
 225     // 2. Decide the tile levels we want to keep as texture (in addition to
 226     //    the one we use for display).
 227     // 3. Recycle unused tiles.
 228     // 4. Activate the tiles we want.
 229     private void layoutTiles() {
 230         if (mViewWidth == 0 || mViewHeight == 0 || !mLayoutTiles) {
 231             return;
 232         }
 233         mLayoutTiles = false;
 234
 235         // The tile levels we want to keep as texture is in the range
 236         // [fromLevel, endLevel).
 237         int fromLevel;
 238         int endLevel;
 239
 240         // We want to use a texture larger than or equal to the display size.
 241         mLevel = Utils.clamp(Utils.floorLog2(1f / mScale), 0, mLevelCount);
 242
 243         // We want to keep one more tile level as texture in addition to what
 244         // we use for display. So it can be faster when the scale moves to the
 245         // next level. We choose the level closest to the current scale.
 246         if (mLevel != mLevelCount) {
 247             Rect range = mTileRange;
 248             getRange(range, mCenterX, mCenterY, mLevel, mScale, mRotation);
 249             mOffsetX = Math.round(mViewWidth / 2f + (range.left - mCenterX) * mScale);
 250             mOffsetY = Math.round(mViewHeight / 2f + (range.top - mCenterY) * mScale);
 251             fromLevel = mScale * (1 << mLevel) > 0.75f ? mLevel - 1 : mLevel;
 252         } else {
 253             // Activate the tiles of the smallest two levels.
 254             fromLevel = mLevel - 2;
 255             mOffsetX = Math.round(mViewWidth / 2f - mCenterX * mScale);
 256             mOffsetY = Math.round(mViewHeight / 2f - mCenterY * mScale);
 257         }
 258
 259         fromLevel = Math.max(0, Math.min(fromLevel, mLevelCount - 2));
 260         endLevel = Math.min(fromLevel + 2, mLevelCount);
 261
 262         Rect range[] = mActiveRange;
 263         for (int i = fromLevel; i < endLevel; ++i) {
 264             getRange(range[i - fromLevel], mCenterX, mCenterY, i, mRotation);
 265         }
 266
 267         // If rotation is transient, don't update the tile.
 268         if (mRotation % 90 != 0) return;
 269
 270         synchronized (mQueueLock) {
 271             mDecodeQueue.clean();
 272             mUploadQueue.clean();
 273             mBackgroundTileUploaded = false;
 274
 275             // Recycle unused tiles: if the level of the active tile is outside the
 276             // range [fromLevel, endLevel) or not in the visible range.
 277             int n = mActiveTiles.size();
 278             for (int i = 0; i < n; i++) {
 279                 Tile tile = mActiveTiles.valueAt(i);
 280                 int level = tile.mTileLevel;
 281                 if (level < fromLevel || level >= endLevel
 282                         || !range[level - fromLevel].contains(tile.mX, tile.mY)) {
 283                     mActiveTiles.removeAt(i);
 284                     i--;
 285                     n--;
 286                     recycleTile(tile);
 287                 }
 288             }
 289         }
 290
 291         for (int i = fromLevel; i < endLevel; ++i) {
 292             int size = mTileSize << i;
 293             Rect r = range[i - fromLevel];
 294             for (int y = r.top, bottom = r.bottom; y < bottom; y += size) {
 295                 for (int x = r.left, right = r.right; x < right; x += size) {
 296                     activateTile(x, y, i);
 297                 }
 298             }
 299         }
 300         invalidate();
 301     }
 302
 303     private void invalidateTiles() {
 304         synchronized (mQueueLock) {
 305             mDecodeQueue.clean();
 306             mUploadQueue.clean();
 307
 308             // TODO disable decoder
 309             int n = mActiveTiles.size();
 310             for (int i = 0; i < n; i++) {
 311                 Tile tile = mActiveTiles.valueAt(i);
 312                 recycleTile(tile);
 313             }
 314             mActiveTiles.clear();
 315         }
 316     }
 317
 318     private void getRange(Rect out, int cX, int cY, int level, int rotation) {
 319         getRange(out, cX, cY, level, 1f / (1 << (level + 1)), rotation);
 320     }
 321
 322     // If the bitmap is scaled by the given factor "scale", return the
 323     // rectangle containing visible range. The left-top coordinate returned is
 324     // aligned to the tile boundary.
 325     //
 326     // (cX, cY) is the point on the original bitmap which will be put in the
 327     // center of the ImageViewer.
 328     private void getRange(Rect out,
 329             int cX, int cY, int level, float scale, int rotation) {
 330
 331         double radians = Math.toRadians(-rotation);
 332         double w = mViewWidth;
 333         double h = mViewHeight;
 334
 335         double cos = Math.cos(radians);
 336         double sin = Math.sin(radians);
 337         int width = (int) Math.ceil(Math.max(
 338                 Math.abs(cos * w - sin * h), Math.abs(cos * w + sin * h)));
 339         int height = (int) Math.ceil(Math.max(
 340                 Math.abs(sin * w + cos * h), Math.abs(sin * w - cos * h)));
 341
 342         int left = (int) Math.floor(cX - width / (2f * scale));
 343         int top = (int) Math.floor(cY - height / (2f * scale));
 344         int right = (int) Math.ceil(left + width / scale);
 345         int bottom = (int) Math.ceil(top + height / scale);
 346
 347         // align the rectangle to tile boundary
 348         int size = mTileSize << level;
 349         left = Math.max(0, size * (left / size));
 350         top = Math.max(0, size * (top / size));
 351         right = Math.min(mImageWidth, right);
 352         bottom = Math.min(mImageHeight, bottom);
 353
 354         out.set(left, top, right, bottom);
 355     }
 356
 357     public void freeTextures() {
 358         mLayoutTiles = true;
 359
 360         synchronized (mQueueLock) {
 361             mUploadQueue.clean();
 362             mDecodeQueue.clean();
 363             Tile tile = mRecycledQueue.pop();
 364             while (tile != null) {
 365                 tile.recycle();
 366                 tile = mRecycledQueue.pop();
 367             }
 368         }
 369
 370         int n = mActiveTiles.size();
 371         for (int i = 0; i < n; i++) {
 372             Tile texture = mActiveTiles.valueAt(i);
 373             texture.recycle();
 374         }
 375         mActiveTiles.clear();
 376         mTileRange.set(0, 0, 0, 0);
 377
 378         if (sTilePool != null) sTilePool.clear();
 379     }
 380
 381     public void draw(GLCanvas canvas) {
 382         layoutTiles();
 383         uploadTiles(canvas);
 384
 385         mUploadQuota = UPLOAD_LIMIT;
 386         mRenderComplete = true;
 387
 388         int level = mLevel;
 389         int rotation = mRotation;
 390         int flags = 0;
 391         if (rotation != 0) flags |= GLCanvas.SAVE_FLAG_MATRIX;
 392
 393         if (flags != 0) {
 394             canvas.save(flags);
 395             if (rotation != 0) {
 396                 int centerX = mViewWidth / 2, centerY = mViewHeight / 2;
 397                 canvas.translate(centerX, centerY);
 398                 canvas.rotate(rotation, 0, 0, 1);
 399                 canvas.translate(-centerX, -centerY);
 400             }
 401         }
 402         try {
 403             if (level != mLevelCount) {
 404                 int size = (mTileSize << level);
 405                 float length = size * mScale;
 406                 Rect r = mTileRange;
 407
 408                 for (int ty = r.top, i = 0; ty < r.bottom; ty += size, i++) {
 409                     float y = mOffsetY + i * length;
 410                     for (int tx = r.left, j = 0; tx < r.right; tx += size, j++) {
 411                         float x = mOffsetX + j * length;
 412                         drawTile(canvas, tx, ty, level, x, y, length);
 413                     }
 414                 }
 415             }
 416         } finally {
 417             if (flags != 0) canvas.restore();
 418         }
 419
 420         if (mRenderComplete) {
 421             if (!mBackgroundTileUploaded) {
 422                 uploadBackgroundTiles(canvas);
 423             }
 424         } else {
 425             invalidate();
 426         }
 427     }
 428
 429     private void uploadBackgroundTiles(GLCanvas canvas) {
 430         mBackgroundTileUploaded = true;
 431         int n = mActiveTiles.size();
 432         for (int i = 0; i < n; i++) {
 433             Tile tile = mActiveTiles.valueAt(i);
 434             if (!tile.isContentValid()) {
 435                 queueForDecode(tile);
 436             }
 437         }
 438     }
 439
 440     private void queueForUpload(Tile tile) {
 441         synchronized (mQueueLock) {
 442             mUploadQueue.push(tile);
 443         }
 444         invalidate();
 445         // TODO
 446 //        if (mTileUploader.mActive.compareAndSet(false, true)) {
 447 //            getGLRoot().addOnGLIdleListener(mTileUploader);
 448 //        }
 449     }
 450
 451    private void queueForDecode(Tile tile) {
 452        synchronized (mQueueLock) {
 453            if (tile.mTileState == STATE_ACTIVATED) {
 454                tile.mTileState = STATE_IN_QUEUE;
 455                if (mDecodeQueue.push(tile)) {
 456                    mQueueLock.notifyAll();
 457                }
 458            }
 459        }
 460     }
 461
 462     private boolean decodeTile(Tile tile) {
 463         synchronized (mQueueLock) {
 464             if (tile.mTileState != STATE_IN_QUEUE) return false;
 465             tile.mTileState = STATE_DECODING;
 466         }
 467         boolean decodeComplete = tile.decode();
 468         synchronized (mQueueLock) {
 469             if (tile.mTileState == STATE_RECYCLING) {
 470                 tile.mTileState = STATE_RECYCLED;
 471                 if (tile.mDecodedTile != null) {
 472                     if (sTilePool != null) sTilePool.put(tile.mDecodedTile);
 473                     tile.mDecodedTile = null;
 474                 }
 475                 mRecycledQueue.push(tile);
 476                 return false;
 477             }
 478             tile.mTileState = decodeComplete ? STATE_DECODED : STATE_DECODE_FAIL;
 479             return decodeComplete;
 480         }
 481     }
 482
 483     private Tile obtainTile(int x, int y, int level) {
 484         synchronized (mQueueLock) {
 485             Tile tile = mRecycledQueue.pop();
 486             if (tile != null) {
 487                 tile.mTileState = STATE_ACTIVATED;
 488                 tile.update(x, y, level);
 489                 return tile;
 490             }
 491             return new Tile(x, y, level);
 492         }
 493     }
 494
 495     private void recycleTile(Tile tile) {
 496         synchronized (mQueueLock) {
 497             if (tile.mTileState == STATE_DECODING) {
 498                 tile.mTileState = STATE_RECYCLING;
 499                 return;
 500             }
 501             tile.mTileState = STATE_RECYCLED;
 502             if (tile.mDecodedTile != null) {
 503                 if (sTilePool != null) sTilePool.put(tile.mDecodedTile);
 504                 tile.mDecodedTile = null;
 505             }
 506             mRecycledQueue.push(tile);
 507         }
 508     }
 509
 510     private void activateTile(int x, int y, int level) {
 511         long key = makeTileKey(x, y, level);
 512         Tile tile = mActiveTiles.get(key);
 513         if (tile != null) {
 514             if (tile.mTileState == STATE_IN_QUEUE) {
 515                 tile.mTileState = STATE_ACTIVATED;
 516             }
 517             return;
 518         }
 519         tile = obtainTile(x, y, level);
 520         mActiveTiles.put(key, tile);
 521     }
 522
 523     private Tile getTile(int x, int y, int level) {
 524         return mActiveTiles.get(makeTileKey(x, y, level));
 525     }
 526
 527     private static long makeTileKey(int x, int y, int level) {
 528         long result = x;
 529         result = (result << 16) | y;
 530         result = (result << 16) | level;
 531         return result;
 532     }
 533
 534     private void uploadTiles(GLCanvas canvas) {
 535         int quota = UPLOAD_LIMIT;
 536         Tile tile = null;
 537         while (quota > 0) {
 538             synchronized (mQueueLock) {
 539                 tile = mUploadQueue.pop();
 540             }
 541             if (tile == null) break;
 542             if (!tile.isContentValid()) {
 543                 Utils.assertTrue(tile.mTileState == STATE_DECODED);
 544                 tile.updateContent(canvas);
 545                 --quota;
 546             }
 547         }
 548         if (tile != null) {
 549             invalidate();
 550         }
 551     }
 552
 553     // Draw the tile to a square at canvas that locates at (x, y) and
 554     // has a side length of length.
 555     private void drawTile(GLCanvas canvas,
 556             int tx, int ty, int level, float x, float y, float length) {
 557         RectF source = mSourceRect;
 558         RectF target = mTargetRect;
 559         target.set(x, y, x + length, y + length);
 560         source.set(0, 0, mTileSize, mTileSize);
 561
 562         Tile tile = getTile(tx, ty, level);
 563         if (tile != null) {
 564             if (!tile.isContentValid()) {
 565                 if (tile.mTileState == STATE_DECODED) {
 566                     if (mUploadQuota > 0) {
 567                         --mUploadQuota;
 568                         tile.updateContent(canvas);
 569                     } else {
 570                         mRenderComplete = false;
 571                     }
 572                 } else if (tile.mTileState != STATE_DECODE_FAIL){
 573                     mRenderComplete = false;
 574                     queueForDecode(tile);
 575                 }
 576             }
 577             drawTile(tile, canvas, source, target);
 578         }
 579     }
 580
 581     private boolean drawTile(
 582             Tile tile, GLCanvas canvas, RectF source, RectF target) {
 583         while (true) {
 584             if (tile.isContentValid()) {
 585                 canvas.drawTexture(tile, source, target);
 586                 return true;
 587             }
 588
 589             // Parent can be divided to four quads and tile is one of the four.
 590             Tile parent = tile.getParentTile();
 591             if (parent == null) return false;
 592             if (tile.mX == parent.mX) {
 593                 source.left /= 2f;
 594                 source.right /= 2f;
 595             } else {
 596                 source.left = (mTileSize + source.left) / 2f;
 597                 source.right = (mTileSize + source.right) / 2f;
 598             }
 599             if (tile.mY == parent.mY) {
 600                 source.top /= 2f;
 601                 source.bottom /= 2f;
 602             } else {
 603                 source.top = (mTileSize + source.top) / 2f;
 604                 source.bottom = (mTileSize + source.bottom) / 2f;
 605             }
 606             tile = parent;
 607         }
 608     }
 609
 610     private class Tile extends UploadedTexture {
 611         public int mX;
 612         public int mY;
 613         public int mTileLevel;
 614         public Tile mNext;
 615         public Bitmap mDecodedTile;
 616         public volatile int mTileState = STATE_ACTIVATED;
 617
 618         public Tile(int x, int y, int level) {
 619             mX = x;
 620             mY = y;
 621             mTileLevel = level;
 622         }
 623
 624         @Override
 625         protected void onFreeBitmap(Bitmap bitmap) {
 626             if (sTilePool != null) sTilePool.put(bitmap);
 627         }
 628
 629         boolean decode() {
 630             // Get a tile from the original image. The tile is down-scaled
 631             // by (1 << mTilelevel) from a region in the original image.
 632             try {
 633                 Bitmap reuse = sTilePool.get(mTileSize, mTileSize);
 634                 mDecodedTile = mModel.getTile(mTileLevel, mX, mY, reuse);
 635             } catch (Throwable t) {
 636                 Log.w(TAG, "fail to decode tile", t);
 637             }
 638             return mDecodedTile != null;
 639         }
 640
 641         @Override
 642         protected Bitmap onGetBitmap() {
 643             Utils.assertTrue(mTileState == STATE_DECODED);
 644
 645             // We need to override the width and height, so that we won't
 646             // draw beyond the boundaries.
 647             int rightEdge = ((mImageWidth - mX) >> mTileLevel);
 648             int bottomEdge = ((mImageHeight - mY) >> mTileLevel);
 649             setSize(Math.min(mTileSize, rightEdge), Math.min(mTileSize, bottomEdge));
 650
 651             Bitmap bitmap = mDecodedTile;
 652             mDecodedTile = null;
 653             mTileState = STATE_ACTIVATED;
 654             return bitmap;
 655         }
 656
 657         // We override getTextureWidth() and getTextureHeight() here, so the
 658         // texture can be re-used for different tiles regardless of the actual
 659         // size of the tile (which may be small because it is a tile at the
 660         // boundary).
 661         @Override
 662         public int getTextureWidth() {
 663             return mTileSize;
 664         }
 665
 666         @Override
 667         public int getTextureHeight() {
 668             return mTileSize;
 669         }
 670
 671         public void update(int x, int y, int level) {
 672             mX = x;
 673             mY = y;
 674             mTileLevel = level;
 675             invalidateContent();
 676         }
 677
 678         public Tile getParentTile() {
 679             if (mTileLevel + 1 == mLevelCount) return null;
 680             int size = mTileSize << (mTileLevel + 1);
 681             int x = size * (mX / size);
 682             int y = size * (mY / size);
 683             return getTile(x, y, mTileLevel + 1);
 684         }
 685
 686         @Override
 687         public String toString() {
 688             return String.format("tile(%s, %s, %s / %s)",
 689                     mX / mTileSize, mY / mTileSize, mLevel, mLevelCount);
 690         }
 691     }
 692
 693     private static class TileQueue {
 694         private Tile mHead;
 695
 696         public Tile pop() {
 697             Tile tile = mHead;
 698             if (tile != null) mHead = tile.mNext;
 699             return tile;
 700         }
 701
 702         public boolean push(Tile tile) {
 703             boolean wasEmpty = mHead == null;
 704             tile.mNext = mHead;
 705             mHead = tile;
 706             return wasEmpty;
 707         }
 708
 709         public void clean() {
 710             mHead = null;
 711         }
 712     }
 713
 714     private class TileDecoder extends Thread {
 715
 716         public void finishAndWait() {
 717             interrupt();
 718             try {
 719                 join();
 720             } catch (InterruptedException e) {
 721                 Log.w(TAG, "Interrupted while waiting for TileDecoder thread to finish!");
 722             }
 723         }
 724
 725         private Tile waitForTile() throws InterruptedException {
 726             synchronized(mQueueLock) {
 727                 while (true) {
 728                     Tile tile = mDecodeQueue.pop();
 729                     if (tile != null) {
 730                         return tile;
 731                     }
 732                     mQueueLock.wait();
 733                 }
 734             }
 735         }
 736
 737         @Override
 738         public void run() {
 739             try {
 740                 while (!isInterrupted()) {
 741                     Tile tile = waitForTile();
 742                     if (decodeTile(tile)) {
 743                         queueForUpload(tile);
 744                     }
 745                 }
 746             } catch (InterruptedException ex) {
 747             }
 748         }
 749
 750     }
 751 }