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