summaryrefslogtreecommitdiff
path: root/hwc2/common/base/Hwcomposer.cpp (plain)
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
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->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
148int32_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
161int32_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
181int32_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
201int32_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
215int32_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
231int32_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
248int32_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
263int32_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
279int32_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
294int32_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
309int32_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
327int32_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
341int32_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
355int32_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
374int32_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
390int32_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
404int32_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
418int32_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
437int32_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
451int32_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
466int32_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
485int32_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
499int32_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
521int32_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
536int32_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
552int32_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
578int32_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
603int32_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
628int32_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
653int32_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
678int32_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
703int32_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
728int32_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
753int32_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
778int32_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
803int32_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
828int32_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
853int32_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
878template <typename T>
879static hwc2_function_pointer_t asFP(T function)
880{
881 return reinterpret_cast<hwc2_function_pointer_t>(function);
882}
883
884void 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
895void 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
913void 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
922bool Hwcomposer::release() {
923 RETURN_FALSE_IF_NOT_INIT();
924
925 return true;
926}
927
928bool 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
973void 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
992IDisplayDevice* 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
1000VsyncManager* Hwcomposer::getVsyncManager() {
1001 return mVsyncManager;
1002}
1003
1004UeventObserver* Hwcomposer::getUeventObserver()
1005{
1006 return mUeventObserver;
1007}
1008
1009private_module_t* Hwcomposer::getGrallocModule() {
1010 return mGrallocModule;
1011}
1012
1013} // namespace amlogic
1014} // namespace android
1015
generated by cgit at 2024-05-10 12:05:11 (GMT)