virtual status_t captureScreen(const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform,
Rotation rotation = eRotateNone) = 0;
status_t show(const sp<IBinder>& id);
status_t setFlags(const sp<IBinder>& id, uint32_t flags, uint32_t mask);
status_t setTransparentRegionHint(const sp<IBinder>& id, const Region& transparent);
- status_t setLayer(const sp<IBinder>& id, uint32_t layer);
+ status_t setLayer(const sp<IBinder>& id, int32_t layer);
status_t setLayerInfo(const sp<IBinder>& id, uint32_t type, uint32_t appid);
status_t setAlpha(const sp<IBinder>& id, float alpha=1.0f);
status_t setMatrix(const sp<IBinder>& id, float dsdx, float dtdx, float dsdy, float dtdy);
const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform);
static status_t captureToBuffer(
const sp<IBinder>& display,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform,
uint32_t rotation,
sp<GraphicBuffer>* outbuffer);
bool useIdentityTransform);
status_t update(const sp<IBinder>& display,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform);
status_t update(const sp<IBinder>& display,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, uint32_t rotation);
sp<CpuConsumer> getCpuConsumer() const;
void disconnect();
status_t setLayerStack(uint32_t layerStack);
- status_t setLayer(uint32_t layer);
+ status_t setLayer(int32_t layer);
status_t setLayerInfo(uint32_t type, uint32_t appid);
status_t setPosition(float x, float y);
status_t setSize(uint32_t w, uint32_t h);
uint32_t what;
float x;
float y;
- uint32_t z;
+ int32_t z;
uint32_t w;
uint32_t h;
uint32_t layerStack;
virtual status_t captureScreen(const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform,
ISurfaceComposer::Rotation rotation)
{
data.write(sourceCrop);
data.writeUint32(reqWidth);
data.writeUint32(reqHeight);
- data.writeUint32(minLayerZ);
- data.writeUint32(maxLayerZ);
+ data.writeInt32(minLayerZ);
+ data.writeInt32(maxLayerZ);
data.writeInt32(static_cast<int32_t>(useIdentityTransform));
data.writeInt32(static_cast<int32_t>(rotation));
remote()->transact(BnSurfaceComposer::CAPTURE_SCREEN, data, &reply);
data.read(sourceCrop);
uint32_t reqWidth = data.readUint32();
uint32_t reqHeight = data.readUint32();
- uint32_t minLayerZ = data.readUint32();
- uint32_t maxLayerZ = data.readUint32();
+ int32_t minLayerZ = data.readInt32();
+ int32_t maxLayerZ = data.readInt32();
bool useIdentityTransform = static_cast<bool>(data.readInt32());
int32_t rotation = data.readInt32();
output.writeUint32(what);
output.writeFloat(x);
output.writeFloat(y);
- output.writeUint32(z);
+ output.writeInt32(z);
output.writeUint32(w);
output.writeUint32(h);
output.writeUint32(layerStack);
what = input.readUint32();
x = input.readFloat();
y = input.readFloat();
- z = input.readUint32();
+ z = input.readInt32();
w = input.readUint32();
h = input.readUint32();
layerStack = input.readUint32();
status_t setSize(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id,
uint32_t w, uint32_t h);
status_t setLayer(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id,
- uint32_t z);
+ int32_t z);
status_t setLayerInfo(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id,
uint32_t type, uint32_t appid);
status_t setFlags(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id,
}
status_t Composer::setLayer(const sp<SurfaceComposerClient>& client,
- const sp<IBinder>& id, uint32_t z) {
+ const sp<IBinder>& id, int32_t z) {
Mutex::Autolock _l(mLock);
layer_state_t* s = getLayerStateLocked(client, id);
if (!s)
return getComposer().setSize(this, id, w, h);
}
-status_t SurfaceComposerClient::setLayer(const sp<IBinder>& id, uint32_t z) {
+status_t SurfaceComposerClient::setLayer(const sp<IBinder>& id, int32_t z) {
return getComposer().setLayer(this, id, z);
}
const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ, bool useIdentityTransform) {
+ int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform) {
sp<ISurfaceComposer> s(ComposerService::getComposerService());
if (s == NULL) return NO_INIT;
return s->captureScreen(display, producer, sourceCrop,
status_t ScreenshotClient::captureToBuffer(const sp<IBinder>& display,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ, bool useIdentityTransform,
+ int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform,
uint32_t rotation,
sp<GraphicBuffer>* outBuffer) {
sp<ISurfaceComposer> s(ComposerService::getComposerService());
status_t ScreenshotClient::update(const sp<IBinder>& display,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, uint32_t rotation) {
sp<ISurfaceComposer> s(ComposerService::getComposerService());
if (s == NULL) return NO_INIT;
status_t ScreenshotClient::update(const sp<IBinder>& display,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform) {
return ScreenshotClient::update(display, sourceCrop, reqWidth, reqHeight,
status_t ScreenshotClient::update(const sp<IBinder>& display, Rect sourceCrop,
bool useIdentityTransform) {
- return ScreenshotClient::update(display, sourceCrop, 0, 0, 0, -1U,
+ return ScreenshotClient::update(display, sourceCrop, 0, 0,
+ INT32_MIN, INT32_MAX,
useIdentityTransform, ISurfaceComposer::eRotateNone);
}
status_t ScreenshotClient::update(const sp<IBinder>& display, Rect sourceCrop,
uint32_t reqWidth, uint32_t reqHeight, bool useIdentityTransform) {
return ScreenshotClient::update(display, sourceCrop, reqWidth, reqHeight,
- 0, -1U, useIdentityTransform, ISurfaceComposer::eRotateNone);
+ INT32_MIN, INT32_MAX,
+ useIdentityTransform, ISurfaceComposer::eRotateNone);
}
void ScreenshotClient::release() {
if (err < 0) return err;
return mClient->setLayerStack(mHandle, layerStack);
}
-status_t SurfaceControl::setLayer(uint32_t layer) {
+status_t SurfaceControl::setLayer(int32_t layer) {
status_t err = validate();
if (err < 0) return err;
return mClient->setLayer(mHandle, layer);
status_t captureScreen(const sp<IBinder>& /*display*/,
const sp<IGraphicBufferProducer>& /*producer*/,
Rect /*sourceCrop*/, uint32_t /*reqWidth*/, uint32_t /*reqHeight*/,
- uint32_t /*minLayerZ*/, uint32_t /*maxLayerZ*/,
+ int32_t /*minLayerZ*/, int32_t /*maxLayerZ*/,
bool /*useIdentityTransform*/,
Rotation /*rotation*/) override { return NO_ERROR; }
status_t clearAnimationFrameStats() override { return NO_ERROR; }
}
#ifdef USE_HWC2
-void Layer::setGeometry(const sp<const DisplayDevice>& displayDevice)
+void Layer::setGeometry(const sp<const DisplayDevice>& displayDevice, uint32_t z)
#else
void Layer::setGeometry(
const sp<const DisplayDevice>& hw,
"%s (%d)", mName.string(), s.alpha, to_string(error).c_str(),
static_cast<int32_t>(error));
- error = hwcLayer->setZOrder(s.z);
+ error = hwcLayer->setZOrder(z);
ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set Z %u: %s (%d)",
- mName.string(), s.z, to_string(error).c_str(),
+ mName.string(), z, to_string(error).c_str(),
static_cast<int32_t>(error));
#else
if (!frame.intersect(hw->getViewport(), &frame)) {
return true;
}
-bool Layer::setLayer(uint32_t z) {
+bool Layer::setLayer(int32_t z) {
if (mCurrentState.z == z)
return false;
mCurrentState.sequence++;
struct State {
Geometry active;
Geometry requested;
- uint32_t z;
+ int32_t z;
uint32_t layerStack;
#ifdef USE_HWC2
float alpha;
// modify current state
bool setPosition(float x, float y, bool immediate);
- bool setLayer(uint32_t z);
+ bool setLayer(int32_t z);
bool setSize(uint32_t w, uint32_t h);
#ifdef USE_HWC2
bool setAlpha(float alpha);
// -----------------------------------------------------------------------
#ifdef USE_HWC2
- void setGeometry(const sp<const DisplayDevice>& displayDevice);
+ void setGeometry(const sp<const DisplayDevice>& displayDevice, uint32_t z);
void forceClientComposition(int32_t hwcId);
void setPerFrameData(const sp<const DisplayDevice>& displayDevice);
const Vector<sp<Layer>>& currentLayers(
displayDevice->getVisibleLayersSortedByZ());
bool foundLayerWithoutHwc = false;
- for (auto& layer : currentLayers) {
+ for (size_t i = 0; i < currentLayers.size(); i++) {
+ auto const& layer = currentLayers[i];
if (!layer->hasHwcLayer(hwcId)) {
auto hwcLayer = mHwc->createLayer(hwcId);
if (hwcLayer) {
}
}
- layer->setGeometry(displayDevice);
+ layer->setGeometry(displayDevice, i);
if (mDebugDisableHWC || mDebugRegion) {
layer->forceClientComposition(hwcId);
}
status_t SurfaceFlinger::captureScreen(const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, ISurfaceComposer::Rotation rotation) {
if (CC_UNLIKELY(display == 0))
const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform,
Transform::orientation_flags rotation,
bool isLocalScreenshot)
void SurfaceFlinger::renderScreenImplLocked(
const sp<const DisplayDevice>& hw,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation)
{
ATRACE_CALL();
const sp<const DisplayDevice>& hw,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, Transform::orientation_flags rotation,
bool isLocalScreenshot)
{
}
void SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
- const sp<const DisplayDevice>& hw, uint32_t minLayerZ, uint32_t maxLayerZ) {
+ const sp<const DisplayDevice>& hw, int32_t minLayerZ, int32_t maxLayerZ) {
if (DEBUG_SCREENSHOTS) {
for (size_t y=0 ; y<h ; y++) {
uint32_t const * p = (uint32_t const *)vaddr + y*s;
virtual status_t captureScreen(const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, ISurfaceComposer::Rotation rotation);
virtual status_t getDisplayStats(const sp<IBinder>& display,
DisplayStatInfo* stats);
void renderScreenImplLocked(
const sp<const DisplayDevice>& hw,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation);
status_t captureScreenImplLocked(
const sp<const DisplayDevice>& hw,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, Transform::orientation_flags rotation,
bool isLocalScreenshot);
void appendSfConfigString(String8& result) const;
void checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
const sp<const DisplayDevice>& hw,
- uint32_t minLayerZ, uint32_t maxLayerZ);
+ int32_t minLayerZ, int32_t maxLayerZ);
void logFrameStats();
status_t SurfaceFlinger::captureScreen(const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, ISurfaceComposer::Rotation rotation) {
if (CC_UNLIKELY(display == 0))
sp<IGraphicBufferProducer> producer;
Rect sourceCrop;
uint32_t reqWidth, reqHeight;
- uint32_t minLayerZ,maxLayerZ;
+ int32_t minLayerZ,maxLayerZ;
bool useIdentityTransform;
Transform::orientation_flags rotation;
status_t result;
const sp<IBinder>& display,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform,
Transform::orientation_flags rotation,
bool isLocalScreenshot)
void SurfaceFlinger::renderScreenImplLocked(
const sp<const DisplayDevice>& hw,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation)
{
ATRACE_CALL();
const sp<const DisplayDevice>& hw,
const sp<IGraphicBufferProducer>& producer,
Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
- uint32_t minLayerZ, uint32_t maxLayerZ,
+ int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, Transform::orientation_flags rotation,
bool isLocalScreenshot)
{
}
void SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
- const sp<const DisplayDevice>& hw, uint32_t minLayerZ, uint32_t maxLayerZ) {
+ const sp<const DisplayDevice>& hw, int32_t minLayerZ, int32_t maxLayerZ) {
if (DEBUG_SCREENSHOTS) {
for (size_t y=0 ; y<h ; y++) {
uint32_t const * p = (uint32_t const *)vaddr + y*s;