// Note: this need to be called within th lock.
// Only called by updateDirtyBaseTiles() for now
void TransferQueue::cleanupTransportQueue()
{
int index = getNextTransferQueueIndex();
for (int i = 0 ; i < ST_BUFFER_NUMBER; 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)
XLOGC("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
BaseTile* tile = m_transferQueue[index].savedBaseTilePtr;
BaseTileTexture* texture = m_transferQueue[index].savedBaseTileTexturePtr;
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();
XLOG("transfer queue discarded tile %p, removed texture", tile);
}
m_transferQueue[index].savedBaseTilePtr = 0;
m_transferQueue[index].savedBaseTileTexturePtr = 0;
m_transferQueue[index].status = emptyItem;
}
index = (index + 1) % ST_BUFFER_NUMBER;
}
}
void TransferQueue::setTextureUploadType(TextureUploadType type)
{
if (m_currentUploadType == type)
return;
discardQueue();
android::Mutex::Autolock lock(m_transferQueueItemLocks);
m_currentUploadType = type;
XLOGC("Now we set the upload to %s", m_currentUploadType == GpuUpload ? "GpuUpload" : "CpuUpload");
}
void TransferQueue::setTextureUploadType(TextureUploadType type)
{
if (m_currentUploadType == type)
return;
discardQueue();
android::Mutex::Autolock lock(m_transferQueueItemLocks);
m_currentUploadType = CpuUpload; // force to cpu upload mode for now until gpu upload mode is fixed
XLOGC("Now we set the upload to %s", m_currentUploadType == GpuUpload ? "GpuUpload" : "CpuUpload");
}
void GLExtras::drawGL(IntRect& webViewRect, SkRect& viewport, int titleBarHeight)
{
if (m_drawExtra) {
if (m_drawExtra == m_ring)
drawCursorRings();
else if (m_drawExtra == m_findOnPage)
drawFindOnPage(viewport);
else
XLOGC("m_drawExtra %p is unknown! (cursor: %p, find: %p",
m_drawExtra, m_ring, m_findOnPage);
}
}
void TransferQueue::setTextureUploadType(TextureUploadType type)
{
if (m_currentUploadType == type)
return;
discardQueue();
android::Mutex::Autolock lock(m_transferQueueItemLocks);
// SAMSUNG CHANGE ++ Change upload type for QCOM
#ifdef SUPPORT_QCOM
m_currentUploadType = CpuUpload;
#else
m_currentUploadType = type;
#endif
// SAMSUNG CHANGE --
XLOGC("Now we set the upload to %s", m_currentUploadType == GpuUpload ? "GpuUpload" : "CpuUpload");
}
// Call on UI thread to copy from the shared Surface Texture to the BaseTile's texture.
void TransferQueue::updateDirtyBaseTiles()
{
android::Mutex::Autolock lock(m_transferQueueItemLocks);
cleanupTransportQueue();
if (!getHasGLContext())
setHasGLContext(true);
// Start from the oldest item, we call the updateTexImage to retrive
// the texture and blit that into each BaseTile's texture.
const int nextItemIndex = getNextTransferQueueIndex();
int index = nextItemIndex;
bool usedFboForUpload = false;
for (int k = 0; k < ST_BUFFER_NUMBER ; k++) {
if (m_transferQueue[index].status == pendingBlit) {
bool obsoleteBaseTile = checkObsolete(index);
// Save the needed info, update the Surf Tex, clean up the item in
// the queue. Then either move on to next item or copy the content.
BaseTileTexture* destTexture = 0;
if (!obsoleteBaseTile)
destTexture = m_transferQueue[index].savedBaseTilePtr->backTexture();
if (m_transferQueue[index].uploadType == GpuUpload) {
status_t result = m_sharedSurfaceTexture->updateTexImage();
if (result != OK)
XLOGC("unexpected error: updateTexImage return %d", result);
}
m_transferQueue[index].savedBaseTilePtr = 0;
m_transferQueue[index].status = emptyItem;
if (obsoleteBaseTile) {
XLOG("Warning: the texture is obsolete for this baseTile");
index = (index + 1) % ST_BUFFER_NUMBER;
continue;
}
// guarantee that we have a texture to blit into
destTexture->requireGLTexture();
if (m_transferQueue[index].uploadType == CpuUpload) {
// Here we just need to upload the bitmap content to the GL Texture
GLUtils::updateTextureWithBitmap(destTexture->m_ownTextureId, 0, 0,
*m_transferQueue[index].bitmap);
} else {
if (!usedFboForUpload) {
saveGLState();
usedFboForUpload = true;
}
blitTileFromQueue(m_fboID, destTexture,
m_sharedSurfaceTextureId,
m_sharedSurfaceTexture->getCurrentTextureTarget(),
index);
}
// After the base tile copied into the GL texture, we need to
// update the texture's info such that at draw time, readyFor
// will find the latest texture's info
// We don't need a map any more, each texture contains its own
// texturesTileInfo.
destTexture->setOwnTextureTileInfoFromQueue(&m_transferQueue[index].tileInfo);
XLOG("Blit tile x, y %d %d with dest texture %p to destTexture->m_ownTextureId %d",
m_transferQueue[index].tileInfo.m_x,
m_transferQueue[index].tileInfo.m_y,
destTexture,
destTexture->m_ownTextureId);
}
index = (index + 1) % ST_BUFFER_NUMBER;
}
// Clean up FBO setup. Doing this for both CPU/GPU upload can make the
// dynamic switch possible. Moving this out from the loop can save some
// milli-seconds.
if (usedFboForUpload) {
glBindFramebuffer(GL_FRAMEBUFFER, 0); // rebind the standard FBO
restoreGLState();
GLUtils::checkGlError("updateDirtyBaseTiles");
}
m_emptyItemCount = ST_BUFFER_NUMBER;
m_transferQueueItemCond.signal();
}
