summaryrefslogtreecommitdiff
path: root/hwc2/common/base/Hwcomposer.cpp (plain)
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
25namespace android {
26namespace amlogic {
27
28Hwcomposer* Hwcomposer::sInstance(0);
29
30Hwcomposer::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
41Hwcomposer::~Hwcomposer()
42{
43 CTRACE();
44 deinitialize();
45}
46
47bool Hwcomposer::initCheck() const {
48 return mInitialized;
49}
50
51int32_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
70int32_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
84void 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
106uint32_t Hwcomposer::getMaxVirtualDisplayCount() {
107
108 // TODO: we only support 1 virtual display now.
109 return 1;
110}
111
112int32_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
147int32_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
160int32_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
180int32_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
200int32_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
214int32_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
230int32_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
247int32_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
262int32_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
278int32_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
293int32_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
308int32_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
326int32_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
340int32_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
354int32_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
373int32_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
389int32_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
403int32_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
417int32_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
436int32_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
450int32_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
465int32_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
484int32_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
498int32_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
520int32_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
535int32_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
551int32_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
577int32_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
602int32_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
627int32_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
652int32_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
677int32_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
702int32_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
727int32_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
752int32_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
777int32_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
802int32_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
827int32_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
852int32_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
877template <typename T>
878static hwc2_function_pointer_t asFP(T function)
879{
880 return reinterpret_cast<hwc2_function_pointer_t>(function);
881}
882
883void 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
894void 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
912void 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
921bool Hwcomposer::release() {
922 RETURN_FALSE_IF_NOT_INIT();
923
924 return true;
925}
926
927bool 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
972void 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
991IDisplayDevice* 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
999VsyncManager* Hwcomposer::getVsyncManager() {
1000 return mVsyncManager;
1001}
1002
1003UeventObserver* Hwcomposer::getUeventObserver()
1004{
1005 return mUeventObserver;
1006}
1007
1008private_module_t* Hwcomposer::getGrallocModule() {
1009 return mGrallocModule;
1010}
1011
1012} // namespace amlogic
1013} // namespace android
1014
generated by cgit at 2024-05-10 08:29:18 (GMT)