Lines Matching refs:Layer
68 #include "Layer.h"
1047 // rebuild the visible layer list per screen
1057 Vector< sp<Layer> > layersSortedByZ;
1067 const sp<Layer>& layer(layers[i]);
1068 const Layer::State& s(layer->getDrawingState());
1071 layer->visibleNonTransparentRegion));
1074 layersSortedByZ.add(layer);
1099 // - When a display is created with a private layer stack, we won't
1100 // emit any black frames until a layer is added to the layer stack.
1126 const Vector< sp<Layer> >& currentLayers(
1133 const sp<Layer>& layer(currentLayers[i]);
1134 layer->setGeometry(hw, *cur);
1149 const Vector< sp<Layer> >& currentLayers(
1156 * update the per-frame h/w composer data for each layer
1159 const sp<Layer>& layer(currentLayers[i]);
1160 layer->setPerFrameData(hw, *cur);
1170 const Vector< sp<Layer> >& currentLayers(
1176 const sp<Layer>& layer(currentLayers[i]);
1177 if (layer->isPotentialCursor()) {
1243 const Vector< sp<Layer> >& currentLayers(hw->getVisibleLayersSortedByZ());
1310 const sp<Layer>& layer(currentLayers[i]);
1311 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
1314 const uint32_t flags = layer->doTransaction(0);
1315 if (flags & Layer::eVisibleRegion)
1414 // they have external state (layer stack, projection,
1483 // (either because a display has changed, or because a layer
1489 // If a layer is visible only on a single display, then that
1496 // NOTE: layer transactions have taken place already, so we use their
1498 // happened yet, so we must use the current state layer list
1506 // of displays for every layer).
1507 const sp<Layer>& layer(currentLayers[i]);
1508 uint32_t layerStack = layer->getDrawingState().layerStack;
1531 // could be null when this layer is using a layerStack
1536 layer->updateTransformHint(disp);
1558 const sp<Layer>& layer(layers[i]);
1559 if (currentLayers.indexOf(layer) < 0) {
1560 // this layer is not visible anymore
1564 const Layer::State& s(layer->getDrawingState());
1586 const Vector< sp<Layer> >& currentLayers(
1595 const sp<Layer>& layer(currentLayers[i]);
1596 Rect cursorPos = layer->getPosition(hw);
1637 const sp<Layer>& layer = currentLayers[i];
1640 const Layer::State& s(layer->getDrawingState());
1642 // only consider the layers on the given layer stack
1653 * and not fully transparent. This is essentially the layer's
1667 * transparent. This is only used to tell when the layer has no visible
1668 * non-transparent regions and can be removed from the layer list. It
1669 * does not affect the visibleRegion of this layer or any layers
1677 if (CC_LIKELY(layer->isVisible())) {
1678 const bool translucent = !layer->isOpaque(s);
1679 Rect bounds(s.transform.transform(layer->computeBounds()));
1703 // the opaque region is the layer's footprint
1712 // Update aboveCoveredLayers for next (lower) layer
1718 // compute this layer's dirty region
1719 if (layer->contentDirty) {
1723 dirty.orSelf(layer->visibleRegion);
1724 layer->contentDirty = false;
1739 const Region oldVisibleRegion = layer->visibleRegion;
1740 const Region oldCoveredRegion = layer->coveredRegion;
1749 // Update aboveOpaqueLayers for next (lower) layer
1753 layer->setVisibleRegion(visibleRegion);
1754 layer->setCoveredRegion(coveredRegion);
1755 layer->setVisibleNonTransparentRegion(
1783 // 1.) Layer 0 is latched
1784 // 2.) Layer 0 gets a new frame
1785 Layer 1 gets a new frame
1786 // 3.) Layer 1 is latched.
1787 // Display is now waiting on Layer 1's frame, which is behind layer 0's
1788 // second frame. But layer 0's second frame could be waiting on display.
1789 Vector<Layer*> layersWithQueuedFrames;
1791 const sp<Layer>& layer(layers[i]);
1792 if (layer->hasQueuedFrame()) {
1794 if (layer->shouldPresentNow(mPrimaryDispSync)) {
1795 layersWithQueuedFrames.push_back(layer.get());
1797 layer->useEmptyDamage();
1800 layer->useEmptyDamage();
1804 Layer* layer = layersWithQueuedFrames[i];
1805 const Region dirty(layer->latchBuffer(visibleRegions));
1806 layer->useSurfaceDamage();
1807 const Layer::State& s(layer->getDrawingState());
1961 const Vector< sp<Layer> >& layers(hw->getVisibleLayersSortedByZ());
1967 const sp<Layer>& layer(layers[i]);
1968 const Region clip(dirty.intersect(tr.transform(layer->visibleRegion)));
1973 const Layer::State& state(layer->getDrawingState());
1976 && layer->isOpaque(state) && (state.alpha == 0xFF)
1978 // never clear the very first layer since we're
1980 layer->clearWithOpenGL(hw, clip);
1985 layer->draw(hw, clip);
1996 layer->setAcquireFence(hw, *cur);
2001 const sp<Layer>& layer(layers[i]);
2003 tr.transform(layer->visibleRegion)));
2005 layer->draw(hw, clip);
2024 const sp<Layer>& lbc)
2026 // add this layer to the current state list
2036 // attach this layer to the client
2042 status_t SurfaceFlinger::removeLayer(const sp<Layer>& layer) {
2044 ssize_t index = mCurrentState.layersSortedByZ.remove(layer);
2046 mLayersPendingRemoval.push(layer);
2203 sp<Layer> layer(client->getLayerUser(s.surface));
2204 if (layer != 0) {
2207 if (layer->setPosition(s.x, s.y))
2212 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2213 if (layer->setLayer(s.z)) {
2215 layer);
2222 if (layer->setSize(s.w, s.h)) {
2227 if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f)))
2231 if (layer->setMatrix(s.matrix))
2235 if (layer->setTransparentRegionHint(s.transparentRegion))
2239 if (layer->setFlags(s.flags, s.mask))
2243 if (layer->setCrop(s.crop))
2248 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2249 if (layer->setLayerStack(s.layerStack)) {
2251 mCurrentState.layersSortedByZ.add(layer);
2276 sp<Layer> layer;
2282 handle, gbp, &layer);
2287 handle, gbp, &layer);
2298 result = addClientLayer(client, *handle, *gbp, layer);
2309 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2322 *outLayer = new Layer(this, client, name, w, h, flags);
2335 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2345 // called by the window manager when it wants to remove a Layer
2347 sp<Layer> l(client->getLayerUser(handle));
2351 "error removing layer=%p (%s)", l.get(), strerror(-err));
2356 status_t SurfaceFlinger::onLayerDestroyed(const wp<Layer>& layer)
2361 sp<Layer> l(layer.promote());
2365 "error removing layer=%p (%s)", l.get(), strerror(-err));
2373 // reset screen orientation and use primary layer stack
2564 const sp<Layer>& layer(currentLayers[i]);
2565 result.appendFormat("%s\n", layer->getName().string());
2588 const sp<Layer>& layer(currentLayers[i]);
2589 if (name == layer->getName()) {
2590 layer->dumpFrameStats(result);
2608 const sp<Layer>& layer(currentLayers[i]);
2609 if (name.isEmpty() || (name == layer->getName())) {
2610 layer->clearFrameStats();
2623 const sp<Layer>& layer(drawingLayers[i]);
2624 layer->logFrameStats();
2716 * Dump the visible layer list
2724 const sp<Layer>& layer(currentLayers[i]);
2725 layer->dump(result, colorizer);
2810 const Vector< sp<Layer> >&
3292 const sp<Layer>& layer(layers[i]);
3293 const Layer::State& state(layer->getDrawingState());
3296 if (layer->isVisible()) {
3297 if (filtering) layer->setFiltering(true);
3298 layer->draw(hw, useIdentityTransform);
3299 if (filtering) layer->setFiltering(false);
3459 const sp<Layer>& layer(layers[i]);
3460 const Layer::State& state(layer->getDrawingState());
3463 && (layer->isVisible());
3466 i, layer->getName().string(), state.layerStack, state.z,
3467 layer->isVisible(), state.flags, state.alpha);
3478 : SortedVector<sp<Layer> >(rhs) {
3484 // sort layers per layer-stack, then by z-order and finally by sequence
3485 const sp<Layer>& l(*reinterpret_cast<const sp<Layer>*>(lhs));
3486 const sp<Layer>& r(*reinterpret_cast<const sp<Layer>*>(rhs));
