// Note: this need to be called within the lock and on the UI thread.
// Only called by updateDirtyTiles() and emptyQueue() for now
void TransferQueue::cleanupPendingDiscard()
{
int index = getNextTransferQueueIndex();
for (int i = 0 ; i < m_transferQueueSize; i++) {
if (m_transferQueue[index].status == pendingDiscard) {
// No matter what the current upload type is, as long as there has
// been a Surf Tex enqueue operation, this updateTexImage need to
// be called to keep things in sync.
if (m_transferQueue[index].uploadType == GpuUpload) {
status_t result = m_sharedSurfaceTexture->updateTexImage();
if (result != OK)
ALOGE("unexpected error: updateTexImage return %d", result);
}
// since tiles in the queue may be from another webview, remove
// their textures so that they will be repainted / retransferred
Tile* tile = m_transferQueue[index].savedTilePtr;
TileTexture* texture = m_transferQueue[index].savedTileTexturePtr;
if (tile && texture && texture->owner() == tile) {
// since tile destruction removes textures on the UI thread, the
// texture->owner ptr guarantees the tile is valid
tile->discardBackTexture();
ALOGV("transfer queue discarded tile %p, removed texture", tile);
}
clearItemInTranferQueue(index);
}
index = (index + 1) % m_transferQueueSize;
}
}
void TilesManager::printTextures()
{
#ifdef DEBUG
ALOGV("++++++");
for (unsigned int i = 0; i < m_textures.size(); i++) {
TileTexture* texture = m_textures[i];
Tile* o = 0;
if (texture->owner())
o = (Tile*) texture->owner();
int x = -1;
int y = -1;
if (o) {
x = o->x();
y = o->y();
}
ALOGV("[%d] texture %x owner: %x (%d, %d) scale: %.2f",
i, texture, o, x, y, o ? o->scale() : 0);
}
ALOGV("------");
#endif // DEBUG
}
bool Tile::isTileReady()
{
// Return true if the tile's most recently drawn texture is up to date
android::AutoMutex lock(m_atomicSync);
TileTexture * texture = (m_state == ReadyToSwap) ? m_backTexture : m_frontTexture;
if (!texture)
return false;
if (texture->owner() != this)
return false;
if (m_dirty)
return false;
if (m_state != ReadyToSwap && m_state != UpToDate)
return false;
return true;
}
TileTexture* TilesManager::getAvailableTexture(Tile* owner)
{
android::Mutex::Autolock lock(m_texturesLock);
WTF::Vector<TileTexture*>* availableTexturePool;
if (owner->isLayerTile())
availableTexturePool = &m_availableTilesTextures;
else
availableTexturePool = &m_availableTextures;
// Sanity check that the tile does not already own a texture
if (owner->backTexture() && owner->backTexture()->owner() == owner) {
int removeIndex = availableTexturePool->find(owner->backTexture());
// TODO: investigate why texture isn't found
if (removeIndex >= 0)
availableTexturePool->remove(removeIndex);
return owner->backTexture();
}
// The heuristic for selecting a texture is as follows:
// 1. Skip textures currently being painted, they can't be painted while
// busy anyway
// 2. If a tile isn't owned, break with that one
// 3. Don't let tiles acquire their front textures
// 4. Otherwise, use the least recently prepared tile, but ignoring tiles
// drawn in the last frame to avoid flickering
TileTexture* farthestTexture = 0;
unsigned long long oldestDrawCount = getDrawGLCount() - 1;
const unsigned int max = availableTexturePool->size();
for (unsigned int i = 0; i < max; i++) {
TileTexture* texture = (*availableTexturePool)[i];
Tile* currentOwner = static_cast<Tile*>(texture->owner());
if (!currentOwner) {
// unused texture! take it!
farthestTexture = texture;
break;
}
if (currentOwner == owner) {
// Don't let a tile acquire its own front texture, as the
// acquisition logic doesn't handle that
continue;
}
unsigned long long textureDrawCount = currentOwner->drawCount();
if (oldestDrawCount > textureDrawCount) {
farthestTexture = texture;
oldestDrawCount = textureDrawCount;
}
}
if (farthestTexture) {
Tile* previousOwner = static_cast<Tile*>(farthestTexture->owner());
if (farthestTexture->acquire(owner)) {
if (previousOwner) {
previousOwner->removeTexture(farthestTexture);
ALOGV("%s texture %p stolen from tile %d, %d for %d, %d, drawCount was %llu (now %llu)",
owner->isLayerTile() ? "LAYER" : "BASE",
farthestTexture, previousOwner->x(), previousOwner->y(),
owner->x(), owner->y(),
oldestDrawCount, getDrawGLCount());
}
availableTexturePool->remove(availableTexturePool->find(farthestTexture));
return farthestTexture;
}
} else {
if (owner->isLayerTile()) {
// couldn't find a tile for a layer, layers shouldn't request redraw
// TODO: once we do layer prefetching, don't set this for those
// tiles
m_layerTexturesRemain = false;
}
}
ALOGV("Couldn't find an available texture for %s tile %x (%d, %d) out of %d available",
owner->isLayerTile() ? "LAYER" : "BASE",
owner, owner->x(), owner->y(), max);
#ifdef DEBUG
printTextures();
#endif // DEBUG
return 0;
}
// This is called from the texture generation thread
void Tile::paintBitmap(TilePainter* painter, BaseRenderer* renderer)
{
// We acquire the values below atomically. This ensures that we are reading
// values correctly across cores. Further, once we have these values they
// can be updated by other threads without consequence.
m_atomicSync.lock();
bool dirty = m_dirty;
TileTexture* texture = m_backTexture;
SkRegion dirtyArea = m_dirtyArea;
float scale = m_scale;
const int x = m_x;
const int y = m_y;
if (!dirty || !texture) {
m_atomicSync.unlock();
return;
}
if (m_state != Unpainted) {
ALOGV("Warning: started painting tile %p, but was at state %d, ft %p bt %p",
this, m_state, m_frontTexture, m_backTexture);
}
m_state = PaintingStarted;
TextureInfo* textureInfo = texture->getTextureInfo();
m_atomicSync.unlock();
// at this point we can safely check the ownership (if the texture got
// transferred to another Tile under us)
if (texture->owner() != this) {
return;
}
// setup the common renderInfo fields;
TileRenderInfo renderInfo;
renderInfo.x = x;
renderInfo.y = y;
renderInfo.scale = scale;
renderInfo.tileSize = texture->getSize();
renderInfo.tilePainter = painter;
renderInfo.baseTile = this;
renderInfo.textureInfo = textureInfo;
const float tileWidth = renderInfo.tileSize.width();
const float tileHeight = renderInfo.tileSize.height();
renderer->renderTiledContent(renderInfo);
m_atomicSync.lock();
if (texture == m_backTexture) {
// set the fullrepaint flags
m_fullRepaint = false;
// The various checks to see if we are still dirty...
m_dirty = false;
if (m_scale != scale)
m_dirty = true;
m_dirtyArea.setEmpty();
ALOGV("painted tile %p (%d, %d), texture %p, dirty=%d", this, x, y, texture, m_dirty);
validatePaint();
} else {
ALOGV("tile %p no longer owns texture %p, m_state %d. ft %p bt %p",
this, texture, m_state, m_frontTexture, m_backTexture);
}
m_atomicSync.unlock();
}