blob: 341ef53b6603c02d2cadada1752e5e7c1bcfa242
1 | /* |
2 | // Copyright (c) 2014 Intel Corporation |
3 | // |
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 | // This file is modified by Amlogic, Inc. 2017.01.17. |
17 | */ |
18 | |
19 | #include <HwcTrace.h> |
20 | #include <Hwcomposer.h> |
21 | #include <Dump.h> |
22 | #include <UeventObserver.h> |
23 | #include <inttypes.h> |
24 | |
25 | namespace android { |
26 | namespace amlogic { |
27 | |
28 | Hwcomposer* Hwcomposer::sInstance(0); |
29 | |
30 | Hwcomposer::Hwcomposer(IPlatFactory *factory) |
31 | : mPlatFactory(factory), |
32 | mVsyncManager(0), |
33 | mInitialized(false) |
34 | { |
35 | CTRACE(); |
36 | |
37 | mDisplayDevices.setCapacity(IDisplayDevice::DEVICE_COUNT); |
38 | mDisplayDevices.clear(); |
39 | } |
40 | |
41 | Hwcomposer::~Hwcomposer() |
42 | { |
43 | CTRACE(); |
44 | deinitialize(); |
45 | } |
46 | |
47 | bool Hwcomposer::initCheck() const { |
48 | return mInitialized; |
49 | } |
50 | |
51 | int32_t Hwcomposer::createVirtualDisplay( |
52 | uint32_t width, |
53 | uint32_t height, |
54 | int32_t* /*android_pixel_format_t*/ format, |
55 | hwc2_display_t* outDisplay) { |
56 | DTRACE("createVirtualDisplay"); |
57 | if (width > 1920 && height > 1080) { |
58 | return HWC2_ERROR_UNSUPPORTED; |
59 | } |
60 | |
61 | IDisplayDevice *device = getDisplayDevice(HWC_DISPLAY_VIRTUAL); |
62 | if (!device) { |
63 | ETRACE("no device found"); |
64 | return HWC2_ERROR_BAD_DISPLAY; |
65 | } |
66 | |
67 | return device->createVirtualDisplay(width, height, format, outDisplay); |
68 | } |
69 | |
70 | int32_t Hwcomposer::destroyVirtualDisplay( |
71 | hwc2_display_t display) { |
72 | DTRACE("destroyVirtualDisplay: %d", (int32_t)display); |
73 | IDisplayDevice *device = getDisplayDevice(HWC_DISPLAY_VIRTUAL); |
74 | if (!device) { |
75 | ETRACE("no device found"); |
76 | return HWC2_ERROR_BAD_DISPLAY; |
77 | } |
78 | |
79 | return device->destroyVirtualDisplay(display); |
80 | |
81 | return HWC2_ERROR_NONE; |
82 | } |
83 | |
84 | void Hwcomposer::dump( |
85 | uint32_t* outSize, |
86 | char* outBuffer) { |
87 | RETURN_VOID_IF_NOT_INIT(); |
88 | |
89 | if (NULL == outBuffer) { |
90 | *outSize = 4096; |
91 | } else { |
92 | Dump d(outBuffer, *outSize); |
93 | |
94 | // dump composer status |
95 | d.append("Hardware Composer state(version: %08x):\n", |
96 | this->common.version & HARDWARE_API_VERSION_2_MAJ_MIN_MASK); |
97 | // dump device status |
98 | for (size_t i= 0; i < mDisplayDevices.size(); i++) { |
99 | IDisplayDevice *device = mDisplayDevices.itemAt(i); |
100 | if (device) |
101 | device->dump(d); |
102 | } |
103 | } |
104 | } |
105 | |
106 | uint32_t Hwcomposer::getMaxVirtualDisplayCount() { |
107 | |
108 | // TODO: we only support 1 virtual display now. |
109 | return 1; |
110 | } |
111 | |
112 | int32_t Hwcomposer::registerCallback( |
113 | int32_t /*hwc2_callback_descriptor_t*/ descriptor, |
114 | hwc2_callback_data_t callbackData, |
115 | hwc2_function_pointer_t pointer) { |
116 | switch (descriptor) { |
117 | // callback functions |
118 | case HWC2_CALLBACK_HOTPLUG: |
119 | hotplug_cb_data = callbackData; |
120 | pfnHotplug = reinterpret_cast<HWC2_PFN_HOTPLUG>(pointer); |
121 | if (pfnHotplug) { |
122 | DTRACE("First primary hotplug, just for now!!"); |
123 | IDisplayDevice *device = getDisplayDevice(HWC_DISPLAY_PRIMARY); |
124 | if (!device) { |
125 | ETRACE("no device found"); |
126 | } |
127 | device->onHotplug(HWC_DISPLAY_PRIMARY, true); |
128 | } |
129 | break; |
130 | case HWC2_CALLBACK_REFRESH: |
131 | refresh_cb_data = callbackData; |
132 | pfnRefresh = reinterpret_cast<HWC2_PFN_REFRESH>(pointer);; |
133 | break; |
134 | case HWC2_CALLBACK_VSYNC: |
135 | vsync_cb_data = callbackData; |
136 | pfnVsync = reinterpret_cast<HWC2_PFN_VSYNC>(pointer);; |
137 | break; |
138 | case HWC2_CALLBACK_INVALID: |
139 | default: |
140 | ETRACE("registerCallback bad parameter: %d", descriptor); |
141 | return HWC2_ERROR_BAD_PARAMETER; |
142 | } |
143 | |
144 | return HWC2_ERROR_NONE; |
145 | } |
146 | |
147 | int32_t Hwcomposer::acceptDisplayChanges( |
148 | hwc2_display_t display) { |
149 | DTRACE("acceptDisplayChanges disp = %d", (int32_t)display); |
150 | |
151 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
152 | if (!device) { |
153 | ETRACE("no device found"); |
154 | return HWC2_ERROR_BAD_DISPLAY; |
155 | } |
156 | |
157 | return device->acceptDisplayChanges(); |
158 | } |
159 | |
160 | int32_t Hwcomposer::createLayer( |
161 | hwc2_display_t display, |
162 | hwc2_layer_t* outLayer) { |
163 | DTRACE("createLayer disp = %d", (int32_t)display); |
164 | |
165 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
166 | if (!device) { |
167 | ETRACE("no device found"); |
168 | return HWC2_ERROR_BAD_DISPLAY; |
169 | } |
170 | |
171 | bool ret = device->createLayer(outLayer); |
172 | if (ret == false) { |
173 | ETRACE("createLayer failed on display = %d", (int32_t)display); |
174 | return HWC2_ERROR_NO_RESOURCES; |
175 | } |
176 | |
177 | return HWC2_ERROR_NONE; |
178 | } |
179 | |
180 | int32_t Hwcomposer::destroyLayer( |
181 | hwc2_display_t display, |
182 | hwc2_layer_t layer) { |
183 | DTRACE("destroyLayer disp = %d, layer = %llu", (int32_t)display, layer); |
184 | |
185 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
186 | if (!device) { |
187 | ETRACE("no device found"); |
188 | return HWC2_ERROR_BAD_DISPLAY; |
189 | } |
190 | |
191 | bool ret = device->destroyLayer(layer); |
192 | if (ret == false) { |
193 | ETRACE("destroyLayer failed on display = %d", (int32_t)display); |
194 | return HWC2_ERROR_BAD_LAYER; |
195 | } |
196 | |
197 | return HWC2_ERROR_NONE; |
198 | } |
199 | |
200 | int32_t Hwcomposer::getActiveConfig( |
201 | hwc2_display_t display, |
202 | hwc2_config_t* outConfig) { |
203 | DTRACE("getActiveConfig disp = %d", (int32_t)display); |
204 | |
205 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
206 | if (!device) { |
207 | ETRACE("no device found"); |
208 | return HWC2_ERROR_BAD_DISPLAY; |
209 | } |
210 | |
211 | return device->getActiveConfig(outConfig); |
212 | } |
213 | |
214 | int32_t Hwcomposer::getChangedCompositionTypes( |
215 | hwc2_display_t display, |
216 | uint32_t* outNumElements, |
217 | hwc2_layer_t* outLayers, |
218 | int32_t* /*hwc2_composition_t*/ outTypes) { |
219 | DTRACE("getChangedCompositionTypes disp = %d", (int32_t)display); |
220 | |
221 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
222 | if (!device) { |
223 | ETRACE("no device found"); |
224 | return HWC2_ERROR_BAD_DISPLAY; |
225 | } |
226 | |
227 | return device->getChangedCompositionTypes(outNumElements, outLayers, outTypes); |
228 | } |
229 | |
230 | int32_t Hwcomposer::getClientTargetSupport( |
231 | hwc2_display_t display, |
232 | uint32_t width, |
233 | uint32_t height, |
234 | int32_t /*android_pixel_format_t*/ format, |
235 | int32_t /*android_dataspace_t*/ dataspace) { |
236 | DTRACE("getClientTargetSupport disp = %d", (int32_t)display); |
237 | |
238 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
239 | if (!device) { |
240 | ETRACE("no device found"); |
241 | return HWC2_ERROR_BAD_DISPLAY; |
242 | } |
243 | |
244 | return device->getClientTargetSupport(width, height, format, dataspace); |
245 | } |
246 | |
247 | int32_t Hwcomposer::getColorModes( |
248 | hwc2_display_t display, |
249 | uint32_t* outNumModes, |
250 | int32_t* /*android_color_mode_t*/ outModes) { |
251 | DTRACE("getColorModes disp = %d", (int32_t)display); |
252 | |
253 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
254 | if (!device) { |
255 | ETRACE("no device found"); |
256 | return HWC2_ERROR_BAD_DISPLAY; |
257 | } |
258 | |
259 | return device->getColorModes(outNumModes, outModes); |
260 | } |
261 | |
262 | int32_t Hwcomposer::getDisplayAttribute( |
263 | hwc2_display_t display, |
264 | hwc2_config_t config, |
265 | int32_t /*hwc2_attribute_t*/ attribute, |
266 | int32_t* outValue) { |
267 | DTRACE("getDisplayAttribute disp = %d", (int32_t)display); |
268 | |
269 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
270 | if (!device) { |
271 | ETRACE("no device found"); |
272 | return HWC2_ERROR_BAD_DISPLAY; |
273 | } |
274 | |
275 | return device->getDisplayAttribute(config, attribute, outValue); |
276 | } |
277 | |
278 | int32_t Hwcomposer::getDisplayConfigs( |
279 | hwc2_display_t display, |
280 | uint32_t* outNumConfigs, |
281 | hwc2_config_t* outConfigs) { |
282 | DTRACE("getDisplayConfigs disp = %d", (int32_t)display); |
283 | |
284 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
285 | if (!device) { |
286 | ETRACE("no device found"); |
287 | return HWC2_ERROR_BAD_DISPLAY; |
288 | } |
289 | |
290 | return device->getDisplayConfigs(outNumConfigs, outConfigs); |
291 | } |
292 | |
293 | int32_t Hwcomposer::getDisplayName( |
294 | hwc2_display_t display, |
295 | uint32_t* outSize, |
296 | char* outName) { |
297 | DTRACE("getDisplayName disp = %d", (int32_t)display); |
298 | |
299 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
300 | if (!device) { |
301 | ETRACE("no device found"); |
302 | return HWC2_ERROR_BAD_DISPLAY; |
303 | } |
304 | |
305 | return device->getDisplayName(outSize, outName); |
306 | } |
307 | |
308 | int32_t Hwcomposer::getDisplayRequests( |
309 | hwc2_display_t display, |
310 | int32_t* /*hwc2_display_request_t*/ outDisplayRequests, |
311 | uint32_t* outNumElements, |
312 | hwc2_layer_t* outLayers, |
313 | int32_t* /*hwc2_layer_request_t*/ outLayerRequests) { |
314 | DTRACE("getDisplayRequests disp = %d", (int32_t)display); |
315 | |
316 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
317 | if (!device) { |
318 | ETRACE("no device found"); |
319 | return HWC2_ERROR_BAD_DISPLAY; |
320 | } |
321 | |
322 | return device->getDisplayRequests(outDisplayRequests, outNumElements, |
323 | outLayers, outLayerRequests); |
324 | } |
325 | |
326 | int32_t Hwcomposer::getDisplayType( |
327 | hwc2_display_t display, |
328 | int32_t* /*hwc2_display_type_t*/ outType) { |
329 | DTRACE("getDisplayType disp = %d", (int32_t)display); |
330 | |
331 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
332 | if (!device) { |
333 | ETRACE("no device found"); |
334 | return HWC2_ERROR_BAD_DISPLAY; |
335 | } |
336 | |
337 | return device->getDisplayType(outType); |
338 | } |
339 | |
340 | int32_t Hwcomposer::getDozeSupport( |
341 | hwc2_display_t display, |
342 | int32_t* outSupport) { |
343 | DTRACE("getDozeSupport disp = %d", (int32_t)display); |
344 | |
345 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
346 | if (!device) { |
347 | ETRACE("no device found"); |
348 | return HWC2_ERROR_BAD_DISPLAY; |
349 | } |
350 | |
351 | return device->getDozeSupport(outSupport); |
352 | } |
353 | |
354 | int32_t Hwcomposer::getHdrCapabilities( |
355 | hwc2_display_t display, |
356 | uint32_t* outNumTypes, |
357 | int32_t* /*android_hdr_t*/ outTypes, |
358 | float* outMaxLuminance, |
359 | float* outMaxAverageLuminance, |
360 | float* outMinLuminance) { |
361 | DTRACE("getHdrCapabilities disp = %d", (int32_t)display); |
362 | |
363 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
364 | if (!device) { |
365 | ETRACE("no device found"); |
366 | return HWC2_ERROR_BAD_DISPLAY; |
367 | } |
368 | |
369 | return device->getHdrCapabilities(outNumTypes, outTypes, outMaxLuminance, |
370 | outMaxAverageLuminance, outMinLuminance); |
371 | } |
372 | |
373 | int32_t Hwcomposer::getReleaseFences( |
374 | hwc2_display_t display, |
375 | uint32_t* outNumElements, |
376 | hwc2_layer_t* outLayers, |
377 | int32_t* outFences) { |
378 | DTRACE("getReleaseFences disp = %d", (int32_t)display); |
379 | |
380 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
381 | if (!device) { |
382 | ETRACE("no device found"); |
383 | return HWC2_ERROR_BAD_DISPLAY; |
384 | } |
385 | |
386 | return device->getReleaseFences(outNumElements, outLayers, outFences); |
387 | } |
388 | |
389 | int32_t Hwcomposer::presentDisplay( |
390 | hwc2_display_t display, |
391 | int32_t* outRetireFence) { |
392 | DTRACE("presentDisplay disp = %d", (int32_t)display); |
393 | |
394 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
395 | if (!device) { |
396 | ETRACE("no device found"); |
397 | return HWC2_ERROR_BAD_DISPLAY; |
398 | } |
399 | |
400 | return device->presentDisplay(outRetireFence); |
401 | } |
402 | |
403 | int32_t Hwcomposer::setActiveConfig( |
404 | hwc2_display_t display, |
405 | hwc2_config_t config) { |
406 | DTRACE("setActiveConfig disp = %d", (int32_t)display); |
407 | |
408 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
409 | if (!device) { |
410 | ETRACE("no device found"); |
411 | return HWC2_ERROR_BAD_DISPLAY; |
412 | } |
413 | |
414 | return device->setActiveConfig(config); |
415 | } |
416 | |
417 | int32_t Hwcomposer::setClientTarget( |
418 | hwc2_display_t display, |
419 | buffer_handle_t target, |
420 | int32_t acquireFence, |
421 | int32_t /*android_dataspace_t*/ dataspace, |
422 | hwc_region_t damage) { |
423 | DTRACE("setClientTarget disp = %d, targetHnd = %" PRIxPTR "," |
424 | "acquireFence = %d, dataspace = %d", (int32_t)display, target, acquireFence, dataspace); |
425 | |
426 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
427 | if (!device) { |
428 | ETRACE("no device found"); |
429 | return HWC2_ERROR_BAD_DISPLAY; |
430 | } |
431 | |
432 | return device->setClientTarget(target, acquireFence, |
433 | dataspace, damage); |
434 | } |
435 | |
436 | int32_t Hwcomposer::setColorMode( |
437 | hwc2_display_t display, |
438 | int32_t /*android_color_mode_t*/ mode) { |
439 | DTRACE("setColorMode disp = %d, mode = %d", (int32_t)display, mode); |
440 | |
441 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
442 | if (!device) { |
443 | ETRACE("no device found"); |
444 | return HWC2_ERROR_BAD_DISPLAY; |
445 | } |
446 | |
447 | return device->setColorMode(mode); |
448 | } |
449 | |
450 | int32_t Hwcomposer::setColorTransform( |
451 | hwc2_display_t display, |
452 | const float* matrix, |
453 | int32_t /*android_color_transform_t*/ hint) { |
454 | DTRACE("setColorTransform disp = %d, hint = %d", (int32_t)display, hint); |
455 | |
456 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
457 | if (!device) { |
458 | ETRACE("no device found"); |
459 | return HWC2_ERROR_BAD_DISPLAY; |
460 | } |
461 | |
462 | return device->setColorTransform(matrix, hint); |
463 | } |
464 | |
465 | int32_t Hwcomposer::setOutputBuffer( |
466 | hwc2_display_t display, |
467 | buffer_handle_t buffer, |
468 | int32_t releaseFence) { |
469 | DTRACE("setOutputBuffer disp = %d, releaseFence = %d", (int32_t)display, releaseFence); |
470 | if (display != HWC_DISPLAY_VIRTUAL) { |
471 | ETRACE("Should be a virtual display: %d", (int32_t)display); |
472 | return HWC2_ERROR_UNSUPPORTED; |
473 | } |
474 | |
475 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
476 | if (!device) { |
477 | ETRACE("no device found"); |
478 | return HWC2_ERROR_BAD_DISPLAY; |
479 | } |
480 | |
481 | return device->setOutputBuffer(buffer, releaseFence); |
482 | } |
483 | |
484 | int32_t Hwcomposer::setPowerMode( |
485 | hwc2_display_t display, |
486 | int32_t /*hwc2_power_mode_t*/ mode) { |
487 | DTRACE("setPowerMode disp = %d, mode = %d", (int32_t)display, mode); |
488 | |
489 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
490 | if (!device) { |
491 | ETRACE("no device found"); |
492 | return HWC2_ERROR_BAD_DISPLAY; |
493 | } |
494 | |
495 | return device->setPowerMode(mode); |
496 | } |
497 | |
498 | int32_t Hwcomposer::setVsyncEnabled( |
499 | hwc2_display_t display, |
500 | int32_t /*hwc2_vsync_t*/ enabled) { |
501 | DTRACE("disp = %d, enabled = %d", (int32_t)display, enabled); |
502 | |
503 | bool vsync_enable = false; |
504 | switch (enabled) { |
505 | case HWC2_VSYNC_ENABLE: |
506 | vsync_enable = true; |
507 | break; |
508 | case HWC2_VSYNC_DISABLE: |
509 | vsync_enable = false; |
510 | break; |
511 | case HWC2_VSYNC_INVALID: |
512 | default: |
513 | ETRACE("setVsyncEnabled bad parameter: %d", enabled); |
514 | return HWC2_ERROR_BAD_PARAMETER; |
515 | } |
516 | |
517 | return mVsyncManager->handleVsyncControl((int32_t)display, vsync_enable); |
518 | } |
519 | |
520 | int32_t Hwcomposer::validateDisplay( |
521 | hwc2_display_t display, |
522 | uint32_t* outNumTypes, |
523 | uint32_t* outNumRequests) { |
524 | DTRACE("validateDisplay disp = %d", (int32_t)display); |
525 | |
526 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
527 | if (!device) { |
528 | ETRACE("no device found"); |
529 | return HWC2_ERROR_BAD_DISPLAY; |
530 | } |
531 | |
532 | return device->validateDisplay(outNumTypes, outNumRequests); |
533 | } |
534 | |
535 | int32_t Hwcomposer::setCursorPosition( |
536 | hwc2_display_t display, |
537 | hwc2_layer_t layer, |
538 | int32_t x, |
539 | int32_t y) { |
540 | DTRACE("setCursorPosition disp = %d", (int32_t)display); |
541 | |
542 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
543 | if (!device) { |
544 | ETRACE("no device found"); |
545 | return HWC2_ERROR_BAD_DISPLAY; |
546 | } |
547 | |
548 | return device->setCursorPosition(layer, x, y); |
549 | } |
550 | |
551 | int32_t Hwcomposer::setLayerBuffer( |
552 | hwc2_display_t display, |
553 | hwc2_layer_t layer, |
554 | buffer_handle_t buffer, |
555 | int32_t acquireFence) { |
556 | HwcLayer* hwcLayer = NULL; |
557 | int32_t err = HWC2_ERROR_NONE; |
558 | DTRACE("setLayerBuffer disp = %d", (int32_t)display); |
559 | |
560 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
561 | if (!device) { |
562 | ETRACE("no device found"); |
563 | return HWC2_ERROR_BAD_DISPLAY; |
564 | } |
565 | |
566 | hwcLayer = device->getLayerById(layer); |
567 | if (hwcLayer) { |
568 | err = hwcLayer->setBuffer(buffer,acquireFence); |
569 | } else { |
570 | ETRACE("bad layer."); |
571 | return HWC2_ERROR_BAD_LAYER; |
572 | } |
573 | |
574 | return err; |
575 | } |
576 | |
577 | int32_t Hwcomposer::setLayerSurfaceDamage( |
578 | hwc2_display_t display, |
579 | hwc2_layer_t layer, |
580 | hwc_region_t damage) { |
581 | HwcLayer* hwcLayer = NULL; |
582 | int32_t err = HWC2_ERROR_NONE; |
583 | DTRACE("setLayerSurfaceDamage disp = %d", (int32_t)display); |
584 | |
585 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
586 | if (!device) { |
587 | ETRACE("no device found"); |
588 | return HWC2_ERROR_BAD_DISPLAY; |
589 | } |
590 | |
591 | hwcLayer = device->getLayerById(layer); |
592 | if (hwcLayer) { |
593 | err = hwcLayer->setSurfaceDamage(damage); |
594 | } else { |
595 | ETRACE("bad layer."); |
596 | return HWC2_ERROR_BAD_LAYER; |
597 | } |
598 | |
599 | return err; |
600 | } |
601 | |
602 | int32_t Hwcomposer::setLayerBlendMode( |
603 | hwc2_display_t display, |
604 | hwc2_layer_t layer, |
605 | int32_t /*hwc2_blend_mode_t*/ mode) { |
606 | HwcLayer* hwcLayer = NULL; |
607 | int32_t err = HWC2_ERROR_NONE; |
608 | DTRACE("setLayerBlendMode disp = %d", (int32_t)display); |
609 | |
610 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
611 | if (!device) { |
612 | ETRACE("no device found"); |
613 | return HWC2_ERROR_BAD_DISPLAY; |
614 | } |
615 | |
616 | hwcLayer = device->getLayerById(layer); |
617 | if (hwcLayer) { |
618 | err = hwcLayer->setBlendMode(mode); |
619 | } else { |
620 | ETRACE("bad layer."); |
621 | return HWC2_ERROR_BAD_LAYER; |
622 | } |
623 | |
624 | return err; |
625 | } |
626 | |
627 | int32_t Hwcomposer::setLayerColor( |
628 | hwc2_display_t display, |
629 | hwc2_layer_t layer, |
630 | hwc_color_t color) { |
631 | HwcLayer* hwcLayer = NULL; |
632 | int32_t err = HWC2_ERROR_NONE; |
633 | DTRACE("setLayerColor disp = %d", (int32_t)display); |
634 | |
635 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
636 | if (!device) { |
637 | ETRACE("no device found"); |
638 | return HWC2_ERROR_BAD_DISPLAY; |
639 | } |
640 | |
641 | hwcLayer = device->getLayerById(layer); |
642 | if (hwcLayer) { |
643 | err = hwcLayer->setColor(color); |
644 | } else { |
645 | ETRACE("bad layer."); |
646 | return HWC2_ERROR_BAD_LAYER; |
647 | } |
648 | |
649 | return err; |
650 | } |
651 | |
652 | int32_t Hwcomposer::setLayerCompositionType( |
653 | hwc2_display_t display, |
654 | hwc2_layer_t layer, |
655 | int32_t /*hwc2_composition_t*/ type) { |
656 | HwcLayer* hwcLayer = NULL; |
657 | int32_t err = HWC2_ERROR_NONE; |
658 | DTRACE("setLayerCompositionType disp = %d", (int32_t)display); |
659 | |
660 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
661 | if (!device) { |
662 | ETRACE("no device found"); |
663 | return HWC2_ERROR_BAD_DISPLAY; |
664 | } |
665 | |
666 | hwcLayer = device->getLayerById(layer); |
667 | if (hwcLayer) { |
668 | err = hwcLayer->setCompositionType(type); |
669 | } else { |
670 | ETRACE("bad layer."); |
671 | return HWC2_ERROR_BAD_LAYER; |
672 | } |
673 | |
674 | return err; |
675 | } |
676 | |
677 | int32_t Hwcomposer::setLayerDataspace( |
678 | hwc2_display_t display, |
679 | hwc2_layer_t layer, |
680 | int32_t /*android_dataspace_t*/ dataspace) { |
681 | HwcLayer* hwcLayer = NULL; |
682 | int32_t err = HWC2_ERROR_NONE; |
683 | DTRACE("setLayerDataspace disp = %d", (int32_t)display); |
684 | |
685 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
686 | if (!device) { |
687 | ETRACE("no device found"); |
688 | return HWC2_ERROR_BAD_DISPLAY; |
689 | } |
690 | |
691 | hwcLayer = device->getLayerById(layer); |
692 | if (hwcLayer) { |
693 | err = hwcLayer->setDataspace(dataspace); |
694 | } else { |
695 | ETRACE("bad layer."); |
696 | return HWC2_ERROR_BAD_LAYER; |
697 | } |
698 | |
699 | return err; |
700 | } |
701 | |
702 | int32_t Hwcomposer::setLayerDisplayFrame( |
703 | hwc2_display_t display, |
704 | hwc2_layer_t layer, |
705 | hwc_rect_t frame) { |
706 | HwcLayer* hwcLayer = NULL; |
707 | int32_t err = HWC2_ERROR_NONE; |
708 | DTRACE("setLayerDisplayFrame disp = %d", (int32_t)display); |
709 | |
710 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
711 | if (!device) { |
712 | ETRACE("no device found"); |
713 | return HWC2_ERROR_BAD_DISPLAY; |
714 | } |
715 | |
716 | hwcLayer = device->getLayerById(layer); |
717 | if (hwcLayer) { |
718 | err = hwcLayer->setDisplayFrame(frame); |
719 | } else { |
720 | ETRACE("bad layer."); |
721 | return HWC2_ERROR_BAD_LAYER; |
722 | } |
723 | |
724 | return err; |
725 | } |
726 | |
727 | int32_t Hwcomposer::setLayerPlaneAlpha( |
728 | hwc2_display_t display, |
729 | hwc2_layer_t layer, |
730 | float alpha) { |
731 | HwcLayer* hwcLayer = NULL; |
732 | int32_t err = HWC2_ERROR_NONE; |
733 | DTRACE("setLayerPlaneAlpha disp = %d", (int32_t)display); |
734 | |
735 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
736 | if (!device) { |
737 | ETRACE("no device found"); |
738 | return HWC2_ERROR_BAD_DISPLAY; |
739 | } |
740 | |
741 | hwcLayer = device->getLayerById(layer); |
742 | if (hwcLayer) { |
743 | err = hwcLayer->setPlaneAlpha(alpha); |
744 | } else { |
745 | ETRACE("bad layer."); |
746 | return HWC2_ERROR_BAD_LAYER; |
747 | } |
748 | |
749 | return err; |
750 | } |
751 | |
752 | int32_t Hwcomposer::setLayerSidebandStream( |
753 | hwc2_display_t display, |
754 | hwc2_layer_t layer, |
755 | const native_handle_t* stream) { |
756 | HwcLayer* hwcLayer = NULL; |
757 | int32_t err = HWC2_ERROR_NONE; |
758 | DTRACE("setLayerSidebandStream disp = %d", (int32_t)display); |
759 | |
760 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
761 | if (!device) { |
762 | ETRACE("no device found"); |
763 | return HWC2_ERROR_BAD_DISPLAY; |
764 | } |
765 | |
766 | hwcLayer = device->getLayerById(layer); |
767 | if (hwcLayer) { |
768 | err = hwcLayer->setSidebandStream(stream); |
769 | } else { |
770 | ETRACE("bad layer."); |
771 | return HWC2_ERROR_BAD_LAYER; |
772 | } |
773 | |
774 | return err; |
775 | } |
776 | |
777 | int32_t Hwcomposer::setLayerSourceCrop( |
778 | hwc2_display_t display, |
779 | hwc2_layer_t layer, |
780 | hwc_frect_t crop) { |
781 | HwcLayer* hwcLayer = NULL; |
782 | int32_t err = HWC2_ERROR_NONE; |
783 | DTRACE("setLayerSourceCrop disp = %d", (int32_t)display); |
784 | |
785 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
786 | if (!device) { |
787 | ETRACE("no device found"); |
788 | return HWC2_ERROR_BAD_DISPLAY; |
789 | } |
790 | |
791 | hwcLayer = device->getLayerById(layer); |
792 | if (hwcLayer) { |
793 | err = hwcLayer->setSourceCrop(crop); |
794 | } else { |
795 | ETRACE("bad layer."); |
796 | return HWC2_ERROR_BAD_LAYER; |
797 | } |
798 | |
799 | return err; |
800 | } |
801 | |
802 | int32_t Hwcomposer::setLayerTransform( |
803 | hwc2_display_t display, |
804 | hwc2_layer_t layer, |
805 | int32_t /*hwc_transform_t*/ transform) { |
806 | HwcLayer* hwcLayer = NULL; |
807 | int32_t err = HWC2_ERROR_NONE; |
808 | DTRACE("setLayerTransform disp = %d", (int32_t)display); |
809 | |
810 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
811 | if (!device) { |
812 | ETRACE("no device found"); |
813 | return HWC2_ERROR_BAD_DISPLAY; |
814 | } |
815 | |
816 | hwcLayer = device->getLayerById(layer); |
817 | if (hwcLayer) { |
818 | err = hwcLayer->setTransform(transform); |
819 | } else { |
820 | ETRACE("bad layer."); |
821 | return HWC2_ERROR_BAD_LAYER; |
822 | } |
823 | |
824 | return err; |
825 | } |
826 | |
827 | int32_t Hwcomposer::setLayerVisibleRegion( |
828 | hwc2_display_t display, |
829 | hwc2_layer_t layer, |
830 | hwc_region_t visible) { |
831 | HwcLayer* hwcLayer = NULL; |
832 | int32_t err = HWC2_ERROR_NONE; |
833 | DTRACE("setLayerVisibleRegion disp = %d", (int32_t)display); |
834 | |
835 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
836 | if (!device) { |
837 | ETRACE("no device found"); |
838 | return HWC2_ERROR_BAD_DISPLAY; |
839 | } |
840 | |
841 | hwcLayer = device->getLayerById(layer); |
842 | if (hwcLayer) { |
843 | err = hwcLayer->setVisibleRegion(visible); |
844 | } else { |
845 | ETRACE("bad layer."); |
846 | return HWC2_ERROR_BAD_LAYER; |
847 | } |
848 | |
849 | return err; |
850 | } |
851 | |
852 | int32_t Hwcomposer::setLayerZOrder( |
853 | hwc2_display_t display, |
854 | hwc2_layer_t layer, |
855 | uint32_t z) { |
856 | HwcLayer* hwcLayer = NULL; |
857 | int32_t err = HWC2_ERROR_NONE; |
858 | DTRACE("setLayerZOrder disp = %d", (int32_t)display); |
859 | |
860 | IDisplayDevice *device = getDisplayDevice((int32_t)display); |
861 | if (!device) { |
862 | ETRACE("no device found"); |
863 | return HWC2_ERROR_BAD_DISPLAY; |
864 | } |
865 | |
866 | hwcLayer = device->getLayerById(layer); |
867 | if (hwcLayer) { |
868 | err = hwcLayer->setZ(z); |
869 | } else { |
870 | ETRACE("bad layer."); |
871 | return HWC2_ERROR_BAD_LAYER; |
872 | } |
873 | |
874 | return err; |
875 | } |
876 | |
877 | template <typename T> |
878 | static hwc2_function_pointer_t asFP(T function) |
879 | { |
880 | return reinterpret_cast<hwc2_function_pointer_t>(function); |
881 | } |
882 | |
883 | void Hwcomposer::vsync(int disp, int64_t timestamp) { |
884 | RETURN_VOID_IF_NOT_INIT(); |
885 | |
886 | if (pfnVsync) { |
887 | VTRACE("report vsync on disp %d, timestamp %llu", disp, timestamp); |
888 | // workaround to pretend vsync is from primary display |
889 | // Display will freeze if vsync is from external display. |
890 | pfnVsync(vsync_cb_data, IDisplayDevice::DEVICE_PRIMARY, timestamp); |
891 | } |
892 | } |
893 | |
894 | void Hwcomposer::hotplug(int disp, bool connected) { |
895 | RETURN_VOID_IF_NOT_INIT(); |
896 | |
897 | int32_t cnet = HWC2_CONNECTION_INVALID; |
898 | if (connected) |
899 | cnet = HWC2_CONNECTION_CONNECTED; |
900 | else |
901 | cnet = HWC2_CONNECTION_DISCONNECTED; |
902 | |
903 | if (pfnHotplug) { |
904 | DTRACE("report hotplug on disp %d, connected %d", disp, cnet); |
905 | pfnHotplug(hotplug_cb_data, disp, cnet); |
906 | DTRACE("hotplug callback processed and returned!"); |
907 | } |
908 | |
909 | // mDisplayAnalyzer->postHotplugEvent(connected); |
910 | } |
911 | |
912 | void Hwcomposer::refresh(int disp) { |
913 | RETURN_VOID_IF_NOT_INIT(); |
914 | |
915 | if (pfnRefresh) { |
916 | DTRACE("refresh screen..."); |
917 | pfnRefresh(refresh_cb_data, disp); |
918 | } |
919 | } |
920 | |
921 | bool Hwcomposer::release() { |
922 | RETURN_FALSE_IF_NOT_INIT(); |
923 | |
924 | return true; |
925 | } |
926 | |
927 | bool Hwcomposer::initialize(private_module_t *grallocModule) { |
928 | CTRACE(); |
929 | |
930 | if (!mPlatFactory) { |
931 | DEINIT_AND_RETURN_FALSE("failed to provide a PlatFactory"); |
932 | } |
933 | |
934 | #if PLATFORM_SDK_VERSION < 26 |
935 | if ( !grallocModule) { |
936 | DEINIT_AND_RETURN_FALSE("failed to provide a grallocModule"); |
937 | } |
938 | // initial gralloc module. |
939 | mGrallocModule = grallocModule; |
940 | #endif |
941 | |
942 | mUeventObserver = new UeventObserver(); |
943 | if (!mUeventObserver || !mUeventObserver->initialize()) { |
944 | DEINIT_AND_RETURN_FALSE("failed to initialize uevent observer"); |
945 | } |
946 | |
947 | // create display device |
948 | mDisplayDevices.clear(); |
949 | for (int i = 0; i < IDisplayDevice::DEVICE_COUNT; i++) { |
950 | IDisplayDevice *device = mPlatFactory->createDisplayDevice(i); |
951 | if (!device || !device->initialize()) { |
952 | DEINIT_AND_DELETE_OBJ(device); |
953 | ETRACE("failed to create device %d", i); |
954 | } |
955 | // add this device |
956 | DTRACE("HWC devices initialize device is %p at %d", device, i); |
957 | mDisplayDevices.insertAt(device, i, 1); |
958 | } |
959 | |
960 | mVsyncManager = new VsyncManager(*this); |
961 | if (!mVsyncManager || !mVsyncManager->initialize()) { |
962 | DEINIT_AND_RETURN_FALSE("failed to create Vsync Manager"); |
963 | } |
964 | |
965 | // all initialized, starting uevent observer |
966 | mUeventObserver->start(); |
967 | |
968 | mInitialized = true; |
969 | return true; |
970 | } |
971 | |
972 | void Hwcomposer::deinitialize() { |
973 | // delete mVsyncManager first as it holds reference to display devices. |
974 | DEINIT_AND_DELETE_OBJ(mVsyncManager); |
975 | |
976 | // destroy display devices |
977 | for (size_t i = 0; i < mDisplayDevices.size(); i++) { |
978 | IDisplayDevice *device = mDisplayDevices.itemAt(i); |
979 | DEINIT_AND_DELETE_OBJ(device); |
980 | } |
981 | mDisplayDevices.clear(); |
982 | |
983 | if (mPlatFactory) { |
984 | delete mPlatFactory; |
985 | mPlatFactory = 0; |
986 | } |
987 | |
988 | mInitialized = false; |
989 | } |
990 | |
991 | IDisplayDevice* Hwcomposer::getDisplayDevice(int disp) { |
992 | if (disp < 0 || disp >= IDisplayDevice::DEVICE_COUNT) { |
993 | ETRACE("invalid disp %d", disp); |
994 | return NULL; |
995 | } |
996 | return mDisplayDevices.itemAt(disp); |
997 | } |
998 | |
999 | VsyncManager* Hwcomposer::getVsyncManager() { |
1000 | return mVsyncManager; |
1001 | } |
1002 | |
1003 | UeventObserver* Hwcomposer::getUeventObserver() |
1004 | { |
1005 | return mUeventObserver; |
1006 | } |
1007 | |
1008 | private_module_t* Hwcomposer::getGrallocModule() { |
1009 | return mGrallocModule; |
1010 | } |
1011 | |
1012 | } // namespace amlogic |
1013 | } // namespace android |
1014 |