path: root/hwc2/common/devices/PhysicalDevice.cpp (plain)
blob: 7daffdd4bf817202fc2a11cff1df9a4eabf2bede

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 <fcntl.h>
20	#include <inttypes.h>
21	#include <HwcTrace.h>
22	#include <PhysicalDevice.h>
23	#include <Hwcomposer.h>
24	#include <sys/ioctl.h>
25	#include <sync/sync.h>
26	#include <Utils.h>
27	#include <HwcFenceControl.h>
28	#include <cutils/properties.h>
29	#include <tvp/OmxUtil.h>
30	#include <framebuffer.h>
31
32	#define FBIOPUT_OSD_CURSOR 0x451a
33
34	namespace android {
35	namespace amlogic {
36
37	PhysicalDevice::PhysicalDevice(hwc2_display_t id, Hwcomposer& hwc, IComposeDeviceFactory* controlFactory)
38	: mId(id),
39	mHwc(hwc),
40	mControlFactory(controlFactory),
41	mVsyncObserver(NULL),
42	mConnectorPresent(false),
43	mSecure(false),
44	mFramebufferHnd(NULL),
45	mSystemControl(NULL),
46	mFbSlot(0),
47	mComposer(NULL),
48	mPriorFrameRetireFence(-1),
49	mClientTargetHnd(NULL),
50	mTargetAcquireFence(-1),
51	mRenderMode(GLES_COMPOSE_MODE),
52	mPreviousRenderMode(GLES_COMPOSE_MODE),
53	mIsValidated(false),
54	mIsContinuousBuf(true),
55	mDirectRenderLayerId(0),
56	mVideoOverlayLayerId(0),
57	mGE2DClearVideoRegionCount(0),
58	mGE2DComposeFrameCount(0),
59	mDirectComposeFrameCount(0),
60	mGetInitState(false),
61	mInitialized(false),
62	mOmxVideoHandle(0),
63	mFirstPostFb(true){
64	CTRACE();
65
66	switch (id) {
67	case DEVICE_PRIMARY:
68	mName = "Primary";
69	break;
70	case DEVICE_EXTERNAL:
71	mName = "External";
72	break;
73	default:
74	mName = "Unknown";
75	}
76
77	mHdrCapabilities.init = false;
78
79	// clear layers vectors.
80	mHwcSecureLayers.clear();
81	mHwcLayersChangeType.clear();
82	mHwcLayersChangeRequest.clear();
83	mHwcGlesLayers.clear();
84	mHwcLayers.clear();
85	mGE2DRenderSortedLayerIds.clear();
86
87	mHwcCurReleaseFences = mHwcPriorReleaseFences = NULL;
88	}
89
90	PhysicalDevice::~PhysicalDevice() {
91	WARN_IF_NOT_DEINIT();
92	clearFenceList(mHwcCurReleaseFences);
93	clearFenceList(mHwcPriorReleaseFences);
94	if (mOmxVideoHandle != 0) {
95	closeamvideo();
96	mOmxVideoHandle = 0;
97	}
98	}
99
100	bool PhysicalDevice::initialize() {
101	CTRACE();
102
103	if (mId != DEVICE_PRIMARY && mId != DEVICE_EXTERNAL) {
104	ETRACE("invalid device type");
105	return false;
106	}
107
108	// init Display here.
109	initDisplay();
110
111	// create vsync event observer, we only have soft vsync now...
112	mVsyncObserver = new SoftVsyncObserver(*this);
113	if (!mVsyncObserver || !mVsyncObserver->initialize()) {
114	DEINIT_AND_RETURN_FALSE("failed to create vsync observer");
115	}
116
117	UeventObserver *observer = Hwcomposer::getInstance().getUeventObserver();
118	if (observer) {
119	observer->registerListener(
120	Utils::getHdcpUeventEnvelope(),
121	hdcpEventListener,
122	this);
123	} else {
124	ETRACE("PhysicalDevice::Uevent observer is NULL");
125	}
126
127	mDisplayHdmi = new DisplayHdmi();
128	framebuffer_info_t framebufferInfo = *(mFramebufferContext->getInfo());
129	framebufferInfo.info.xres = mDisplayWidth;
130	framebufferInfo.info.yres = mDisplayHeight;
131	mDisplayHdmi->initialize(framebufferInfo);
132
133	mInitialized = true;
134	return true;
135	}
136
137	void PhysicalDevice::updateDisplayInfo(char defaultMode[64]) {
138	if (!strncmp(defaultMode, "720", 3)) {
139	mDisplayWidth= FULL_WIDTH_720;
140	mDisplayHeight = FULL_HEIGHT_720;
141	} else if (!strncmp(defaultMode, "1080", 4)) {
142	mDisplayWidth = FULL_WIDTH_1080;
143	mDisplayHeight = FULL_HEIGHT_1080;
144	} else if (!strncmp(defaultMode, "4k2k", 4)) {
145	mDisplayWidth = FULL_WIDTH_4K2K;
146	mDisplayHeight = FULL_HEIGHT_4K2K;
147	}
148	}
149
150	void PhysicalDevice::hdcpEventListener(void *data, bool status) {
151	PhysicalDevice *pThis = (PhysicalDevice*)data;
152	if (pThis) {
153	pThis->setSecureStatus(status);
154	}
155	}
156
157	void PhysicalDevice::setSecureStatus(bool status) {
158	DTRACE("hdcp event: %d", status);
159	mSecure = status;
160	}
161
162	void PhysicalDevice::deinitialize() {
163	Mutex::Autolock _l(mLock);
164
165	DEINIT_AND_DELETE_OBJ(mVsyncObserver);
166	DEINIT_AND_DELETE_OBJ(mDisplayHdmi);
167	DEINIT_AND_DELETE_OBJ(mComposer);
168
169	if (mFramebufferContext != NULL) {
170	delete mFramebufferContext;
171	mFramebufferContext = NULL;
172	}
173
174	if (mCursorContext != NULL) {
175	delete mCursorContext;
176	mCursorContext = NULL;
177	}
178
179	mInitialized = false;
180	}
181
182	HwcLayer* PhysicalDevice::getLayerById(hwc2_layer_t layerId) {
183	HwcLayer* layer = NULL;
184	ssize_t index = mHwcLayers.indexOfKey(layerId);
185
186	if (index >= 0) {
187	layer = mHwcLayers.valueFor(layerId);
188	}
189
190	if (!layer) {
191	DTRACE("getLayerById %lld error!", layerId);
192	}
193	return layer;
194	}
195
196	int32_t PhysicalDevice::acceptDisplayChanges() {
197	HwcLayer* layer = NULL;
198
199	for (uint32_t i=0; i<mHwcLayersChangeType.size(); i++) {
200	hwc2_layer_t layerId = mHwcLayersChangeType.keyAt(i);
201	layer = mHwcLayersChangeType.valueAt(i);
202	if (layer) {
203	// deal non secure display.
204	if (!mSecure && !mHwcSecureLayers.isEmpty()) {
205	for (uint32_t j=0; j<mHwcSecureLayers.size(); j++) {
206	hwc2_layer_t secureLayerId = mHwcSecureLayers.keyAt(j);
207	HwcLayer* secureLayer = mHwcSecureLayers.valueAt(j);
208	// deal secure layers release fence and composition type on non secure display.
209	addReleaseFence(secureLayerId, secureLayer->getDuppedAcquireFence());
210	if (layerId == secureLayerId) {
211	if (layer->getCompositionType() != HWC2_COMPOSITION_DEVICE) {
212	layer->setCompositionType(HWC2_COMPOSITION_DEVICE);
213	continue;
214	}
215	}
216	}
217	}
218	if (layer->getCompositionType() == HWC2_COMPOSITION_DEVICE
219	|| layer->getCompositionType() == HWC2_COMPOSITION_SOLID_COLOR) {
220	layer->setCompositionType(HWC2_COMPOSITION_CLIENT);
221	} else if (layer->getCompositionType() == HWC2_COMPOSITION_SIDEBAND) {
222	layer->setCompositionType(HWC2_COMPOSITION_DEVICE);
223	}
224	}
225	}
226
227	return HWC2_ERROR_NONE;
228	}
229
230	bool PhysicalDevice::createLayer(hwc2_layer_t* outLayer) {
231	HwcLayer* layer = new HwcLayer(mId);
232
233	if (layer == NULL || !layer->initialize()) {
234	ETRACE("createLayer: failed !");
235	return false;
236	}
237
238	hwc2_layer_t layerId = reinterpret_cast<hwc2_layer_t>(layer);
239	mHwcLayers.add(layerId, layer);
240	*outLayer = layerId;
241	DTRACE("::createLayer layerId (%lld), size: [%d].\n", layerId, mHwcLayers.size());
242
243	return true;
244	}
245
246	bool PhysicalDevice::destroyLayer(hwc2_layer_t layerId) {
247	HwcLayer* layer = mHwcLayers.valueFor(layerId);
248	DTRACE("::destroyLayer layerId %lld, size: [%d].\n", layerId, mHwcLayers.size());
249
250	if (layer == NULL) {
251	ETRACE("destroyLayer: no Hwclayer found (%d)", layerId);
252	return false;
253	}
254
255	for (int i = 0; i < 2; i++) {
256	ssize_t idx = mLayerReleaseFences[i].indexOfKey(layerId);
257	if (idx >= 0) {
258	HwcFenceControl::closeFd(mLayerReleaseFences[i].valueAt(idx));
259	mLayerReleaseFences[i].removeItemsAt(idx);
260	DTRACE("destroyLayer layer(%lld) from cur release list (%p).\n", layerId, &(mLayerReleaseFences[i]));
261	}
262	}
263
264	mHwcLayers.removeItem(layerId);
265	DEINIT_AND_DELETE_OBJ(layer);
266	return true;
267	}
268
269	int32_t PhysicalDevice::getActiveConfig(
270	hwc2_config_t* outConfig) {
271	Mutex::Autolock _l(mLock);
272
273	return mDisplayHdmi->getActiveConfig(outConfig);
274	}
275
276	int32_t PhysicalDevice::getChangedCompositionTypes(
277	uint32_t* outNumElements,
278	hwc2_layer_t* outLayers,
279	int32_t* /*hwc2_composition_t*/ outTypes) {
280	HwcLayer* layer = NULL;
281
282	// if outLayers or outTypes were NULL, the number of layers and types which would have been returned.
283	if (NULL == outLayers || NULL == outTypes) {
284	*outNumElements = mHwcLayersChangeType.size();
285	} else {
286	for (uint32_t i=0; i<mHwcLayersChangeType.size(); i++) {
287	hwc2_layer_t layerId = mHwcLayersChangeType.keyAt(i);
288	layer = mHwcLayersChangeType.valueAt(i);
289	if (layer) {
290	// deal non secure display.
291	if (!mSecure && !mHwcSecureLayers.isEmpty()) {
292	for (uint32_t j=0; j<mHwcSecureLayers.size(); j++) {
293	hwc2_layer_t secureLayerId = mHwcSecureLayers.keyAt(j);
294	if (layerId == secureLayerId) {
295	if (layer->getCompositionType() != HWC2_COMPOSITION_DEVICE) {
296	outLayers[i] = layerId;
297	outTypes[i] = HWC2_COMPOSITION_DEVICE;
298	continue;
299	}
300	}
301	}
302	}
303
304	if (layer->getCompositionType() == HWC2_COMPOSITION_DEVICE
305	|| layer->getCompositionType() == HWC2_COMPOSITION_SOLID_COLOR) {
306	// change all other device type to client.
307	outLayers[i] = layerId;
308	outTypes[i] = HWC2_COMPOSITION_CLIENT;
309	continue;
310	}
311
312	// sideband stream.
313	if (layer->getCompositionType() == HWC2_COMPOSITION_SIDEBAND
314	/* && layer->getSidebandStream()*/) {
315	// TODO: we just transact SIDEBAND to OVERLAY for now;
316	DTRACE("get HWC_SIDEBAND layer, just change to overlay");
317	outLayers[i] = layerId;
318	outTypes[i] = HWC2_COMPOSITION_DEVICE;
319	continue;
320	}
321	}
322	}
323
324	if (mHwcLayersChangeType.size() > 0) {
325	DTRACE("There are %d layers type has changed.", mHwcLayersChangeType.size());
326	*outNumElements = mHwcLayersChangeType.size();
327	} else {
328	DTRACE("No layers compositon type changed.");
329	}
330	}
331
332	return HWC2_ERROR_NONE;
333	}
334
335	int32_t PhysicalDevice::getClientTargetSupport(
336	uint32_t width,
337	uint32_t height,
338	int32_t /*android_pixel_format_t*/ format,
339	int32_t /*android_dataspace_t*/ dataspace) {
340	framebuffer_info_t* fbInfo = mFramebufferContext->getInfo();
341
342	if (width == fbInfo->info.xres
343	&& height == fbInfo->info.yres
344	&& format == HAL_PIXEL_FORMAT_RGBA_8888
345	&& dataspace == HAL_DATASPACE_UNKNOWN) {
346	return HWC2_ERROR_NONE;
347	}
348
349	DTRACE("fbinfo: [%d x %d], client: [%d x %d]"
350	"format: %d, dataspace: %d",
351	fbInfo->info.xres,
352	fbInfo->info.yres,
353	width, height, format, dataspace);
354
355	// TODO: ?
356	return HWC2_ERROR_UNSUPPORTED;
357	}
358
359	int32_t PhysicalDevice::getColorModes(
360	uint32_t* outNumModes,
361	int32_t* /*android_color_mode_t*/ outModes) {
362
363	if (NULL == outModes) {
364	*outNumModes = 1;
365	} else {
366	*outModes = HAL_COLOR_MODE_NATIVE;
367	}
368
369	return HWC2_ERROR_NONE;
370	}
371
372	int32_t PhysicalDevice::getDisplayAttribute(
373	hwc2_config_t config,
374	int32_t /*hwc2_attribute_t*/ attribute,
375	int32_t* outValue) {
376	Mutex::Autolock _l(mLock);
377
378	if (!mConnectorPresent) {
379	ETRACE("display %d is not connected.", mId);
380	}
381
382	int ret = mDisplayHdmi->getDisplayAttribute(config, attribute, outValue);
383	if (ret < 0)
384	return HWC2_ERROR_BAD_CONFIG;
385
386	return HWC2_ERROR_NONE;
387	}
388
389	int32_t PhysicalDevice::getDisplayConfigs(
390	uint32_t* outNumConfigs,
391	hwc2_config_t* outConfigs) {
392	Mutex::Autolock _l(mLock);
393
394	return mDisplayHdmi->getDisplayConfigs(outNumConfigs, outConfigs);
395	}
396
397	int32_t PhysicalDevice::getDisplayName(
398	uint32_t* outSize,
399	char* outName) {
400	return HWC2_ERROR_NONE;
401	}
402
403	int32_t PhysicalDevice::getDisplayRequests(
404	int32_t* /*hwc2_display_request_t*/ outDisplayRequests,
405	uint32_t* outNumElements,
406	hwc2_layer_t* outLayers,
407	int32_t* /*hwc2_layer_request_t*/ outLayerRequests) {
408
409	// if outLayers or outTypes were NULL, the number of layers and types which would have been returned.
410	if (NULL == outLayers || NULL == outLayerRequests) {
411	*outNumElements = mHwcLayersChangeRequest.size();
412	} else {
413	for (uint32_t i=0; i<mHwcLayersChangeRequest.size(); i++) {
414	hwc2_layer_t layerId = mHwcLayersChangeRequest.keyAt(i);
415	HwcLayer *layer = mHwcLayersChangeRequest.valueAt(i);
416	if (layer->getCompositionType() == HWC2_COMPOSITION_DEVICE) {
417	// video overlay.
418	if (layerId == mVideoOverlayLayerId) {
419	outLayers[i] = layerId;
420	outLayerRequests[i] = HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET;
421	}
422	/* if (layer->getBufferHandle()) {
423	private_handle_t const* hnd =
424	private_handle_t::dynamicCast(layer->getBufferHandle());
425	if (hnd->flags & private_handle_t::PRIV_FLAGS_VIDEO_OVERLAY) {
426	outLayers[i] = layerId;
427	outLayerRequests[i] = HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET;
428	continue;
429	}
430	} */
431	}
432
433	// sideband stream.
434	if ((layer->getCompositionType() == HWC2_COMPOSITION_SIDEBAND /*&& layer->getSidebandStream()*/)
435	|| layer->getCompositionType() == HWC2_COMPOSITION_CURSOR) {
436	// TODO: we just transact SIDEBAND to OVERLAY for now;
437	DTRACE("get HWC_SIDEBAND layer, just change to overlay");
438	outLayers[i] = layerId;
439	outLayerRequests[i] = HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET;
440	continue;
441	}
442	}
443
444	if (mHwcLayersChangeRequest.size() > 0) {
445	DTRACE("There are %d layer requests.", mHwcLayersChangeRequest.size());
446	*outNumElements = mHwcLayersChangeRequest.size();
447	} else {
448	DTRACE("No layer requests.");
449	}
450	}
451
452	return HWC2_ERROR_NONE;
453	}
454
455	int32_t PhysicalDevice::getDisplayType(
456	int32_t* /*hwc2_display_type_t*/ outType) {
457
458	*outType = HWC2_DISPLAY_TYPE_PHYSICAL;
459	return HWC2_ERROR_NONE;
460	}
461
462	int32_t PhysicalDevice::getDozeSupport(
463	int32_t* outSupport) {
464	return HWC2_ERROR_NONE;
465	}
466
467	int32_t PhysicalDevice::getHdrCapabilities(
468	uint32_t* outNumTypes,
469	int32_t* /*android_hdr_t*/ outTypes,
470	float* outMaxLuminance,
471	float* outMaxAverageLuminance,
472	float* outMinLuminance) {
473
474	Mutex::Autolock _l(mLock);
475	if (!mConnectorPresent) {
476	ETRACE("disp: %llu is not connected", mId);
477	return HWC2_ERROR_BAD_DISPLAY;
478	}
479
480	if (!mHdrCapabilities.init) {
481	ETRACE("HDRCapability not updated.");
482	}
483
484	if (NULL == outTypes) {
485	int num = 0;
486	if (mHdrCapabilities.dvSupport) num++;
487	if (mHdrCapabilities.hdrSupport) num++;
488
489	*outNumTypes = num;
490	} else {
491	if (mHdrCapabilities.dvSupport) *outTypes++ = HAL_HDR_DOLBY_VISION;
492	if (mHdrCapabilities.hdrSupport) *outTypes++ = HAL_HDR_HDR10;
493
494	*outMaxLuminance = mHdrCapabilities.maxLuminance;
495	*outMaxAverageLuminance = mHdrCapabilities.avgLuminance;
496	*outMinLuminance = mHdrCapabilities.minLuminance;
497	}
498
499	return HWC2_ERROR_NONE;
500	}
501
502	void PhysicalDevice::swapReleaseFence() {
503	//dumpFenceList(mHwcCurReleaseFences);
504
505	if (mHwcCurReleaseFences == NULL || mHwcPriorReleaseFences == NULL) {
506	if (mHwcCurReleaseFences) {
507	clearFenceList(mHwcPriorReleaseFences);
508	}
509
510	if (mHwcPriorReleaseFences) {
511	clearFenceList(mHwcPriorReleaseFences);
512	}
513
514	mHwcCurReleaseFences = &(mLayerReleaseFences[0]);
515	mHwcPriorReleaseFences = &(mLayerReleaseFences[1]);
516	} else {
517	KeyedVector<hwc2_layer_t, int32_t> * tmp = mHwcCurReleaseFences;
518	clearFenceList(mHwcPriorReleaseFences);
519	mHwcCurReleaseFences = mHwcPriorReleaseFences;
520	mHwcPriorReleaseFences = tmp;
521	}
522	}
523
524	void PhysicalDevice::addReleaseFence(hwc2_layer_t layerId, int32_t fenceFd) {
525	ssize_t idx = mHwcCurReleaseFences->indexOfKey(layerId);
526	if (idx >= 0 && idx < mHwcCurReleaseFences->size()) {
527	int32_t oldFence = mHwcCurReleaseFences->valueAt(idx);
528	String8 mergeName("hwc-release");
529	int32_t newFence = HwcFenceControl::merge(mergeName, oldFence, fenceFd);
530	mHwcCurReleaseFences->replaceValueAt(idx, newFence);
531	HwcFenceControl::closeFd(oldFence);
532	HwcFenceControl::closeFd(fenceFd);
533	DTRACE("addReleaseFence:(%d, %d) + %d -> (%d,%d)\n", idx, oldFence, fenceFd, idx, newFence);
534	dumpFenceList(mHwcCurReleaseFences);
535	} else {
536	mHwcCurReleaseFences->add(layerId, fenceFd);
537	}
538	}
539
540	void PhysicalDevice::clearFenceList(KeyedVector<hwc2_layer_t, int32_t> * fenceList) {
541	if (!fenceList || !fenceList->size())
542	return;
543
544	for (int i = 0; i < fenceList->size(); i++) {
545	int32_t fenceFd = fenceList->valueAt(i);
546	HwcFenceControl::closeFd(fenceFd);
547	DTRACE("clearFenceList close fd %d\n", fenceFd);
548	fenceList->replaceValueAt(i, -1);
549	}
550	fenceList->clear();
551	}
552
553	void PhysicalDevice::dumpFenceList(KeyedVector<hwc2_layer_t, int32_t> * fenceList) {
554	if (!fenceList || fenceList->isEmpty())
555	return;
556
557	String8 resultStr("dumpFenceList: ");
558	for (int i = 0; i < fenceList->size(); i++) {
559	hwc2_layer_t layerId = fenceList->keyAt(i);
560	int32_t fenceFd = fenceList->valueAt(i);
561	resultStr.appendFormat("(%lld, %d), ", layerId, fenceFd);
562	}
563
564	ETRACE("%s", resultStr.string());
565	}
566
567	int32_t PhysicalDevice::getReleaseFences(
568	uint32_t* outNumElements,
569	hwc2_layer_t* outLayers,
570	int32_t* outFences) {
571	*outNumElements = mHwcPriorReleaseFences->size();
572
573	if (outLayers && outFences) {
574	for (uint32_t i=0; i<mHwcPriorReleaseFences->size(); i++) {
575	outLayers[i] = mHwcPriorReleaseFences->keyAt(i);
576	outFences[i] = HwcFenceControl::dupFence(mHwcPriorReleaseFences->valueAt(i));
577	}
578	}
579
580	return HWC2_ERROR_NONE;
581	}
582
583	void PhysicalDevice::directCompose(framebuffer_info_t * fbInfo) {
584	HwcLayer* layer = NULL;
585	ssize_t idx = mHwcLayers.indexOfKey(mDirectRenderLayerId);
586	if (idx >= 0) {
587	layer = mHwcLayers.valueAt(idx);
588	if (mTargetAcquireFence > -1) {
589	ETRACE("ERROR:directCompose with mTargetAcquireFence %d\n", mTargetAcquireFence);
590	HwcFenceControl::closeFd(mTargetAcquireFence);
591	}
592
593	mTargetAcquireFence = layer->getDuppedAcquireFence();
594	mClientTargetHnd = layer->getBufferHandle();
595	DTRACE("Hit only one non video overlay layer, handle: %08" PRIxPTR ", fence: %d",
596	intptr_t(mClientTargetHnd), mTargetAcquireFence);
597
598	// fill up fb sync request struct.
599	hwc_frect_t srcCrop = layer->getSourceCrop();
600	hwc_rect_t displayFrame = layer->getDisplayFrame();
601	mFbSyncRequest.xoffset = (unsigned int)srcCrop.left;
602	mFbSyncRequest.yoffset = (unsigned int)srcCrop.top;
603	mFbSyncRequest.width = (unsigned int)(srcCrop.right - srcCrop.left);
604	mFbSyncRequest.height = (unsigned int)(srcCrop.bottom - srcCrop.top);
605	mFbSyncRequest.dst_x = displayFrame.left;
606	mFbSyncRequest.dst_y = displayFrame.top;
607	mFbSyncRequest.dst_w = displayFrame.right - displayFrame.left;
608	mFbSyncRequest.dst_h = displayFrame.bottom - displayFrame.top;
609	return;
610	}
611
612	ETRACE("Didn't find direct compose layer!");
613	}
614
615	#ifdef ENABLE_AML_GE2D_COMPOSER
616	void PhysicalDevice::ge2dCompose(framebuffer_info_t * fbInfo, bool hasVideoOverlay) {
617	if (mGE2DRenderSortedLayerIds.size() > 0) {
618	DTRACE("GE2D compose mFbSlot: %d", mFbSlot);
619	if (hasVideoOverlay) {
620	if (mGE2DClearVideoRegionCount < 3) {
621	mComposer->setVideoOverlayLayerId(mVideoOverlayLayerId);
622	}
623	}
624	if (mTargetAcquireFence > -1) {
625	ETRACE("ERROR:GE2D compose with mTargetAcquireFence %d\n", mTargetAcquireFence);
626	HwcFenceControl::closeFd(mTargetAcquireFence);
627	}
628	mTargetAcquireFence = mComposer->startCompose(mGE2DRenderSortedLayerIds, &mFbSlot, mGE2DComposeFrameCount);
629	for (uint32_t i=0; i<mGE2DRenderSortedLayerIds.size(); i++) {
630	addReleaseFence(mGE2DRenderSortedLayerIds.itemAt(i), HwcFenceControl::dupFence(mTargetAcquireFence));
631	}
632	// HwcFenceControl::traceFenceInfo(mTargetAcquireFence);
633	// dumpLayers(mGE2DRenderSortedLayerIds);
634	if (mGE2DComposeFrameCount < 3) {
635	mGE2DComposeFrameCount++;
636	}
637	mClientTargetHnd = mComposer->getBufHnd();
638	fbInfo->yOffset = mFbSlot;
639	return;
640	}
641
642	ETRACE("Didn't find ge2d compose layers!");
643	}
644	#endif
645
646	int32_t PhysicalDevice::postFramebuffer(int32_t* outRetireFence, bool hasVideoOverlay) {
647	HwcLayer* layer = NULL;
648	void *cbuffer;
649	bool bUseHwcPost = true;
650
651	// deal physical display's client target layer
652	framebuffer_info_t fbInfo = *(mFramebufferContext->getInfo());
653	framebuffer_info_t* cbInfo = mCursorContext->getInfo();
654	bool cursorShow = false;
655	bool haveCursorLayer = false;
656	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
657	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
658	layer = mHwcLayers.valueAt(i);
659	if (layer && layer->getCompositionType()== HWC2_COMPOSITION_CURSOR) {
660	private_handle_t *hnd = private_handle_t::dynamicCast(layer->getBufferHandle());
661	if (!hnd) {
662	ETRACE("invalid cursor layer handle.");
663	break;
664	}
665	haveCursorLayer = true;
666	DTRACE("This is a Sprite, hnd->stride is %d, hnd->height is %d", hnd->stride, hnd->height);
667	if (cbInfo->info.xres != (uint32_t)hnd->stride || cbInfo->info.yres != (uint32_t)hnd->height) {
668	DTRACE("disp: %d cursor need to redrew", mId);
669	update_cursor_buffer_locked(cbInfo, hnd->stride, hnd->height);
670	cbuffer = mmap(NULL, hnd->size, PROT_READ|PROT_WRITE, MAP_SHARED, cbInfo->fd, 0);
671	if (cbuffer != MAP_FAILED) {
672	memcpy(cbuffer, hnd->base, hnd->size);
673	munmap(cbuffer, hnd->size);
674	DTRACE("setCursor ok");
675	} else {
676	ETRACE("Cursor display buffer mmap fail!");
677	}
678	}
679	cursorShow = true;
680	break;
681	}
682	}
683
684	if (mRenderMode == GLES_COMPOSE_MODE) {
685	//if no layers to compose, post blank op to osd.
686	if (mPreviousRenderMode != GLES_COMPOSE_MODE && mHwcGlesLayers.size() == 0) {
687	mClientTargetHnd = NULL;
688	}
689	} else if (mRenderMode == DIRECT_COMPOSE_MODE) { // if only one layer exists, let hwc do her work.
690	directCompose(&fbInfo);
691	}
692	#ifdef ENABLE_AML_GE2D_COMPOSER
693	else if (mRenderMode == GE2D_COMPOSE_MODE) {
694	ge2dCompose(&fbInfo, hasVideoOverlay);
695	}
696	#endif
697	mFbSyncRequest.type = mRenderMode;
698
699	if (!mClientTargetHnd || private_handle_t::validate(mClientTargetHnd) < 0 || mPowerMode == HWC2_POWER_MODE_OFF) {
700	DTRACE("Post blank to screen, mClientTargetHnd(%p, %d), mTargetAcquireFence(%d)",
701	mClientTargetHnd, private_handle_t::validate(mClientTargetHnd), mTargetAcquireFence);
702	*outRetireFence = HwcFenceControl::merge(String8("ScreenBlank"), mPriorFrameRetireFence, mPriorFrameRetireFence);
703	HwcFenceControl::closeFd(mTargetAcquireFence);
704	mTargetAcquireFence = -1;
705	HwcFenceControl::closeFd(mPriorFrameRetireFence);
706	mPriorFrameRetireFence = -1;
707	//for nothing to display, post blank to osd which will signal the last retire fence.
708	mFbSyncRequest.type = DIRECT_COMPOSE_MODE;
709	mFbSyncRequest.op |= OSD_BLANK_OP_BIT;
710	mFramebufferContext->setStatus(true);
711	mPriorFrameRetireFence = hwc_fb_post_with_fence_locked(&fbInfo, &mFbSyncRequest, NULL);
712	} else {
713	*outRetireFence = HwcFenceControl::dupFence(mPriorFrameRetireFence);
714	if (*outRetireFence >= 0) {
715	DTRACE("Get prior frame's retire fence %d", *outRetireFence);
716	} else {
717	ETRACE("No valid prior frame's retire returned. %d ", *outRetireFence);
718	// -1 means no fence, less than -1 is some error
719	*outRetireFence = -1;
720	}
721	HwcFenceControl::closeFd(mPriorFrameRetireFence);
722	mPriorFrameRetireFence = -1;
723
724	bool needBlankFb0 = false;
725	uint32_t layerNum = mHwcLayers.size();
726	if (hasVideoOverlay
727	&& (layerNum == 1
728	|| (layerNum == 2
729	&& haveCursorLayer))) {
730	needBlankFb0 = true;
731	}
732
733	//close uboot logo, if bootanim begin to show
734	if (mFirstPostFb) {
735	mFirstPostFb = false;
736
737	Utils::setSysfsStr(DISPLAY_LOGO_INDEX, "-1");
738	Utils::setSysfsStr(DISPLAY_FB0_FREESCALE_SWTICH, "0x10001");
739	}
740
741	// real post framebuffer here.
742	DTRACE("render type: %d", mFbSyncRequest.type);
743
744	if (!bUseHwcPost) {
745	setOSD0Blank(needBlankFb0);
746	mPriorFrameRetireFence = fb_post_with_fence_locked(&fbInfo, mClientTargetHnd, mTargetAcquireFence);
747	} else {
748	// bit 0 is osd blank flag.
749	if (needBlankFb0) {
750	mFbSyncRequest.op |= OSD_BLANK_OP_BIT;
751	} else {
752	mFbSyncRequest.op &= ~(OSD_BLANK_OP_BIT);
753	}
754	mFramebufferContext->setStatus(needBlankFb0);
755	// acquire fence.
756	mFbSyncRequest.in_fen_fd = mTargetAcquireFence;
757	mPriorFrameRetireFence = hwc_fb_post_with_fence_locked(&fbInfo, &mFbSyncRequest, mClientTargetHnd);
758	}
759	mTargetAcquireFence = -1;
760
761	if (mRenderMode == GE2D_COMPOSE_MODE) {
762	mComposer->mergeRetireFence(mFbSlot, HwcFenceControl::dupFence(mPriorFrameRetireFence));
763	} else {
764	if (mComposer && mGE2DComposeFrameCount != 0) {
765	mComposer->removeRetireFence(mFbSlot);
766	}
767
768	if (mRenderMode == DIRECT_COMPOSE_MODE) {
769	addReleaseFence(mDirectRenderLayerId, HwcFenceControl::dupFence(mPriorFrameRetireFence));
770	}
771	}
772
773	// finally we need to update cursor's blank status.
774	if (cbInfo->fd > 0 && cursorShow != mCursorContext->getStatus()) {
775	mCursorContext->setStatus(cursorShow);
776	DTRACE("UPDATE FB1 status to %d", !cursorShow);
777	ioctl(cbInfo->fd, FBIOBLANK, !cursorShow);
778	}
779	}
780
781	if (mRenderMode != GE2D_COMPOSE_MODE) {
782	mGE2DComposeFrameCount = 0;
783	}
784
785	return HWC2_ERROR_NONE;
786	}
787
788	// TODO: need add fence wait.
789	int32_t PhysicalDevice::setOSD0Blank(bool blank) {
790	framebuffer_info_t* fbInfo = mFramebufferContext->getInfo();
791
792	if (fbInfo->fd > 0 && blank != mFramebufferContext->getStatus()) {
793	mFramebufferContext->setStatus(blank);
794	DTRACE("UPDATE FB0 status to %d", blank);
795	ioctl(fbInfo->fd, FBIOBLANK, blank);
796	}
797
798	return HWC2_ERROR_NONE;
799	}
800
801	int32_t PhysicalDevice::presentDisplay(
802	int32_t* outRetireFence) {
803	int32_t err = HWC2_ERROR_NONE;
804	HwcLayer* layer = NULL;
805	bool hasVideoOverlay = false;
806
807	if (mIsValidated) {
808	// TODO: need improve the way to set video axis.
809	bool bPresent = true;
810	if (mHwcSecureLayers.indexOfKey(mVideoOverlayLayerId) >= 0) {
811	bPresent = false;
812	}
813
814	ssize_t index = mHwcLayers.indexOfKey(mVideoOverlayLayerId);
815	if (index >= 0) {
816	layer = mHwcLayers.valueFor(mVideoOverlayLayerId);
817	if (layer != NULL) {
818	layer->presentOverlay(bPresent);
819	hasVideoOverlay = true;
820	if (mGE2DClearVideoRegionCount < 3) {
821	mGE2DClearVideoRegionCount++;
822	}
823	}
824	} else {
825	mGE2DClearVideoRegionCount = 0;
826	}
827	err = postFramebuffer(outRetireFence, hasVideoOverlay);
828	} else { // display not validate yet.
829	err = HWC2_ERROR_NOT_VALIDATED;
830	}
831
832	finishCompose();
833	return err;
834	}
835
836	int32_t PhysicalDevice::setActiveConfig(
837	hwc2_config_t config) {
838	Mutex::Autolock _l(mLock);
839
840	int32_t err = mDisplayHdmi->setActiveConfig(config);
841	if (err == HWC2_ERROR_NONE) {
842	updateActiveDisplayAttribute();
843	}
844
845	return err;
846	}
847
848	int32_t PhysicalDevice::setClientTarget(
849	buffer_handle_t target,
850	int32_t acquireFence,
851	int32_t /*android_dataspace_t*/ dataspace,
852	hwc_region_t damage) {
853
854	if (target && private_handle_t::validate(target) < 0) {
855	return HWC2_ERROR_BAD_PARAMETER;
856	}
857
858	if (NULL != target) {
859	mClientTargetHnd = target;
860	mClientTargetDamageRegion = damage;
861	mTargetAcquireFence = acquireFence;
862	DTRACE("setClientTarget %p, %d", target, acquireFence);
863	// TODO: HWC2_ERROR_BAD_PARAMETER && dataspace && damage.
864	} else {
865	DTRACE("client target is null!, no need to update this frame.");
866	}
867
868	return HWC2_ERROR_NONE;
869	}
870
871	int32_t PhysicalDevice::setColorMode(
872	int32_t /*android_color_mode_t*/ mode) {
873	return HWC2_ERROR_NONE;
874	}
875
876	int32_t PhysicalDevice::setColorTransform(
877	const float* matrix,
878	int32_t /*android_color_transform_t*/ hint) {
879	return HWC2_ERROR_NONE;
880	}
881
882	int32_t PhysicalDevice::setPowerMode(
883	int32_t /*hwc2_power_mode_t*/ mode){
884
885	mPowerMode = mode;
886	return HWC2_ERROR_NONE;
887	}
888
889	bool PhysicalDevice::vsyncControl(bool enabled) {
890	RETURN_FALSE_IF_NOT_INIT();
891
892	ATRACE("disp = %d, enabled = %d", mId, enabled);
893	return mVsyncObserver->control(enabled);
894	}
895
896	void PhysicalDevice::dumpLayers(Vector < hwc2_layer_t > layerIds) {
897	for (uint32_t x=0; x<layerIds.size(); x++) {
898	HwcLayer* layer = getLayerById(layerIds.itemAt(x));
899	static char const* compositionTypeName[] = {
900	"UNKNOWN",
901	"GLES",
902	"HWC",
903	"SOLID",
904	"HWC_CURSOR",
905	"SIDEBAND"};
906	ETRACE(" %11s | %12" PRIxPTR " | %10d | %02x | %1.2f | %02x | %04x |%7.1f,%7.1f,%7.1f,%7.1f |%5d,%5d,%5d,%5d \n",
907	compositionTypeName[layer->getCompositionType()],
908	intptr_t(layer->getBufferHandle()), layer->getZ(), layer->getDataspace(),
909	layer->getPlaneAlpha(), layer->getTransform(), layer->getBlendMode(),
910	layer->getSourceCrop().left, layer->getSourceCrop().top, layer->getSourceCrop().right, layer->getSourceCrop().bottom,
911	layer->getDisplayFrame().left, layer->getDisplayFrame().top, layer->getDisplayFrame().right, layer->getDisplayFrame().bottom);
912	}
913	}
914
915	void PhysicalDevice::dumpLayers(KeyedVector<hwc2_layer_t, HwcLayer*> layers) {
916	for (uint32_t x=0; x<layers.size(); x++) {
917	HwcLayer* layer = layers.valueAt(x);
918	static char const* compositionTypeName[] = {
919	"UNKNOWN",
920	"GLES",
921	"HWC",
922	"SOLID",
923	"HWC_CURSOR",
924	"SIDEBAND"};
925	ETRACE(" %11s | %12" PRIxPTR " | %10d | %02x | %1.2f | %02x | %04x |%7.1f,%7.1f,%7.1f,%7.1f |%5d,%5d,%5d,%5d \n",
926	compositionTypeName[layer->getCompositionType()],
927	intptr_t(layer->getBufferHandle()), layer->getZ(), layer->getDataspace(),
928	layer->getPlaneAlpha(), layer->getTransform(), layer->getBlendMode(),
929	layer->getSourceCrop().left, layer->getSourceCrop().top, layer->getSourceCrop().right, layer->getSourceCrop().bottom,
930	layer->getDisplayFrame().left, layer->getDisplayFrame().top, layer->getDisplayFrame().right, layer->getDisplayFrame().bottom);
931	}
932	}
933
934	bool PhysicalDevice::layersStateCheck(int32_t renderMode,
935	KeyedVector<hwc2_layer_t, HwcLayer*> & composeLayers) {
936	bool ret = false;
937	uint32_t layerNum = composeLayers.size();
938	hwc_frect_t sourceCrop[HWC2_MAX_LAYERS];
939	HwcLayer* layer[HWC2_MAX_LAYERS] = { NULL };
940	private_handle_t const* hnd[HWC2_MAX_LAYERS] = { NULL };
941	hwc_rect_t displayFrame[HWC2_MAX_LAYERS];
942
943	for (int32_t i=0; i<layerNum; i++) {
944	layer[i] = composeLayers.valueAt(i);
945	sourceCrop[i] = layer[i]->getSourceCrop();
946	displayFrame[i] = layer[i]->getDisplayFrame();
947	hnd[i] = private_handle_t::dynamicCast(layer[i]->getBufferHandle());
948	if (hnd[i] == NULL) return false; // no buffer to process.
949	if (hnd[i]->share_fd == -1) return false; // no buffer to process.
950	if ((sourceCrop[i].right - sourceCrop[i].left > HWC2_HW_COMPOSE_WIDTH_MAX) ||
951	(sourceCrop[i].bottom - sourceCrop[i].top > HWC2_HW_COMPOSE_HEIGHT_MAX)) {
952	return false;
953	}
954	DTRACE("layer[%d] zorder: %d, blend: %d, PlaneAlpha: %f, "
955	"mColor: [%d, %d, %d, %d], mDataSpace: %d, format hnd[%d]: %x",
956	i, layer[i]->getZ(), layer[i]->getBlendMode(), layer[i]->getPlaneAlpha(),
957	layer[i]->getColor().r, layer[i]->getColor().g, layer[i]->getColor().b,
958	layer[i]->getColor().a, layer[i]->getDataspace(), i, hnd[i]->format);
959	}
960
961	if (renderMode == DIRECT_COMPOSE_MODE) {
962	switch (hnd[0]->format) {
963	case HAL_PIXEL_FORMAT_RGBA_8888:
964	case HAL_PIXEL_FORMAT_RGBX_8888:
965	case HAL_PIXEL_FORMAT_RGB_888:
966	case HAL_PIXEL_FORMAT_RGB_565:
967	case HAL_PIXEL_FORMAT_BGRA_8888:
968	DTRACE("Layer format match direct composer.");
969	ret = true;
970	break;
971	default:
972	DTRACE("Layer format not support by direct compose");
973	return false;
974	break;
975	}
976	if (layer[0]->getTransform() != 0) {
977	//DTRACE("Direct composer can NOT support rotation now.");
978	return false;
979	}
980	}
981	#ifdef ENABLE_AML_GE2D_COMPOSER
982	else if (renderMode == GE2D_COMPOSE_MODE) {
983	bool yuv420Sp = false;
984	for (int32_t i=0; i<layerNum; i++) {
985	switch (hnd[i]->format) {
986	case HAL_PIXEL_FORMAT_YCrCb_420_SP:
987	yuv420Sp = true;
988	case HAL_PIXEL_FORMAT_RGBA_8888:
989	case HAL_PIXEL_FORMAT_RGBX_8888:
990	case HAL_PIXEL_FORMAT_RGB_888:
991	case HAL_PIXEL_FORMAT_RGB_565:
992	case HAL_PIXEL_FORMAT_BGRA_8888:
993	case HAL_PIXEL_FORMAT_YV12:
994	case HAL_PIXEL_FORMAT_Y8:
995	case HAL_PIXEL_FORMAT_YCbCr_422_SP:
996	case HAL_PIXEL_FORMAT_YCbCr_422_I:
997	DTRACE("Layer format match ge2d composer.");
998	ret = true;
999	break;
1000	default:
1001	DTRACE("Layer format not support by ge2d");
1002	return false;
1003	break;
1004	}
1005	if (layer[i]->havePlaneAlpha()
1006	|| layer[i]->haveColor()
1007	|| layer[i]->haveDataspace()
1008	|| (layer[i]->isBlended()
1009	&& layer[i]->isScaled())) {
1010	DTRACE("ge2d compose can not process!");
1011	return false;
1012	}
1013	}
1014	#if 0
1015	if (yuv420Sp && HWC2_TWO_LAYERS == layerNum) {
1016	if (Utils::compareRect(sourceCrop[0], sourceCrop[1])
1017	&& Utils::compareRect(sourceCrop[0], displayFrame[0])
1018	&& Utils::compareRect(sourceCrop[1], displayFrame[1])) {
1019	DTRACE("2 layers is same size and have yuv420sp format ge2d compose can not process!");
1020	return false;
1021	}
1022	}
1023	#endif
1024	if (HWC2_TWO_LAYERS == layerNum
1025	&& (layer[0]->isScaled() || layer[1]->isScaled())) {
1026	DTRACE("when 2 layer's size is difference, ge2d compose can not process!");
1027	return false;
1028	}
1029	}
1030	#endif
1031
1032	return ret;
1033	}
1034
1035	/*************************************************************
1036	* For direct framebuffer composer:
1037	* 1) only support one layer.
1038	* 2) layer format: rgba, rgbx,rgb565,bgra;
1039	* 3) layer no rotation.
1040
1041	* For ge2d composer:
1042	* 1) support layer format that direct composer can't support.
1043	* 2) support 2 layers blending.
1044	* 3) support scale and rotation etc.
1045	**************************************************************/
1046	int32_t PhysicalDevice::composersFilter(
1047	KeyedVector<hwc2_layer_t, HwcLayer*> & composeLayers) {
1048
1049	// direct Composer.
1050	if (composeLayers.size() == HWC2_ONE_LAYER) {
1051	// if only one layer exists, do direct framebuffer composer.
1052	bool directCompose = layersStateCheck(DIRECT_COMPOSE_MODE, composeLayers);
1053	if (directCompose) {
1054	if (mDirectComposeFrameCount >= 3) {
1055	hwc2_layer_t layerGlesLayerId = composeLayers.keyAt(0);
1056	composeLayers.clear();
1057	mDirectRenderLayerId = layerGlesLayerId;
1058	return DIRECT_COMPOSE_MODE;
1059	}
1060	mDirectComposeFrameCount++;
1061	return GLES_COMPOSE_MODE;
1062	}
1063	}
1064
1065	#ifdef ENABLE_AML_GE2D_COMPOSER
1066	// if direct composer can't work, try this.
1067	if (composeLayers.size() > HWC2_NO_LAYER
1068	&& composeLayers.size() < HWC2_MAX_LAYERS) {
1069	bool ge2dCompose = layersStateCheck(GE2D_COMPOSE_MODE, composeLayers);
1070	if (!ge2dCompose) return GLES_COMPOSE_MODE;
1071	mGE2DRenderSortedLayerIds.clear();
1072	for (uint32_t i=0; i<composeLayers.size(); i++) {
1073	hwc2_layer_t layerGlesLayerId = composeLayers.keyAt(i);
1074	HwcLayer* layer = getLayerById(layerGlesLayerId);
1075	if (0 == i) {
1076	mGE2DRenderSortedLayerIds.push_front(layerGlesLayerId);
1077	continue;
1078	}
1079	for (uint32_t j=0; j<i; j++) {
1080	HwcLayer* layer1 = getLayerById(mGE2DRenderSortedLayerIds.itemAt(j));
1081	HwcLayer* layer2 = getLayerById(layerGlesLayerId);
1082	if (layer1 != NULL && layer2 != NULL) {
1083	uint32_t z1 = layer1->getZ();
1084	uint32_t z2 = layer2->getZ();
1085	if (layer1->getZ() > layer2->getZ()) {
1086	mGE2DRenderSortedLayerIds.insertAt(layerGlesLayerId, j, 1);
1087	break;
1088	}
1089	if (j == i-1) mGE2DRenderSortedLayerIds.push_back(layerGlesLayerId);
1090	} else {
1091	ETRACE("Layer1 or Layer2 is NULL!!!");
1092	}
1093	}
1094	}
1095
1096	// Vector < hwc2_layer_t > layerIds;
1097	if (!mComposer) {
1098	// create ge2d composer...
1099	mComposer = mControlFactory->createComposer(*this);
1100	if (!mComposer || !mComposer->initialize(mFramebufferContext->getInfo())) {
1101	DEINIT_AND_DELETE_OBJ(mComposer);
1102	return GLES_COMPOSE_MODE;
1103	}
1104	}
1105	composeLayers.clear();
1106	return GE2D_COMPOSE_MODE;
1107	}
1108	#endif
1109
1110	return GLES_COMPOSE_MODE;
1111	}
1112
1113	bool PhysicalDevice::calReverseScale() {
1114	static float fb_w = 1920; // Query activeConfig for FB size?
1115	static float fb_h = 1080; // Query activeConfig for FB size?
1116
1117	mReverseScaleX = mReverseScaleY = 0.0f;
1118	if (fb_w <= 0.01f || fb_h <= 0.01f)
1119	return false;
1120
1121	float display_w, display_h;
1122	hwc2_config_t config;
1123	if (HWC2_ERROR_NONE != mDisplayHdmi->getRealActiveConfig(&config))
1124	return false;
1125
1126	int32_t tmpSize = 0.0f;
1127	if ( mDisplayHdmi->getDisplayAttribute(config,
1128	HWC2_ATTRIBUTE_WIDTH, &tmpSize) != NO_ERROR)
1129	return false;
1130	display_w = tmpSize;
1131	if ( mDisplayHdmi->getDisplayAttribute(config,
1132	HWC2_ATTRIBUTE_HEIGHT, &tmpSize) != NO_ERROR)
1133	return false;
1134	display_h = tmpSize;
1135
1136	if (display_w <= 0.01f || display_h <= 0.01f)
1137	return false;
1138
1139	mReverseScaleX = fb_w / display_w;
1140	mReverseScaleY = fb_h /display_h;
1141	return false;
1142	}
1143
1144	int32_t PhysicalDevice::preValidate() {
1145	bool bScale = (mReverseScaleX >= 0.01f && mReverseScaleX >= 0.01f) ? true : false;
1146	HwcLayer* layer = NULL;
1147	//find out video layer first.
1148	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
1149	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
1150	layer = mHwcLayers.valueAt(i);
1151	if (!layer) {
1152	ETRACE("Meet empty layer, id(%lld)", layerId);
1153	continue;
1154	}
1155
1156	if (bScale && (layer->getDisplayFrame().right >= 3800))
1157	layer->reverseScaledFrame(mReverseScaleX, mReverseScaleY);
1158
1159	private_handle_t const* hnd = private_handle_t::dynamicCast(layer->getBufferHandle());
1160	if (hnd && !((hnd->flags & private_handle_t::PRIV_FLAGS_CONTINUOUS_BUF)
1161	|| (hnd->flags & private_handle_t::PRIV_FLAGS_VIDEO_OVERLAY))) {
1162	mIsContinuousBuf = false;
1163	}
1164
1165	if ((hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_VIDEO_OVERLAY) &&
1166	(layer->getCompositionType() == HWC2_COMPOSITION_DEVICE)) ||
1167	(layer->getCompositionType() == HWC2_COMPOSITION_SIDEBAND
1168	/* && layer->getSidebandStream()*/)) {
1169	if (mVideoOverlayLayerId != 0) {
1170	ETRACE("ERROR: Find two video layer, should never get here !!");
1171	}
1172	mVideoOverlayLayerId = layerId;
1173	}
1174	}
1175
1176	return HWC2_ERROR_NONE;
1177	}
1178
1179	int32_t PhysicalDevice::beginCompose() {
1180	swapReleaseFence();
1181	// reset layer changed or requested size to zero.
1182	mHwcLayersChangeType.clear();
1183	mHwcLayersChangeRequest.clear();
1184	mHwcGlesLayers.clear();
1185	// deal non secure display device.
1186	mHwcSecureLayers.clear();
1187
1188	memset(&mFbSyncRequest, 0, sizeof(mFbSyncRequest));
1189	mFbSyncRequest.in_fen_fd = -1;
1190
1191	mVideoOverlayLayerId = 0;
1192	mIsContinuousBuf = true;
1193	mIsValidated = false;
1194	mRenderMode = GLES_COMPOSE_MODE;
1195
1196	return HWC2_ERROR_NONE;
1197	}
1198
1199	int32_t PhysicalDevice::finishCompose() {
1200	HwcLayer* layer = NULL;
1201	// reset layers' acquire fence.
1202	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
1203	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
1204	layer = mHwcLayers.valueAt(i);
1205	if (layer != NULL) {
1206	layer->resetAcquireFence();
1207	}
1208	}
1209
1210	mClientTargetHnd = NULL;
1211	mPreviousRenderMode = mRenderMode;
1212	return HWC2_ERROR_NONE;
1213	}
1214
1215	int32_t PhysicalDevice::validateDisplay(uint32_t* outNumTypes,
1216	uint32_t* outNumRequests) {
1217	HwcLayer* layer = NULL, *videoLayer = NULL;
1218	hwc_rect_t videoRect;
1219	KeyedVector<hwc2_layer_t, HwcLayer*> composeLayers;
1220	composeLayers.clear();
1221
1222	beginCompose();
1223
1224	if (preValidate() != HWC2_ERROR_NONE) {
1225	return HWC2_ERROR_BAD_LAYER;
1226	}
1227
1228	if (mVideoOverlayLayerId) {
1229	videoLayer = mHwcLayers.valueFor(mVideoOverlayLayerId);
1230	videoRect = videoLayer->getDisplayFrame();
1231	}
1232
1233	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
1234	int overlapType = Utils::OVERLAP_EMPTY;
1235	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
1236	layer = mHwcLayers.valueAt(i);
1237	if (!layer)
1238	continue;
1239
1240	private_handle_t const* hnd = private_handle_t::dynamicCast(layer->getBufferHandle());
1241
1242	#ifdef HWC_SUPPORT_SECURE_LAYER
1243	// secure or protected layer.
1244	if (!mSecure && hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_PROTECTED)) {
1245	DTRACE("layer's secure or protected buffer flag is set! usage (%x)", hnd->flags);
1246	if (layer->getCompositionType() != HWC2_COMPOSITION_DEVICE) {
1247	mHwcLayersChangeType.add(layerId, layer);
1248	}
1249	mHwcSecureLayers.add(layerId, layer);
1250	continue;
1251	}
1252	#endif
1253	if (hnd && hnd->flags & private_handle_t::PRIV_FLAGS_VIDEO_OMX) {
1254	set_omx_pts((char*)hnd->base, &mOmxVideoHandle);
1255	}
1256
1257	if (videoLayer && (layer->getZ() < videoLayer->getZ())) {
1258	DTRACE("Layer covered by video layer.");
1259	hwc_rect_t layerRect = layer->getDisplayFrame();
1260	overlapType = Utils::rectOverlap(layerRect, videoRect);
1261	}
1262
1263	switch (layer->getCompositionType()) {
1264	case HWC2_COMPOSITION_CLIENT:
1265	mHwcGlesLayers.add(layerId, layer);
1266	DTRACE("Meet a client layer!");
1267	break;
1268	case HWC2_COMPOSITION_DEVICE:
1269	if (layerId == mVideoOverlayLayerId) {
1270	mHwcLayersChangeRequest.add(layerId, layer);
1271	} else {
1272	composeLayers.add(layerId, layer);
1273	}
1274	break;
1275	case HWC2_COMPOSITION_SOLID_COLOR:
1276	if (overlapType != Utils::OVERLAP_FULL) {
1277	mHwcGlesLayers.add(layerId, layer);
1278	mHwcLayersChangeType.add(layerId, layer);
1279	}
1280	break;
1281	case HWC2_COMPOSITION_CURSOR:
1282	DTRACE("This is a Cursor layer!");
1283	mHwcLayersChangeRequest.add(layerId, layer);
1284	break;
1285	case HWC2_COMPOSITION_SIDEBAND:
1286	if (layerId == mVideoOverlayLayerId) {
1287	DTRACE("get HWC_SIDEBAND layer, just change to overlay");
1288	mHwcLayersChangeRequest.add(layerId, layer);
1289	mHwcLayersChangeType.add(layerId, layer);
1290	} else {
1291	ETRACE("SIDEBAND not handled.");
1292	}
1293	break;
1294	default:
1295	ETRACE("get layer of unknown composition type (%d)", layer->getCompositionType());
1296	break;
1297	}
1298	}
1299
1300	bool noDevComp = Utils::checkBoolProp("sys.sf.debug.nohwc");
1301	#ifndef USE_CONTINOUS_BUFFER_COMPOSER
1302	DTRACE("No continous buffer composer!");
1303	noDevComp = true;
1304	mIsContinuousBuf = false;
1305	#endif
1306
1307	if (mHwcLayers.size() == 0) {
1308	mIsContinuousBuf = false;
1309	}
1310
1311	// dumpLayers(mHwcLayers);
1312	if (mIsContinuousBuf && !noDevComp && (mHwcGlesLayers.size() == 0)) {
1313	mRenderMode = composersFilter(composeLayers);
1314	} else {
1315	mDirectComposeFrameCount = 0;
1316	}
1317
1318	// DEVICE_COMPOSE layers set to CLIENT_COMPOSE layers.
1319	for (int i=0; i<composeLayers.size(); i++) {
1320	mHwcLayersChangeType.add(composeLayers.keyAt(i), composeLayers.valueAt(i));
1321	mHwcGlesLayers.add(composeLayers.keyAt(i), composeLayers.valueAt(i));
1322	}
1323
1324	if (mHwcLayersChangeRequest.size() > 0) {
1325	DTRACE("There are %d layer requests.", mHwcLayersChangeRequest.size());
1326	*outNumRequests = mHwcLayersChangeRequest.size();
1327	}
1328
1329	mIsValidated = true;
1330
1331	if (mHwcLayersChangeType.size() > 0) {
1332	DTRACE("there are %d layer types has changed.", mHwcLayersChangeType.size());
1333	*outNumTypes = mHwcLayersChangeType.size();
1334	return HWC2_ERROR_HAS_CHANGES;
1335	}
1336
1337	return HWC2_ERROR_NONE;
1338	}
1339
1340	int32_t PhysicalDevice::setCursorPosition(hwc2_layer_t layerId, int32_t x, int32_t y) {
1341	HwcLayer* layer = getLayerById(layerId);
1342	if (layer && HWC2_COMPOSITION_CURSOR == layer->getCompositionType()) {
1343	framebuffer_info_t* cbInfo = mCursorContext->getInfo();
1344	fb_cursor cinfo;
1345	if (cbInfo->fd < 0) {
1346	ETRACE("setCursorPosition fd=%d", cbInfo->fd );
1347	}else {
1348	cinfo.hot.x = x;
1349	cinfo.hot.y = y;
1350	DTRACE("setCursorPosition x_pos=%d, y_pos=%d", cinfo.hot.x, cinfo.hot.y);
1351
1352	ioctl(cbInfo->fd, FBIOPUT_OSD_CURSOR, &cinfo);
1353	}
1354	} else {
1355	ETRACE("setCursorPosition bad layer.");
1356	return HWC2_ERROR_BAD_LAYER;
1357	}
1358
1359	return HWC2_ERROR_NONE;
1360	}
1361
1362
1363	/*
1364	Operater of framebuffer
1365	*/
1366	int32_t PhysicalDevice::initDisplay() {
1367	Mutex::Autolock _l(mLock);
1368
1369	if (!mFramebufferHnd) {
1370	// init framebuffer context.
1371	mFramebufferContext = new FBContext();
1372	framebuffer_info_t* fbInfo = mFramebufferContext->getInfo();
1373	// init information from osd.
1374	fbInfo->displayType = mId;
1375	fbInfo->fbIdx = getOsdIdx(mId);
1376	int32_t err = init_frame_buffer_locked(fbInfo);
1377	int32_t bufferSize = fbInfo->finfo.line_length
1378	* fbInfo->info.yres;
1379	DTRACE("init_frame_buffer get fbinfo->fbIdx (%d) "
1380	"fbinfo->info.xres (%d) fbinfo->info.yres (%d)",
1381	fbInfo->fbIdx, fbInfo->info.xres,
1382	fbInfo->info.yres);
1383	int32_t usage = 0;
1384
1385	mFramebufferHnd = new private_handle_t(
1386	private_handle_t::PRIV_FLAGS_FRAMEBUFFER,
1387	usage, fbInfo->fbSize, 0,
1388	0, fbInfo->fd, bufferSize, 0);
1389
1390	DTRACE("init_frame_buffer get frame size %d usage %d",
1391	bufferSize, usage);
1392	}
1393
1394	// init cursor framebuffer
1395	mCursorContext = new FBContext();
1396	framebuffer_info_t* cbInfo = mCursorContext->getInfo();
1397	cbInfo->fd = -1;
1398
1399	//init information from cursor framebuffer.
1400	cbInfo->fbIdx = mId*2+1;
1401	if (1 != cbInfo->fbIdx && 3 != cbInfo->fbIdx) {
1402	ETRACE("invalid fb index: %d, need to check!",
1403	cbInfo->fbIdx);
1404	return 0;
1405	}
1406	int32_t err = init_cursor_buffer_locked(cbInfo);
1407	if (err != 0) {
1408	ETRACE("init_cursor_buffer_locked failed, need to check!");
1409	return 0;
1410	}
1411	ITRACE("init_cursor_buffer get cbinfo->fbIdx (%d) "
1412	"cbinfo->info.xres (%d) cbinfo->info.yres (%d)",
1413	cbInfo->fbIdx,
1414	cbInfo->info.xres,
1415	cbInfo->info.yres);
1416
1417	if ( cbInfo->fd >= 0) {
1418	DTRACE("init_cursor_buffer success!");
1419	}else{
1420	DTRACE("init_cursor_buffer fail!");
1421	}
1422
1423	return 0;
1424	}
1425
1426	void PhysicalDevice::updateActiveDisplayAttribute() {
1427	hwc2_config_t config;
1428	if (HWC2_ERROR_NONE == mDisplayHdmi->getRealActiveConfig(&config)) {
1429	int32_t period = 0;
1430	mDisplayHdmi->getDisplayAttribute(config, HWC2_ATTRIBUTE_VSYNC_PERIOD, &period);
1431	mVsyncObserver->setRefreshPeriod(period);
1432	}
1433
1434	calReverseScale();
1435	}
1436
1437	bool PhysicalDevice::updateDisplayConfigs() {
1438	Mutex::Autolock _l(mLock);
1439	framebuffer_info_t* fbinfo = mFramebufferContext->getInfo();
1440	mDisplayHdmi->updateHotplug(mConnectorPresent, *fbinfo);
1441
1442	if (mConnectorPresent) {
1443	updateActiveDisplayAttribute();
1444	} else {
1445	ETRACE("disp: %llu is not connected, should change mode to null", mId);
1446	// mDisplayHdmi->setBestDisplayMode();
1447	return false;
1448	}
1449
1450	// update HDR info.
1451	if (!mHdrCapabilities.init) {
1452	ETRACE("update hdr infomation.");
1453	parseHdrCapabilities();
1454	mHdrCapabilities.init = true;
1455	}
1456
1457	mSecure = mDisplayHdmi->isSecure();
1458	return true;
1459	}
1460
1461	void PhysicalDevice::onVsync(int64_t timestamp) {
1462	RETURN_VOID_IF_NOT_INIT();
1463	ATRACE("timestamp = %lld", timestamp);
1464
1465	if (!mConnectorPresent)
1466	return;
1467
1468	// notify hwc
1469	mHwc.vsync(mId, timestamp);
1470	}
1471
1472	void PhysicalDevice::onHotplug(int disp, bool connected) {
1473	RETURN_VOID_IF_NOT_INIT();
1474	ETRACE("connect status = (%d)", connected);
1475
1476	if (!mGetInitState) {
1477	mGetInitState = true;
1478	if (mDisplayHdmi->chkPresent()) {
1479	updateHotplugState(true);
1480	}
1481	}
1482
1483	if (!updateDisplayConfigs())
1484	ETRACE("failed to update display config");
1485
1486	// notify hwc
1487	if (connected)
1488	mHwc.hotplug(disp, connected);
1489	}
1490
1491	int32_t PhysicalDevice::createVirtualDisplay(
1492	uint32_t width,
1493	uint32_t height,
1494	int32_t* /*android_pixel_format_t*/ format,
1495	hwc2_display_t* outDisplay) {
1496
1497	return HWC2_ERROR_NONE;
1498	}
1499
1500	int32_t PhysicalDevice::destroyVirtualDisplay(
1501	hwc2_display_t display) {
1502
1503	return HWC2_ERROR_NONE;
1504	}
1505
1506	int32_t PhysicalDevice::setOutputBuffer(
1507	buffer_handle_t buffer, int32_t releaseFence) {
1508	// Virtual Display Only.
1509	return HWC2_ERROR_NONE;
1510	}
1511
1512	void PhysicalDevice::updateHotplugState(bool connected) {
1513	Mutex::Autolock _l(mLock);
1514
1515	mConnectorPresent = connected;
1516	// if plug out, need reinit
1517	if (!connected)
1518	memset(&mHdrCapabilities, 0, sizeof(hdr_capabilities_t));
1519	}
1520
1521	int32_t PhysicalDevice::getLineValue(const char *lineStr, const char *magicStr) {
1522	int len = 0;
1523	char value[100] = {0};
1524	const char *pos = NULL;
1525
1526	if ((NULL == lineStr) || (NULL == magicStr)) {
1527	ETRACE("line string: %s, magic string: %s\n", lineStr, magicStr);
1528	return 0;
1529	}
1530
1531	if (NULL != (pos = strstr(lineStr, magicStr))) {
1532	pos = pos + strlen(magicStr);
1533	const char* start = pos;
1534	while (*start != '\n' && (strlen(start) > 0))
1535	start++;
1536
1537	len = start - pos;
1538	strncpy(value, pos, len);
1539	value[len] = '\0';
1540	return atoi(value);
1541	}
1542
1543	return 0;
1544	}
1545
1546	/*******************************************
1547	* cat /sys/class/amhdmitx/amhdmitx0/hdr_cap
1548	* Supported EOTF:
1549	* Traditional SDR: 1
1550	* Traditional HDR: 0
1551	* SMPTE ST 2084: 1
1552	* Future EOTF: 0
1553	* Supported SMD type1: 1
1554	* Luminance Data
1555	* Max: 0
1556	* Avg: 0
1557	* Min: 0
1558	* cat /sys/class/amhdmitx/amhdmitx0/dv_cap
1559	* DolbyVision1 RX support list:
1560	* 2160p30hz: 1
1561	* global dimming
1562	* colorimetry
1563	* IEEEOUI: 0x00d046
1564	* DM Ver: 1
1565	*******************************************/
1566	int32_t PhysicalDevice::parseHdrCapabilities() {
1567	// DolbyVision1
1568	const char *DV_PATH = "/sys/class/amhdmitx/amhdmitx0/dv_cap";
1569	// HDR
1570	const char *HDR_PATH = "/sys/class/amhdmitx/amhdmitx0/hdr_cap";
1571
1572	char buf[1024+1] = {0};
1573	char* pos = buf;
1574	int fd, len;
1575
1576	memset(&mHdrCapabilities, 0, sizeof(hdr_capabilities_t));
1577	if ((fd = open(DV_PATH, O_RDONLY)) < 0) {
1578	ETRACE("open %s fail.", DV_PATH);
1579	goto exit;
1580	}
1581
1582	len = read(fd, buf, 1024);
1583	if (len < 0) {
1584	ETRACE("read error: %s, %s\n", DV_PATH, strerror(errno));
1585	goto exit;
1586	}
1587	close(fd);
1588
1589	if ((NULL != strstr(pos, "2160p30hz")) || (NULL != strstr(pos, "2160p60hz")))
1590	mHdrCapabilities.dvSupport = true;
1591	// dobly version parse end
1592
1593	memset(buf, 0, 1024);
1594	if ((fd = open(HDR_PATH, O_RDONLY)) < 0) {
1595	ETRACE("open %s fail.", HDR_PATH);
1596	goto exit;
1597	}
1598
1599	len = read(fd, buf, 1024);
1600	if (len < 0) {
1601	ETRACE("read error: %s, %s\n", HDR_PATH, strerror(errno));
1602	goto exit;
1603	}
1604
1605	pos = strstr(pos, "SMPTE ST 2084: ");
1606	if ((NULL != pos) && ('1' == *(pos + strlen("SMPTE ST 2084: ")))) {
1607	mHdrCapabilities.hdrSupport = true;
1608
1609	mHdrCapabilities.maxLuminance = getLineValue(pos, "Max: ");
1610	mHdrCapabilities.avgLuminance = getLineValue(pos, "Avg: ");
1611	mHdrCapabilities.minLuminance = getLineValue(pos, "Min: ");
1612	}
1613
1614	ITRACE("dolby version support:%d, hdr support:%d max:%d, avg:%d, min:%d\n",
1615	mHdrCapabilities.dvSupport?1:0, mHdrCapabilities.hdrSupport?1:0, mHdrCapabilities.maxLuminance, mHdrCapabilities.avgLuminance, mHdrCapabilities.minLuminance);
1616	exit:
1617	close(fd);
1618	return HWC2_ERROR_NONE;
1619	}
1620
1621	void PhysicalDevice::dump(Dump& d) {
1622	Mutex::Autolock _l(mLock);
1623	d.append("-------------------------------------------------------------"
1624	"----------------------------------------------------------------\n");
1625	d.append("Device Name: %s (%s), (%f, %f)\n", mName,
1626	mConnectorPresent ? "connected" : "disconnected",
1627	mReverseScaleX, mReverseScaleY);
1628
1629	d.append("isSecure : %s\n", mSecure ? "TRUE" : "FALSE");
1630
1631	mDisplayHdmi->dump(d);
1632
1633	#if 0 //all the info already dumped by SurfaceFlinger, comment it.
1634	// dump layer list
1635	d.append(" Layers state:\n");
1636	d.append(" numLayers=%zu\n", mHwcLayers.size());
1637	// d.append(" numChangedTypeLayers=%zu\n", mHwcLayersChangeType.size());
1638	// d.append(" numChangedRequestLayers=%zu\n", mHwcLayersChangeRequest.size());
1639
1640	if (mHwcLayers.size() > 0) {
1641	d.append(
1642	" type | handle | zorder | ds | alpa | tr | blnd |"
1643	" source crop (l,t,r,b) | frame \n"
1644	" -------------+--------------+------------+----+------+----+------+"
1645	"--------------------------------+------------------------\n");
1646	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
1647	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
1648	HwcLayer *layer = mHwcLayers.valueAt(i);
1649	if (layer) layer->dump(d);
1650	}
1651	}
1652	#endif
1653
1654	// HDR info
1655	d.append(" HDR Capabilities:\n");
1656	d.append(" DolbyVision1=%zu\n", mHdrCapabilities.dvSupport?1:0);
1657	d.append(" HDR10=%zu, maxLuminance=%zu, avgLuminance=%zu, minLuminance=%zu\n",
1658	mHdrCapabilities.hdrSupport?1:0, mHdrCapabilities.maxLuminance, mHdrCapabilities.avgLuminance, mHdrCapabilities.minLuminance);
1659	}
1660
1661	} // namespace amlogic
1662	} // namespace android
1663