blob: 86e4f5d773d17998f0950faf58a9ae1c4fa2acd5 [file] [log] [blame]
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001/* Copyright 2016 The Android Open Source Project
2 *
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16//#define LOG_NDEBUG 0
17#define LOG_TAG "SurfaceReplayer"
18
19#include "Replayer.h"
20
21#include <android/native_window.h>
22
Colin Cross63549382016-10-26 12:52:53 -070023#include <android-base/file.h>
24
Sahil Dhanju01041fe2016-08-08 20:27:23 -070025#include <gui/BufferQueue.h>
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070026#include <gui/ISurfaceComposer.h>
Robert Carr4cdc58f2017-08-23 14:22:20 -070027#include <gui/LayerState.h>
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070028#include <gui/Surface.h>
29#include <private/gui/ComposerService.h>
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070030
31#include <ui/DisplayInfo.h>
32#include <utils/Log.h>
33#include <utils/String8.h>
34#include <utils/Trace.h>
35
36#include <chrono>
37#include <cmath>
38#include <condition_variable>
39#include <cstdlib>
40#include <fstream>
41#include <functional>
42#include <iostream>
43#include <mutex>
Sahil Dhanju01041fe2016-08-08 20:27:23 -070044#include <sstream>
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070045#include <string>
46#include <thread>
Sahil Dhanju01041fe2016-08-08 20:27:23 -070047#include <vector>
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070048
49using namespace android;
50
51std::atomic_bool Replayer::sReplayingManually(false);
52
Sahil Dhanju01041fe2016-08-08 20:27:23 -070053Replayer::Replayer(const std::string& filename, bool replayManually, int numThreads, bool wait,
54 nsecs_t stopHere)
55 : mTrace(),
56 mLoaded(false),
57 mIncrementIndex(0),
58 mCurrentTime(0),
59 mNumThreads(numThreads),
60 mWaitForTimeStamps(wait),
61 mStopTimeStamp(stopHere) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070062 srand(RAND_COLOR_SEED);
63
Colin Cross63549382016-10-26 12:52:53 -070064 std::string input;
65 if (!android::base::ReadFileToString(filename, &input, true)) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070066 std::cerr << "Trace did not load. Does " << filename << " exist?" << std::endl;
67 abort();
68 }
69
Colin Cross63549382016-10-26 12:52:53 -070070 mLoaded = mTrace.ParseFromString(input);
71 if (!mLoaded) {
72 std::cerr << "Trace did not load." << std::endl;
73 abort();
74 }
75
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070076 mCurrentTime = mTrace.increment(0).time_stamp();
77
78 sReplayingManually.store(replayManually);
Sahil Dhanju01041fe2016-08-08 20:27:23 -070079
80 if (stopHere < 0) {
81 mHasStopped = true;
82 }
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070083}
84
Sahil Dhanju01041fe2016-08-08 20:27:23 -070085Replayer::Replayer(const Trace& t, bool replayManually, int numThreads, bool wait, nsecs_t stopHere)
86 : mTrace(t),
87 mLoaded(true),
88 mIncrementIndex(0),
89 mCurrentTime(0),
90 mNumThreads(numThreads),
91 mWaitForTimeStamps(wait),
92 mStopTimeStamp(stopHere) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070093 srand(RAND_COLOR_SEED);
94 mCurrentTime = mTrace.increment(0).time_stamp();
95
96 sReplayingManually.store(replayManually);
Sahil Dhanju01041fe2016-08-08 20:27:23 -070097
98 if (stopHere < 0) {
99 mHasStopped = true;
100 }
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700101}
102
103status_t Replayer::replay() {
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700104 signal(SIGINT, Replayer::stopAutoReplayHandler); //for manual control
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700105
106 ALOGV("There are %d increments.", mTrace.increment_size());
107
108 status_t status = loadSurfaceComposerClient();
109
110 if (status != NO_ERROR) {
111 ALOGE("Couldn't create SurfaceComposerClient (%d)", status);
112 return status;
113 }
114
115 SurfaceComposerClient::enableVSyncInjections(true);
116
117 initReplay();
118
119 ALOGV("Starting actual Replay!");
120 while (!mPendingIncrements.empty()) {
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700121 mCurrentIncrement = mTrace.increment(mIncrementIndex);
122
123 if (mHasStopped == false && mCurrentIncrement.time_stamp() >= mStopTimeStamp) {
124 mHasStopped = true;
125 sReplayingManually.store(true);
126 }
127
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700128 waitForConsoleCommmand();
129
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700130 if (mWaitForTimeStamps) {
131 waitUntilTimestamp(mCurrentIncrement.time_stamp());
132 }
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700133
134 auto event = mPendingIncrements.front();
135 mPendingIncrements.pop();
136
137 event->complete();
138
139 if (event->getIncrementType() == Increment::kVsyncEvent) {
140 mWaitingForNextVSync = false;
141 }
142
143 if (mIncrementIndex + mNumThreads < mTrace.increment_size()) {
144 status = dispatchEvent(mIncrementIndex + mNumThreads);
145
146 if (status != NO_ERROR) {
147 SurfaceComposerClient::enableVSyncInjections(false);
148 return status;
149 }
150 }
151
152 mIncrementIndex++;
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700153 mCurrentTime = mCurrentIncrement.time_stamp();
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700154 }
155
156 SurfaceComposerClient::enableVSyncInjections(false);
157
158 return status;
159}
160
161status_t Replayer::initReplay() {
162 for (int i = 0; i < mNumThreads && i < mTrace.increment_size(); i++) {
163 status_t status = dispatchEvent(i);
164
165 if (status != NO_ERROR) {
166 ALOGE("Unable to dispatch event (%d)", status);
167 return status;
168 }
169 }
170
171 return NO_ERROR;
172}
173
174void Replayer::stopAutoReplayHandler(int /*signal*/) {
175 if (sReplayingManually) {
176 SurfaceComposerClient::enableVSyncInjections(false);
177 exit(0);
178 }
179
180 sReplayingManually.store(true);
181}
182
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700183std::vector<std::string> split(const std::string& s, const char delim) {
184 std::vector<std::string> elems;
185 std::stringstream ss(s);
186 std::string item;
187 while (getline(ss, item, delim)) {
188 elems.push_back(item);
189 }
190 return elems;
191}
192
193bool isNumber(const std::string& s) {
194 return !s.empty() &&
195 std::find_if(s.begin(), s.end(), [](char c) { return !std::isdigit(c); }) == s.end();
196}
197
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700198void Replayer::waitForConsoleCommmand() {
199 if (!sReplayingManually || mWaitingForNextVSync) {
200 return;
201 }
202
203 while (true) {
204 std::string input = "";
205 std::cout << "> ";
206 getline(std::cin, input);
207
208 if (input.empty()) {
209 input = mLastInput;
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700210 } else {
211 mLastInput = input;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700212 }
213
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700214 if (mLastInput.empty()) {
215 continue;
216 }
217
218 std::vector<std::string> inputs = split(input, ' ');
219
220 if (inputs[0] == "n") { // next vsync
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700221 mWaitingForNextVSync = true;
222 break;
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700223
224 } else if (inputs[0] == "ni") { // next increment
225 break;
226
227 } else if (inputs[0] == "c") { // continue
228 if (inputs.size() > 1 && isNumber(inputs[1])) {
229 long milliseconds = stoi(inputs[1]);
230 std::thread([&] {
231 std::cout << "Started!" << std::endl;
232 std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
233 sReplayingManually.store(true);
234 std::cout << "Should have stopped!" << std::endl;
235 }).detach();
236 }
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700237 sReplayingManually.store(false);
238 mWaitingForNextVSync = false;
239 break;
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700240
241 } else if (inputs[0] == "s") { // stop at this timestamp
242 if (inputs.size() < 1) {
243 std::cout << "No time stamp given" << std::endl;
244 continue;
245 }
246 sReplayingManually.store(false);
247 mStopTimeStamp = stol(inputs[1]);
248 mHasStopped = false;
249 break;
250 } else if (inputs[0] == "l") { // list
251 std::cout << "Time stamp: " << mCurrentIncrement.time_stamp() << "\n";
252 continue;
253 } else if (inputs[0] == "q") { // quit
254 SurfaceComposerClient::enableVSyncInjections(false);
255 exit(0);
256
257 } else if (inputs[0] == "h") { // help
258 // add help menu
259 std::cout << "Manual Replay options:\n";
260 std::cout << " n - Go to next VSync\n";
261 std::cout << " ni - Go to next increment\n";
262 std::cout << " c - Continue\n";
263 std::cout << " c [milliseconds] - Continue until specified number of milliseconds\n";
264 std::cout << " s [timestamp] - Continue and stop at specified timestamp\n";
265 std::cout << " l - List out timestamp of current increment\n";
266 std::cout << " h - Display help menu\n";
267 std::cout << std::endl;
268 continue;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700269 }
270
271 std::cout << "Invalid Command" << std::endl;
272 }
273}
274
275status_t Replayer::dispatchEvent(int index) {
276 auto increment = mTrace.increment(index);
277 std::shared_ptr<Event> event = std::make_shared<Event>(increment.increment_case());
278 mPendingIncrements.push(event);
279
280 status_t status = NO_ERROR;
281 switch (increment.increment_case()) {
282 case increment.kTransaction: {
283 std::thread(&Replayer::doTransaction, this, increment.transaction(), event).detach();
284 } break;
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700285 case increment.kSurfaceCreation: {
286 std::thread(&Replayer::createSurfaceControl, this, increment.surface_creation(), event)
287 .detach();
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700288 } break;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700289 case increment.kBufferUpdate: {
290 std::lock_guard<std::mutex> lock1(mLayerLock);
291 std::lock_guard<std::mutex> lock2(mBufferQueueSchedulerLock);
292
293 Dimensions dimensions(increment.buffer_update().w(), increment.buffer_update().h());
294 BufferEvent bufferEvent(event, dimensions);
295
296 auto layerId = increment.buffer_update().id();
297 if (mBufferQueueSchedulers.count(layerId) == 0) {
298 mBufferQueueSchedulers[layerId] = std::make_shared<BufferQueueScheduler>(
299 mLayers[layerId], mColors[layerId], layerId);
300 mBufferQueueSchedulers[layerId]->addEvent(bufferEvent);
301
302 std::thread(&BufferQueueScheduler::startScheduling,
303 mBufferQueueSchedulers[increment.buffer_update().id()].get())
304 .detach();
305 } else {
306 auto bqs = mBufferQueueSchedulers[increment.buffer_update().id()];
307 bqs->addEvent(bufferEvent);
308 }
309 } break;
310 case increment.kVsyncEvent: {
311 std::thread(&Replayer::injectVSyncEvent, this, increment.vsync_event(), event).detach();
312 } break;
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700313 case increment.kDisplayCreation: {
314 std::thread(&Replayer::createDisplay, this, increment.display_creation(), event)
315 .detach();
316 } break;
317 case increment.kDisplayDeletion: {
318 std::thread(&Replayer::deleteDisplay, this, increment.display_deletion(), event)
319 .detach();
320 } break;
321 case increment.kPowerModeUpdate: {
322 std::thread(&Replayer::updatePowerMode, this, increment.power_mode_update(), event)
323 .detach();
324 } break;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700325 default:
326 ALOGE("Unknown Increment Type: %d", increment.increment_case());
327 status = BAD_VALUE;
328 break;
329 }
330
331 return status;
332}
333
334status_t Replayer::doTransaction(const Transaction& t, const std::shared_ptr<Event>& event) {
335 ALOGV("Started Transaction");
336
Robert Carr4cdc58f2017-08-23 14:22:20 -0700337 SurfaceComposerClient::Transaction liveTransaction;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700338
339 status_t status = NO_ERROR;
340
Robert Carr4cdc58f2017-08-23 14:22:20 -0700341 status = doSurfaceTransaction(liveTransaction, t.surface_change());
342 doDisplayTransaction(liveTransaction, t.display_change());
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700343
344 if (t.animation()) {
Robert Carr4cdc58f2017-08-23 14:22:20 -0700345 liveTransaction.setAnimationTransaction();
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700346 }
347
348 event->readyToExecute();
349
Robert Carr4cdc58f2017-08-23 14:22:20 -0700350 liveTransaction.apply(t.synchronous());
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700351
352 ALOGV("Ended Transaction");
353
354 return status;
355}
356
Robert Carr4cdc58f2017-08-23 14:22:20 -0700357status_t Replayer::doSurfaceTransaction(
358 SurfaceComposerClient::Transaction& transaction,
359 const SurfaceChanges& surfaceChanges) {
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700360 status_t status = NO_ERROR;
361
362 for (const SurfaceChange& change : surfaceChanges) {
363 std::unique_lock<std::mutex> lock(mLayerLock);
364 if (mLayers[change.id()] == nullptr) {
365 mLayerCond.wait(lock, [&] { return (mLayers[change.id()] != nullptr); });
366 }
367
368 switch (change.SurfaceChange_case()) {
369 case SurfaceChange::SurfaceChangeCase::kPosition:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700370 setPosition(transaction, change.id(), change.position());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700371 break;
372 case SurfaceChange::SurfaceChangeCase::kSize:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700373 setSize(transaction, change.id(), change.size());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700374 break;
375 case SurfaceChange::SurfaceChangeCase::kAlpha:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700376 setAlpha(transaction, change.id(), change.alpha());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700377 break;
378 case SurfaceChange::SurfaceChangeCase::kLayer:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700379 setLayer(transaction, change.id(), change.layer());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700380 break;
381 case SurfaceChange::SurfaceChangeCase::kCrop:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700382 setCrop(transaction, change.id(), change.crop());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700383 break;
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700384 case SurfaceChange::SurfaceChangeCase::kCornerRadius:
385 setCornerRadius(transaction, change.id(), change.corner_radius());
386 break;
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700387 case SurfaceChange::SurfaceChangeCase::kMatrix:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700388 setMatrix(transaction, change.id(), change.matrix());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700389 break;
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700390 case SurfaceChange::SurfaceChangeCase::kOverrideScalingMode:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700391 setOverrideScalingMode(transaction, change.id(),
392 change.override_scaling_mode());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700393 break;
394 case SurfaceChange::SurfaceChangeCase::kTransparentRegionHint:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700395 setTransparentRegionHint(transaction, change.id(),
396 change.transparent_region_hint());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700397 break;
398 case SurfaceChange::SurfaceChangeCase::kLayerStack:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700399 setLayerStack(transaction, change.id(), change.layer_stack());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700400 break;
401 case SurfaceChange::SurfaceChangeCase::kHiddenFlag:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700402 setHiddenFlag(transaction, change.id(), change.hidden_flag());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700403 break;
404 case SurfaceChange::SurfaceChangeCase::kOpaqueFlag:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700405 setOpaqueFlag(transaction, change.id(), change.opaque_flag());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700406 break;
407 case SurfaceChange::SurfaceChangeCase::kSecureFlag:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700408 setSecureFlag(transaction, change.id(), change.secure_flag());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700409 break;
410 case SurfaceChange::SurfaceChangeCase::kDeferredTransaction:
411 waitUntilDeferredTransactionLayerExists(change.deferred_transaction(), lock);
Robert Carr4cdc58f2017-08-23 14:22:20 -0700412 setDeferredTransaction(transaction, change.id(),
413 change.deferred_transaction());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700414 break;
Vishnu Nair456bbb22019-07-18 16:02:00 -0700415 case SurfaceChange::SurfaceChangeCase::kReparent:
416 setReparentChange(transaction, change.id(), change.reparent());
417 break;
418 case SurfaceChange::SurfaceChangeCase::kReparentChildren:
419 setReparentChildrenChange(transaction, change.id(), change.reparent_children());
420 break;
421 case SurfaceChange::SurfaceChangeCase::kRelativeParent:
422 setRelativeParentChange(transaction, change.id(), change.relative_parent());
423 break;
424 case SurfaceChange::SurfaceChangeCase::kDetachChildren:
425 setDetachChildrenChange(transaction, change.id(), change.detach_children());
426 break;
Vishnu Nair95a1ed42019-12-06 12:25:11 -0800427 case SurfaceChange::SurfaceChangeCase::kShadowRadius:
428 setShadowRadiusChange(transaction, change.id(), change.shadow_radius());
429 break;
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700430 default:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700431 status = 1;
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700432 break;
433 }
434
435 if (status != NO_ERROR) {
Robert Carr4cdc58f2017-08-23 14:22:20 -0700436 ALOGE("Unknown Transaction Code");
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700437 return status;
438 }
439 }
440 return status;
441}
442
Robert Carr4cdc58f2017-08-23 14:22:20 -0700443void Replayer::doDisplayTransaction(SurfaceComposerClient::Transaction& t,
444 const DisplayChanges& displayChanges) {
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700445 for (const DisplayChange& change : displayChanges) {
446 ALOGV("Doing display transaction");
447 std::unique_lock<std::mutex> lock(mDisplayLock);
448 if (mDisplays[change.id()] == nullptr) {
449 mDisplayCond.wait(lock, [&] { return (mDisplays[change.id()] != nullptr); });
450 }
451
452 switch (change.DisplayChange_case()) {
453 case DisplayChange::DisplayChangeCase::kSurface:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700454 setDisplaySurface(t, change.id(), change.surface());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700455 break;
456 case DisplayChange::DisplayChangeCase::kLayerStack:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700457 setDisplayLayerStack(t, change.id(), change.layer_stack());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700458 break;
459 case DisplayChange::DisplayChangeCase::kSize:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700460 setDisplaySize(t, change.id(), change.size());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700461 break;
462 case DisplayChange::DisplayChangeCase::kProjection:
Robert Carr4cdc58f2017-08-23 14:22:20 -0700463 setDisplayProjection(t, change.id(), change.projection());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700464 break;
465 default:
466 break;
467 }
468 }
469}
470
Robert Carr4cdc58f2017-08-23 14:22:20 -0700471void Replayer::setPosition(SurfaceComposerClient::Transaction& t,
472 layer_id id, const PositionChange& pc) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700473 ALOGV("Layer %d: Setting Position -- x=%f, y=%f", id, pc.x(), pc.y());
Robert Carr4cdc58f2017-08-23 14:22:20 -0700474 t.setPosition(mLayers[id], pc.x(), pc.y());
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700475}
476
Robert Carr4cdc58f2017-08-23 14:22:20 -0700477void Replayer::setSize(SurfaceComposerClient::Transaction& t,
478 layer_id id, const SizeChange& sc) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700479 ALOGV("Layer %d: Setting Size -- w=%u, h=%u", id, sc.w(), sc.h());
Robert Carr4cdc58f2017-08-23 14:22:20 -0700480 t.setSize(mLayers[id], sc.w(), sc.h());
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700481}
482
Robert Carr4cdc58f2017-08-23 14:22:20 -0700483void Replayer::setLayer(SurfaceComposerClient::Transaction& t,
484 layer_id id, const LayerChange& lc) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700485 ALOGV("Layer %d: Setting Layer -- layer=%d", id, lc.layer());
Robert Carr4cdc58f2017-08-23 14:22:20 -0700486 t.setLayer(mLayers[id], lc.layer());
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700487}
488
Robert Carr4cdc58f2017-08-23 14:22:20 -0700489void Replayer::setAlpha(SurfaceComposerClient::Transaction& t,
490 layer_id id, const AlphaChange& ac) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700491 ALOGV("Layer %d: Setting Alpha -- alpha=%f", id, ac.alpha());
Robert Carr4cdc58f2017-08-23 14:22:20 -0700492 t.setAlpha(mLayers[id], ac.alpha());
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700493}
494
Robert Carr4cdc58f2017-08-23 14:22:20 -0700495void Replayer::setCrop(SurfaceComposerClient::Transaction& t,
496 layer_id id, const CropChange& cc) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700497 ALOGV("Layer %d: Setting Crop -- left=%d, top=%d, right=%d, bottom=%d", id,
498 cc.rectangle().left(), cc.rectangle().top(), cc.rectangle().right(),
499 cc.rectangle().bottom());
500
501 Rect r = Rect(cc.rectangle().left(), cc.rectangle().top(), cc.rectangle().right(),
502 cc.rectangle().bottom());
Marissa Wallf58c14b2018-07-24 10:50:43 -0700503 t.setCrop_legacy(mLayers[id], r);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700504}
505
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700506void Replayer::setCornerRadius(SurfaceComposerClient::Transaction& t,
507 layer_id id, const CornerRadiusChange& cc) {
508 ALOGV("Layer %d: Setting Corner Radius -- cornerRadius=%d", id, cc.corner_radius());
509
510 t.setCornerRadius(mLayers[id], cc.corner_radius());
511}
512
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800513void Replayer::setBackgroundBlurRadius(SurfaceComposerClient::Transaction& t,
514 layer_id id, const BackgroundBlurRadiusChange& cc) {
515 ALOGV("Layer %d: Setting Background Blur Radius -- backgroundBlurRadius=%d", id,
516 cc.background_blur_radius());
517
518 t.setBackgroundBlurRadius(mLayers[id], cc.background_blur_radius());
519}
520
Robert Carr4cdc58f2017-08-23 14:22:20 -0700521void Replayer::setMatrix(SurfaceComposerClient::Transaction& t,
522 layer_id id, const MatrixChange& mc) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700523 ALOGV("Layer %d: Setting Matrix -- dsdx=%f, dtdx=%f, dsdy=%f, dtdy=%f", id, mc.dsdx(),
524 mc.dtdx(), mc.dsdy(), mc.dtdy());
Robert Carr4cdc58f2017-08-23 14:22:20 -0700525 t.setMatrix(mLayers[id], mc.dsdx(), mc.dtdx(), mc.dsdy(), mc.dtdy());
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700526}
527
Robert Carr4cdc58f2017-08-23 14:22:20 -0700528void Replayer::setOverrideScalingMode(SurfaceComposerClient::Transaction& t,
529 layer_id id, const OverrideScalingModeChange& osmc) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700530 ALOGV("Layer %d: Setting Override Scaling Mode -- mode=%d", id, osmc.override_scaling_mode());
Robert Carr4cdc58f2017-08-23 14:22:20 -0700531 t.setOverrideScalingMode(mLayers[id], osmc.override_scaling_mode());
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700532}
533
Robert Carr4cdc58f2017-08-23 14:22:20 -0700534void Replayer::setTransparentRegionHint(SurfaceComposerClient::Transaction& t,
535 layer_id id, const TransparentRegionHintChange& trhc) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700536 ALOGV("Setting Transparent Region Hint");
537 Region re = Region();
538
Chih-Hung Hsiehcb057c22017-08-03 15:48:25 -0700539 for (const auto& r : trhc.region()) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700540 Rect rect = Rect(r.left(), r.top(), r.right(), r.bottom());
541 re.merge(rect);
542 }
543
Robert Carr4cdc58f2017-08-23 14:22:20 -0700544 t.setTransparentRegionHint(mLayers[id], re);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700545}
546
Robert Carr4cdc58f2017-08-23 14:22:20 -0700547void Replayer::setLayerStack(SurfaceComposerClient::Transaction& t,
548 layer_id id, const LayerStackChange& lsc) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700549 ALOGV("Layer %d: Setting LayerStack -- layer_stack=%d", id, lsc.layer_stack());
Robert Carr4cdc58f2017-08-23 14:22:20 -0700550 t.setLayerStack(mLayers[id], lsc.layer_stack());
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700551}
552
Robert Carr4cdc58f2017-08-23 14:22:20 -0700553void Replayer::setHiddenFlag(SurfaceComposerClient::Transaction& t,
554 layer_id id, const HiddenFlagChange& hfc) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700555 ALOGV("Layer %d: Setting Hidden Flag -- hidden_flag=%d", id, hfc.hidden_flag());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700556 layer_id flag = hfc.hidden_flag() ? layer_state_t::eLayerHidden : 0;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700557
Robert Carr4cdc58f2017-08-23 14:22:20 -0700558 t.setFlags(mLayers[id], flag, layer_state_t::eLayerHidden);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700559}
560
Robert Carr4cdc58f2017-08-23 14:22:20 -0700561void Replayer::setOpaqueFlag(SurfaceComposerClient::Transaction& t,
562 layer_id id, const OpaqueFlagChange& ofc) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700563 ALOGV("Layer %d: Setting Opaque Flag -- opaque_flag=%d", id, ofc.opaque_flag());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700564 layer_id flag = ofc.opaque_flag() ? layer_state_t::eLayerOpaque : 0;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700565
Robert Carr4cdc58f2017-08-23 14:22:20 -0700566 t.setFlags(mLayers[id], flag, layer_state_t::eLayerOpaque);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700567}
568
Robert Carr4cdc58f2017-08-23 14:22:20 -0700569void Replayer::setSecureFlag(SurfaceComposerClient::Transaction& t,
570 layer_id id, const SecureFlagChange& sfc) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700571 ALOGV("Layer %d: Setting Secure Flag -- secure_flag=%d", id, sfc.secure_flag());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700572 layer_id flag = sfc.secure_flag() ? layer_state_t::eLayerSecure : 0;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700573
Robert Carr4cdc58f2017-08-23 14:22:20 -0700574 t.setFlags(mLayers[id], flag, layer_state_t::eLayerSecure);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700575}
576
Robert Carr4cdc58f2017-08-23 14:22:20 -0700577void Replayer::setDeferredTransaction(SurfaceComposerClient::Transaction& t,
578 layer_id id, const DeferredTransactionChange& dtc) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700579 ALOGV("Layer %d: Setting Deferred Transaction -- layer_id=%d, "
580 "frame_number=%llu",
581 id, dtc.layer_id(), dtc.frame_number());
582 if (mLayers.count(dtc.layer_id()) == 0 || mLayers[dtc.layer_id()] == nullptr) {
583 ALOGE("Layer %d not found in Deferred Transaction", dtc.layer_id());
Robert Carr4cdc58f2017-08-23 14:22:20 -0700584 return;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700585 }
586
Pablo Gamito11dcc222020-09-12 15:49:39 +0000587 t.deferTransactionUntil_legacy(mLayers[id], mLayers[dtc.layer_id()], dtc.frame_number());
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700588}
589
Robert Carr4cdc58f2017-08-23 14:22:20 -0700590void Replayer::setDisplaySurface(SurfaceComposerClient::Transaction& t,
591 display_id id, const DispSurfaceChange& /*dsc*/) {
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700592 sp<IGraphicBufferProducer> outProducer;
593 sp<IGraphicBufferConsumer> outConsumer;
594 BufferQueue::createBufferQueue(&outProducer, &outConsumer);
595
Robert Carr4cdc58f2017-08-23 14:22:20 -0700596 t.setDisplaySurface(mDisplays[id], outProducer);
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700597}
598
Robert Carr4cdc58f2017-08-23 14:22:20 -0700599void Replayer::setDisplayLayerStack(SurfaceComposerClient::Transaction& t,
600 display_id id, const LayerStackChange& lsc) {
601 t.setDisplayLayerStack(mDisplays[id], lsc.layer_stack());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700602}
603
Robert Carr4cdc58f2017-08-23 14:22:20 -0700604void Replayer::setDisplaySize(SurfaceComposerClient::Transaction& t,
605 display_id id, const SizeChange& sc) {
606 t.setDisplaySize(mDisplays[id], sc.w(), sc.h());
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700607}
608
Robert Carr4cdc58f2017-08-23 14:22:20 -0700609void Replayer::setDisplayProjection(SurfaceComposerClient::Transaction& t,
610 display_id id, const ProjectionChange& pc) {
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700611 Rect viewport = Rect(pc.viewport().left(), pc.viewport().top(), pc.viewport().right(),
612 pc.viewport().bottom());
613 Rect frame = Rect(pc.frame().left(), pc.frame().top(), pc.frame().right(), pc.frame().bottom());
614
Dominik Laskowski718f9602019-11-09 20:01:35 -0800615 t.setDisplayProjection(mDisplays[id], ui::toRotation(pc.orientation()), viewport, frame);
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700616}
617
618status_t Replayer::createSurfaceControl(
619 const SurfaceCreation& create, const std::shared_ptr<Event>& event) {
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700620 event->readyToExecute();
621
622 ALOGV("Creating Surface Control: ID: %d", create.id());
623 sp<SurfaceControl> surfaceControl = mComposerClient->createSurface(
624 String8(create.name().c_str()), create.w(), create.h(), PIXEL_FORMAT_RGBA_8888, 0);
625
626 if (surfaceControl == nullptr) {
627 ALOGE("CreateSurfaceControl: unable to create surface control");
628 return BAD_VALUE;
629 }
630
631 std::lock_guard<std::mutex> lock1(mLayerLock);
632 auto& layer = mLayers[create.id()];
633 layer = surfaceControl;
634
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700635 mColors[create.id()] = HSV(rand() % 360, 1, 1);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700636
637 mLayerCond.notify_all();
638
639 std::lock_guard<std::mutex> lock2(mBufferQueueSchedulerLock);
640 if (mBufferQueueSchedulers.count(create.id()) != 0) {
641 mBufferQueueSchedulers[create.id()]->setSurfaceControl(
642 mLayers[create.id()], mColors[create.id()]);
643 }
644
645 return NO_ERROR;
646}
647
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700648status_t Replayer::injectVSyncEvent(
649 const VSyncEvent& vSyncEvent, const std::shared_ptr<Event>& event) {
650 ALOGV("Injecting VSync Event");
651
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700652 event->readyToExecute();
653
654 SurfaceComposerClient::injectVSync(vSyncEvent.when());
655
656 return NO_ERROR;
657}
658
Sahil Dhanju01041fe2016-08-08 20:27:23 -0700659void Replayer::createDisplay(const DisplayCreation& create, const std::shared_ptr<Event>& event) {
660 ALOGV("Creating display");
661 event->readyToExecute();
662
663 std::lock_guard<std::mutex> lock(mDisplayLock);
664 sp<IBinder> display = SurfaceComposerClient::createDisplay(
665 String8(create.name().c_str()), create.is_secure());
666 mDisplays[create.id()] = display;
667
668 mDisplayCond.notify_all();
669
670 ALOGV("Done creating display");
671}
672
673void Replayer::deleteDisplay(const DisplayDeletion& delete_, const std::shared_ptr<Event>& event) {
674 ALOGV("Delete display");
675 event->readyToExecute();
676
677 std::lock_guard<std::mutex> lock(mDisplayLock);
678 SurfaceComposerClient::destroyDisplay(mDisplays[delete_.id()]);
679 mDisplays.erase(delete_.id());
680}
681
682void Replayer::updatePowerMode(const PowerModeUpdate& pmu, const std::shared_ptr<Event>& event) {
683 ALOGV("Updating power mode");
684 event->readyToExecute();
685 SurfaceComposerClient::setDisplayPowerMode(mDisplays[pmu.id()], pmu.mode());
686}
687
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700688void Replayer::waitUntilTimestamp(int64_t timestamp) {
689 ALOGV("Waiting for %lld nanoseconds...", static_cast<int64_t>(timestamp - mCurrentTime));
690 std::this_thread::sleep_for(std::chrono::nanoseconds(timestamp - mCurrentTime));
691}
692
693void Replayer::waitUntilDeferredTransactionLayerExists(
694 const DeferredTransactionChange& dtc, std::unique_lock<std::mutex>& lock) {
695 if (mLayers.count(dtc.layer_id()) == 0 || mLayers[dtc.layer_id()] == nullptr) {
696 mLayerCond.wait(lock, [&] { return (mLayers[dtc.layer_id()] != nullptr); });
697 }
698}
699
700status_t Replayer::loadSurfaceComposerClient() {
701 mComposerClient = new SurfaceComposerClient;
702 return mComposerClient->initCheck();
703}
Vishnu Nair456bbb22019-07-18 16:02:00 -0700704
705void Replayer::setReparentChange(SurfaceComposerClient::Transaction& t,
706 layer_id id, const ReparentChange& c) {
Pablo Gamito11dcc222020-09-12 15:49:39 +0000707 sp<SurfaceControl> newSurfaceControl = nullptr;
Vishnu Nair456bbb22019-07-18 16:02:00 -0700708 if (mLayers.count(c.parent_id()) != 0 && mLayers[c.parent_id()] != nullptr) {
Pablo Gamito11dcc222020-09-12 15:49:39 +0000709 newSurfaceControl = mLayers[c.parent_id()];
Vishnu Nair456bbb22019-07-18 16:02:00 -0700710 }
Pablo Gamito11dcc222020-09-12 15:49:39 +0000711 t.reparent(mLayers[id], newSurfaceControl);
Vishnu Nair456bbb22019-07-18 16:02:00 -0700712}
713
714void Replayer::setRelativeParentChange(SurfaceComposerClient::Transaction& t,
715 layer_id id, const RelativeParentChange& c) {
716 if (mLayers.count(c.relative_parent_id()) == 0 || mLayers[c.relative_parent_id()] == nullptr) {
717 ALOGE("Layer %d not found in set relative parent transaction", c.relative_parent_id());
718 return;
719 }
Pablo Gamito11dcc222020-09-12 15:49:39 +0000720 t.setRelativeLayer(mLayers[id], mLayers[c.relative_parent_id()], c.z());
Vishnu Nair456bbb22019-07-18 16:02:00 -0700721}
722
723void Replayer::setDetachChildrenChange(SurfaceComposerClient::Transaction& t,
724 layer_id id, const DetachChildrenChange& c) {
725 t.detachChildren(mLayers[id]);
726}
727
728void Replayer::setReparentChildrenChange(SurfaceComposerClient::Transaction& t,
729 layer_id id, const ReparentChildrenChange& c) {
730 if (mLayers.count(c.parent_id()) == 0 || mLayers[c.parent_id()] == nullptr) {
731 ALOGE("Layer %d not found in reparent children transaction", c.parent_id());
732 return;
733 }
Pablo Gamito11dcc222020-09-12 15:49:39 +0000734 t.reparentChildren(mLayers[id], mLayers[c.parent_id()]);
Vishnu Nair456bbb22019-07-18 16:02:00 -0700735}
Vishnu Nair95a1ed42019-12-06 12:25:11 -0800736
737void Replayer::setShadowRadiusChange(SurfaceComposerClient::Transaction& t,
738 layer_id id, const ShadowRadiusChange& c) {
739 t.setShadowRadius(mLayers[id], c.radius());
740}