blob: c4fb1cf40880792d2ebad3013e75fd6c765a86ca [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001/*
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002 * Copyright (C) 2010 The Android Open Source Project
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "Surface"
Mathias Agopiane3c697f2013-02-14 17:11:02 -080018#define ATRACE_TAG ATRACE_TAG_GRAPHICS
19//#define LOG_NDEBUG 0
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080020
Mathias Agopian05debe12017-02-08 17:04:18 -080021#include <gui/Surface.h>
Mathias Agopianb0e76f42012-03-23 14:15:44 -070022
Yiwei Zhang9e919eb2019-03-07 23:21:40 -080023#include <condition_variable>
24#include <deque>
25#include <mutex>
26#include <thread>
27
Mathias Agopiancb496ac2017-05-22 14:21:00 -070028#include <inttypes.h>
29
Huihong Luoaa7fc2e2022-02-15 10:43:00 -080030#include <android/gui/DisplayStatInfo.h>
Mathias Agopian05debe12017-02-08 17:04:18 -080031#include <android/native_window.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080032
chaviw5b4b29b2022-06-06 15:35:15 -050033#include <gui/TraceUtils.h>
Mathias Agopian9cce3252010-02-09 17:46:37 -080034#include <utils/Log.h>
Rachad7cb0d392014-07-29 17:53:53 -070035#include <utils/NativeHandle.h>
chaviw5b4b29b2022-06-06 15:35:15 -050036#include <utils/Trace.h>
Mathias Agopian9cce3252010-02-09 17:46:37 -080037
Marin Shalamanov228f46b2021-01-28 21:11:45 +010038#include <ui/DynamicDisplayInfo.h>
Courtney Goeltzenleuchterc5b97c52017-02-26 14:47:13 -070039#include <ui/Fence.h>
Shuzhen Wang067fcd32019-08-14 10:41:12 -070040#include <ui/GraphicBuffer.h>
Courtney Goeltzenleuchterc5b97c52017-02-26 14:47:13 -070041#include <ui/Region.h>
Mathias Agopiana67932f2011-04-20 14:20:59 -070042
Huihong Luo3bdef862022-03-03 11:57:19 -080043#include <gui/AidlStatusUtil.h>
Mathias Agopian2b5dd402017-02-07 17:36:19 -080044#include <gui/BufferItem.h>
Dan Stozaf0eaf252014-03-21 13:05:51 -070045#include <gui/IProducerListener.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080046
Mathias Agopian2b5dd402017-02-07 17:36:19 -080047#include <gui/ISurfaceComposer.h>
Steven Thomas62a4cf82020-01-31 12:04:03 -080048#include <gui/LayerState.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080049#include <private/gui/ComposerService.h>
Huihong Luo07e72362022-02-14 14:26:04 -080050#include <private/gui/ComposerServiceAIDL.h>
Mathias Agopian076b1cc2009-04-10 14:24:30 -070051
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080052namespace android {
53
Huihong Luo3bdef862022-03-03 11:57:19 -080054using gui::aidl_utils::statusTFromBinderStatus;
Peiyong Lin34beb7a2018-03-28 11:57:12 -070055using ui::Dataspace;
Peiyong Linfd997e02018-03-28 15:29:00 -070056
Alec Mouri09d122a2019-11-25 10:00:53 -080057namespace {
58
Huihong Luo31b5ac22022-08-15 20:38:10 -070059enum {
60 // moved from nativewindow/include/system/window.h, to be removed
61 NATIVE_WINDOW_GET_WIDE_COLOR_SUPPORT = 28,
62 NATIVE_WINDOW_GET_HDR_SUPPORT = 29,
63};
64
Alec Mouri09d122a2019-11-25 10:00:53 -080065bool isInterceptorRegistrationOp(int op) {
66 return op == NATIVE_WINDOW_SET_CANCEL_INTERCEPTOR ||
67 op == NATIVE_WINDOW_SET_DEQUEUE_INTERCEPTOR ||
68 op == NATIVE_WINDOW_SET_PERFORM_INTERCEPTOR ||
John Reck401cda62020-05-07 16:04:41 -070069 op == NATIVE_WINDOW_SET_QUEUE_INTERCEPTOR ||
70 op == NATIVE_WINDOW_SET_QUERY_INTERCEPTOR;
Alec Mouri09d122a2019-11-25 10:00:53 -080071}
72
73} // namespace
74
Vishnu Nair992496b2020-10-22 17:27:21 -070075Surface::Surface(const sp<IGraphicBufferProducer>& bufferProducer, bool controlledByApp,
76 const sp<IBinder>& surfaceControlHandle)
Ian Elliotta2eb34c2017-07-18 11:05:49 -060077 : mGraphicBufferProducer(bufferProducer),
78 mCrop(Rect::EMPTY_RECT),
79 mBufferAge(0),
80 mGenerationNumber(0),
81 mSharedBufferMode(false),
82 mAutoRefresh(false),
Vishnu Nair1d298262021-07-16 11:17:09 -070083 mAutoPrerotation(false),
Ian Elliotta2eb34c2017-07-18 11:05:49 -060084 mSharedBufferSlot(BufferItem::INVALID_BUFFER_SLOT),
85 mSharedBufferHasBeenQueued(false),
86 mQueriedSupportedTimestamps(false),
87 mFrameTimestampsSupportsPresent(false),
88 mEnableFrameTimestamps(false),
89 mFrameEventHistory(std::make_unique<ProducerFrameEventHistory>()) {
Mathias Agopiane3c697f2013-02-14 17:11:02 -080090 // Initialize the ANativeWindow function pointers.
91 ANativeWindow::setSwapInterval = hook_setSwapInterval;
92 ANativeWindow::dequeueBuffer = hook_dequeueBuffer;
93 ANativeWindow::cancelBuffer = hook_cancelBuffer;
94 ANativeWindow::queueBuffer = hook_queueBuffer;
95 ANativeWindow::query = hook_query;
96 ANativeWindow::perform = hook_perform;
97
98 ANativeWindow::dequeueBuffer_DEPRECATED = hook_dequeueBuffer_DEPRECATED;
99 ANativeWindow::cancelBuffer_DEPRECATED = hook_cancelBuffer_DEPRECATED;
100 ANativeWindow::lockBuffer_DEPRECATED = hook_lockBuffer_DEPRECATED;
101 ANativeWindow::queueBuffer_DEPRECATED = hook_queueBuffer_DEPRECATED;
102
103 const_cast<int&>(ANativeWindow::minSwapInterval) = 0;
104 const_cast<int&>(ANativeWindow::maxSwapInterval) = 1;
105
106 mReqWidth = 0;
107 mReqHeight = 0;
108 mReqFormat = 0;
109 mReqUsage = 0;
110 mTimestamp = NATIVE_WINDOW_TIMESTAMP_AUTO;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700111 mDataSpace = Dataspace::UNKNOWN;
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800112 mScalingMode = NATIVE_WINDOW_SCALING_MODE_FREEZE;
113 mTransform = 0;
Ruben Brunk1681d952014-06-27 15:51:55 -0700114 mStickyTransform = 0;
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800115 mDefaultWidth = 0;
116 mDefaultHeight = 0;
117 mUserWidth = 0;
118 mUserHeight = 0;
119 mTransformHint = 0;
120 mConsumerRunningBehind = false;
121 mConnectedToCpu = false;
Eino-Ville Talvala7895e902013-08-21 11:53:37 -0700122 mProducerControlledByApp = controlledByApp;
Mathias Agopian7cdd7862013-07-18 22:10:56 -0700123 mSwapIntervalZero = false;
Yiwei Zhang74c9cc32020-06-20 03:35:17 -0700124 mMaxBufferCount = NUM_BUFFER_SLOTS;
Vishnu Nair992496b2020-10-22 17:27:21 -0700125 mSurfaceControlHandle = surfaceControlHandle;
Mathias Agopian62185b72009-04-16 16:19:50 -0700126}
127
Mathias Agopian35ffa6a2013-03-12 18:45:09 -0700128Surface::~Surface() {
129 if (mConnectedToCpu) {
130 Surface::disconnect(NATIVE_WINDOW_API_CPU);
131 }
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800132}
133
Brian Anderson3da8d272016-07-28 16:20:47 -0700134sp<ISurfaceComposer> Surface::composerService() const {
135 return ComposerService::getComposerService();
136}
137
Huihong Luo37396db2022-02-15 10:43:00 -0800138sp<gui::ISurfaceComposer> Surface::composerServiceAIDL() const {
139 return ComposerServiceAIDL::getComposerService();
140}
141
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800142nsecs_t Surface::now() const {
143 return systemTime();
144}
145
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800146sp<IGraphicBufferProducer> Surface::getIGraphicBufferProducer() const {
147 return mGraphicBufferProducer;
148}
149
Wonsik Kim0ee14ca2014-03-17 17:46:53 +0900150void Surface::setSidebandStream(const sp<NativeHandle>& stream) {
151 mGraphicBufferProducer->setSidebandStream(stream);
152}
153
Dan Stoza29a3e902014-06-20 13:13:57 -0700154void Surface::allocateBuffers() {
155 uint32_t reqWidth = mReqWidth ? mReqWidth : mUserWidth;
156 uint32_t reqHeight = mReqHeight ? mReqHeight : mUserHeight;
Pablo Ceballos567dbbb2015-08-26 18:59:08 -0700157 mGraphicBufferProducer->allocateBuffers(reqWidth, reqHeight,
158 mReqFormat, mReqUsage);
Dan Stoza29a3e902014-06-20 13:13:57 -0700159}
160
Dan Stoza812ed062015-06-02 15:45:22 -0700161status_t Surface::setGenerationNumber(uint32_t generation) {
162 status_t result = mGraphicBufferProducer->setGenerationNumber(generation);
163 if (result == NO_ERROR) {
164 mGenerationNumber = generation;
165 }
166 return result;
167}
168
Dan Stoza7dde5992015-05-22 09:51:44 -0700169uint64_t Surface::getNextFrameNumber() const {
Pablo Ceballosbc8c1922016-07-01 14:15:41 -0700170 Mutex::Autolock lock(mMutex);
171 return mNextFrameNumber;
Dan Stoza7dde5992015-05-22 09:51:44 -0700172}
173
Dan Stozac6f30bd2015-06-08 09:32:50 -0700174String8 Surface::getConsumerName() const {
175 return mGraphicBufferProducer->getConsumerName();
176}
177
Dan Stoza127fc632015-06-30 13:43:32 -0700178status_t Surface::setDequeueTimeout(nsecs_t timeout) {
179 return mGraphicBufferProducer->setDequeueTimeout(timeout);
180}
181
Dan Stoza50101d02016-04-07 16:53:23 -0700182status_t Surface::getLastQueuedBuffer(sp<GraphicBuffer>* outBuffer,
John Reck1a61da52016-04-28 13:18:15 -0700183 sp<Fence>* outFence, float outTransformMatrix[16]) {
184 return mGraphicBufferProducer->getLastQueuedBuffer(outBuffer, outFence,
185 outTransformMatrix);
Dan Stoza50101d02016-04-07 16:53:23 -0700186}
187
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800188status_t Surface::getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration) {
189 ATRACE_CALL();
190
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800191 gui::DisplayStatInfo stats;
192 binder::Status status = composerServiceAIDL()->getDisplayStats(nullptr, &stats);
193 if (!status.isOk()) {
Huihong Luo3bdef862022-03-03 11:57:19 -0800194 return statusTFromBinderStatus(status);
Chih-Hung Hsiehd66be0a2017-10-05 13:51:32 -0700195 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800196
197 *outRefreshDuration = stats.vsyncPeriod;
198
199 return NO_ERROR;
200}
201
Brian Anderson7c3ba8a2016-07-25 12:48:08 -0700202void Surface::enableFrameTimestamps(bool enable) {
203 Mutex::Autolock lock(mMutex);
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800204 // If going from disabled to enabled, get the initial values for
205 // compositor and display timing.
206 if (!mEnableFrameTimestamps && enable) {
207 FrameEventHistoryDelta delta;
208 mGraphicBufferProducer->getFrameTimestamps(&delta);
209 mFrameEventHistory->applyDelta(delta);
210 }
Brian Anderson7c3ba8a2016-07-25 12:48:08 -0700211 mEnableFrameTimestamps = enable;
212}
213
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800214status_t Surface::getCompositorTiming(
215 nsecs_t* compositeDeadline, nsecs_t* compositeInterval,
216 nsecs_t* compositeToPresentLatency) {
217 Mutex::Autolock lock(mMutex);
218 if (!mEnableFrameTimestamps) {
219 return INVALID_OPERATION;
220 }
221
222 if (compositeDeadline != nullptr) {
223 *compositeDeadline =
224 mFrameEventHistory->getNextCompositeDeadline(now());
225 }
226 if (compositeInterval != nullptr) {
227 *compositeInterval = mFrameEventHistory->getCompositeInterval();
228 }
229 if (compositeToPresentLatency != nullptr) {
230 *compositeToPresentLatency =
231 mFrameEventHistory->getCompositeToPresentLatency();
232 }
233 return NO_ERROR;
234}
235
Brian Anderson50143b32016-09-30 14:01:24 -0700236static bool checkConsumerForUpdates(
237 const FrameEvents* e, const uint64_t lastFrameNumber,
Brian Andersonf7fd56a2016-09-02 10:10:04 -0700238 const nsecs_t* outLatchTime,
239 const nsecs_t* outFirstRefreshStartTime,
240 const nsecs_t* outLastRefreshStartTime,
Brian Andersonb04c6f02016-10-21 12:57:46 -0700241 const nsecs_t* outGpuCompositionDoneTime,
Brian Anderson50143b32016-09-30 14:01:24 -0700242 const nsecs_t* outDisplayPresentTime,
Brian Andersonf7fd56a2016-09-02 10:10:04 -0700243 const nsecs_t* outDequeueReadyTime,
Brian Anderson50143b32016-09-30 14:01:24 -0700244 const nsecs_t* outReleaseTime) {
Brian Andersonf7fd56a2016-09-02 10:10:04 -0700245 bool checkForLatch = (outLatchTime != nullptr) && !e->hasLatchInfo();
246 bool checkForFirstRefreshStart = (outFirstRefreshStartTime != nullptr) &&
Brian Anderson50143b32016-09-30 14:01:24 -0700247 !e->hasFirstRefreshStartInfo();
Brian Andersonb04c6f02016-10-21 12:57:46 -0700248 bool checkForGpuCompositionDone = (outGpuCompositionDoneTime != nullptr) &&
Brian Anderson50143b32016-09-30 14:01:24 -0700249 !e->hasGpuCompositionDoneInfo();
250 bool checkForDisplayPresent = (outDisplayPresentTime != nullptr) &&
251 !e->hasDisplayPresentInfo();
252
Brian Anderson6b376712017-04-04 10:51:39 -0700253 // LastRefreshStart, DequeueReady, and Release are never available for the
254 // last frame.
Brian Andersonf7fd56a2016-09-02 10:10:04 -0700255 bool checkForLastRefreshStart = (outLastRefreshStartTime != nullptr) &&
256 !e->hasLastRefreshStartInfo() &&
257 (e->frameNumber != lastFrameNumber);
Brian Andersonf7fd56a2016-09-02 10:10:04 -0700258 bool checkForDequeueReady = (outDequeueReadyTime != nullptr) &&
259 !e->hasDequeueReadyInfo() && (e->frameNumber != lastFrameNumber);
Brian Anderson50143b32016-09-30 14:01:24 -0700260 bool checkForRelease = (outReleaseTime != nullptr) &&
261 !e->hasReleaseInfo() && (e->frameNumber != lastFrameNumber);
262
263 // RequestedPresent and Acquire info are always available producer-side.
Brian Andersonf7fd56a2016-09-02 10:10:04 -0700264 return checkForLatch || checkForFirstRefreshStart ||
Brian Andersonb04c6f02016-10-21 12:57:46 -0700265 checkForLastRefreshStart || checkForGpuCompositionDone ||
Brian Anderson4e606e32017-03-16 15:34:57 -0700266 checkForDisplayPresent || checkForDequeueReady || checkForRelease;
Brian Anderson50143b32016-09-30 14:01:24 -0700267}
268
Brian Anderson3d4039d2016-09-23 16:31:30 -0700269static void getFrameTimestamp(nsecs_t *dst, const nsecs_t& src) {
270 if (dst != nullptr) {
Brian Andersondc96fdf2017-03-20 16:54:25 -0700271 // We always get valid timestamps for these eventually.
272 *dst = (src == FrameEvents::TIMESTAMP_PENDING) ?
273 NATIVE_WINDOW_TIMESTAMP_PENDING : src;
Brian Anderson3d4039d2016-09-23 16:31:30 -0700274 }
275}
276
Brian Andersondc96fdf2017-03-20 16:54:25 -0700277static void getFrameTimestampFence(nsecs_t *dst,
278 const std::shared_ptr<FenceTime>& src, bool fenceShouldBeKnown) {
Brian Anderson3d4039d2016-09-23 16:31:30 -0700279 if (dst != nullptr) {
Brian Andersondc96fdf2017-03-20 16:54:25 -0700280 if (!fenceShouldBeKnown) {
281 *dst = NATIVE_WINDOW_TIMESTAMP_PENDING;
282 return;
283 }
284
Brian Anderson3d4039d2016-09-23 16:31:30 -0700285 nsecs_t signalTime = src->getSignalTime();
Brian Andersondc96fdf2017-03-20 16:54:25 -0700286 *dst = (signalTime == Fence::SIGNAL_TIME_PENDING) ?
287 NATIVE_WINDOW_TIMESTAMP_PENDING :
288 (signalTime == Fence::SIGNAL_TIME_INVALID) ?
289 NATIVE_WINDOW_TIMESTAMP_INVALID :
290 signalTime;
Brian Anderson3d4039d2016-09-23 16:31:30 -0700291 }
292}
293
Brian Anderson069b3652016-07-22 10:32:47 -0700294status_t Surface::getFrameTimestamps(uint64_t frameNumber,
Brian Andersondbd0ea82016-07-22 09:38:59 -0700295 nsecs_t* outRequestedPresentTime, nsecs_t* outAcquireTime,
Brian Andersonf7fd56a2016-09-02 10:10:04 -0700296 nsecs_t* outLatchTime, nsecs_t* outFirstRefreshStartTime,
Brian Andersonb04c6f02016-10-21 12:57:46 -0700297 nsecs_t* outLastRefreshStartTime, nsecs_t* outGpuCompositionDoneTime,
Brian Anderson4e606e32017-03-16 15:34:57 -0700298 nsecs_t* outDisplayPresentTime, nsecs_t* outDequeueReadyTime,
299 nsecs_t* outReleaseTime) {
Pablo Ceballosce796e72016-02-04 19:10:51 -0800300 ATRACE_CALL();
301
Brian Anderson3890c392016-07-25 12:48:08 -0700302 Mutex::Autolock lock(mMutex);
Brian Anderson069b3652016-07-22 10:32:47 -0700303
Brian Anderson7c3ba8a2016-07-25 12:48:08 -0700304 if (!mEnableFrameTimestamps) {
305 return INVALID_OPERATION;
306 }
307
Brian Anderson6b376712017-04-04 10:51:39 -0700308 // Verify the requested timestamps are supported.
309 querySupportedTimestampsLocked();
310 if (outDisplayPresentTime != nullptr && !mFrameTimestampsSupportsPresent) {
311 return BAD_VALUE;
312 }
313
Brian Anderson3da8d272016-07-28 16:20:47 -0700314 FrameEvents* events = mFrameEventHistory->getFrame(frameNumber);
Brian Anderson50143b32016-09-30 14:01:24 -0700315 if (events == nullptr) {
316 // If the entry isn't available in the producer, it's definitely not
317 // available in the consumer.
318 return NAME_NOT_FOUND;
Brian Anderson3890c392016-07-25 12:48:08 -0700319 }
320
Brian Anderson50143b32016-09-30 14:01:24 -0700321 // Update our cache of events if the requested events are not available.
322 if (checkConsumerForUpdates(events, mLastFrameNumber,
Brian Andersonf7fd56a2016-09-02 10:10:04 -0700323 outLatchTime, outFirstRefreshStartTime, outLastRefreshStartTime,
Brian Andersonb04c6f02016-10-21 12:57:46 -0700324 outGpuCompositionDoneTime, outDisplayPresentTime,
Brian Anderson4e606e32017-03-16 15:34:57 -0700325 outDequeueReadyTime, outReleaseTime)) {
Brian Anderson50143b32016-09-30 14:01:24 -0700326 FrameEventHistoryDelta delta;
327 mGraphicBufferProducer->getFrameTimestamps(&delta);
Brian Anderson3da8d272016-07-28 16:20:47 -0700328 mFrameEventHistory->applyDelta(delta);
329 events = mFrameEventHistory->getFrame(frameNumber);
Brian Anderson50143b32016-09-30 14:01:24 -0700330 }
331
Brian Anderson3890c392016-07-25 12:48:08 -0700332 if (events == nullptr) {
Brian Anderson50143b32016-09-30 14:01:24 -0700333 // The entry was available before the update, but was overwritten
334 // after the update. Make sure not to send the wrong frame's data.
Brian Anderson069b3652016-07-22 10:32:47 -0700335 return NAME_NOT_FOUND;
Pablo Ceballosce796e72016-02-04 19:10:51 -0800336 }
Brian Anderson069b3652016-07-22 10:32:47 -0700337
Brian Anderson3d4039d2016-09-23 16:31:30 -0700338 getFrameTimestamp(outRequestedPresentTime, events->requestedPresentTime);
Brian Andersonf7fd56a2016-09-02 10:10:04 -0700339 getFrameTimestamp(outLatchTime, events->latchTime);
340 getFrameTimestamp(outFirstRefreshStartTime, events->firstRefreshStartTime);
341 getFrameTimestamp(outLastRefreshStartTime, events->lastRefreshStartTime);
342 getFrameTimestamp(outDequeueReadyTime, events->dequeueReadyTime);
Brian Anderson3890c392016-07-25 12:48:08 -0700343
Brian Andersondc96fdf2017-03-20 16:54:25 -0700344 getFrameTimestampFence(outAcquireTime, events->acquireFence,
345 events->hasAcquireInfo());
346 getFrameTimestampFence(outGpuCompositionDoneTime,
347 events->gpuCompositionDoneFence,
348 events->hasGpuCompositionDoneInfo());
349 getFrameTimestampFence(outDisplayPresentTime, events->displayPresentFence,
350 events->hasDisplayPresentInfo());
351 getFrameTimestampFence(outReleaseTime, events->releaseFence,
352 events->hasReleaseInfo());
Brian Anderson069b3652016-07-22 10:32:47 -0700353
354 return NO_ERROR;
Pablo Ceballosce796e72016-02-04 19:10:51 -0800355}
356
Huihong Luo31b5ac22022-08-15 20:38:10 -0700357// Deprecated(b/242763577): to be removed, this method should not be used
358// The reason this method still exists here is to support compiled vndk
359// Surface support should not be tied to the display
360// Return true since most displays should have this support
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -0700361status_t Surface::getWideColorSupport(bool* supported) {
362 ATRACE_CALL();
363
Huihong Luo31b5ac22022-08-15 20:38:10 -0700364 *supported = true;
365 return NO_ERROR;
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -0700366}
367
Huihong Luo31b5ac22022-08-15 20:38:10 -0700368// Deprecated(b/242763577): to be removed, this method should not be used
369// The reason this method still exists here is to support compiled vndk
370// Surface support should not be tied to the display
371// Return true since most displays should have this support
Courtney Goeltzenleuchterc5b97c52017-02-26 14:47:13 -0700372status_t Surface::getHdrSupport(bool* supported) {
373 ATRACE_CALL();
374
Huihong Luo31b5ac22022-08-15 20:38:10 -0700375 *supported = true;
Courtney Goeltzenleuchterc5b97c52017-02-26 14:47:13 -0700376 return NO_ERROR;
377}
378
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800379int Surface::hook_setSwapInterval(ANativeWindow* window, int interval) {
380 Surface* c = getSelf(window);
381 return c->setSwapInterval(interval);
382}
383
384int Surface::hook_dequeueBuffer(ANativeWindow* window,
385 ANativeWindowBuffer** buffer, int* fenceFd) {
386 Surface* c = getSelf(window);
Alec Mouri09d122a2019-11-25 10:00:53 -0800387 {
388 std::shared_lock<std::shared_mutex> lock(c->mInterceptorMutex);
389 if (c->mDequeueInterceptor != nullptr) {
390 auto interceptor = c->mDequeueInterceptor;
391 auto data = c->mDequeueInterceptorData;
392 return interceptor(window, Surface::dequeueBufferInternal, data, buffer, fenceFd);
393 }
394 }
395 return c->dequeueBuffer(buffer, fenceFd);
396}
397
398int Surface::dequeueBufferInternal(ANativeWindow* window, ANativeWindowBuffer** buffer,
399 int* fenceFd) {
400 Surface* c = getSelf(window);
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800401 return c->dequeueBuffer(buffer, fenceFd);
402}
403
404int Surface::hook_cancelBuffer(ANativeWindow* window,
405 ANativeWindowBuffer* buffer, int fenceFd) {
406 Surface* c = getSelf(window);
Alec Mouri09d122a2019-11-25 10:00:53 -0800407 {
408 std::shared_lock<std::shared_mutex> lock(c->mInterceptorMutex);
409 if (c->mCancelInterceptor != nullptr) {
410 auto interceptor = c->mCancelInterceptor;
411 auto data = c->mCancelInterceptorData;
412 return interceptor(window, Surface::cancelBufferInternal, data, buffer, fenceFd);
413 }
414 }
415 return c->cancelBuffer(buffer, fenceFd);
416}
417
418int Surface::cancelBufferInternal(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd) {
419 Surface* c = getSelf(window);
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800420 return c->cancelBuffer(buffer, fenceFd);
421}
422
423int Surface::hook_queueBuffer(ANativeWindow* window,
424 ANativeWindowBuffer* buffer, int fenceFd) {
425 Surface* c = getSelf(window);
Alec Mouri09d122a2019-11-25 10:00:53 -0800426 {
427 std::shared_lock<std::shared_mutex> lock(c->mInterceptorMutex);
428 if (c->mQueueInterceptor != nullptr) {
429 auto interceptor = c->mQueueInterceptor;
430 auto data = c->mQueueInterceptorData;
431 return interceptor(window, Surface::queueBufferInternal, data, buffer, fenceFd);
432 }
433 }
434 return c->queueBuffer(buffer, fenceFd);
435}
436
437int Surface::queueBufferInternal(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd) {
438 Surface* c = getSelf(window);
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800439 return c->queueBuffer(buffer, fenceFd);
440}
441
442int Surface::hook_dequeueBuffer_DEPRECATED(ANativeWindow* window,
443 ANativeWindowBuffer** buffer) {
444 Surface* c = getSelf(window);
445 ANativeWindowBuffer* buf;
446 int fenceFd = -1;
447 int result = c->dequeueBuffer(&buf, &fenceFd);
Mike Stroyan87709c92016-06-03 12:43:26 -0600448 if (result != OK) {
449 return result;
450 }
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800451 sp<Fence> fence(new Fence(fenceFd));
Mathias Agopianea74d3b2013-05-16 18:03:22 -0700452 int waitResult = fence->waitForever("dequeueBuffer_DEPRECATED");
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800453 if (waitResult != OK) {
454 ALOGE("dequeueBuffer_DEPRECATED: Fence::wait returned an error: %d",
455 waitResult);
456 c->cancelBuffer(buf, -1);
457 return waitResult;
Mathias Agopian62185b72009-04-16 16:19:50 -0700458 }
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800459 *buffer = buf;
460 return result;
Mathias Agopian62185b72009-04-16 16:19:50 -0700461}
462
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800463int Surface::hook_cancelBuffer_DEPRECATED(ANativeWindow* window,
464 ANativeWindowBuffer* buffer) {
465 Surface* c = getSelf(window);
466 return c->cancelBuffer(buffer, -1);
Mathias Agopian62185b72009-04-16 16:19:50 -0700467}
468
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800469int Surface::hook_lockBuffer_DEPRECATED(ANativeWindow* window,
470 ANativeWindowBuffer* buffer) {
471 Surface* c = getSelf(window);
472 return c->lockBuffer_DEPRECATED(buffer);
Mathias Agopian62185b72009-04-16 16:19:50 -0700473}
474
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800475int Surface::hook_queueBuffer_DEPRECATED(ANativeWindow* window,
476 ANativeWindowBuffer* buffer) {
477 Surface* c = getSelf(window);
478 return c->queueBuffer(buffer, -1);
Jamie Gennisf15a83f2012-05-10 20:43:55 -0700479}
Mathias Agopian62185b72009-04-16 16:19:50 -0700480
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800481int Surface::hook_perform(ANativeWindow* window, int operation, ...) {
482 va_list args;
483 va_start(args, operation);
484 Surface* c = getSelf(window);
Alec Mouri09d122a2019-11-25 10:00:53 -0800485 int result;
486 // Don't acquire shared ownership of the interceptor mutex if we're going to
487 // do interceptor registration, as otherwise we'll deadlock on acquiring
488 // exclusive ownership.
489 if (!isInterceptorRegistrationOp(operation)) {
490 std::shared_lock<std::shared_mutex> lock(c->mInterceptorMutex);
491 if (c->mPerformInterceptor != nullptr) {
492 result = c->mPerformInterceptor(window, Surface::performInternal,
493 c->mPerformInterceptorData, operation, args);
494 va_end(args);
495 return result;
496 }
497 }
498 result = c->perform(operation, args);
Haixia Shid89c2bb2015-09-14 11:02:18 -0700499 va_end(args);
500 return result;
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800501}
502
Alec Mouri09d122a2019-11-25 10:00:53 -0800503int Surface::performInternal(ANativeWindow* window, int operation, va_list args) {
504 Surface* c = getSelf(window);
505 return c->perform(operation, args);
506}
507
508int Surface::hook_query(const ANativeWindow* window, int what, int* value) {
509 const Surface* c = getSelf(window);
John Reck401cda62020-05-07 16:04:41 -0700510 {
511 std::shared_lock<std::shared_mutex> lock(c->mInterceptorMutex);
512 if (c->mQueryInterceptor != nullptr) {
513 auto interceptor = c->mQueryInterceptor;
514 auto data = c->mQueryInterceptorData;
515 return interceptor(window, Surface::queryInternal, data, what, value);
516 }
517 }
518 return c->query(what, value);
519}
520
521int Surface::queryInternal(const ANativeWindow* window, int what, int* value) {
522 const Surface* c = getSelf(window);
Alec Mouri09d122a2019-11-25 10:00:53 -0800523 return c->query(what, value);
524}
525
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800526int Surface::setSwapInterval(int interval) {
527 ATRACE_CALL();
528 // EGL specification states:
529 // interval is silently clamped to minimum and maximum implementation
530 // dependent values before being stored.
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800531
532 if (interval < minSwapInterval)
533 interval = minSwapInterval;
534
535 if (interval > maxSwapInterval)
536 interval = maxSwapInterval;
537
Jorim Jaggi0a3e7842018-07-17 13:48:33 +0200538 const bool wasSwapIntervalZero = mSwapIntervalZero;
Mathias Agopian7cdd7862013-07-18 22:10:56 -0700539 mSwapIntervalZero = (interval == 0);
Jorim Jaggi0a3e7842018-07-17 13:48:33 +0200540
541 if (mSwapIntervalZero != wasSwapIntervalZero) {
542 mGraphicBufferProducer->setAsyncMode(mSwapIntervalZero);
543 }
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800544
Mathias Agopian7cdd7862013-07-18 22:10:56 -0700545 return NO_ERROR;
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800546}
547
Yiwei Zhang9e919eb2019-03-07 23:21:40 -0800548class FenceMonitor {
549public:
550 explicit FenceMonitor(const char* name) : mName(name), mFencesQueued(0), mFencesSignaled(0) {
551 std::thread thread(&FenceMonitor::loop, this);
552 pthread_setname_np(thread.native_handle(), mName);
553 thread.detach();
554 }
555
556 void queueFence(const sp<Fence>& fence) {
557 char message[64];
558
559 std::lock_guard<std::mutex> lock(mMutex);
Yiwei Zhang28178132019-03-08 17:14:53 -0800560 if (fence->getSignalTime() != Fence::SIGNAL_TIME_PENDING) {
561 snprintf(message, sizeof(message), "%s fence %u has signaled", mName, mFencesQueued);
562 ATRACE_NAME(message);
563 // Need an increment on both to make the trace number correct.
564 mFencesQueued++;
565 mFencesSignaled++;
566 return;
567 }
568 snprintf(message, sizeof(message), "Trace %s fence %u", mName, mFencesQueued);
Yiwei Zhang9e919eb2019-03-07 23:21:40 -0800569 ATRACE_NAME(message);
570
571 mQueue.push_back(fence);
572 mCondition.notify_one();
573 mFencesQueued++;
574 ATRACE_INT(mName, int32_t(mQueue.size()));
575 }
576
577private:
578#pragma clang diagnostic push
579#pragma clang diagnostic ignored "-Wmissing-noreturn"
580 void loop() {
581 while (true) {
582 threadLoop();
583 }
584 }
585#pragma clang diagnostic pop
586
587 void threadLoop() {
588 sp<Fence> fence;
589 uint32_t fenceNum;
590 {
591 std::unique_lock<std::mutex> lock(mMutex);
592 while (mQueue.empty()) {
593 mCondition.wait(lock);
594 }
595 fence = mQueue[0];
596 fenceNum = mFencesSignaled;
597 }
598 {
599 char message[64];
600 snprintf(message, sizeof(message), "waiting for %s %u", mName, fenceNum);
601 ATRACE_NAME(message);
602
603 status_t result = fence->waitForever(message);
604 if (result != OK) {
605 ALOGE("Error waiting for fence: %d", result);
606 }
607 }
608 {
609 std::lock_guard<std::mutex> lock(mMutex);
610 mQueue.pop_front();
611 mFencesSignaled++;
612 ATRACE_INT(mName, int32_t(mQueue.size()));
613 }
614 }
615
616 const char* mName;
617 uint32_t mFencesQueued;
618 uint32_t mFencesSignaled;
619 std::deque<sp<Fence>> mQueue;
620 std::condition_variable mCondition;
621 std::mutex mMutex;
622};
623
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -0800624void Surface::getDequeueBufferInputLocked(
625 IGraphicBufferProducer::DequeueBufferInput* dequeueInput) {
626 LOG_ALWAYS_FATAL_IF(dequeueInput == nullptr, "input is null");
627
628 dequeueInput->width = mReqWidth ? mReqWidth : mUserWidth;
629 dequeueInput->height = mReqHeight ? mReqHeight : mUserHeight;
630
631 dequeueInput->format = mReqFormat;
632 dequeueInput->usage = mReqUsage;
633
634 dequeueInput->getTimestamps = mEnableFrameTimestamps;
635}
636
Mathias Agopianba93b3f2013-08-01 15:48:40 -0700637int Surface::dequeueBuffer(android_native_buffer_t** buffer, int* fenceFd) {
chaviw5b4b29b2022-06-06 15:35:15 -0500638 ATRACE_FORMAT("dequeueBuffer - %s", getDebugName());
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800639 ALOGV("Surface::dequeueBuffer");
Igor Murashkin0f1889e2014-02-28 18:44:21 -0800640
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -0800641 IGraphicBufferProducer::DequeueBufferInput dqInput;
Igor Murashkin0f1889e2014-02-28 18:44:21 -0800642 {
643 Mutex::Autolock lock(mMutex);
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -0700644 if (mReportRemovedBuffers) {
645 mRemovedBuffers.clear();
646 }
Igor Murashkin0f1889e2014-02-28 18:44:21 -0800647
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -0800648 getDequeueBufferInputLocked(&dqInput);
Brian Anderson7c3ba8a2016-07-25 12:48:08 -0700649
Pablo Ceballos3559fbf2016-03-17 15:50:23 -0700650 if (mSharedBufferMode && mAutoRefresh && mSharedBufferSlot !=
Pablo Ceballosff95aab2016-01-13 17:09:58 -0800651 BufferItem::INVALID_BUFFER_SLOT) {
652 sp<GraphicBuffer>& gbuf(mSlots[mSharedBufferSlot].buffer);
Yi Kong48a619f2018-06-05 16:34:59 -0700653 if (gbuf != nullptr) {
Pablo Ceballosff95aab2016-01-13 17:09:58 -0800654 *buffer = gbuf.get();
655 *fenceFd = -1;
656 return OK;
657 }
658 }
Igor Murashkin0f1889e2014-02-28 18:44:21 -0800659 } // Drop the lock so that we can still touch the Surface while blocking in IGBP::dequeueBuffer
660
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800661 int buf = -1;
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800662 sp<Fence> fence;
Dan Stoza932f0082017-05-31 13:50:16 -0700663 nsecs_t startTime = systemTime();
Brian Anderson7c3ba8a2016-07-25 12:48:08 -0700664
665 FrameEventHistoryDelta frameTimestamps;
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -0800666 status_t result = mGraphicBufferProducer->dequeueBuffer(&buf, &fence, dqInput.width,
667 dqInput.height, dqInput.format,
668 dqInput.usage, &mBufferAge,
669 dqInput.getTimestamps ?
670 &frameTimestamps : nullptr);
Dan Stoza932f0082017-05-31 13:50:16 -0700671 mLastDequeueDuration = systemTime() - startTime;
Igor Murashkin0f1889e2014-02-28 18:44:21 -0800672
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800673 if (result < 0) {
Pablo Ceballos567dbbb2015-08-26 18:59:08 -0700674 ALOGV("dequeueBuffer: IGraphicBufferProducer::dequeueBuffer"
Mathias Agopiancb496ac2017-05-22 14:21:00 -0700675 "(%d, %d, %d, %#" PRIx64 ") failed: %d",
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -0800676 dqInput.width, dqInput.height, dqInput.format, dqInput.usage, result);
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800677 return result;
Mathias Agopian62185b72009-04-16 16:19:50 -0700678 }
Igor Murashkin0f1889e2014-02-28 18:44:21 -0800679
Dan Stoza90ce2a92017-05-01 16:31:53 -0700680 if (buf < 0 || buf >= NUM_BUFFER_SLOTS) {
681 ALOGE("dequeueBuffer: IGraphicBufferProducer returned invalid slot number %d", buf);
682 android_errorWriteLog(0x534e4554, "36991414"); // SafetyNet logging
683 return FAILED_TRANSACTION;
684 }
685
Igor Murashkin0f1889e2014-02-28 18:44:21 -0800686 Mutex::Autolock lock(mMutex);
687
Dan Stoza932f0082017-05-31 13:50:16 -0700688 // Write this while holding the mutex
689 mLastDequeueStartTime = startTime;
690
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800691 sp<GraphicBuffer>& gbuf(mSlots[buf].buffer);
Mathias Agopianba93b3f2013-08-01 15:48:40 -0700692
693 // this should never happen
Yi Kong48a619f2018-06-05 16:34:59 -0700694 ALOGE_IF(fence == nullptr, "Surface::dequeueBuffer: received null Fence! buf=%d", buf);
Mathias Agopianba93b3f2013-08-01 15:48:40 -0700695
Yiwei Zhang9e919eb2019-03-07 23:21:40 -0800696 if (CC_UNLIKELY(atrace_is_tag_enabled(ATRACE_TAG_GRAPHICS))) {
697 static FenceMonitor hwcReleaseThread("HWC release");
698 hwcReleaseThread.queueFence(fence);
699 }
700
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800701 if (result & IGraphicBufferProducer::RELEASE_ALL_BUFFERS) {
702 freeAllBuffers();
Mathias Agopian579b3f82010-06-08 19:54:15 -0700703 }
Ted Bonkenburgbd050ab2011-07-15 15:10:10 -0700704
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -0800705 if (dqInput.getTimestamps) {
Brian Anderson3da8d272016-07-28 16:20:47 -0700706 mFrameEventHistory->applyDelta(frameTimestamps);
Brian Anderson7c3ba8a2016-07-25 12:48:08 -0700707 }
708
Yin-Chia Yehe572fd72017-03-28 19:07:39 -0700709 if ((result & IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) || gbuf == nullptr) {
710 if (mReportRemovedBuffers && (gbuf != nullptr)) {
Yin-Chia Yehe572fd72017-03-28 19:07:39 -0700711 mRemovedBuffers.push_back(gbuf);
712 }
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800713 result = mGraphicBufferProducer->requestBuffer(buf, &gbuf);
714 if (result != NO_ERROR) {
Mathias Agopianba93b3f2013-08-01 15:48:40 -0700715 ALOGE("dequeueBuffer: IGraphicBufferProducer::requestBuffer failed: %d", result);
Jesse Hall9f5a1b62014-10-02 11:09:03 -0700716 mGraphicBufferProducer->cancelBuffer(buf, fence);
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800717 return result;
718 }
719 }
Mathias Agopian579b3f82010-06-08 19:54:15 -0700720
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800721 if (fence->isValid()) {
722 *fenceFd = fence->dup();
723 if (*fenceFd == -1) {
724 ALOGE("dequeueBuffer: error duping fence: %d", errno);
725 // dup() should never fail; something is badly wrong. Soldier on
726 // and hope for the best; the worst that should happen is some
727 // visible corruption that lasts until the next frame.
728 }
Ted Bonkenburge5d6eb82011-08-09 22:38:41 -0700729 } else {
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800730 *fenceFd = -1;
Mathias Agopiana0c30e92010-06-04 18:26:32 -0700731 }
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800732
733 *buffer = gbuf.get();
Pablo Ceballosff95aab2016-01-13 17:09:58 -0800734
Pablo Ceballos3559fbf2016-03-17 15:50:23 -0700735 if (mSharedBufferMode && mAutoRefresh) {
Pablo Ceballosff95aab2016-01-13 17:09:58 -0800736 mSharedBufferSlot = buf;
737 mSharedBufferHasBeenQueued = false;
738 } else if (mSharedBufferSlot == buf) {
739 mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT;
740 mSharedBufferHasBeenQueued = false;
741 }
742
Yin-Chia Yehda2e6092020-07-29 15:00:07 -0700743 mDequeuedSlots.insert(buf);
744
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800745 return OK;
Jamie Gennisaca4e222010-07-15 17:29:15 -0700746}
747
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -0800748int Surface::dequeueBuffers(std::vector<BatchBuffer>* buffers) {
749 using DequeueBufferInput = IGraphicBufferProducer::DequeueBufferInput;
750 using DequeueBufferOutput = IGraphicBufferProducer::DequeueBufferOutput;
751 using CancelBufferInput = IGraphicBufferProducer::CancelBufferInput;
752 using RequestBufferOutput = IGraphicBufferProducer::RequestBufferOutput;
753
754 ATRACE_CALL();
755 ALOGV("Surface::dequeueBuffers");
756
757 if (buffers->size() == 0) {
758 ALOGE("%s: must dequeue at least 1 buffer!", __FUNCTION__);
759 return BAD_VALUE;
760 }
761
762 if (mSharedBufferMode) {
763 ALOGE("%s: batch operation is not supported in shared buffer mode!",
764 __FUNCTION__);
765 return INVALID_OPERATION;
766 }
767
768 size_t numBufferRequested = buffers->size();
769 DequeueBufferInput input;
770
771 {
772 Mutex::Autolock lock(mMutex);
773 if (mReportRemovedBuffers) {
774 mRemovedBuffers.clear();
775 }
776
777 getDequeueBufferInputLocked(&input);
778 } // Drop the lock so that we can still touch the Surface while blocking in IGBP::dequeueBuffers
779
780 std::vector<DequeueBufferInput> dequeueInput(numBufferRequested, input);
781 std::vector<DequeueBufferOutput> dequeueOutput;
782
783 nsecs_t startTime = systemTime();
784
785 status_t result = mGraphicBufferProducer->dequeueBuffers(dequeueInput, &dequeueOutput);
786
787 mLastDequeueDuration = systemTime() - startTime;
788
789 if (result < 0) {
790 ALOGV("%s: IGraphicBufferProducer::dequeueBuffers"
791 "(%d, %d, %d, %#" PRIx64 ") failed: %d",
792 __FUNCTION__, input.width, input.height, input.format, input.usage, result);
793 return result;
794 }
795
796 std::vector<CancelBufferInput> cancelBufferInputs(numBufferRequested);
797 std::vector<status_t> cancelBufferOutputs;
798 for (size_t i = 0; i < numBufferRequested; i++) {
799 cancelBufferInputs[i].slot = dequeueOutput[i].slot;
800 cancelBufferInputs[i].fence = dequeueOutput[i].fence;
801 }
802
803 for (const auto& output : dequeueOutput) {
804 if (output.result < 0) {
805 mGraphicBufferProducer->cancelBuffers(cancelBufferInputs, &cancelBufferOutputs);
806 ALOGV("%s: IGraphicBufferProducer::dequeueBuffers"
807 "(%d, %d, %d, %#" PRIx64 ") failed: %d",
808 __FUNCTION__, input.width, input.height, input.format, input.usage,
809 output.result);
810 return output.result;
811 }
812
813 if (output.slot < 0 || output.slot >= NUM_BUFFER_SLOTS) {
814 mGraphicBufferProducer->cancelBuffers(cancelBufferInputs, &cancelBufferOutputs);
815 ALOGE("%s: IGraphicBufferProducer returned invalid slot number %d",
816 __FUNCTION__, output.slot);
817 android_errorWriteLog(0x534e4554, "36991414"); // SafetyNet logging
818 return FAILED_TRANSACTION;
819 }
820
821 if (input.getTimestamps && !output.timestamps.has_value()) {
822 mGraphicBufferProducer->cancelBuffers(cancelBufferInputs, &cancelBufferOutputs);
823 ALOGE("%s: no frame timestamp returns!", __FUNCTION__);
824 return FAILED_TRANSACTION;
825 }
826
827 // this should never happen
828 ALOGE_IF(output.fence == nullptr,
829 "%s: received null Fence! slot=%d", __FUNCTION__, output.slot);
830 }
831
832 Mutex::Autolock lock(mMutex);
833
834 // Write this while holding the mutex
835 mLastDequeueStartTime = startTime;
836
837 std::vector<int32_t> requestBufferSlots;
838 requestBufferSlots.reserve(numBufferRequested);
839 // handle release all buffers and request buffers
840 for (const auto& output : dequeueOutput) {
841 if (output.result & IGraphicBufferProducer::RELEASE_ALL_BUFFERS) {
842 ALOGV("%s: RELEASE_ALL_BUFFERS during batch operation", __FUNCTION__);
843 freeAllBuffers();
844 break;
845 }
846 }
847
848 for (const auto& output : dequeueOutput) {
849 // Collect slots that needs requesting buffer
850 sp<GraphicBuffer>& gbuf(mSlots[output.slot].buffer);
851 if ((result & IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) || gbuf == nullptr) {
852 if (mReportRemovedBuffers && (gbuf != nullptr)) {
853 mRemovedBuffers.push_back(gbuf);
854 }
855 requestBufferSlots.push_back(output.slot);
856 }
857 }
858
859 // Batch request Buffer
860 std::vector<RequestBufferOutput> reqBufferOutput;
861 if (requestBufferSlots.size() > 0) {
862 result = mGraphicBufferProducer->requestBuffers(requestBufferSlots, &reqBufferOutput);
863 if (result != NO_ERROR) {
864 ALOGE("%s: IGraphicBufferProducer::requestBuffers failed: %d",
865 __FUNCTION__, result);
866 mGraphicBufferProducer->cancelBuffers(cancelBufferInputs, &cancelBufferOutputs);
867 return result;
868 }
869
870 // Check if we have any single failure
871 for (size_t i = 0; i < requestBufferSlots.size(); i++) {
872 if (reqBufferOutput[i].result != OK) {
873 ALOGE("%s: IGraphicBufferProducer::requestBuffers failed at %zu-th buffer, slot %d",
874 __FUNCTION__, i, requestBufferSlots[i]);
875 mGraphicBufferProducer->cancelBuffers(cancelBufferInputs, &cancelBufferOutputs);
876 return reqBufferOutput[i].result;
877 }
878 }
879
880 // Fill request buffer results to mSlots
881 for (size_t i = 0; i < requestBufferSlots.size(); i++) {
882 mSlots[requestBufferSlots[i]].buffer = reqBufferOutput[i].buffer;
883 }
884 }
885
886 for (size_t batchIdx = 0; batchIdx < numBufferRequested; batchIdx++) {
887 const auto& output = dequeueOutput[batchIdx];
888 int slot = output.slot;
889 sp<GraphicBuffer>& gbuf(mSlots[slot].buffer);
890
891 if (CC_UNLIKELY(atrace_is_tag_enabled(ATRACE_TAG_GRAPHICS))) {
892 static FenceMonitor hwcReleaseThread("HWC release");
893 hwcReleaseThread.queueFence(output.fence);
894 }
895
896 if (input.getTimestamps) {
897 mFrameEventHistory->applyDelta(output.timestamps.value());
898 }
899
900 if (output.fence->isValid()) {
901 buffers->at(batchIdx).fenceFd = output.fence->dup();
902 if (buffers->at(batchIdx).fenceFd == -1) {
903 ALOGE("%s: error duping fence: %d", __FUNCTION__, errno);
904 // dup() should never fail; something is badly wrong. Soldier on
905 // and hope for the best; the worst that should happen is some
906 // visible corruption that lasts until the next frame.
907 }
908 } else {
909 buffers->at(batchIdx).fenceFd = -1;
910 }
911
912 buffers->at(batchIdx).buffer = gbuf.get();
913 mDequeuedSlots.insert(slot);
914 }
915 return OK;
916}
917
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800918int Surface::cancelBuffer(android_native_buffer_t* buffer,
919 int fenceFd) {
920 ATRACE_CALL();
921 ALOGV("Surface::cancelBuffer");
922 Mutex::Autolock lock(mMutex);
923 int i = getSlotFromBufferLocked(buffer);
924 if (i < 0) {
Taiju Tsuiki4d0cd3f2015-04-30 22:15:33 +0900925 if (fenceFd >= 0) {
926 close(fenceFd);
927 }
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800928 return i;
929 }
Pablo Ceballosff95aab2016-01-13 17:09:58 -0800930 if (mSharedBufferSlot == i && mSharedBufferHasBeenQueued) {
931 if (fenceFd >= 0) {
932 close(fenceFd);
933 }
934 return OK;
935 }
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800936 sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE);
937 mGraphicBufferProducer->cancelBuffer(i, fence);
Pablo Ceballosff95aab2016-01-13 17:09:58 -0800938
Pablo Ceballos3559fbf2016-03-17 15:50:23 -0700939 if (mSharedBufferMode && mAutoRefresh && mSharedBufferSlot == i) {
Pablo Ceballosff95aab2016-01-13 17:09:58 -0800940 mSharedBufferHasBeenQueued = true;
941 }
942
Yin-Chia Yehda2e6092020-07-29 15:00:07 -0700943 mDequeuedSlots.erase(i);
944
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800945 return OK;
946}
947
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -0800948int Surface::cancelBuffers(const std::vector<BatchBuffer>& buffers) {
949 using CancelBufferInput = IGraphicBufferProducer::CancelBufferInput;
950 ATRACE_CALL();
951 ALOGV("Surface::cancelBuffers");
952
953 if (mSharedBufferMode) {
954 ALOGE("%s: batch operation is not supported in shared buffer mode!",
955 __FUNCTION__);
956 return INVALID_OPERATION;
957 }
958
959 size_t numBuffers = buffers.size();
960 std::vector<CancelBufferInput> cancelBufferInputs(numBuffers);
961 std::vector<status_t> cancelBufferOutputs;
962 size_t numBuffersCancelled = 0;
963 int badSlotResult = 0;
964 for (size_t i = 0; i < numBuffers; i++) {
965 int slot = getSlotFromBufferLocked(buffers[i].buffer);
966 int fenceFd = buffers[i].fenceFd;
967 if (slot < 0) {
968 if (fenceFd >= 0) {
969 close(fenceFd);
970 }
971 ALOGE("%s: cannot find slot number for cancelled buffer", __FUNCTION__);
972 badSlotResult = slot;
973 } else {
974 sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE);
975 cancelBufferInputs[numBuffersCancelled].slot = slot;
976 cancelBufferInputs[numBuffersCancelled++].fence = fence;
977 }
978 }
979 cancelBufferInputs.resize(numBuffersCancelled);
980 mGraphicBufferProducer->cancelBuffers(cancelBufferInputs, &cancelBufferOutputs);
981
982
983 for (size_t i = 0; i < numBuffersCancelled; i++) {
984 mDequeuedSlots.erase(cancelBufferInputs[i].slot);
985 }
986
987 if (badSlotResult != 0) {
988 return badSlotResult;
989 }
990 return OK;
991}
992
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800993int Surface::getSlotFromBufferLocked(
994 android_native_buffer_t* buffer) const {
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -0800995 if (buffer == nullptr) {
996 ALOGE("%s: input buffer is null!", __FUNCTION__);
997 return BAD_VALUE;
998 }
999
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001000 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
Yi Kong48a619f2018-06-05 16:34:59 -07001001 if (mSlots[i].buffer != nullptr &&
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001002 mSlots[i].buffer->handle == buffer->handle) {
1003 return i;
Jamie Gennisaca4e222010-07-15 17:29:15 -07001004 }
1005 }
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08001006 ALOGE("%s: unknown buffer: %p", __FUNCTION__, buffer->handle);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001007 return BAD_VALUE;
Mathias Agopiana0c30e92010-06-04 18:26:32 -07001008}
1009
Igor Murashkin7d2d1602013-11-12 18:02:20 -08001010int Surface::lockBuffer_DEPRECATED(android_native_buffer_t* buffer __attribute__((unused))) {
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001011 ALOGV("Surface::lockBuffer");
1012 Mutex::Autolock lock(mMutex);
1013 return OK;
1014}
Mathias Agopian631f3582010-05-25 17:51:34 -07001015
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08001016void Surface::getQueueBufferInputLocked(android_native_buffer_t* buffer, int fenceFd,
1017 nsecs_t timestamp, IGraphicBufferProducer::QueueBufferInput* out) {
Andy McFadden3c256212013-08-16 14:55:39 -07001018 bool isAutoTimestamp = false;
Pablo Ceballosff95aab2016-01-13 17:09:58 -08001019
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08001020 if (timestamp == NATIVE_WINDOW_TIMESTAMP_AUTO) {
Andy McFadden4b49e082013-08-02 15:31:45 -07001021 timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
Andy McFadden3c256212013-08-16 14:55:39 -07001022 isAutoTimestamp = true;
Andy McFadden4b49e082013-08-02 15:31:45 -07001023 ALOGV("Surface::queueBuffer making up timestamp: %.2f ms",
Colin Cross9a80d502016-09-27 14:12:48 -07001024 timestamp / 1000000.0);
Mathias Agopian631f3582010-05-25 17:51:34 -07001025 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001026
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001027 // Make sure the crop rectangle is entirely inside the buffer.
Pablo Ceballos60d69222015-08-07 14:47:20 -07001028 Rect crop(Rect::EMPTY_RECT);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001029 mCrop.intersect(Rect(buffer->width, buffer->height), &crop);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001030
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001031 sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE);
Andy McFadden3c256212013-08-16 14:55:39 -07001032 IGraphicBufferProducer::QueueBufferInput input(timestamp, isAutoTimestamp,
Peiyong Lin34beb7a2018-03-28 11:57:12 -07001033 static_cast<android_dataspace>(mDataSpace), crop, mScalingMode,
1034 mTransform ^ mStickyTransform, fence, mStickyTransform,
1035 mEnableFrameTimestamps);
Dan Stoza5065a552015-03-17 16:23:42 -07001036
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -07001037 // we should send HDR metadata as needed if this becomes a bottleneck
1038 input.setHdrMetadata(mHdrMetadata);
1039
Dan Stozac62acbd2015-04-21 16:42:49 -07001040 if (mConnectedToCpu || mDirtyRegion.bounds() == Rect::INVALID_RECT) {
Dan Stoza5065a552015-03-17 16:23:42 -07001041 input.setSurfaceDamage(Region::INVALID_REGION);
1042 } else {
Dan Stozadb4850c2015-06-25 16:10:18 -07001043 // Here we do two things:
1044 // 1) The surface damage was specified using the OpenGL ES convention of
1045 // the origin being in the bottom-left corner. Here we flip to the
1046 // convention that the rest of the system uses (top-left corner) by
1047 // subtracting all top/bottom coordinates from the buffer height.
1048 // 2) If the buffer is coming in rotated (for example, because the EGL
1049 // implementation is reacting to the transform hint coming back from
1050 // SurfaceFlinger), the surface damage needs to be rotated the
1051 // opposite direction, since it was generated assuming an unrotated
1052 // buffer (the app doesn't know that the EGL implementation is
1053 // reacting to the transform hint behind its back). The
1054 // transformations in the switch statement below apply those
1055 // complementary rotations (e.g., if 90 degrees, rotate 270 degrees).
1056
1057 int width = buffer->width;
Dan Stoza0e65e6c2015-05-26 13:22:27 -07001058 int height = buffer->height;
Dan Stozadb4850c2015-06-25 16:10:18 -07001059 bool rotated90 = (mTransform ^ mStickyTransform) &
1060 NATIVE_WINDOW_TRANSFORM_ROT_90;
1061 if (rotated90) {
1062 std::swap(width, height);
Dan Stoza0e65e6c2015-05-26 13:22:27 -07001063 }
Dan Stozadb4850c2015-06-25 16:10:18 -07001064
Dan Stoza5065a552015-03-17 16:23:42 -07001065 Region flippedRegion;
1066 for (auto rect : mDirtyRegion) {
Dan Stozadb4850c2015-06-25 16:10:18 -07001067 int left = rect.left;
1068 int right = rect.right;
1069 int top = height - rect.bottom; // Flip from OpenGL convention
1070 int bottom = height - rect.top; // Flip from OpenGL convention
1071 switch (mTransform ^ mStickyTransform) {
1072 case NATIVE_WINDOW_TRANSFORM_ROT_90: {
1073 // Rotate 270 degrees
1074 Rect flippedRect{top, width - right, bottom, width - left};
1075 flippedRegion.orSelf(flippedRect);
1076 break;
1077 }
1078 case NATIVE_WINDOW_TRANSFORM_ROT_180: {
1079 // Rotate 180 degrees
1080 Rect flippedRect{width - right, height - bottom,
1081 width - left, height - top};
1082 flippedRegion.orSelf(flippedRect);
1083 break;
1084 }
1085 case NATIVE_WINDOW_TRANSFORM_ROT_270: {
1086 // Rotate 90 degrees
1087 Rect flippedRect{height - bottom, left,
1088 height - top, right};
1089 flippedRegion.orSelf(flippedRect);
1090 break;
1091 }
1092 default: {
1093 Rect flippedRect{left, top, right, bottom};
1094 flippedRegion.orSelf(flippedRect);
1095 break;
1096 }
1097 }
Dan Stoza5065a552015-03-17 16:23:42 -07001098 }
1099
1100 input.setSurfaceDamage(flippedRegion);
1101 }
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08001102 *out = input;
1103}
Dan Stoza5065a552015-03-17 16:23:42 -07001104
Alec Mouri9c604e32022-03-18 22:47:44 +00001105void Surface::applyGrallocMetadataLocked(
1106 android_native_buffer_t* buffer,
1107 const IGraphicBufferProducer::QueueBufferInput& queueBufferInput) {
1108 ATRACE_CALL();
1109 auto& mapper = GraphicBufferMapper::get();
1110 mapper.setDataspace(buffer->handle, static_cast<ui::Dataspace>(queueBufferInput.dataSpace));
1111 mapper.setSmpte2086(buffer->handle, queueBufferInput.getHdrMetadata().getSmpte2086());
1112 mapper.setCta861_3(buffer->handle, queueBufferInput.getHdrMetadata().getCta8613());
1113 mapper.setSmpte2094_40(buffer->handle, queueBufferInput.getHdrMetadata().getHdr10Plus());
1114}
1115
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08001116void Surface::onBufferQueuedLocked(int slot, sp<Fence> fence,
1117 const IGraphicBufferProducer::QueueBufferOutput& output) {
1118 mDequeuedSlots.erase(slot);
Yin-Chia Yehda2e6092020-07-29 15:00:07 -07001119
Brian Anderson7c3ba8a2016-07-25 12:48:08 -07001120 if (mEnableFrameTimestamps) {
Brian Anderson3da8d272016-07-28 16:20:47 -07001121 mFrameEventHistory->applyDelta(output.frameTimestamps);
Brian Anderson7c3ba8a2016-07-25 12:48:08 -07001122 // Update timestamps with the local acquire fence.
1123 // The consumer doesn't send it back to prevent us from having two
1124 // file descriptors of the same fence.
Brian Anderson3da8d272016-07-28 16:20:47 -07001125 mFrameEventHistory->updateAcquireFence(mNextFrameNumber,
Yiwei Zhangf0c12502019-03-13 16:09:05 -07001126 std::make_shared<FenceTime>(fence));
Brian Anderson3d4039d2016-09-23 16:31:30 -07001127
1128 // Cache timestamps of signaled fences so we can close their file
1129 // descriptors.
Brian Anderson3da8d272016-07-28 16:20:47 -07001130 mFrameEventHistory->updateSignalTimes();
Brian Anderson7c3ba8a2016-07-25 12:48:08 -07001131 }
1132
Brian Anderson50143b32016-09-30 14:01:24 -07001133 mLastFrameNumber = mNextFrameNumber;
1134
Brian Anderson7c3ba8a2016-07-25 12:48:08 -07001135 mDefaultWidth = output.width;
1136 mDefaultHeight = output.height;
1137 mNextFrameNumber = output.nextFrameNumber;
tedbo1e7fa9e2011-06-22 15:52:53 -07001138
Vishnu Nair5eb3f062019-04-08 08:21:03 -07001139 // Ignore transform hint if sticky transform is set or transform to display inverse flag is
1140 // set.
1141 if (mStickyTransform == 0 && !transformToDisplayInverse()) {
Brian Anderson7c3ba8a2016-07-25 12:48:08 -07001142 mTransformHint = output.transformHint;
Ruben Brunk1681d952014-06-27 15:51:55 -07001143 }
1144
Brian Anderson7c3ba8a2016-07-25 12:48:08 -07001145 mConsumerRunningBehind = (output.numPendingBuffers >= 2);
Mathias Agopian631f3582010-05-25 17:51:34 -07001146
Dan Stozac62acbd2015-04-21 16:42:49 -07001147 if (!mConnectedToCpu) {
1148 // Clear surface damage back to full-buffer
1149 mDirtyRegion = Region::INVALID_REGION;
1150 }
Dan Stoza5065a552015-03-17 16:23:42 -07001151
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08001152 if (mSharedBufferMode && mAutoRefresh && mSharedBufferSlot == slot) {
Pablo Ceballosff95aab2016-01-13 17:09:58 -08001153 mSharedBufferHasBeenQueued = true;
1154 }
1155
Robert Carr9f31e292016-04-11 11:15:32 -07001156 mQueueBufferCondition.broadcast();
1157
Yiwei Zhang9e919eb2019-03-07 23:21:40 -08001158 if (CC_UNLIKELY(atrace_is_tag_enabled(ATRACE_TAG_GRAPHICS))) {
1159 static FenceMonitor gpuCompletionThread("GPU completion");
1160 gpuCompletionThread.queueFence(fence);
1161 }
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08001162}
1163
1164int Surface::queueBuffer(android_native_buffer_t* buffer, int fenceFd) {
1165 ATRACE_CALL();
1166 ALOGV("Surface::queueBuffer");
1167 Mutex::Autolock lock(mMutex);
1168
1169 int i = getSlotFromBufferLocked(buffer);
1170 if (i < 0) {
1171 if (fenceFd >= 0) {
1172 close(fenceFd);
1173 }
1174 return i;
1175 }
1176 if (mSharedBufferSlot == i && mSharedBufferHasBeenQueued) {
1177 if (fenceFd >= 0) {
1178 close(fenceFd);
1179 }
1180 return OK;
1181 }
1182
1183 IGraphicBufferProducer::QueueBufferOutput output;
1184 IGraphicBufferProducer::QueueBufferInput input;
1185 getQueueBufferInputLocked(buffer, fenceFd, mTimestamp, &input);
Alec Mouri9c604e32022-03-18 22:47:44 +00001186 applyGrallocMetadataLocked(buffer, input);
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08001187 sp<Fence> fence = input.fence;
1188
1189 nsecs_t now = systemTime();
Alec Mouri9c604e32022-03-18 22:47:44 +00001190
Yin-Chia Yeh78c0ad72020-02-07 14:05:35 -08001191 status_t err = mGraphicBufferProducer->queueBuffer(i, input, &output);
1192 mLastQueueDuration = systemTime() - now;
1193 if (err != OK) {
1194 ALOGE("queueBuffer: error queuing buffer, %d", err);
1195 }
1196
1197 onBufferQueuedLocked(i, fence, output);
1198 return err;
1199}
1200
1201int Surface::queueBuffers(const std::vector<BatchQueuedBuffer>& buffers) {
1202 ATRACE_CALL();
1203 ALOGV("Surface::queueBuffers");
1204 Mutex::Autolock lock(mMutex);
1205
1206 if (mSharedBufferMode) {
1207 ALOGE("%s: batched operation is not supported in shared buffer mode", __FUNCTION__);
1208 return INVALID_OPERATION;
1209 }
1210
1211 size_t numBuffers = buffers.size();
1212 std::vector<IGraphicBufferProducer::QueueBufferInput> queueBufferInputs(numBuffers);
1213 std::vector<IGraphicBufferProducer::QueueBufferOutput> queueBufferOutputs;
1214 std::vector<int> bufferSlots(numBuffers, -1);
1215 std::vector<sp<Fence>> bufferFences(numBuffers);
1216
1217 for (size_t batchIdx = 0; batchIdx < numBuffers; batchIdx++) {
1218 int i = getSlotFromBufferLocked(buffers[batchIdx].buffer);
1219 if (i < 0) {
1220 if (buffers[batchIdx].fenceFd >= 0) {
1221 close(buffers[batchIdx].fenceFd);
1222 }
1223 return i;
1224 }
1225 bufferSlots[batchIdx] = i;
1226
1227 IGraphicBufferProducer::QueueBufferInput input;
1228 getQueueBufferInputLocked(
1229 buffers[batchIdx].buffer, buffers[batchIdx].fenceFd, buffers[batchIdx].timestamp,
1230 &input);
1231 bufferFences[batchIdx] = input.fence;
1232 queueBufferInputs[batchIdx] = input;
1233 }
1234
1235 nsecs_t now = systemTime();
1236 status_t err = mGraphicBufferProducer->queueBuffers(queueBufferInputs, &queueBufferOutputs);
1237 mLastQueueDuration = systemTime() - now;
1238 if (err != OK) {
1239 ALOGE("%s: error queuing buffer, %d", __FUNCTION__, err);
1240 }
1241
1242
1243 for (size_t batchIdx = 0; batchIdx < numBuffers; batchIdx++) {
1244 onBufferQueuedLocked(bufferSlots[batchIdx], bufferFences[batchIdx],
1245 queueBufferOutputs[batchIdx]);
1246 }
Yiwei Zhang9e919eb2019-03-07 23:21:40 -08001247
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001248 return err;
1249}
Mathias Agopian076b1cc2009-04-10 14:24:30 -07001250
Brian Anderson6b376712017-04-04 10:51:39 -07001251void Surface::querySupportedTimestampsLocked() const {
1252 // mMutex must be locked when calling this method.
1253
1254 if (mQueriedSupportedTimestamps) {
1255 return;
1256 }
1257 mQueriedSupportedTimestamps = true;
1258
1259 std::vector<FrameEvent> supportedFrameTimestamps;
Huihong Luo0a81aa32022-02-22 16:02:36 -08001260 binder::Status status =
1261 composerServiceAIDL()->getSupportedFrameTimestamps(&supportedFrameTimestamps);
Brian Anderson6b376712017-04-04 10:51:39 -07001262
Huihong Luo0a81aa32022-02-22 16:02:36 -08001263 if (!status.isOk()) {
Brian Anderson6b376712017-04-04 10:51:39 -07001264 return;
1265 }
1266
1267 for (auto sft : supportedFrameTimestamps) {
1268 if (sft == FrameEvent::DISPLAY_PRESENT) {
1269 mFrameTimestampsSupportsPresent = true;
1270 }
1271 }
1272}
1273
Mathias Agopiana67932f2011-04-20 14:20:59 -07001274int Surface::query(int what, int* value) const {
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001275 ATRACE_CALL();
1276 ALOGV("Surface::query");
1277 { // scope for the lock
1278 Mutex::Autolock lock(mMutex);
1279 switch (what) {
1280 case NATIVE_WINDOW_FORMAT:
1281 if (mReqFormat) {
Dan Stoza3be1c6b2014-11-18 10:24:03 -08001282 *value = static_cast<int>(mReqFormat);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001283 return NO_ERROR;
1284 }
1285 break;
1286 case NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER: {
Vishnu Nair17dde612020-12-28 11:39:59 -08001287 status_t err = mGraphicBufferProducer->query(what, value);
1288 if (err == NO_ERROR) {
1289 return NO_ERROR;
1290 }
Huihong Luo3bdef862022-03-03 11:57:19 -08001291 sp<gui::ISurfaceComposer> surfaceComposer = composerServiceAIDL();
Brian Lindahl9b85a192021-05-10 09:56:33 +00001292 if (surfaceComposer == nullptr) {
1293 return -EPERM; // likely permissions error
1294 }
Huihong Luo3bdef862022-03-03 11:57:19 -08001295 // ISurfaceComposer no longer supports authenticateSurfaceTexture
1296 *value = 0;
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001297 return NO_ERROR;
1298 }
1299 case NATIVE_WINDOW_CONCRETE_TYPE:
1300 *value = NATIVE_WINDOW_SURFACE;
1301 return NO_ERROR;
1302 case NATIVE_WINDOW_DEFAULT_WIDTH:
Dan Stoza3be1c6b2014-11-18 10:24:03 -08001303 *value = static_cast<int>(
1304 mUserWidth ? mUserWidth : mDefaultWidth);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001305 return NO_ERROR;
1306 case NATIVE_WINDOW_DEFAULT_HEIGHT:
Dan Stoza3be1c6b2014-11-18 10:24:03 -08001307 *value = static_cast<int>(
1308 mUserHeight ? mUserHeight : mDefaultHeight);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001309 return NO_ERROR;
1310 case NATIVE_WINDOW_TRANSFORM_HINT:
Robert Carr82d07c92021-05-10 11:36:43 -07001311 *value = static_cast<int>(getTransformHint());
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001312 return NO_ERROR;
1313 case NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND: {
1314 status_t err = NO_ERROR;
1315 if (!mConsumerRunningBehind) {
1316 *value = 0;
1317 } else {
1318 err = mGraphicBufferProducer->query(what, value);
1319 if (err == NO_ERROR) {
1320 mConsumerRunningBehind = *value;
1321 }
1322 }
1323 return err;
1324 }
Ian Elliotta2eb34c2017-07-18 11:05:49 -06001325 case NATIVE_WINDOW_BUFFER_AGE: {
1326 if (mBufferAge > INT32_MAX) {
1327 *value = 0;
1328 } else {
1329 *value = static_cast<int32_t>(mBufferAge);
1330 }
1331 return NO_ERROR;
1332 }
Dan Stoza70ccba52016-07-01 14:00:40 -07001333 case NATIVE_WINDOW_LAST_DEQUEUE_DURATION: {
1334 int64_t durationUs = mLastDequeueDuration / 1000;
1335 *value = durationUs > std::numeric_limits<int>::max() ?
1336 std::numeric_limits<int>::max() :
1337 static_cast<int>(durationUs);
1338 return NO_ERROR;
1339 }
1340 case NATIVE_WINDOW_LAST_QUEUE_DURATION: {
1341 int64_t durationUs = mLastQueueDuration / 1000;
1342 *value = durationUs > std::numeric_limits<int>::max() ?
1343 std::numeric_limits<int>::max() :
1344 static_cast<int>(durationUs);
1345 return NO_ERROR;
1346 }
Brian Anderson6b376712017-04-04 10:51:39 -07001347 case NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT: {
1348 querySupportedTimestampsLocked();
1349 *value = mFrameTimestampsSupportsPresent ? 1 : 0;
1350 return NO_ERROR;
1351 }
Mathias Agopian10e9ab52017-03-08 15:02:55 -08001352 case NATIVE_WINDOW_IS_VALID: {
1353 *value = mGraphicBufferProducer != nullptr ? 1 : 0;
1354 return NO_ERROR;
1355 }
Peiyong Lin654f87b2018-01-30 14:21:33 -08001356 case NATIVE_WINDOW_DATASPACE: {
1357 *value = static_cast<int>(mDataSpace);
1358 return NO_ERROR;
1359 }
silence_dogoode9d092a2019-06-19 16:14:53 -07001360 case NATIVE_WINDOW_MAX_BUFFER_COUNT: {
1361 *value = mMaxBufferCount;
1362 return NO_ERROR;
1363 }
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001364 }
Jamie Gennis391bbe22011-03-14 15:00:06 -07001365 }
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001366 return mGraphicBufferProducer->query(what, value);
Eino-Ville Talvala1d01a122011-02-18 11:02:42 -08001367}
1368
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001369int Surface::perform(int operation, va_list args)
1370{
1371 int res = NO_ERROR;
1372 switch (operation) {
1373 case NATIVE_WINDOW_CONNECT:
1374 // deprecated. must return NO_ERROR.
1375 break;
1376 case NATIVE_WINDOW_DISCONNECT:
1377 // deprecated. must return NO_ERROR.
1378 break;
1379 case NATIVE_WINDOW_SET_USAGE:
1380 res = dispatchSetUsage(args);
1381 break;
1382 case NATIVE_WINDOW_SET_CROP:
1383 res = dispatchSetCrop(args);
1384 break;
1385 case NATIVE_WINDOW_SET_BUFFER_COUNT:
1386 res = dispatchSetBufferCount(args);
1387 break;
1388 case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY:
1389 res = dispatchSetBuffersGeometry(args);
1390 break;
1391 case NATIVE_WINDOW_SET_BUFFERS_TRANSFORM:
1392 res = dispatchSetBuffersTransform(args);
1393 break;
Ruben Brunk1681d952014-06-27 15:51:55 -07001394 case NATIVE_WINDOW_SET_BUFFERS_STICKY_TRANSFORM:
1395 res = dispatchSetBuffersStickyTransform(args);
1396 break;
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001397 case NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP:
1398 res = dispatchSetBuffersTimestamp(args);
1399 break;
1400 case NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS:
1401 res = dispatchSetBuffersDimensions(args);
1402 break;
1403 case NATIVE_WINDOW_SET_BUFFERS_USER_DIMENSIONS:
1404 res = dispatchSetBuffersUserDimensions(args);
1405 break;
1406 case NATIVE_WINDOW_SET_BUFFERS_FORMAT:
1407 res = dispatchSetBuffersFormat(args);
1408 break;
1409 case NATIVE_WINDOW_LOCK:
1410 res = dispatchLock(args);
1411 break;
1412 case NATIVE_WINDOW_UNLOCK_AND_POST:
1413 res = dispatchUnlockAndPost(args);
1414 break;
1415 case NATIVE_WINDOW_SET_SCALING_MODE:
1416 res = dispatchSetScalingMode(args);
1417 break;
1418 case NATIVE_WINDOW_API_CONNECT:
1419 res = dispatchConnect(args);
1420 break;
1421 case NATIVE_WINDOW_API_DISCONNECT:
1422 res = dispatchDisconnect(args);
1423 break;
Rachad7cb0d392014-07-29 17:53:53 -07001424 case NATIVE_WINDOW_SET_SIDEBAND_STREAM:
1425 res = dispatchSetSidebandStream(args);
1426 break;
Eino-Ville Talvala82c6bcc2015-02-19 16:10:43 -08001427 case NATIVE_WINDOW_SET_BUFFERS_DATASPACE:
1428 res = dispatchSetBuffersDataSpace(args);
1429 break;
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -07001430 case NATIVE_WINDOW_SET_BUFFERS_SMPTE2086_METADATA:
1431 res = dispatchSetBuffersSmpte2086Metadata(args);
1432 break;
1433 case NATIVE_WINDOW_SET_BUFFERS_CTA861_3_METADATA:
1434 res = dispatchSetBuffersCta8613Metadata(args);
1435 break;
Valerie Haua82679d2018-11-21 09:31:43 -08001436 case NATIVE_WINDOW_SET_BUFFERS_HDR10_PLUS_METADATA:
1437 res = dispatchSetBuffersHdr10PlusMetadata(args);
1438 break;
Dan Stoza5065a552015-03-17 16:23:42 -07001439 case NATIVE_WINDOW_SET_SURFACE_DAMAGE:
1440 res = dispatchSetSurfaceDamage(args);
1441 break;
Pablo Ceballos3559fbf2016-03-17 15:50:23 -07001442 case NATIVE_WINDOW_SET_SHARED_BUFFER_MODE:
1443 res = dispatchSetSharedBufferMode(args);
Pablo Ceballosccdfd602015-10-07 15:05:45 -07001444 break;
Pablo Ceballosff95aab2016-01-13 17:09:58 -08001445 case NATIVE_WINDOW_SET_AUTO_REFRESH:
1446 res = dispatchSetAutoRefresh(args);
1447 break;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001448 case NATIVE_WINDOW_GET_REFRESH_CYCLE_DURATION:
1449 res = dispatchGetDisplayRefreshCycleDuration(args);
1450 break;
Brian Anderson1049d1d2016-12-16 17:25:57 -08001451 case NATIVE_WINDOW_GET_NEXT_FRAME_ID:
1452 res = dispatchGetNextFrameId(args);
1453 break;
Brian Anderson7c3ba8a2016-07-25 12:48:08 -07001454 case NATIVE_WINDOW_ENABLE_FRAME_TIMESTAMPS:
1455 res = dispatchEnableFrameTimestamps(args);
1456 break;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001457 case NATIVE_WINDOW_GET_COMPOSITOR_TIMING:
1458 res = dispatchGetCompositorTiming(args);
1459 break;
Pablo Ceballosce796e72016-02-04 19:10:51 -08001460 case NATIVE_WINDOW_GET_FRAME_TIMESTAMPS:
1461 res = dispatchGetFrameTimestamps(args);
1462 break;
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -07001463 case NATIVE_WINDOW_GET_WIDE_COLOR_SUPPORT:
1464 res = dispatchGetWideColorSupport(args);
1465 break;
Courtney Goeltzenleuchterc5b97c52017-02-26 14:47:13 -07001466 case NATIVE_WINDOW_GET_HDR_SUPPORT:
1467 res = dispatchGetHdrSupport(args);
1468 break;
Mathias Agopiancb496ac2017-05-22 14:21:00 -07001469 case NATIVE_WINDOW_SET_USAGE64:
1470 res = dispatchSetUsage64(args);
1471 break;
Chia-I Wue2786ea2017-08-07 10:36:08 -07001472 case NATIVE_WINDOW_GET_CONSUMER_USAGE64:
1473 res = dispatchGetConsumerUsage64(args);
1474 break;
Yiwei Zhang538cedc2019-06-24 19:35:03 -07001475 case NATIVE_WINDOW_SET_AUTO_PREROTATION:
1476 res = dispatchSetAutoPrerotation(args);
1477 break;
Alec Mouria1619662019-08-21 19:30:48 -07001478 case NATIVE_WINDOW_GET_LAST_DEQUEUE_START:
1479 res = dispatchGetLastDequeueStartTime(args);
1480 break;
Alec Mouri04fdb602019-08-23 19:41:43 -07001481 case NATIVE_WINDOW_SET_DEQUEUE_TIMEOUT:
1482 res = dispatchSetDequeueTimeout(args);
1483 break;
Alec Mouri72670c52019-08-31 01:54:33 -07001484 case NATIVE_WINDOW_GET_LAST_DEQUEUE_DURATION:
1485 res = dispatchGetLastDequeueDuration(args);
1486 break;
1487 case NATIVE_WINDOW_GET_LAST_QUEUE_DURATION:
1488 res = dispatchGetLastQueueDuration(args);
1489 break;
Steven Thomas3172e202020-01-06 19:25:30 -08001490 case NATIVE_WINDOW_SET_FRAME_RATE:
1491 res = dispatchSetFrameRate(args);
1492 break;
Alec Mouri09d122a2019-11-25 10:00:53 -08001493 case NATIVE_WINDOW_SET_CANCEL_INTERCEPTOR:
1494 res = dispatchAddCancelInterceptor(args);
1495 break;
1496 case NATIVE_WINDOW_SET_DEQUEUE_INTERCEPTOR:
1497 res = dispatchAddDequeueInterceptor(args);
1498 break;
1499 case NATIVE_WINDOW_SET_PERFORM_INTERCEPTOR:
1500 res = dispatchAddPerformInterceptor(args);
1501 break;
1502 case NATIVE_WINDOW_SET_QUEUE_INTERCEPTOR:
1503 res = dispatchAddQueueInterceptor(args);
1504 break;
John Reck401cda62020-05-07 16:04:41 -07001505 case NATIVE_WINDOW_SET_QUERY_INTERCEPTOR:
1506 res = dispatchAddQueryInterceptor(args);
1507 break;
Alec Mouri74aef6d2019-12-09 17:10:24 -08001508 case NATIVE_WINDOW_ALLOCATE_BUFFERS:
1509 allocateBuffers();
1510 res = NO_ERROR;
1511 break;
Alec Mourief0b1532019-12-17 09:39:07 -08001512 case NATIVE_WINDOW_GET_LAST_QUEUED_BUFFER:
1513 res = dispatchGetLastQueuedBuffer(args);
1514 break;
John Reckaa5a0b22021-05-18 00:42:56 -04001515 case NATIVE_WINDOW_GET_LAST_QUEUED_BUFFER2:
1516 res = dispatchGetLastQueuedBuffer2(args);
1517 break;
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001518 case NATIVE_WINDOW_SET_FRAME_TIMELINE_INFO:
1519 res = dispatchSetFrameTimelineInfo(args);
Ady Abraham74e17562020-08-24 18:18:19 -07001520 break;
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001521 default:
1522 res = NAME_NOT_FOUND;
1523 break;
1524 }
1525 return res;
1526}
Mathias Agopiana138f892010-05-21 17:24:35 -07001527
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001528int Surface::dispatchConnect(va_list args) {
1529 int api = va_arg(args, int);
1530 return connect(api);
1531}
Mathias Agopian55fa2512010-03-11 15:06:54 -08001532
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001533int Surface::dispatchDisconnect(va_list args) {
1534 int api = va_arg(args, int);
1535 return disconnect(api);
1536}
1537
1538int Surface::dispatchSetUsage(va_list args) {
Mathias Agopiancb496ac2017-05-22 14:21:00 -07001539 uint64_t usage = va_arg(args, uint32_t);
1540 return setUsage(usage);
1541}
1542
1543int Surface::dispatchSetUsage64(va_list args) {
1544 uint64_t usage = va_arg(args, uint64_t);
1545 return setUsage(usage);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001546}
1547
1548int Surface::dispatchSetCrop(va_list args) {
1549 android_native_rect_t const* rect = va_arg(args, android_native_rect_t*);
1550 return setCrop(reinterpret_cast<Rect const*>(rect));
1551}
1552
1553int Surface::dispatchSetBufferCount(va_list args) {
1554 size_t bufferCount = va_arg(args, size_t);
Dan Stoza3be1c6b2014-11-18 10:24:03 -08001555 return setBufferCount(static_cast<int32_t>(bufferCount));
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001556}
1557
1558int Surface::dispatchSetBuffersGeometry(va_list args) {
Dan Stoza3be1c6b2014-11-18 10:24:03 -08001559 uint32_t width = va_arg(args, uint32_t);
1560 uint32_t height = va_arg(args, uint32_t);
1561 PixelFormat format = va_arg(args, PixelFormat);
1562 int err = setBuffersDimensions(width, height);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001563 if (err != 0) {
1564 return err;
1565 }
Dan Stoza3be1c6b2014-11-18 10:24:03 -08001566 return setBuffersFormat(format);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001567}
1568
1569int Surface::dispatchSetBuffersDimensions(va_list args) {
Dan Stoza3be1c6b2014-11-18 10:24:03 -08001570 uint32_t width = va_arg(args, uint32_t);
1571 uint32_t height = va_arg(args, uint32_t);
1572 return setBuffersDimensions(width, height);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001573}
1574
1575int Surface::dispatchSetBuffersUserDimensions(va_list args) {
Dan Stoza3be1c6b2014-11-18 10:24:03 -08001576 uint32_t width = va_arg(args, uint32_t);
1577 uint32_t height = va_arg(args, uint32_t);
1578 return setBuffersUserDimensions(width, height);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001579}
1580
1581int Surface::dispatchSetBuffersFormat(va_list args) {
Dan Stoza3be1c6b2014-11-18 10:24:03 -08001582 PixelFormat format = va_arg(args, PixelFormat);
1583 return setBuffersFormat(format);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001584}
1585
1586int Surface::dispatchSetScalingMode(va_list args) {
Dan Stoza3be1c6b2014-11-18 10:24:03 -08001587 int mode = va_arg(args, int);
1588 return setScalingMode(mode);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001589}
1590
1591int Surface::dispatchSetBuffersTransform(va_list args) {
Dan Stoza3be1c6b2014-11-18 10:24:03 -08001592 uint32_t transform = va_arg(args, uint32_t);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001593 return setBuffersTransform(transform);
1594}
1595
Ruben Brunk1681d952014-06-27 15:51:55 -07001596int Surface::dispatchSetBuffersStickyTransform(va_list args) {
Dan Stoza3be1c6b2014-11-18 10:24:03 -08001597 uint32_t transform = va_arg(args, uint32_t);
Ruben Brunk1681d952014-06-27 15:51:55 -07001598 return setBuffersStickyTransform(transform);
1599}
1600
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001601int Surface::dispatchSetBuffersTimestamp(va_list args) {
1602 int64_t timestamp = va_arg(args, int64_t);
1603 return setBuffersTimestamp(timestamp);
1604}
1605
1606int Surface::dispatchLock(va_list args) {
1607 ANativeWindow_Buffer* outBuffer = va_arg(args, ANativeWindow_Buffer*);
1608 ARect* inOutDirtyBounds = va_arg(args, ARect*);
1609 return lock(outBuffer, inOutDirtyBounds);
1610}
1611
Igor Murashkin7d2d1602013-11-12 18:02:20 -08001612int Surface::dispatchUnlockAndPost(va_list args __attribute__((unused))) {
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001613 return unlockAndPost();
1614}
1615
Rachad7cb0d392014-07-29 17:53:53 -07001616int Surface::dispatchSetSidebandStream(va_list args) {
1617 native_handle_t* sH = va_arg(args, native_handle_t*);
1618 sp<NativeHandle> sidebandHandle = NativeHandle::create(sH, false);
1619 setSidebandStream(sidebandHandle);
1620 return OK;
1621}
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001622
Eino-Ville Talvala82c6bcc2015-02-19 16:10:43 -08001623int Surface::dispatchSetBuffersDataSpace(va_list args) {
Peiyong Lin34beb7a2018-03-28 11:57:12 -07001624 Dataspace dataspace = static_cast<Dataspace>(va_arg(args, int));
Eino-Ville Talvala82c6bcc2015-02-19 16:10:43 -08001625 return setBuffersDataSpace(dataspace);
1626}
1627
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -07001628int Surface::dispatchSetBuffersSmpte2086Metadata(va_list args) {
1629 const android_smpte2086_metadata* metadata =
1630 va_arg(args, const android_smpte2086_metadata*);
1631 return setBuffersSmpte2086Metadata(metadata);
1632}
1633
1634int Surface::dispatchSetBuffersCta8613Metadata(va_list args) {
1635 const android_cta861_3_metadata* metadata =
1636 va_arg(args, const android_cta861_3_metadata*);
1637 return setBuffersCta8613Metadata(metadata);
1638}
1639
Valerie Haua82679d2018-11-21 09:31:43 -08001640int Surface::dispatchSetBuffersHdr10PlusMetadata(va_list args) {
1641 const size_t size = va_arg(args, size_t);
1642 const uint8_t* metadata = va_arg(args, const uint8_t*);
1643 return setBuffersHdr10PlusMetadata(size, metadata);
1644}
1645
Dan Stoza5065a552015-03-17 16:23:42 -07001646int Surface::dispatchSetSurfaceDamage(va_list args) {
1647 android_native_rect_t* rects = va_arg(args, android_native_rect_t*);
1648 size_t numRects = va_arg(args, size_t);
1649 setSurfaceDamage(rects, numRects);
1650 return NO_ERROR;
1651}
1652
Pablo Ceballos3559fbf2016-03-17 15:50:23 -07001653int Surface::dispatchSetSharedBufferMode(va_list args) {
1654 bool sharedBufferMode = va_arg(args, int);
1655 return setSharedBufferMode(sharedBufferMode);
Pablo Ceballosff95aab2016-01-13 17:09:58 -08001656}
1657
1658int Surface::dispatchSetAutoRefresh(va_list args) {
1659 bool autoRefresh = va_arg(args, int);
1660 return setAutoRefresh(autoRefresh);
Pablo Ceballosccdfd602015-10-07 15:05:45 -07001661}
1662
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001663int Surface::dispatchGetDisplayRefreshCycleDuration(va_list args) {
1664 nsecs_t* outRefreshDuration = va_arg(args, int64_t*);
1665 return getDisplayRefreshCycleDuration(outRefreshDuration);
1666}
1667
Brian Anderson1049d1d2016-12-16 17:25:57 -08001668int Surface::dispatchGetNextFrameId(va_list args) {
1669 uint64_t* nextFrameId = va_arg(args, uint64_t*);
1670 *nextFrameId = getNextFrameNumber();
1671 return NO_ERROR;
1672}
1673
Brian Anderson7c3ba8a2016-07-25 12:48:08 -07001674int Surface::dispatchEnableFrameTimestamps(va_list args) {
1675 bool enable = va_arg(args, int);
1676 enableFrameTimestamps(enable);
1677 return NO_ERROR;
1678}
1679
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001680int Surface::dispatchGetCompositorTiming(va_list args) {
1681 nsecs_t* compositeDeadline = va_arg(args, int64_t*);
1682 nsecs_t* compositeInterval = va_arg(args, int64_t*);
1683 nsecs_t* compositeToPresentLatency = va_arg(args, int64_t*);
1684 return getCompositorTiming(compositeDeadline, compositeInterval,
1685 compositeToPresentLatency);
1686}
1687
Pablo Ceballosce796e72016-02-04 19:10:51 -08001688int Surface::dispatchGetFrameTimestamps(va_list args) {
Brian Anderson1049d1d2016-12-16 17:25:57 -08001689 uint64_t frameId = va_arg(args, uint64_t);
Brian Andersondbd0ea82016-07-22 09:38:59 -07001690 nsecs_t* outRequestedPresentTime = va_arg(args, int64_t*);
Pablo Ceballosce796e72016-02-04 19:10:51 -08001691 nsecs_t* outAcquireTime = va_arg(args, int64_t*);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001692 nsecs_t* outLatchTime = va_arg(args, int64_t*);
1693 nsecs_t* outFirstRefreshStartTime = va_arg(args, int64_t*);
1694 nsecs_t* outLastRefreshStartTime = va_arg(args, int64_t*);
Brian Andersonb04c6f02016-10-21 12:57:46 -07001695 nsecs_t* outGpuCompositionDoneTime = va_arg(args, int64_t*);
Brian Anderson069b3652016-07-22 10:32:47 -07001696 nsecs_t* outDisplayPresentTime = va_arg(args, int64_t*);
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001697 nsecs_t* outDequeueReadyTime = va_arg(args, int64_t*);
Pablo Ceballosce796e72016-02-04 19:10:51 -08001698 nsecs_t* outReleaseTime = va_arg(args, int64_t*);
Brian Anderson1049d1d2016-12-16 17:25:57 -08001699 return getFrameTimestamps(frameId,
Brian Andersonf7fd56a2016-09-02 10:10:04 -07001700 outRequestedPresentTime, outAcquireTime, outLatchTime,
1701 outFirstRefreshStartTime, outLastRefreshStartTime,
Brian Andersonb04c6f02016-10-21 12:57:46 -07001702 outGpuCompositionDoneTime, outDisplayPresentTime,
Brian Anderson4e606e32017-03-16 15:34:57 -07001703 outDequeueReadyTime, outReleaseTime);
Pablo Ceballosce796e72016-02-04 19:10:51 -08001704}
1705
Courtney Goeltzenleuchter1eb1b272017-02-02 16:51:06 -07001706int Surface::dispatchGetWideColorSupport(va_list args) {
1707 bool* outSupport = va_arg(args, bool*);
1708 return getWideColorSupport(outSupport);
1709}
1710
Courtney Goeltzenleuchterc5b97c52017-02-26 14:47:13 -07001711int Surface::dispatchGetHdrSupport(va_list args) {
1712 bool* outSupport = va_arg(args, bool*);
1713 return getHdrSupport(outSupport);
1714}
1715
Chia-I Wue2786ea2017-08-07 10:36:08 -07001716int Surface::dispatchGetConsumerUsage64(va_list args) {
1717 uint64_t* usage = va_arg(args, uint64_t*);
1718 return getConsumerUsage(usage);
1719}
1720
Yiwei Zhang538cedc2019-06-24 19:35:03 -07001721int Surface::dispatchSetAutoPrerotation(va_list args) {
1722 bool autoPrerotation = va_arg(args, int);
1723 return setAutoPrerotation(autoPrerotation);
1724}
1725
Alec Mouria1619662019-08-21 19:30:48 -07001726int Surface::dispatchGetLastDequeueStartTime(va_list args) {
1727 int64_t* lastDequeueStartTime = va_arg(args, int64_t*);
1728 *lastDequeueStartTime = mLastDequeueStartTime;
1729 return NO_ERROR;
1730}
1731
Alec Mouri04fdb602019-08-23 19:41:43 -07001732int Surface::dispatchSetDequeueTimeout(va_list args) {
1733 nsecs_t timeout = va_arg(args, int64_t);
1734 return setDequeueTimeout(timeout);
1735}
1736
Alec Mouri72670c52019-08-31 01:54:33 -07001737int Surface::dispatchGetLastDequeueDuration(va_list args) {
1738 int64_t* lastDequeueDuration = va_arg(args, int64_t*);
1739 *lastDequeueDuration = mLastDequeueDuration;
1740 return NO_ERROR;
1741}
1742
1743int Surface::dispatchGetLastQueueDuration(va_list args) {
1744 int64_t* lastQueueDuration = va_arg(args, int64_t*);
1745 *lastQueueDuration = mLastQueueDuration;
1746 return NO_ERROR;
1747}
1748
Steven Thomas3172e202020-01-06 19:25:30 -08001749int Surface::dispatchSetFrameRate(va_list args) {
1750 float frameRate = static_cast<float>(va_arg(args, double));
Steven Thomas62a4cf82020-01-31 12:04:03 -08001751 int8_t compatibility = static_cast<int8_t>(va_arg(args, int));
Marin Shalamanovc5986772021-03-16 16:09:49 +01001752 int8_t changeFrameRateStrategy = static_cast<int8_t>(va_arg(args, int));
1753 return setFrameRate(frameRate, compatibility, changeFrameRateStrategy);
Steven Thomas3172e202020-01-06 19:25:30 -08001754}
1755
Alec Mouri09d122a2019-11-25 10:00:53 -08001756int Surface::dispatchAddCancelInterceptor(va_list args) {
1757 ANativeWindow_cancelBufferInterceptor interceptor =
1758 va_arg(args, ANativeWindow_cancelBufferInterceptor);
1759 void* data = va_arg(args, void*);
1760 std::lock_guard<std::shared_mutex> lock(mInterceptorMutex);
1761 mCancelInterceptor = interceptor;
1762 mCancelInterceptorData = data;
1763 return NO_ERROR;
1764}
1765
1766int Surface::dispatchAddDequeueInterceptor(va_list args) {
1767 ANativeWindow_dequeueBufferInterceptor interceptor =
1768 va_arg(args, ANativeWindow_dequeueBufferInterceptor);
1769 void* data = va_arg(args, void*);
1770 std::lock_guard<std::shared_mutex> lock(mInterceptorMutex);
1771 mDequeueInterceptor = interceptor;
1772 mDequeueInterceptorData = data;
1773 return NO_ERROR;
1774}
1775
1776int Surface::dispatchAddPerformInterceptor(va_list args) {
1777 ANativeWindow_performInterceptor interceptor = va_arg(args, ANativeWindow_performInterceptor);
1778 void* data = va_arg(args, void*);
1779 std::lock_guard<std::shared_mutex> lock(mInterceptorMutex);
1780 mPerformInterceptor = interceptor;
1781 mPerformInterceptorData = data;
1782 return NO_ERROR;
1783}
1784
1785int Surface::dispatchAddQueueInterceptor(va_list args) {
1786 ANativeWindow_queueBufferInterceptor interceptor =
1787 va_arg(args, ANativeWindow_queueBufferInterceptor);
1788 void* data = va_arg(args, void*);
1789 std::lock_guard<std::shared_mutex> lock(mInterceptorMutex);
1790 mQueueInterceptor = interceptor;
1791 mQueueInterceptorData = data;
1792 return NO_ERROR;
1793}
1794
John Reck401cda62020-05-07 16:04:41 -07001795int Surface::dispatchAddQueryInterceptor(va_list args) {
1796 ANativeWindow_queryInterceptor interceptor = va_arg(args, ANativeWindow_queryInterceptor);
1797 void* data = va_arg(args, void*);
1798 std::lock_guard<std::shared_mutex> lock(mInterceptorMutex);
1799 mQueryInterceptor = interceptor;
1800 mQueryInterceptorData = data;
1801 return NO_ERROR;
1802}
1803
Alec Mourief0b1532019-12-17 09:39:07 -08001804int Surface::dispatchGetLastQueuedBuffer(va_list args) {
1805 AHardwareBuffer** buffer = va_arg(args, AHardwareBuffer**);
1806 int* fence = va_arg(args, int*);
1807 float* matrix = va_arg(args, float*);
1808 sp<GraphicBuffer> graphicBuffer;
1809 sp<Fence> spFence;
1810
1811 int result = mGraphicBufferProducer->getLastQueuedBuffer(&graphicBuffer, &spFence, matrix);
1812
1813 if (graphicBuffer != nullptr) {
Yiwei Zhang03fbf9c2020-06-03 10:01:34 -07001814 *buffer = graphicBuffer->toAHardwareBuffer();
Alec Mourief0b1532019-12-17 09:39:07 -08001815 AHardwareBuffer_acquire(*buffer);
1816 } else {
1817 *buffer = nullptr;
1818 }
1819
1820 if (spFence != nullptr) {
1821 *fence = spFence->dup();
1822 } else {
1823 *fence = -1;
1824 }
1825 return result;
1826}
1827
John Reckaa5a0b22021-05-18 00:42:56 -04001828int Surface::dispatchGetLastQueuedBuffer2(va_list args) {
1829 AHardwareBuffer** buffer = va_arg(args, AHardwareBuffer**);
1830 int* fence = va_arg(args, int*);
1831 ARect* crop = va_arg(args, ARect*);
1832 uint32_t* transform = va_arg(args, uint32_t*);
1833 sp<GraphicBuffer> graphicBuffer;
1834 sp<Fence> spFence;
1835
1836 Rect r;
1837 int result =
1838 mGraphicBufferProducer->getLastQueuedBuffer(&graphicBuffer, &spFence, &r, transform);
1839
1840 if (graphicBuffer != nullptr) {
1841 *buffer = graphicBuffer->toAHardwareBuffer();
1842 AHardwareBuffer_acquire(*buffer);
1843
1844 // Avoid setting crop* unless buffer is valid (matches IGBP behavior)
1845 crop->left = r.left;
1846 crop->top = r.top;
1847 crop->right = r.right;
1848 crop->bottom = r.bottom;
1849 } else {
1850 *buffer = nullptr;
1851 }
1852
1853 if (spFence != nullptr) {
1854 *fence = spFence->dup();
1855 } else {
1856 *fence = -1;
1857 }
1858 return result;
1859}
1860
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001861int Surface::dispatchSetFrameTimelineInfo(va_list args) {
Ady Abraham74e17562020-08-24 18:18:19 -07001862 ATRACE_CALL();
1863 auto frameTimelineVsyncId = static_cast<int64_t>(va_arg(args, int64_t));
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001864 auto inputEventId = static_cast<int32_t>(va_arg(args, int32_t));
Rachel Leeed511ef2021-10-11 15:09:51 -07001865 auto startTimeNanos = static_cast<int64_t>(va_arg(args, int64_t));
Ady Abraham74e17562020-08-24 18:18:19 -07001866
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001867 ALOGV("Surface::%s", __func__);
Huihong Luo3bdef862022-03-03 11:57:19 -08001868 FrameTimelineInfo ftlInfo;
1869 ftlInfo.vsyncId = frameTimelineVsyncId;
1870 ftlInfo.inputEventId = inputEventId;
1871 ftlInfo.startTimeNanos = startTimeNanos;
1872 return setFrameTimelineInfo(ftlInfo);
Ady Abraham74e17562020-08-24 18:18:19 -07001873}
1874
Robert Carr82d07c92021-05-10 11:36:43 -07001875bool Surface::transformToDisplayInverse() const {
Vishnu Nair5eb3f062019-04-08 08:21:03 -07001876 return (mTransform & NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY) ==
1877 NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY;
1878}
1879
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001880int Surface::connect(int api) {
Peiyong Lind8460c82020-07-28 16:04:22 -07001881 static sp<IProducerListener> listener = new StubProducerListener();
Dan Stoza966b98b2015-03-02 22:12:37 -08001882 return connect(api, listener);
1883}
1884
1885int Surface::connect(int api, const sp<IProducerListener>& listener) {
Yin-Chia Yehe572fd72017-03-28 19:07:39 -07001886 return connect(api, listener, false);
1887}
1888
1889int Surface::connect(
Shuzhen Wang067fcd32019-08-14 10:41:12 -07001890 int api, bool reportBufferRemoval, const sp<SurfaceListener>& sListener) {
1891 if (sListener != nullptr) {
1892 mListenerProxy = new ProducerListenerProxy(this, sListener);
1893 }
1894 return connect(api, mListenerProxy, reportBufferRemoval);
1895}
1896
1897int Surface::connect(
Yin-Chia Yehe572fd72017-03-28 19:07:39 -07001898 int api, const sp<IProducerListener>& listener, bool reportBufferRemoval) {
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001899 ATRACE_CALL();
1900 ALOGV("Surface::connect");
1901 Mutex::Autolock lock(mMutex);
1902 IGraphicBufferProducer::QueueBufferOutput output;
Yin-Chia Yehe572fd72017-03-28 19:07:39 -07001903 mReportRemovedBuffers = reportBufferRemoval;
Dan Stozaf0eaf252014-03-21 13:05:51 -07001904 int err = mGraphicBufferProducer->connect(listener, api, mProducerControlledByApp, &output);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001905 if (err == NO_ERROR) {
Brian Anderson7c3ba8a2016-07-25 12:48:08 -07001906 mDefaultWidth = output.width;
1907 mDefaultHeight = output.height;
1908 mNextFrameNumber = output.nextFrameNumber;
silence_dogoode9d092a2019-06-19 16:14:53 -07001909 mMaxBufferCount = output.maxBufferCount;
Ruben Brunk1681d952014-06-27 15:51:55 -07001910
Vishnu Nair5eb3f062019-04-08 08:21:03 -07001911 // Ignore transform hint if sticky transform is set or transform to display inverse flag is
1912 // set. Transform hint should be ignored if the client is expected to always submit buffers
1913 // in the same orientation.
1914 if (mStickyTransform == 0 && !transformToDisplayInverse()) {
Brian Anderson7c3ba8a2016-07-25 12:48:08 -07001915 mTransformHint = output.transformHint;
Ruben Brunk1681d952014-06-27 15:51:55 -07001916 }
1917
Brian Anderson7c3ba8a2016-07-25 12:48:08 -07001918 mConsumerRunningBehind = (output.numPendingBuffers >= 2);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001919 }
1920 if (!err && api == NATIVE_WINDOW_API_CPU) {
1921 mConnectedToCpu = true;
Dan Stoza5065a552015-03-17 16:23:42 -07001922 // Clear the dirty region in case we're switching from a non-CPU API
1923 mDirtyRegion.clear();
1924 } else if (!err) {
1925 // Initialize the dirty region for tracking surface damage
1926 mDirtyRegion = Region::INVALID_REGION;
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001927 }
Dan Stoza5065a552015-03-17 16:23:42 -07001928
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001929 return err;
1930}
1931
Mathias Agopian365857d2013-09-11 19:35:45 -07001932
Robert Carr97b9c862016-09-08 13:54:35 -07001933int Surface::disconnect(int api, IGraphicBufferProducer::DisconnectMode mode) {
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001934 ATRACE_CALL();
1935 ALOGV("Surface::disconnect");
1936 Mutex::Autolock lock(mMutex);
Yin-Chia Yehe572fd72017-03-28 19:07:39 -07001937 mRemovedBuffers.clear();
Pablo Ceballosff95aab2016-01-13 17:09:58 -08001938 mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT;
1939 mSharedBufferHasBeenQueued = false;
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001940 freeAllBuffers();
Robert Carr97b9c862016-09-08 13:54:35 -07001941 int err = mGraphicBufferProducer->disconnect(api, mode);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001942 if (!err) {
1943 mReqFormat = 0;
1944 mReqWidth = 0;
1945 mReqHeight = 0;
1946 mReqUsage = 0;
1947 mCrop.clear();
Yiwei Zhang51572c22022-07-22 23:08:30 +00001948 mDataSpace = Dataspace::UNKNOWN;
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001949 mScalingMode = NATIVE_WINDOW_SCALING_MODE_FREEZE;
1950 mTransform = 0;
Ruben Brunk1681d952014-06-27 15:51:55 -07001951 mStickyTransform = 0;
Yiwei Zhang538cedc2019-06-24 19:35:03 -07001952 mAutoPrerotation = false;
Yiwei Zhangc1851922019-08-21 14:02:45 -07001953 mEnableFrameTimestamps = false;
Yiwei Zhang74c9cc32020-06-20 03:35:17 -07001954 mMaxBufferCount = NUM_BUFFER_SLOTS;
Ruben Brunk1681d952014-06-27 15:51:55 -07001955
Mathias Agopiane3c697f2013-02-14 17:11:02 -08001956 if (api == NATIVE_WINDOW_API_CPU) {
1957 mConnectedToCpu = false;
1958 }
1959 }
1960 return err;
1961}
1962
Dan Stozad9c49712015-04-27 11:06:01 -07001963int Surface::detachNextBuffer(sp<GraphicBuffer>* outBuffer,
Dan Stoza231832e2015-03-11 11:55:01 -07001964 sp<Fence>* outFence) {
1965 ATRACE_CALL();
1966 ALOGV("Surface::detachNextBuffer");
1967
Yi Kong48a619f2018-06-05 16:34:59 -07001968 if (outBuffer == nullptr || outFence == nullptr) {
Dan Stoza231832e2015-03-11 11:55:01 -07001969 return BAD_VALUE;
1970 }
1971
1972 Mutex::Autolock lock(mMutex);
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -07001973 if (mReportRemovedBuffers) {
1974 mRemovedBuffers.clear();
1975 }
Dan Stoza231832e2015-03-11 11:55:01 -07001976
Yi Kong48a619f2018-06-05 16:34:59 -07001977 sp<GraphicBuffer> buffer(nullptr);
1978 sp<Fence> fence(nullptr);
Dan Stoza231832e2015-03-11 11:55:01 -07001979 status_t result = mGraphicBufferProducer->detachNextBuffer(
1980 &buffer, &fence);
1981 if (result != NO_ERROR) {
1982 return result;
1983 }
1984
Dan Stozad9c49712015-04-27 11:06:01 -07001985 *outBuffer = buffer;
Yi Kong48a619f2018-06-05 16:34:59 -07001986 if (fence != nullptr && fence->isValid()) {
Dan Stoza231832e2015-03-11 11:55:01 -07001987 *outFence = fence;
1988 } else {
1989 *outFence = Fence::NO_FENCE;
1990 }
1991
Pablo Ceballos23b4abe2016-01-08 12:15:22 -08001992 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
Yi Kong48a619f2018-06-05 16:34:59 -07001993 if (mSlots[i].buffer != nullptr &&
Shuzhen Wang55be5052017-05-23 09:41:54 -07001994 mSlots[i].buffer->getId() == buffer->getId()) {
Yin-Chia Yehe572fd72017-03-28 19:07:39 -07001995 if (mReportRemovedBuffers) {
1996 mRemovedBuffers.push_back(mSlots[i].buffer);
1997 }
Yi Kong48a619f2018-06-05 16:34:59 -07001998 mSlots[i].buffer = nullptr;
Pablo Ceballos23b4abe2016-01-08 12:15:22 -08001999 }
2000 }
2001
Dan Stoza231832e2015-03-11 11:55:01 -07002002 return NO_ERROR;
2003}
2004
2005int Surface::attachBuffer(ANativeWindowBuffer* buffer)
2006{
2007 ATRACE_CALL();
2008 ALOGV("Surface::attachBuffer");
2009
2010 Mutex::Autolock lock(mMutex);
Yin-Chia Yeh1f2af5c2017-05-11 16:54:04 -07002011 if (mReportRemovedBuffers) {
2012 mRemovedBuffers.clear();
2013 }
Dan Stoza231832e2015-03-11 11:55:01 -07002014
2015 sp<GraphicBuffer> graphicBuffer(static_cast<GraphicBuffer*>(buffer));
Dan Stoza812ed062015-06-02 15:45:22 -07002016 uint32_t priorGeneration = graphicBuffer->mGenerationNumber;
2017 graphicBuffer->mGenerationNumber = mGenerationNumber;
Dan Stoza231832e2015-03-11 11:55:01 -07002018 int32_t attachedSlot = -1;
Mathias Agopiancb496ac2017-05-22 14:21:00 -07002019 status_t result = mGraphicBufferProducer->attachBuffer(&attachedSlot, graphicBuffer);
Dan Stoza231832e2015-03-11 11:55:01 -07002020 if (result != NO_ERROR) {
2021 ALOGE("attachBuffer: IGraphicBufferProducer call failed (%d)", result);
Dan Stoza812ed062015-06-02 15:45:22 -07002022 graphicBuffer->mGenerationNumber = priorGeneration;
Dan Stoza231832e2015-03-11 11:55:01 -07002023 return result;
2024 }
Yin-Chia Yehe572fd72017-03-28 19:07:39 -07002025 if (mReportRemovedBuffers && (mSlots[attachedSlot].buffer != nullptr)) {
Yin-Chia Yehe572fd72017-03-28 19:07:39 -07002026 mRemovedBuffers.push_back(mSlots[attachedSlot].buffer);
2027 }
Dan Stoza231832e2015-03-11 11:55:01 -07002028 mSlots[attachedSlot].buffer = graphicBuffer;
Yin-Chia Yehda2e6092020-07-29 15:00:07 -07002029 mDequeuedSlots.insert(attachedSlot);
Dan Stoza231832e2015-03-11 11:55:01 -07002030
2031 return NO_ERROR;
2032}
2033
Mathias Agopiancb496ac2017-05-22 14:21:00 -07002034int Surface::setUsage(uint64_t reqUsage)
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002035{
2036 ALOGV("Surface::setUsage");
2037 Mutex::Autolock lock(mMutex);
Pablo Ceballosff95aab2016-01-13 17:09:58 -08002038 if (reqUsage != mReqUsage) {
2039 mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT;
2040 }
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002041 mReqUsage = reqUsage;
2042 return OK;
2043}
2044
2045int Surface::setCrop(Rect const* rect)
2046{
2047 ATRACE_CALL();
2048
Pablo Ceballos60d69222015-08-07 14:47:20 -07002049 Rect realRect(Rect::EMPTY_RECT);
Yi Kong48a619f2018-06-05 16:34:59 -07002050 if (rect == nullptr || rect->isEmpty()) {
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002051 realRect.clear();
2052 } else {
2053 realRect = *rect;
Mathias Agopian55fa2512010-03-11 15:06:54 -08002054 }
2055
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002056 ALOGV("Surface::setCrop rect=[%d %d %d %d]",
2057 realRect.left, realRect.top, realRect.right, realRect.bottom);
2058
2059 Mutex::Autolock lock(mMutex);
2060 mCrop = realRect;
2061 return NO_ERROR;
2062}
2063
2064int Surface::setBufferCount(int bufferCount)
2065{
2066 ATRACE_CALL();
2067 ALOGV("Surface::setBufferCount");
2068 Mutex::Autolock lock(mMutex);
2069
Pablo Ceballose5b755a2015-08-13 16:18:19 -07002070 status_t err = NO_ERROR;
2071 if (bufferCount == 0) {
2072 err = mGraphicBufferProducer->setMaxDequeuedBufferCount(1);
2073 } else {
2074 int minUndequeuedBuffers = 0;
2075 err = mGraphicBufferProducer->query(
2076 NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &minUndequeuedBuffers);
2077 if (err == NO_ERROR) {
2078 err = mGraphicBufferProducer->setMaxDequeuedBufferCount(
2079 bufferCount - minUndequeuedBuffers);
2080 }
2081 }
Mathias Agopian90147262010-01-22 11:47:55 -08002082
Pablo Ceballose5b755a2015-08-13 16:18:19 -07002083 ALOGE_IF(err, "IGraphicBufferProducer::setBufferCount(%d) returned %s",
2084 bufferCount, strerror(-err));
2085
Mathias Agopian076b1cc2009-04-10 14:24:30 -07002086 return err;
2087}
Mathias Agopian076b1cc2009-04-10 14:24:30 -07002088
Pablo Ceballosfa455352015-08-12 17:47:47 -07002089int Surface::setMaxDequeuedBufferCount(int maxDequeuedBuffers) {
2090 ATRACE_CALL();
2091 ALOGV("Surface::setMaxDequeuedBufferCount");
2092 Mutex::Autolock lock(mMutex);
2093
2094 status_t err = mGraphicBufferProducer->setMaxDequeuedBufferCount(
2095 maxDequeuedBuffers);
2096 ALOGE_IF(err, "IGraphicBufferProducer::setMaxDequeuedBufferCount(%d) "
2097 "returned %s", maxDequeuedBuffers, strerror(-err));
2098
Pablo Ceballosfa455352015-08-12 17:47:47 -07002099 return err;
2100}
2101
2102int Surface::setAsyncMode(bool async) {
2103 ATRACE_CALL();
2104 ALOGV("Surface::setAsyncMode");
2105 Mutex::Autolock lock(mMutex);
2106
2107 status_t err = mGraphicBufferProducer->setAsyncMode(async);
2108 ALOGE_IF(err, "IGraphicBufferProducer::setAsyncMode(%d) returned %s",
2109 async, strerror(-err));
2110
Pablo Ceballosfa455352015-08-12 17:47:47 -07002111 return err;
2112}
2113
Pablo Ceballos3559fbf2016-03-17 15:50:23 -07002114int Surface::setSharedBufferMode(bool sharedBufferMode) {
Pablo Ceballosccdfd602015-10-07 15:05:45 -07002115 ATRACE_CALL();
Pablo Ceballos3559fbf2016-03-17 15:50:23 -07002116 ALOGV("Surface::setSharedBufferMode (%d)", sharedBufferMode);
Pablo Ceballosccdfd602015-10-07 15:05:45 -07002117 Mutex::Autolock lock(mMutex);
2118
Pablo Ceballos3559fbf2016-03-17 15:50:23 -07002119 status_t err = mGraphicBufferProducer->setSharedBufferMode(
2120 sharedBufferMode);
Pablo Ceballosff95aab2016-01-13 17:09:58 -08002121 if (err == NO_ERROR) {
Pablo Ceballos3559fbf2016-03-17 15:50:23 -07002122 mSharedBufferMode = sharedBufferMode;
Pablo Ceballosff95aab2016-01-13 17:09:58 -08002123 }
Pablo Ceballos3559fbf2016-03-17 15:50:23 -07002124 ALOGE_IF(err, "IGraphicBufferProducer::setSharedBufferMode(%d) returned"
2125 "%s", sharedBufferMode, strerror(-err));
Pablo Ceballosccdfd602015-10-07 15:05:45 -07002126
2127 return err;
2128}
2129
Pablo Ceballosff95aab2016-01-13 17:09:58 -08002130int Surface::setAutoRefresh(bool autoRefresh) {
2131 ATRACE_CALL();
2132 ALOGV("Surface::setAutoRefresh (%d)", autoRefresh);
2133 Mutex::Autolock lock(mMutex);
2134
2135 status_t err = mGraphicBufferProducer->setAutoRefresh(autoRefresh);
2136 if (err == NO_ERROR) {
2137 mAutoRefresh = autoRefresh;
2138 }
2139 ALOGE_IF(err, "IGraphicBufferProducer::setAutoRefresh(%d) returned %s",
2140 autoRefresh, strerror(-err));
2141 return err;
2142}
2143
Dan Stoza3be1c6b2014-11-18 10:24:03 -08002144int Surface::setBuffersDimensions(uint32_t width, uint32_t height)
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002145{
2146 ATRACE_CALL();
2147 ALOGV("Surface::setBuffersDimensions");
2148
Dan Stoza3be1c6b2014-11-18 10:24:03 -08002149 if ((width && !height) || (!width && height))
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002150 return BAD_VALUE;
2151
2152 Mutex::Autolock lock(mMutex);
Pablo Ceballosff95aab2016-01-13 17:09:58 -08002153 if (width != mReqWidth || height != mReqHeight) {
2154 mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT;
2155 }
Dan Stoza3be1c6b2014-11-18 10:24:03 -08002156 mReqWidth = width;
2157 mReqHeight = height;
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002158 return NO_ERROR;
2159}
2160
Dan Stoza3be1c6b2014-11-18 10:24:03 -08002161int Surface::setBuffersUserDimensions(uint32_t width, uint32_t height)
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002162{
2163 ATRACE_CALL();
2164 ALOGV("Surface::setBuffersUserDimensions");
2165
Dan Stoza3be1c6b2014-11-18 10:24:03 -08002166 if ((width && !height) || (!width && height))
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002167 return BAD_VALUE;
2168
2169 Mutex::Autolock lock(mMutex);
Pablo Ceballosff95aab2016-01-13 17:09:58 -08002170 if (width != mUserWidth || height != mUserHeight) {
2171 mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT;
2172 }
Dan Stoza3be1c6b2014-11-18 10:24:03 -08002173 mUserWidth = width;
2174 mUserHeight = height;
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002175 return NO_ERROR;
2176}
2177
Dan Stoza3be1c6b2014-11-18 10:24:03 -08002178int Surface::setBuffersFormat(PixelFormat format)
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002179{
2180 ALOGV("Surface::setBuffersFormat");
2181
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002182 Mutex::Autolock lock(mMutex);
Pablo Ceballosff95aab2016-01-13 17:09:58 -08002183 if (format != mReqFormat) {
2184 mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT;
2185 }
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002186 mReqFormat = format;
2187 return NO_ERROR;
2188}
2189
2190int Surface::setScalingMode(int mode)
2191{
2192 ATRACE_CALL();
2193 ALOGV("Surface::setScalingMode(%d)", mode);
2194
2195 switch (mode) {
2196 case NATIVE_WINDOW_SCALING_MODE_FREEZE:
2197 case NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW:
2198 case NATIVE_WINDOW_SCALING_MODE_SCALE_CROP:
Robert Carrc2e77882015-12-16 18:14:03 -08002199 case NATIVE_WINDOW_SCALING_MODE_NO_SCALE_CROP:
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002200 break;
2201 default:
2202 ALOGE("unknown scaling mode: %d", mode);
2203 return BAD_VALUE;
2204 }
2205
2206 Mutex::Autolock lock(mMutex);
2207 mScalingMode = mode;
2208 return NO_ERROR;
2209}
2210
Dan Stoza3be1c6b2014-11-18 10:24:03 -08002211int Surface::setBuffersTransform(uint32_t transform)
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002212{
2213 ATRACE_CALL();
2214 ALOGV("Surface::setBuffersTransform");
2215 Mutex::Autolock lock(mMutex);
Vishnu Nair5eb3f062019-04-08 08:21:03 -07002216 // Ensure NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY is sticky. If the client sets the flag, do not
2217 // override it until the surface is disconnected. This is a temporary workaround for camera
2218 // until they switch to using Buffer State Layers. Currently if client sets the buffer transform
2219 // it may be overriden by the buffer producer when the producer sets the buffer transform.
2220 if (transformToDisplayInverse()) {
2221 transform |= NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY;
2222 }
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002223 mTransform = transform;
2224 return NO_ERROR;
2225}
2226
Dan Stoza3be1c6b2014-11-18 10:24:03 -08002227int Surface::setBuffersStickyTransform(uint32_t transform)
Ruben Brunk1681d952014-06-27 15:51:55 -07002228{
2229 ATRACE_CALL();
2230 ALOGV("Surface::setBuffersStickyTransform");
2231 Mutex::Autolock lock(mMutex);
2232 mStickyTransform = transform;
2233 return NO_ERROR;
2234}
2235
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002236int Surface::setBuffersTimestamp(int64_t timestamp)
2237{
2238 ALOGV("Surface::setBuffersTimestamp");
2239 Mutex::Autolock lock(mMutex);
2240 mTimestamp = timestamp;
2241 return NO_ERROR;
2242}
2243
Peiyong Lin34beb7a2018-03-28 11:57:12 -07002244int Surface::setBuffersDataSpace(Dataspace dataSpace)
Eino-Ville Talvala82c6bcc2015-02-19 16:10:43 -08002245{
2246 ALOGV("Surface::setBuffersDataSpace");
2247 Mutex::Autolock lock(mMutex);
2248 mDataSpace = dataSpace;
2249 return NO_ERROR;
2250}
2251
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -07002252int Surface::setBuffersSmpte2086Metadata(const android_smpte2086_metadata* metadata) {
2253 ALOGV("Surface::setBuffersSmpte2086Metadata");
2254 Mutex::Autolock lock(mMutex);
2255 if (metadata) {
2256 mHdrMetadata.smpte2086 = *metadata;
2257 mHdrMetadata.validTypes |= HdrMetadata::SMPTE2086;
2258 } else {
2259 mHdrMetadata.validTypes &= ~HdrMetadata::SMPTE2086;
2260 }
2261 return NO_ERROR;
2262}
2263
2264int Surface::setBuffersCta8613Metadata(const android_cta861_3_metadata* metadata) {
2265 ALOGV("Surface::setBuffersCta8613Metadata");
2266 Mutex::Autolock lock(mMutex);
2267 if (metadata) {
2268 mHdrMetadata.cta8613 = *metadata;
2269 mHdrMetadata.validTypes |= HdrMetadata::CTA861_3;
2270 } else {
2271 mHdrMetadata.validTypes &= ~HdrMetadata::CTA861_3;
2272 }
2273 return NO_ERROR;
2274}
2275
Valerie Haua82679d2018-11-21 09:31:43 -08002276int Surface::setBuffersHdr10PlusMetadata(const size_t size, const uint8_t* metadata) {
2277 ALOGV("Surface::setBuffersBlobMetadata");
2278 Mutex::Autolock lock(mMutex);
2279 if (size > 0) {
2280 mHdrMetadata.hdr10plus.assign(metadata, metadata + size);
2281 mHdrMetadata.validTypes |= HdrMetadata::HDR10PLUS;
2282 } else {
2283 mHdrMetadata.validTypes &= ~HdrMetadata::HDR10PLUS;
2284 mHdrMetadata.hdr10plus.clear();
2285 }
2286 return NO_ERROR;
2287}
2288
Peiyong Lin34beb7a2018-03-28 11:57:12 -07002289Dataspace Surface::getBuffersDataSpace() {
Courtney Goeltzenleuchter152279d2017-08-14 18:18:30 -06002290 ALOGV("Surface::getBuffersDataSpace");
2291 Mutex::Autolock lock(mMutex);
2292 return mDataSpace;
2293}
2294
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002295void Surface::freeAllBuffers() {
Yin-Chia Yehda2e6092020-07-29 15:00:07 -07002296 if (!mDequeuedSlots.empty()) {
2297 ALOGE("%s: %zu buffers were freed while being dequeued!",
2298 __FUNCTION__, mDequeuedSlots.size());
2299 }
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002300 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
Yi Kong48a619f2018-06-05 16:34:59 -07002301 mSlots[i].buffer = nullptr;
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002302 }
2303}
2304
Shuzhen Wang067fcd32019-08-14 10:41:12 -07002305status_t Surface::getAndFlushBuffersFromSlots(const std::vector<int32_t>& slots,
2306 std::vector<sp<GraphicBuffer>>* outBuffers) {
2307 ALOGV("Surface::getAndFlushBuffersFromSlots");
2308 for (int32_t i : slots) {
2309 if (i < 0 || i >= NUM_BUFFER_SLOTS) {
2310 ALOGE("%s: Invalid slotIndex: %d", __FUNCTION__, i);
2311 return BAD_VALUE;
2312 }
2313 }
2314
2315 Mutex::Autolock lock(mMutex);
2316 for (int32_t i : slots) {
2317 if (mSlots[i].buffer == nullptr) {
2318 ALOGW("%s: Discarded slot %d doesn't contain buffer!", __FUNCTION__, i);
2319 continue;
2320 }
Yin-Chia Yehda2e6092020-07-29 15:00:07 -07002321 // Don't flush currently dequeued buffers
2322 if (mDequeuedSlots.count(i) > 0) {
2323 continue;
2324 }
Shuzhen Wang067fcd32019-08-14 10:41:12 -07002325 outBuffers->push_back(mSlots[i].buffer);
2326 mSlots[i].buffer = nullptr;
2327 }
2328 return OK;
2329}
2330
Dan Stoza5065a552015-03-17 16:23:42 -07002331void Surface::setSurfaceDamage(android_native_rect_t* rects, size_t numRects) {
2332 ATRACE_CALL();
2333 ALOGV("Surface::setSurfaceDamage");
2334 Mutex::Autolock lock(mMutex);
2335
Dan Stozac62acbd2015-04-21 16:42:49 -07002336 if (mConnectedToCpu || numRects == 0) {
Dan Stoza5065a552015-03-17 16:23:42 -07002337 mDirtyRegion = Region::INVALID_REGION;
2338 return;
2339 }
2340
2341 mDirtyRegion.clear();
2342 for (size_t r = 0; r < numRects; ++r) {
2343 // We intentionally flip top and bottom here, since because they're
2344 // specified with a bottom-left origin, top > bottom, which fails
2345 // validation in the Region class. We will fix this up when we flip to a
2346 // top-left origin in queueBuffer.
2347 Rect rect(rects[r].left, rects[r].bottom, rects[r].right, rects[r].top);
2348 mDirtyRegion.orSelf(rect);
2349 }
2350}
2351
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002352// ----------------------------------------------------------------------
2353// the lock/unlock APIs must be used from the same thread
2354
2355static status_t copyBlt(
2356 const sp<GraphicBuffer>& dst,
2357 const sp<GraphicBuffer>& src,
Francis Hart7b09e792015-01-09 11:10:54 +02002358 const Region& reg,
2359 int *dstFenceFd)
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002360{
Dennis Kempinadd458f2017-05-17 19:16:31 -07002361 if (dst->getId() == src->getId())
2362 return OK;
2363
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002364 // src and dst with, height and format must be identical. no verification
2365 // is done here.
2366 status_t err;
Yi Kong48a619f2018-06-05 16:34:59 -07002367 uint8_t* src_bits = nullptr;
Dan Stoza3be1c6b2014-11-18 10:24:03 -08002368 err = src->lock(GRALLOC_USAGE_SW_READ_OFTEN, reg.bounds(),
2369 reinterpret_cast<void**>(&src_bits));
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002370 ALOGE_IF(err, "error locking src buffer %s", strerror(-err));
2371
Yi Kong48a619f2018-06-05 16:34:59 -07002372 uint8_t* dst_bits = nullptr;
Francis Hart7b09e792015-01-09 11:10:54 +02002373 err = dst->lockAsync(GRALLOC_USAGE_SW_WRITE_OFTEN, reg.bounds(),
2374 reinterpret_cast<void**>(&dst_bits), *dstFenceFd);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002375 ALOGE_IF(err, "error locking dst buffer %s", strerror(-err));
Francis Hart7b09e792015-01-09 11:10:54 +02002376 *dstFenceFd = -1;
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002377
2378 Region::const_iterator head(reg.begin());
2379 Region::const_iterator tail(reg.end());
2380 if (head != tail && src_bits && dst_bits) {
2381 const size_t bpp = bytesPerPixel(src->format);
Dan Stoza3be1c6b2014-11-18 10:24:03 -08002382 const size_t dbpr = static_cast<uint32_t>(dst->stride) * bpp;
2383 const size_t sbpr = static_cast<uint32_t>(src->stride) * bpp;
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002384
2385 while (head != tail) {
2386 const Rect& r(*head++);
Dan Stoza3be1c6b2014-11-18 10:24:03 -08002387 int32_t h = r.height();
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002388 if (h <= 0) continue;
Dan Stoza3be1c6b2014-11-18 10:24:03 -08002389 size_t size = static_cast<uint32_t>(r.width()) * bpp;
2390 uint8_t const * s = src_bits +
2391 static_cast<uint32_t>(r.left + src->stride * r.top) * bpp;
2392 uint8_t * d = dst_bits +
2393 static_cast<uint32_t>(r.left + dst->stride * r.top) * bpp;
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002394 if (dbpr==sbpr && size==sbpr) {
Dan Stoza3be1c6b2014-11-18 10:24:03 -08002395 size *= static_cast<size_t>(h);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002396 h = 1;
2397 }
2398 do {
2399 memcpy(d, s, size);
2400 d += dbpr;
2401 s += sbpr;
2402 } while (--h > 0);
2403 }
2404 }
2405
2406 if (src_bits)
2407 src->unlock();
2408
2409 if (dst_bits)
Francis Hart7b09e792015-01-09 11:10:54 +02002410 dst->unlockAsync(dstFenceFd);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002411
2412 return err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002413}
2414
Mathias Agopiana138f892010-05-21 17:24:35 -07002415// ----------------------------------------------------------------------------
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002416
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002417status_t Surface::lock(
2418 ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds)
2419{
Yi Kong48a619f2018-06-05 16:34:59 -07002420 if (mLockedBuffer != nullptr) {
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002421 ALOGE("Surface::lock failed, already locked");
2422 return INVALID_OPERATION;
2423 }
2424
2425 if (!mConnectedToCpu) {
2426 int err = Surface::connect(NATIVE_WINDOW_API_CPU);
2427 if (err) {
2428 return err;
2429 }
2430 // we're intending to do software rendering from this point
2431 setUsage(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
2432 }
2433
2434 ANativeWindowBuffer* out;
2435 int fenceFd = -1;
2436 status_t err = dequeueBuffer(&out, &fenceFd);
2437 ALOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err));
2438 if (err == NO_ERROR) {
2439 sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out));
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002440 const Rect bounds(backBuffer->width, backBuffer->height);
2441
2442 Region newDirtyRegion;
2443 if (inOutDirtyBounds) {
2444 newDirtyRegion.set(static_cast<Rect const&>(*inOutDirtyBounds));
2445 newDirtyRegion.andSelf(bounds);
2446 } else {
2447 newDirtyRegion.set(bounds);
2448 }
2449
2450 // figure out if we can copy the frontbuffer back
2451 const sp<GraphicBuffer>& frontBuffer(mPostedBuffer);
Yi Kong48a619f2018-06-05 16:34:59 -07002452 const bool canCopyBack = (frontBuffer != nullptr &&
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002453 backBuffer->width == frontBuffer->width &&
2454 backBuffer->height == frontBuffer->height &&
2455 backBuffer->format == frontBuffer->format);
2456
2457 if (canCopyBack) {
2458 // copy the area that is invalid and not repainted this round
2459 const Region copyback(mDirtyRegion.subtract(newDirtyRegion));
Francis Hartdc10f842014-12-01 16:04:49 +02002460 if (!copyback.isEmpty()) {
Francis Hart7b09e792015-01-09 11:10:54 +02002461 copyBlt(backBuffer, frontBuffer, copyback, &fenceFd);
Francis Hartdc10f842014-12-01 16:04:49 +02002462 }
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002463 } else {
2464 // if we can't copy-back anything, modify the user's dirty
2465 // region to make sure they redraw the whole buffer
2466 newDirtyRegion.set(bounds);
2467 mDirtyRegion.clear();
2468 Mutex::Autolock lock(mMutex);
2469 for (size_t i=0 ; i<NUM_BUFFER_SLOTS ; i++) {
2470 mSlots[i].dirtyRegion.clear();
2471 }
2472 }
2473
2474
2475 { // scope for the lock
2476 Mutex::Autolock lock(mMutex);
2477 int backBufferSlot(getSlotFromBufferLocked(backBuffer.get()));
2478 if (backBufferSlot >= 0) {
2479 Region& dirtyRegion(mSlots[backBufferSlot].dirtyRegion);
2480 mDirtyRegion.subtract(dirtyRegion);
2481 dirtyRegion = newDirtyRegion;
2482 }
2483 }
2484
2485 mDirtyRegion.orSelf(newDirtyRegion);
2486 if (inOutDirtyBounds) {
2487 *inOutDirtyBounds = newDirtyRegion.getBounds();
2488 }
2489
2490 void* vaddr;
Francis Hart8f396012014-04-01 15:30:53 +03002491 status_t res = backBuffer->lockAsync(
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002492 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
Francis Hart8f396012014-04-01 15:30:53 +03002493 newDirtyRegion.bounds(), &vaddr, fenceFd);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002494
2495 ALOGW_IF(res, "failed locking buffer (handle = %p)",
2496 backBuffer->handle);
2497
2498 if (res != 0) {
2499 err = INVALID_OPERATION;
2500 } else {
2501 mLockedBuffer = backBuffer;
2502 outBuffer->width = backBuffer->width;
2503 outBuffer->height = backBuffer->height;
2504 outBuffer->stride = backBuffer->stride;
2505 outBuffer->format = backBuffer->format;
2506 outBuffer->bits = vaddr;
2507 }
2508 }
2509 return err;
2510}
2511
2512status_t Surface::unlockAndPost()
2513{
Yi Kong48a619f2018-06-05 16:34:59 -07002514 if (mLockedBuffer == nullptr) {
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002515 ALOGE("Surface::unlockAndPost failed, no locked buffer");
2516 return INVALID_OPERATION;
2517 }
2518
Francis Hart8f396012014-04-01 15:30:53 +03002519 int fd = -1;
2520 status_t err = mLockedBuffer->unlockAsync(&fd);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002521 ALOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle);
2522
Francis Hart8f396012014-04-01 15:30:53 +03002523 err = queueBuffer(mLockedBuffer.get(), fd);
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002524 ALOGE_IF(err, "queueBuffer (handle=%p) failed (%s)",
2525 mLockedBuffer->handle, strerror(-err));
2526
2527 mPostedBuffer = mLockedBuffer;
Yi Kong48a619f2018-06-05 16:34:59 -07002528 mLockedBuffer = nullptr;
Mathias Agopiane3c697f2013-02-14 17:11:02 -08002529 return err;
2530}
2531
Robert Carr9f31e292016-04-11 11:15:32 -07002532bool Surface::waitForNextFrame(uint64_t lastFrame, nsecs_t timeout) {
2533 Mutex::Autolock lock(mMutex);
Pablo Ceballosbc8c1922016-07-01 14:15:41 -07002534 if (mNextFrameNumber > lastFrame) {
Robert Carr9f31e292016-04-11 11:15:32 -07002535 return true;
2536 }
2537 return mQueueBufferCondition.waitRelative(mMutex, timeout) == OK;
2538}
2539
Pablo Ceballos8e3e92b2016-06-27 17:56:53 -07002540status_t Surface::getUniqueId(uint64_t* outId) const {
2541 Mutex::Autolock lock(mMutex);
2542 return mGraphicBufferProducer->getUniqueId(outId);
2543}
2544
Chia-I Wue2786ea2017-08-07 10:36:08 -07002545int Surface::getConsumerUsage(uint64_t* outUsage) const {
2546 Mutex::Autolock lock(mMutex);
2547 return mGraphicBufferProducer->getConsumerUsage(outUsage);
2548}
2549
Yin-Chia Yehe572fd72017-03-28 19:07:39 -07002550status_t Surface::getAndFlushRemovedBuffers(std::vector<sp<GraphicBuffer>>* out) {
2551 if (out == nullptr) {
2552 ALOGE("%s: out must not be null!", __FUNCTION__);
2553 return BAD_VALUE;
2554 }
2555
2556 Mutex::Autolock lock(mMutex);
2557 *out = mRemovedBuffers;
2558 mRemovedBuffers.clear();
2559 return OK;
2560}
2561
Peiyong Lin0f6a4122019-06-25 17:25:02 -07002562status_t Surface::attachAndQueueBufferWithDataspace(Surface* surface, sp<GraphicBuffer> buffer,
2563 Dataspace dataspace) {
Chavi Weingarten40482ff2017-11-30 01:51:40 +00002564 if (buffer == nullptr) {
2565 return BAD_VALUE;
2566 }
2567 int err = static_cast<ANativeWindow*>(surface)->perform(surface, NATIVE_WINDOW_API_CONNECT,
2568 NATIVE_WINDOW_API_CPU);
2569 if (err != OK) {
2570 return err;
2571 }
Peiyong Lin0f6a4122019-06-25 17:25:02 -07002572 ui::Dataspace tmpDataspace = surface->getBuffersDataSpace();
2573 err = surface->setBuffersDataSpace(dataspace);
2574 if (err != OK) {
2575 return err;
2576 }
Chavi Weingarten40482ff2017-11-30 01:51:40 +00002577 err = surface->attachBuffer(buffer->getNativeBuffer());
2578 if (err != OK) {
2579 return err;
2580 }
2581 err = static_cast<ANativeWindow*>(surface)->queueBuffer(surface, buffer->getNativeBuffer(), -1);
2582 if (err != OK) {
2583 return err;
2584 }
Peiyong Lin0f6a4122019-06-25 17:25:02 -07002585 err = surface->setBuffersDataSpace(tmpDataspace);
2586 if (err != OK) {
2587 return err;
2588 }
Chavi Weingarten40482ff2017-11-30 01:51:40 +00002589 err = surface->disconnect(NATIVE_WINDOW_API_CPU);
2590 return err;
2591}
2592
Yiwei Zhang538cedc2019-06-24 19:35:03 -07002593int Surface::setAutoPrerotation(bool autoPrerotation) {
2594 ATRACE_CALL();
2595 ALOGV("Surface::setAutoPrerotation (%d)", autoPrerotation);
2596 Mutex::Autolock lock(mMutex);
2597
2598 if (mAutoPrerotation == autoPrerotation) {
2599 return OK;
2600 }
2601
2602 status_t err = mGraphicBufferProducer->setAutoPrerotation(autoPrerotation);
2603 if (err == NO_ERROR) {
2604 mAutoPrerotation = autoPrerotation;
2605 }
2606 ALOGE_IF(err, "IGraphicBufferProducer::setAutoPrerotation(%d) returned %s", autoPrerotation,
2607 strerror(-err));
2608 return err;
2609}
2610
Shuzhen Wang067fcd32019-08-14 10:41:12 -07002611void Surface::ProducerListenerProxy::onBuffersDiscarded(const std::vector<int32_t>& slots) {
2612 ATRACE_CALL();
2613 sp<Surface> parent = mParent.promote();
2614 if (parent == nullptr) {
2615 return;
2616 }
2617
2618 std::vector<sp<GraphicBuffer>> discardedBufs;
2619 status_t res = parent->getAndFlushBuffersFromSlots(slots, &discardedBufs);
2620 if (res != OK) {
2621 ALOGE("%s: Failed to get buffers from slots: %s(%d)", __FUNCTION__,
2622 strerror(-res), res);
2623 return;
2624 }
2625
2626 mSurfaceListener->onBuffersDiscarded(discardedBufs);
2627}
2628
ramindani8ac14eb2022-04-26 20:20:57 +00002629[[deprecated]] status_t Surface::setFrameRate(float /*frameRate*/, int8_t /*compatibility*/,
2630 int8_t /*changeFrameRateStrategy*/) {
2631 ALOGI("Surface::setFrameRate is deprecated, setFrameRate hint is dropped as destination is not "
2632 "SurfaceFlinger");
2633 // ISurfaceComposer no longer supports setFrameRate, we will return NO_ERROR when the api is
2634 // called to avoid apps crashing, as BAD_VALUE can generate fatal exception in apps.
2635 return NO_ERROR;
Steven Thomas3172e202020-01-06 19:25:30 -08002636}
2637
Huihong Luo3bdef862022-03-03 11:57:19 -08002638status_t Surface::setFrameTimelineInfo(const FrameTimelineInfo& /*frameTimelineInfo*/) {
2639 // ISurfaceComposer no longer supports setFrameTimelineInfo
2640 return BAD_VALUE;
Robert Carr9b611b72020-10-19 12:00:23 -07002641}
2642
Vishnu Nair95b6d512021-08-30 15:31:08 -07002643sp<IBinder> Surface::getSurfaceControlHandle() const {
2644 Mutex::Autolock lock(mMutex);
2645 return mSurfaceControlHandle;
2646}
2647
2648void Surface::destroy() {
2649 Mutex::Autolock lock(mMutex);
2650 mSurfaceControlHandle = nullptr;
2651}
2652
chaviw5b4b29b2022-06-06 15:35:15 -05002653const char* Surface::getDebugName() {
2654 std::unique_lock lock{mNameMutex};
2655 if (mName.empty()) {
2656 mName = getConsumerName();
2657 }
2658 return mName.c_str();
2659}
2660
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002661}; // namespace android