void CCVideoLayerImpl::willDraw(LayerRendererChromium* layerRenderer)
{
ASSERT(CCProxy::isImplThread());
MutexLocker locker(m_providerMutex);
if (!m_provider) {
m_frame = 0;
return;
}
m_frame = m_provider->getCurrentFrame();
if (!m_frame)
return;
m_format = convertVFCFormatToGC3DFormat(m_frame);
if (m_format == GraphicsContext3D::INVALID_VALUE) {
m_provider->putCurrentFrame(m_frame);
m_frame = 0;
return;
}
if (!reserveTextures(m_frame, m_format, layerRenderer)) {
m_provider->putCurrentFrame(m_frame);
m_frame = 0;
}
}
void CCLayerTreeHost::updateLayers(LayerChromium* rootLayer, CCTextureUpdater& updater)
{
TRACE_EVENT("CCLayerTreeHost::updateLayers", this, 0);
if (!rootLayer->renderSurface())
rootLayer->createRenderSurface();
rootLayer->renderSurface()->setContentRect(IntRect(IntPoint(0, 0), deviceViewportSize()));
IntRect rootClipRect(IntPoint(), deviceViewportSize());
rootLayer->setClipRect(rootClipRect);
LayerList updateList;
updateList.append(rootLayer);
RenderSurfaceChromium* rootRenderSurface = rootLayer->renderSurface();
rootRenderSurface->clearLayerList();
{
TRACE_EVENT("CCLayerTreeHost::updateLayers::calcDrawEtc", this, 0);
WebTransformationMatrix identityMatrix;
WebTransformationMatrix deviceScaleTransform;
deviceScaleTransform.scale(m_deviceScaleFactor);
CCLayerTreeHostCommon::calculateDrawTransforms(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, updateList, rootRenderSurface->layerList(), layerRendererCapabilities().maxTextureSize);
FloatRect rootScissorRect(FloatPoint(0, 0), viewportSize());
CCLayerTreeHostCommon::calculateVisibleAndScissorRects(updateList, rootScissorRect);
}
// Reset partial texture update requests.
m_partialTextureUpdateRequests = 0;
reserveTextures(updateList);
paintLayerContents(updateList, PaintVisible, updater);
if (!m_triggerIdlePaints)
return;
size_t preferredLimitBytes = m_contentsTextureManager->preferredMemoryLimitBytes();
size_t maxLimitBytes = m_contentsTextureManager->maxMemoryLimitBytes();
m_contentsTextureManager->reduceMemoryToLimit(preferredLimitBytes);
if (m_contentsTextureManager->currentMemoryUseBytes() >= preferredLimitBytes)
return;
// Idle painting should fail when we hit the preferred memory limit,
// otherwise it will always push us towards the maximum limit.
m_contentsTextureManager->setMaxMemoryLimitBytes(preferredLimitBytes);
// The second (idle) paint will be a no-op in layers where painting already occured above.
paintLayerContents(updateList, PaintIdle, updater);
m_contentsTextureManager->setMaxMemoryLimitBytes(maxLimitBytes);
for (size_t i = 0; i < updateList.size(); ++i)
updateList[i]->clearRenderSurface();
}
void VideoLayerChromium::updateCompositorResources(GraphicsContext3D* context)
{
if (!m_contentsDirty || !m_delegate)
return;
ASSERT(drawsContent());
m_skipsDraw = false;
VideoFrameChromium* frame = m_provider->getCurrentFrame();
if (!frame) {
m_skipsDraw = true;
m_provider->putCurrentFrame(frame);
return;
}
m_frameFormat = frame->format();
GC3Denum textureFormat = determineTextureFormat(frame);
if (textureFormat == GraphicsContext3D::INVALID_VALUE) {
// FIXME: Implement other paths.
notImplemented();
m_skipsDraw = true;
m_provider->putCurrentFrame(frame);
return;
}
// Allocate textures for planes if they are not allocated already, or
// reallocate textures that are the wrong size for the frame.
bool texturesReserved = reserveTextures(frame, textureFormat);
if (!texturesReserved) {
m_skipsDraw = true;
m_provider->putCurrentFrame(frame);
return;
}
// Update texture planes.
for (unsigned plane = 0; plane < frame->planes(); plane++) {
Texture& texture = m_textures[plane];
ASSERT(texture.m_texture);
ASSERT(frame->requiredTextureSize(plane) == texture.m_texture->size());
updateTexture(context, texture, frame->data(plane));
}
m_dirtyRect.setSize(FloatSize());
m_contentsDirty = false;
m_provider->putCurrentFrame(frame);
}
