path: root/hwc2/common/devices/PhysicalDevice.cpp (plain)
blob: 69264f81d3e57f13317dbf0926dbb65645f23b14

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	bool bUseHwcPost = true;
648
649	framebuffer_info_t fbInfo = *(mFramebufferContext->getInfo());
650	bool cursorShow = false;
651	cursorShow = updateCursorBuffer();
652
653	if (mRenderMode == GLES_COMPOSE_MODE) {
654	//if no layers to compose, post blank op to osd.
655	if (mPreviousRenderMode != GLES_COMPOSE_MODE && mHwcGlesLayers.size() == 0) {
656	mClientTargetHnd = NULL;
657	}
658	} else if (mRenderMode == DIRECT_COMPOSE_MODE) { // if only one layer exists, let hwc do her work.
659	directCompose(&fbInfo);
660	}
661	#ifdef ENABLE_AML_GE2D_COMPOSER
662	else if (mRenderMode == GE2D_COMPOSE_MODE) {
663	ge2dCompose(&fbInfo, hasVideoOverlay);
664	}
665	#endif
666	mFbSyncRequest.type = mRenderMode;
667
668	if (!mClientTargetHnd || private_handle_t::validate(mClientTargetHnd) < 0 || mPowerMode == HWC2_POWER_MODE_OFF) {
669	DTRACE("Post blank to screen, mClientTargetHnd(%p, %d), mTargetAcquireFence(%d)",
670	mClientTargetHnd, private_handle_t::validate(mClientTargetHnd), mTargetAcquireFence);
671	*outRetireFence = HwcFenceControl::merge(String8("ScreenBlank"), mPriorFrameRetireFence, mPriorFrameRetireFence);
672	HwcFenceControl::closeFd(mTargetAcquireFence);
673	mTargetAcquireFence = -1;
674	HwcFenceControl::closeFd(mPriorFrameRetireFence);
675	mPriorFrameRetireFence = -1;
676	//for nothing to display, post blank to osd which will signal the last retire fence.
677	mFbSyncRequest.type = DIRECT_COMPOSE_MODE;
678	mFbSyncRequest.op |= OSD_BLANK_OP_BIT;
679	mFramebufferContext->setStatus(true);
680	mPriorFrameRetireFence = hwc_fb_post_with_fence_locked(&fbInfo, &mFbSyncRequest, NULL);
681	} else {
682	*outRetireFence = HwcFenceControl::dupFence(mPriorFrameRetireFence);
683	if (*outRetireFence >= 0) {
684	DTRACE("Get prior frame's retire fence %d", *outRetireFence);
685	} else {
686	ETRACE("No valid prior frame's retire returned. %d ", *outRetireFence);
687	// -1 means no fence, less than -1 is some error
688	*outRetireFence = -1;
689	}
690	HwcFenceControl::closeFd(mPriorFrameRetireFence);
691	mPriorFrameRetireFence = -1;
692
693	bool needBlankFb0 = false;
694	uint32_t layerNum = mHwcLayers.size();
695	if (hasVideoOverlay
696	&& (layerNum == 1
697	|| (layerNum == 2
698	&& cursorShow))) {
699	needBlankFb0 = true;
700	}
701
702	//close uboot logo, if bootanim begin to show
703	if (mFirstPostFb) {
704	mFirstPostFb = false;
705
706	Utils::setSysfsStr(DISPLAY_LOGO_INDEX, "-1");
707	Utils::setSysfsStr(DISPLAY_FB0_FREESCALE_SWTICH, "0x10001");
708	}
709
710	// real post framebuffer here.
711	DTRACE("render type: %d", mFbSyncRequest.type);
712
713	if (!bUseHwcPost) {
714	setOSD0Blank(needBlankFb0);
715	mPriorFrameRetireFence = fb_post_with_fence_locked(&fbInfo, mClientTargetHnd, mTargetAcquireFence);
716	} else {
717	// bit 0 is osd blank flag.
718	if (needBlankFb0) {
719	mFbSyncRequest.op |= OSD_BLANK_OP_BIT;
720	} else {
721	mFbSyncRequest.op &= ~(OSD_BLANK_OP_BIT);
722	}
723	mFramebufferContext->setStatus(needBlankFb0);
724	// acquire fence.
725	mFbSyncRequest.in_fen_fd = mTargetAcquireFence;
726	mPriorFrameRetireFence = hwc_fb_post_with_fence_locked(&fbInfo, &mFbSyncRequest, mClientTargetHnd);
727	}
728	mTargetAcquireFence = -1;
729
730	if (mRenderMode == GE2D_COMPOSE_MODE) {
731	mComposer->mergeRetireFence(mFbSlot, HwcFenceControl::dupFence(mPriorFrameRetireFence));
732	} else {
733	if (mComposer && mGE2DComposeFrameCount != 0) {
734	mComposer->removeRetireFence(mFbSlot);
735	}
736
737	if (mRenderMode == DIRECT_COMPOSE_MODE) {
738	addReleaseFence(mDirectRenderLayerId, HwcFenceControl::dupFence(mPriorFrameRetireFence));
739	}
740	}
741
742	// finally we need to update cursor's blank status.
743	setOSD1Blank(cursorShow);
744	}
745
746	if (mRenderMode != GE2D_COMPOSE_MODE) {
747	mGE2DComposeFrameCount = 0;
748	}
749
750	return HWC2_ERROR_NONE;
751	}
752
753	// deal physical display's client target layer
754	bool PhysicalDevice::updateCursorBuffer() {
755	framebuffer_info_t* cbInfo = mCursorContext->getInfo();
756	HwcLayer* layer = NULL;
757	void *cbuffer;
758
759	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
760	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
761	layer = mHwcLayers.valueAt(i);
762	if (layer && layer->getCompositionType()== HWC2_COMPOSITION_CURSOR) {
763	private_handle_t *hnd = private_handle_t::dynamicCast(layer->getBufferHandle());
764	if (!hnd) {
765	ETRACE("invalid cursor layer handle.");
766	break;
767	}
768	DTRACE("This is a Sprite, hnd->width is %d(%d), hnd->height is %d",
769	hnd->width, hnd->stride, hnd->height);
770	if (cbInfo->info.xres != (uint32_t)hnd->stride || cbInfo->info.yres != (uint32_t)hnd->height) {
771	DTRACE("disp: %d cursor need to redrew", mId);
772	update_cursor_buffer_locked(cbInfo, hnd->stride, hnd->height);
773	cbuffer = mmap(NULL, hnd->size, PROT_READ|PROT_WRITE, MAP_SHARED, cbInfo->fd, 0);
774	if (cbuffer != MAP_FAILED) {
775	memset(cbuffer, 1, hnd->size);
776
777	uint32_t irow = 0;
778	char* cpyDst = (char*)cbuffer;
779	char* cpySrc = (char*)hnd->base;
780	for (irow = 0; irow < hnd->height; irow++) {
781	memcpy(cpyDst, cpySrc, 4 * hnd->width);
782	cpyDst += 4 * hnd->stride;
783	cpySrc += 4 * hnd->stride;
784	}
785	munmap(cbuffer, hnd->size);
786	DTRACE("setCursor ok");
787	} else {
788	ETRACE("Cursor display buffer mmap fail!");
789	}
790	}
791	return true;
792	}
793	}
794	return false;
795	}
796
797	int32_t PhysicalDevice::setOSD1Blank(bool cursorShow) {
798	framebuffer_info_t* cbInfo = mCursorContext->getInfo();
799
800	if (cbInfo->fd > 0 && cursorShow != mCursorContext->getStatus()) {
801	mCursorContext->setStatus(cursorShow);
802	DTRACE("UPDATE FB1 status to %d", !cursorShow);
803	ioctl(cbInfo->fd, FBIOBLANK, !cursorShow);
804	}
805
806	return HWC2_ERROR_NONE;
807	}
808
809	// TODO: need add fence wait.
810	int32_t PhysicalDevice::setOSD0Blank(bool blank) {
811	framebuffer_info_t* fbInfo = mFramebufferContext->getInfo();
812
813	if (fbInfo->fd > 0 && blank != mFramebufferContext->getStatus()) {
814	mFramebufferContext->setStatus(blank);
815	DTRACE("UPDATE FB0 status to %d", blank);
816	ioctl(fbInfo->fd, FBIOBLANK, blank);
817	}
818
819	return HWC2_ERROR_NONE;
820	}
821
822	int32_t PhysicalDevice::presentDisplay(
823	int32_t* outRetireFence) {
824	int32_t err = HWC2_ERROR_NONE;
825	HwcLayer* layer = NULL;
826	bool hasVideoOverlay = false;
827
828	if (mIsValidated) {
829	// TODO: need improve the way to set video axis.
830	bool bPresent = true;
831	if (mHwcSecureLayers.indexOfKey(mVideoOverlayLayerId) >= 0) {
832	bPresent = false;
833	}
834
835	ssize_t index = mHwcLayers.indexOfKey(mVideoOverlayLayerId);
836	if (index >= 0) {
837	layer = mHwcLayers.valueFor(mVideoOverlayLayerId);
838	if (layer != NULL) {
839	layer->presentOverlay(bPresent);
840	hasVideoOverlay = true;
841	if (mGE2DClearVideoRegionCount < 3) {
842	mGE2DClearVideoRegionCount++;
843	}
844	}
845	} else {
846	mGE2DClearVideoRegionCount = 0;
847	}
848	err = postFramebuffer(outRetireFence, hasVideoOverlay);
849	} else { // display not validate yet.
850	err = HWC2_ERROR_NOT_VALIDATED;
851	}
852
853	finishCompose();
854	return err;
855	}
856
857	int32_t PhysicalDevice::setActiveConfig(
858	hwc2_config_t config) {
859	Mutex::Autolock _l(mLock);
860
861	int32_t err = mDisplayHdmi->setActiveConfig(config);
862	if (err == HWC2_ERROR_NONE) {
863	updateActiveDisplayAttribute();
864	}
865
866	return err;
867	}
868
869	int32_t PhysicalDevice::setClientTarget(
870	buffer_handle_t target,
871	int32_t acquireFence,
872	int32_t /*android_dataspace_t*/ dataspace,
873	hwc_region_t damage) {
874
875	if (target && private_handle_t::validate(target) < 0) {
876	return HWC2_ERROR_BAD_PARAMETER;
877	}
878
879	if (NULL != target) {
880	mClientTargetHnd = target;
881	mClientTargetDamageRegion = damage;
882	mTargetAcquireFence = acquireFence;
883	DTRACE("setClientTarget %p, %d", target, acquireFence);
884	// TODO: HWC2_ERROR_BAD_PARAMETER && dataspace && damage.
885	} else {
886	DTRACE("client target is null!, no need to update this frame.");
887	}
888
889	return HWC2_ERROR_NONE;
890	}
891
892	int32_t PhysicalDevice::setColorMode(
893	int32_t /*android_color_mode_t*/ mode) {
894	return HWC2_ERROR_NONE;
895	}
896
897	int32_t PhysicalDevice::setColorTransform(
898	const float* matrix,
899	int32_t /*android_color_transform_t*/ hint) {
900	return HWC2_ERROR_NONE;
901	}
902
903	int32_t PhysicalDevice::setPowerMode(
904	int32_t /*hwc2_power_mode_t*/ mode){
905
906	mPowerMode = mode;
907	return HWC2_ERROR_NONE;
908	}
909
910	bool PhysicalDevice::vsyncControl(bool enabled) {
911	RETURN_FALSE_IF_NOT_INIT();
912
913	ATRACE("disp = %d, enabled = %d", mId, enabled);
914	return mVsyncObserver->control(enabled);
915	}
916
917	void PhysicalDevice::dumpLayers(Vector < hwc2_layer_t > layerIds) {
918	for (uint32_t x=0; x<layerIds.size(); x++) {
919	HwcLayer* layer = getLayerById(layerIds.itemAt(x));
920	static char const* compositionTypeName[] = {
921	"UNKNOWN",
922	"GLES",
923	"HWC",
924	"SOLID",
925	"HWC_CURSOR",
926	"SIDEBAND"};
927	ETRACE(" %11s | %12" PRIxPTR " | %10d | %02x | %1.2f | %02x | %04x |%7.1f,%7.1f,%7.1f,%7.1f |%5d,%5d,%5d,%5d \n",
928	compositionTypeName[layer->getCompositionType()],
929	intptr_t(layer->getBufferHandle()), layer->getZ(), layer->getDataspace(),
930	layer->getPlaneAlpha(), layer->getTransform(), layer->getBlendMode(),
931	layer->getSourceCrop().left, layer->getSourceCrop().top, layer->getSourceCrop().right, layer->getSourceCrop().bottom,
932	layer->getDisplayFrame().left, layer->getDisplayFrame().top, layer->getDisplayFrame().right, layer->getDisplayFrame().bottom);
933	}
934	}
935
936	void PhysicalDevice::dumpLayers(KeyedVector<hwc2_layer_t, HwcLayer*> layers) {
937	for (uint32_t x=0; x<layers.size(); x++) {
938	HwcLayer* layer = layers.valueAt(x);
939	static char const* compositionTypeName[] = {
940	"UNKNOWN",
941	"GLES",
942	"HWC",
943	"SOLID",
944	"HWC_CURSOR",
945	"SIDEBAND"};
946	ETRACE(" %11s | %12" PRIxPTR " | %10d | %02x | %1.2f | %02x | %04x |%7.1f,%7.1f,%7.1f,%7.1f |%5d,%5d,%5d,%5d \n",
947	compositionTypeName[layer->getCompositionType()],
948	intptr_t(layer->getBufferHandle()), layer->getZ(), layer->getDataspace(),
949	layer->getPlaneAlpha(), layer->getTransform(), layer->getBlendMode(),
950	layer->getSourceCrop().left, layer->getSourceCrop().top, layer->getSourceCrop().right, layer->getSourceCrop().bottom,
951	layer->getDisplayFrame().left, layer->getDisplayFrame().top, layer->getDisplayFrame().right, layer->getDisplayFrame().bottom);
952	}
953	}
954
955	bool PhysicalDevice::layersStateCheck(int32_t renderMode,
956	KeyedVector<hwc2_layer_t, HwcLayer*> & composeLayers) {
957	bool ret = false;
958	uint32_t layerNum = composeLayers.size();
959	hwc_frect_t sourceCrop[HWC2_MAX_LAYERS];
960	HwcLayer* layer[HWC2_MAX_LAYERS] = { NULL };
961	private_handle_t const* hnd[HWC2_MAX_LAYERS] = { NULL };
962	hwc_rect_t displayFrame[HWC2_MAX_LAYERS];
963
964	for (int32_t i=0; i<layerNum; i++) {
965	layer[i] = composeLayers.valueAt(i);
966	sourceCrop[i] = layer[i]->getSourceCrop();
967	displayFrame[i] = layer[i]->getDisplayFrame();
968	hnd[i] = private_handle_t::dynamicCast(layer[i]->getBufferHandle());
969	if (hnd[i] == NULL) return false; // no buffer to process.
970	if (hnd[i]->share_fd == -1) return false; // no buffer to process.
971	if ((sourceCrop[i].right - sourceCrop[i].left > HWC2_HW_COMPOSE_WIDTH_MAX) ||
972	(sourceCrop[i].bottom - sourceCrop[i].top > HWC2_HW_COMPOSE_HEIGHT_MAX)) {
973	return false;
974	}
975	DTRACE("layer[%d] zorder: %d, blend: %d, PlaneAlpha: %f, "
976	"mColor: [%d, %d, %d, %d], mDataSpace: %d, format hnd[%d]: %x",
977	i, layer[i]->getZ(), layer[i]->getBlendMode(), layer[i]->getPlaneAlpha(),
978	layer[i]->getColor().r, layer[i]->getColor().g, layer[i]->getColor().b,
979	layer[i]->getColor().a, layer[i]->getDataspace(), i, hnd[i]->format);
980	}
981
982	if (renderMode == DIRECT_COMPOSE_MODE) {
983	switch (hnd[0]->format) {
984	case HAL_PIXEL_FORMAT_RGBA_8888:
985	case HAL_PIXEL_FORMAT_RGBX_8888:
986	case HAL_PIXEL_FORMAT_RGB_888:
987	case HAL_PIXEL_FORMAT_RGB_565:
988	case HAL_PIXEL_FORMAT_BGRA_8888:
989	DTRACE("Layer format match direct composer.");
990	ret = true;
991	break;
992	default:
993	DTRACE("Layer format not support by direct compose");
994	return false;
995	break;
996	}
997	if (layer[0]->getTransform() != 0) {
998	//DTRACE("Direct composer can NOT support rotation now.");
999	return false;
1000	}
1001	}
1002	#ifdef ENABLE_AML_GE2D_COMPOSER
1003	else if (renderMode == GE2D_COMPOSE_MODE) {
1004	bool yuv420Sp = false;
1005	for (int32_t i=0; i<layerNum; i++) {
1006	switch (hnd[i]->format) {
1007	case HAL_PIXEL_FORMAT_YCrCb_420_SP:
1008	yuv420Sp = true;
1009	case HAL_PIXEL_FORMAT_RGBA_8888:
1010	case HAL_PIXEL_FORMAT_RGBX_8888:
1011	case HAL_PIXEL_FORMAT_RGB_888:
1012	case HAL_PIXEL_FORMAT_RGB_565:
1013	case HAL_PIXEL_FORMAT_BGRA_8888:
1014	case HAL_PIXEL_FORMAT_YV12:
1015	case HAL_PIXEL_FORMAT_Y8:
1016	case HAL_PIXEL_FORMAT_YCbCr_422_SP:
1017	case HAL_PIXEL_FORMAT_YCbCr_422_I:
1018	DTRACE("Layer format match ge2d composer.");
1019	ret = true;
1020	break;
1021	default:
1022	DTRACE("Layer format not support by ge2d");
1023	return false;
1024	break;
1025	}
1026	if (layer[i]->havePlaneAlpha()
1027	|| layer[i]->haveColor()
1028	|| layer[i]->haveDataspace()
1029	|| (layer[i]->isBlended()
1030	&& layer[i]->isScaled())) {
1031	DTRACE("ge2d compose can not process!");
1032	return false;
1033	}
1034	}
1035	#if 0
1036	if (yuv420Sp && HWC2_TWO_LAYERS == layerNum) {
1037	if (Utils::compareRect(sourceCrop[0], sourceCrop[1])
1038	&& Utils::compareRect(sourceCrop[0], displayFrame[0])
1039	&& Utils::compareRect(sourceCrop[1], displayFrame[1])) {
1040	DTRACE("2 layers is same size and have yuv420sp format ge2d compose can not process!");
1041	return false;
1042	}
1043	}
1044	#endif
1045	if (HWC2_TWO_LAYERS == layerNum
1046	&& (layer[0]->isScaled() || layer[1]->isScaled())) {
1047	DTRACE("when 2 layer's size is difference, ge2d compose can not process!");
1048	return false;
1049	}
1050	}
1051	#endif
1052
1053	return ret;
1054	}
1055
1056	/*************************************************************
1057	* For direct framebuffer composer:
1058	* 1) only support one layer.
1059	* 2) layer format: rgba, rgbx,rgb565,bgra;
1060	* 3) layer no rotation.
1061
1062	* For ge2d composer:
1063	* 1) support layer format that direct composer can't support.
1064	* 2) support 2 layers blending.
1065	* 3) support scale and rotation etc.
1066	**************************************************************/
1067	int32_t PhysicalDevice::composersFilter(
1068	KeyedVector<hwc2_layer_t, HwcLayer*> & composeLayers) {
1069
1070	// direct Composer.
1071	if (composeLayers.size() == HWC2_ONE_LAYER) {
1072	// if only one layer exists, do direct framebuffer composer.
1073	bool directCompose = layersStateCheck(DIRECT_COMPOSE_MODE, composeLayers);
1074	if (directCompose) {
1075	if (mDirectComposeFrameCount >= 3) {
1076	hwc2_layer_t layerGlesLayerId = composeLayers.keyAt(0);
1077	composeLayers.clear();
1078	mDirectRenderLayerId = layerGlesLayerId;
1079	return DIRECT_COMPOSE_MODE;
1080	}
1081	mDirectComposeFrameCount++;
1082	return GLES_COMPOSE_MODE;
1083	}
1084	}
1085
1086	#ifdef ENABLE_AML_GE2D_COMPOSER
1087	// if direct composer can't work, try this.
1088	if (composeLayers.size() > HWC2_NO_LAYER
1089	&& composeLayers.size() < HWC2_MAX_LAYERS) {
1090	bool ge2dCompose = layersStateCheck(GE2D_COMPOSE_MODE, composeLayers);
1091	if (!ge2dCompose) return GLES_COMPOSE_MODE;
1092	mGE2DRenderSortedLayerIds.clear();
1093	for (uint32_t i=0; i<composeLayers.size(); i++) {
1094	hwc2_layer_t layerGlesLayerId = composeLayers.keyAt(i);
1095	HwcLayer* layer = getLayerById(layerGlesLayerId);
1096	if (0 == i) {
1097	mGE2DRenderSortedLayerIds.push_front(layerGlesLayerId);
1098	continue;
1099	}
1100	for (uint32_t j=0; j<i; j++) {
1101	HwcLayer* layer1 = getLayerById(mGE2DRenderSortedLayerIds.itemAt(j));
1102	HwcLayer* layer2 = getLayerById(layerGlesLayerId);
1103	if (layer1 != NULL && layer2 != NULL) {
1104	uint32_t z1 = layer1->getZ();
1105	uint32_t z2 = layer2->getZ();
1106	if (layer1->getZ() > layer2->getZ()) {
1107	mGE2DRenderSortedLayerIds.insertAt(layerGlesLayerId, j, 1);
1108	break;
1109	}
1110	if (j == i-1) mGE2DRenderSortedLayerIds.push_back(layerGlesLayerId);
1111	} else {
1112	ETRACE("Layer1 or Layer2 is NULL!!!");
1113	}
1114	}
1115	}
1116
1117	// Vector < hwc2_layer_t > layerIds;
1118	if (!mComposer) {
1119	// create ge2d composer...
1120	mComposer = mControlFactory->createComposer(*this);
1121	if (!mComposer || !mComposer->initialize(mFramebufferContext->getInfo())) {
1122	DEINIT_AND_DELETE_OBJ(mComposer);
1123	return GLES_COMPOSE_MODE;
1124	}
1125	}
1126	composeLayers.clear();
1127	return GE2D_COMPOSE_MODE;
1128	}
1129	#endif
1130
1131	return GLES_COMPOSE_MODE;
1132	}
1133
1134	bool PhysicalDevice::calReverseScale() {
1135	static float fb_w = 1920; // Query activeConfig for FB size?
1136	static float fb_h = 1080; // Query activeConfig for FB size?
1137
1138	mReverseScaleX = mReverseScaleY = 0.0f;
1139	if (fb_w <= 0.01f || fb_h <= 0.01f)
1140	return false;
1141
1142	float display_w, display_h;
1143	hwc2_config_t config;
1144	if (HWC2_ERROR_NONE != mDisplayHdmi->getRealActiveConfig(&config))
1145	return false;
1146
1147	int32_t tmpSize = 0.0f;
1148	if ( mDisplayHdmi->getDisplayAttribute(config,
1149	HWC2_ATTRIBUTE_WIDTH, &tmpSize) != NO_ERROR)
1150	return false;
1151	display_w = tmpSize;
1152	if ( mDisplayHdmi->getDisplayAttribute(config,
1153	HWC2_ATTRIBUTE_HEIGHT, &tmpSize) != NO_ERROR)
1154	return false;
1155	display_h = tmpSize;
1156
1157	if (display_w <= 0.01f || display_h <= 0.01f)
1158	return false;
1159
1160	mReverseScaleX = fb_w / display_w;
1161	mReverseScaleY = fb_h /display_h;
1162	return false;
1163	}
1164
1165	int32_t PhysicalDevice::preValidate() {
1166	bool bScale = (mReverseScaleX >= 0.01f && mReverseScaleX >= 0.01f) ? true : false;
1167	HwcLayer* layer = NULL;
1168	//find out video layer first.
1169	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
1170	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
1171	layer = mHwcLayers.valueAt(i);
1172	if (!layer) {
1173	ETRACE("Meet empty layer, id(%lld)", layerId);
1174	continue;
1175	}
1176
1177	if (bScale && (layer->getDisplayFrame().right >= 3800))
1178	layer->reverseScaledFrame(mReverseScaleX, mReverseScaleY);
1179
1180	private_handle_t const* hnd = private_handle_t::dynamicCast(layer->getBufferHandle());
1181	if (hnd && !((hnd->flags & private_handle_t::PRIV_FLAGS_CONTINUOUS_BUF)
1182	|| (hnd->flags & private_handle_t::PRIV_FLAGS_VIDEO_OVERLAY))) {
1183	mIsContinuousBuf = false;
1184	}
1185
1186	if ((hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_VIDEO_OVERLAY) &&
1187	(layer->getCompositionType() == HWC2_COMPOSITION_DEVICE)) ||
1188	(layer->getCompositionType() == HWC2_COMPOSITION_SIDEBAND
1189	/* && layer->getSidebandStream()*/)) {
1190	if (mVideoOverlayLayerId != 0) {
1191	ETRACE("ERROR: Find two video layer, should never get here !!");
1192	}
1193	mVideoOverlayLayerId = layerId;
1194	}
1195	}
1196
1197	return HWC2_ERROR_NONE;
1198	}
1199
1200	int32_t PhysicalDevice::beginCompose() {
1201	swapReleaseFence();
1202	// reset layer changed or requested size to zero.
1203	mHwcLayersChangeType.clear();
1204	mHwcLayersChangeRequest.clear();
1205	mHwcGlesLayers.clear();
1206	// deal non secure display device.
1207	mHwcSecureLayers.clear();
1208
1209	memset(&mFbSyncRequest, 0, sizeof(mFbSyncRequest));
1210	mFbSyncRequest.in_fen_fd = -1;
1211
1212	mVideoOverlayLayerId = 0;
1213	mIsContinuousBuf = true;
1214	mIsValidated = false;
1215	mRenderMode = GLES_COMPOSE_MODE;
1216
1217	return HWC2_ERROR_NONE;
1218	}
1219
1220	int32_t PhysicalDevice::finishCompose() {
1221	HwcLayer* layer = NULL;
1222	// reset layers' acquire fence.
1223	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
1224	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
1225	layer = mHwcLayers.valueAt(i);
1226	if (layer != NULL) {
1227	layer->resetAcquireFence();
1228	}
1229	}
1230
1231	mClientTargetHnd = NULL;
1232	mPreviousRenderMode = mRenderMode;
1233	return HWC2_ERROR_NONE;
1234	}
1235
1236	int32_t PhysicalDevice::validateDisplay(uint32_t* outNumTypes,
1237	uint32_t* outNumRequests) {
1238	HwcLayer* layer = NULL, *videoLayer = NULL;
1239	hwc_rect_t videoRect;
1240	KeyedVector<hwc2_layer_t, HwcLayer*> composeLayers;
1241	composeLayers.clear();
1242
1243	beginCompose();
1244
1245	if (preValidate() != HWC2_ERROR_NONE) {
1246	return HWC2_ERROR_BAD_LAYER;
1247	}
1248
1249	if (mVideoOverlayLayerId) {
1250	videoLayer = mHwcLayers.valueFor(mVideoOverlayLayerId);
1251	videoRect = videoLayer->getDisplayFrame();
1252	}
1253
1254	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
1255	int overlapType = Utils::OVERLAP_EMPTY;
1256	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
1257	layer = mHwcLayers.valueAt(i);
1258	if (!layer)
1259	continue;
1260
1261	private_handle_t const* hnd = private_handle_t::dynamicCast(layer->getBufferHandle());
1262
1263	#ifdef HWC_SUPPORT_SECURE_LAYER
1264	// secure or protected layer.
1265	if (!mSecure && hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_PROTECTED)) {
1266	DTRACE("layer's secure or protected buffer flag is set! usage (%x)", hnd->flags);
1267	if (layer->getCompositionType() != HWC2_COMPOSITION_DEVICE) {
1268	mHwcLayersChangeType.add(layerId, layer);
1269	}
1270	mHwcSecureLayers.add(layerId, layer);
1271	continue;
1272	}
1273	#endif
1274	if (hnd && hnd->flags & private_handle_t::PRIV_FLAGS_VIDEO_OMX) {
1275	set_omx_pts((char*)hnd->base, &mOmxVideoHandle);
1276	}
1277
1278	if (videoLayer && (layer->getZ() < videoLayer->getZ())) {
1279	DTRACE("Layer covered by video layer.");
1280	hwc_rect_t layerRect = layer->getDisplayFrame();
1281	overlapType = Utils::rectOverlap(layerRect, videoRect);
1282	}
1283
1284	switch (layer->getCompositionType()) {
1285	case HWC2_COMPOSITION_CLIENT:
1286	mHwcGlesLayers.add(layerId, layer);
1287	DTRACE("Meet a client layer!");
1288	break;
1289	case HWC2_COMPOSITION_DEVICE:
1290	if (layerId == mVideoOverlayLayerId) {
1291	mHwcLayersChangeRequest.add(layerId, layer);
1292	} else {
1293	composeLayers.add(layerId, layer);
1294	}
1295	break;
1296	case HWC2_COMPOSITION_SOLID_COLOR:
1297	if (overlapType != Utils::OVERLAP_FULL) {
1298	mHwcGlesLayers.add(layerId, layer);
1299	mHwcLayersChangeType.add(layerId, layer);
1300	}
1301	break;
1302	case HWC2_COMPOSITION_CURSOR:
1303	DTRACE("This is a Cursor layer!");
1304	mHwcLayersChangeRequest.add(layerId, layer);
1305	break;
1306	case HWC2_COMPOSITION_SIDEBAND:
1307	if (layerId == mVideoOverlayLayerId) {
1308	DTRACE("get HWC_SIDEBAND layer, just change to overlay");
1309	mHwcLayersChangeRequest.add(layerId, layer);
1310	mHwcLayersChangeType.add(layerId, layer);
1311	} else {
1312	ETRACE("SIDEBAND not handled.");
1313	}
1314	break;
1315	default:
1316	ETRACE("get layer of unknown composition type (%d)", layer->getCompositionType());
1317	break;
1318	}
1319	}
1320
1321	bool noDevComp = Utils::checkBoolProp("sys.sf.debug.nohwc");
1322	#ifndef USE_CONTINOUS_BUFFER_COMPOSER
1323	DTRACE("No continous buffer composer!");
1324	noDevComp = true;
1325	mIsContinuousBuf = false;
1326	#endif
1327
1328	if (mHwcLayers.size() == 0) {
1329	mIsContinuousBuf = false;
1330	}
1331
1332	// dumpLayers(mHwcLayers);
1333	if (mIsContinuousBuf && !noDevComp && (mHwcGlesLayers.size() == 0)) {
1334	mRenderMode = composersFilter(composeLayers);
1335	} else {
1336	mDirectComposeFrameCount = 0;
1337	}
1338
1339	// DEVICE_COMPOSE layers set to CLIENT_COMPOSE layers.
1340	for (int i=0; i<composeLayers.size(); i++) {
1341	mHwcLayersChangeType.add(composeLayers.keyAt(i), composeLayers.valueAt(i));
1342	mHwcGlesLayers.add(composeLayers.keyAt(i), composeLayers.valueAt(i));
1343	}
1344
1345	if (mHwcLayersChangeRequest.size() > 0) {
1346	DTRACE("There are %d layer requests.", mHwcLayersChangeRequest.size());
1347	*outNumRequests = mHwcLayersChangeRequest.size();
1348	}
1349
1350	mIsValidated = true;
1351
1352	if (mHwcLayersChangeType.size() > 0) {
1353	DTRACE("there are %d layer types has changed.", mHwcLayersChangeType.size());
1354	*outNumTypes = mHwcLayersChangeType.size();
1355	return HWC2_ERROR_HAS_CHANGES;
1356	}
1357
1358	return HWC2_ERROR_NONE;
1359	}
1360
1361	int32_t PhysicalDevice::setCursorPosition(hwc2_layer_t layerId, int32_t x, int32_t y) {
1362	HwcLayer* layer = getLayerById(layerId);
1363	if (layer && HWC2_COMPOSITION_CURSOR == layer->getCompositionType()) {
1364	framebuffer_info_t* cbInfo = mCursorContext->getInfo();
1365	fb_cursor cinfo;
1366	if (cbInfo->fd < 0) {
1367	ETRACE("setCursorPosition fd=%d", cbInfo->fd );
1368	}else {
1369	cinfo.hot.x = x;
1370	cinfo.hot.y = y;
1371	DTRACE("setCursorPosition x_pos=%d, y_pos=%d", cinfo.hot.x, cinfo.hot.y);
1372
1373	ioctl(cbInfo->fd, FBIOPUT_OSD_CURSOR, &cinfo);
1374	}
1375	} else {
1376	ETRACE("setCursorPosition bad layer.");
1377	return HWC2_ERROR_BAD_LAYER;
1378	}
1379
1380	return HWC2_ERROR_NONE;
1381	}
1382
1383
1384	/*
1385	Operater of framebuffer
1386	*/
1387	int32_t PhysicalDevice::initDisplay() {
1388	Mutex::Autolock _l(mLock);
1389
1390	if (!mFramebufferHnd) {
1391	// init framebuffer context.
1392	mFramebufferContext = new FBContext();
1393	framebuffer_info_t* fbInfo = mFramebufferContext->getInfo();
1394	// init information from osd.
1395	fbInfo->displayType = mId;
1396	fbInfo->fbIdx = getOsdIdx(mId);
1397	int32_t err = init_frame_buffer_locked(fbInfo);
1398	int32_t bufferSize = fbInfo->finfo.line_length
1399	* fbInfo->info.yres;
1400	DTRACE("init_frame_buffer get fbinfo->fbIdx (%d) "
1401	"fbinfo->info.xres (%d) fbinfo->info.yres (%d)",
1402	fbInfo->fbIdx, fbInfo->info.xres,
1403	fbInfo->info.yres);
1404	int32_t usage = 0;
1405
1406	mFramebufferHnd = new private_handle_t(
1407	private_handle_t::PRIV_FLAGS_FRAMEBUFFER,
1408	usage, fbInfo->fbSize, 0,
1409	0, fbInfo->fd, bufferSize, 0);
1410
1411	DTRACE("init_frame_buffer get frame size %d usage %d",
1412	bufferSize, usage);
1413	}
1414
1415	// init cursor framebuffer
1416	mCursorContext = new FBContext();
1417	framebuffer_info_t* cbInfo = mCursorContext->getInfo();
1418	cbInfo->fd = -1;
1419
1420	//init information from cursor framebuffer.
1421	cbInfo->fbIdx = mId*2+1;
1422	if (1 != cbInfo->fbIdx && 3 != cbInfo->fbIdx) {
1423	ETRACE("invalid fb index: %d, need to check!",
1424	cbInfo->fbIdx);
1425	return 0;
1426	}
1427	int32_t err = init_cursor_buffer_locked(cbInfo);
1428	if (err != 0) {
1429	ETRACE("init_cursor_buffer_locked failed, need to check!");
1430	return 0;
1431	}
1432	ITRACE("init_cursor_buffer get cbinfo->fbIdx (%d) "
1433	"cbinfo->info.xres (%d) cbinfo->info.yres (%d)",
1434	cbInfo->fbIdx,
1435	cbInfo->info.xres,
1436	cbInfo->info.yres);
1437
1438	if ( cbInfo->fd >= 0) {
1439	DTRACE("init_cursor_buffer success!");
1440	}else{
1441	DTRACE("init_cursor_buffer fail!");
1442	}
1443
1444	return 0;
1445	}
1446
1447	void PhysicalDevice::updateActiveDisplayAttribute() {
1448	hwc2_config_t config;
1449	if (HWC2_ERROR_NONE == mDisplayHdmi->getRealActiveConfig(&config)) {
1450	int32_t period = 0;
1451	mDisplayHdmi->getDisplayAttribute(config, HWC2_ATTRIBUTE_VSYNC_PERIOD, &period);
1452	mVsyncObserver->setRefreshPeriod(period);
1453	}
1454
1455	calReverseScale();
1456	}
1457
1458	bool PhysicalDevice::updateDisplayConfigs() {
1459	Mutex::Autolock _l(mLock);
1460	framebuffer_info_t* fbinfo = mFramebufferContext->getInfo();
1461	mDisplayHdmi->updateHotplug(mConnectorPresent, *fbinfo);
1462
1463	if (mConnectorPresent) {
1464	updateActiveDisplayAttribute();
1465	} else {
1466	ETRACE("disp: %llu is not connected, should change mode to null", mId);
1467	// mDisplayHdmi->setBestDisplayMode();
1468	return false;
1469	}
1470
1471	// update HDR info.
1472	if (!mHdrCapabilities.init) {
1473	ETRACE("update hdr infomation.");
1474	parseHdrCapabilities();
1475	mHdrCapabilities.init = true;
1476	}
1477
1478	mSecure = mDisplayHdmi->isSecure();
1479	return true;
1480	}
1481
1482	void PhysicalDevice::onVsync(int64_t timestamp) {
1483	RETURN_VOID_IF_NOT_INIT();
1484	ATRACE("timestamp = %lld", timestamp);
1485
1486	if (!mConnectorPresent)
1487	return;
1488
1489	// notify hwc
1490	mHwc.vsync(mId, timestamp);
1491	}
1492
1493	void PhysicalDevice::onHotplug(int disp, bool connected) {
1494	RETURN_VOID_IF_NOT_INIT();
1495	ETRACE("connect status = (%d)", connected);
1496
1497	if (!mGetInitState) {
1498	mGetInitState = true;
1499	if (mDisplayHdmi->chkPresent()) {
1500	updateHotplugState(true);
1501	}
1502	}
1503
1504	if (!updateDisplayConfigs())
1505	ETRACE("failed to update display config");
1506
1507	// notify hwc
1508	if (connected)
1509	mHwc.hotplug(disp, connected);
1510	}
1511
1512	int32_t PhysicalDevice::createVirtualDisplay(
1513	uint32_t width,
1514	uint32_t height,
1515	int32_t* /*android_pixel_format_t*/ format,
1516	hwc2_display_t* outDisplay) {
1517
1518	return HWC2_ERROR_NONE;
1519	}
1520
1521	int32_t PhysicalDevice::destroyVirtualDisplay(
1522	hwc2_display_t display) {
1523
1524	return HWC2_ERROR_NONE;
1525	}
1526
1527	int32_t PhysicalDevice::setOutputBuffer(
1528	buffer_handle_t buffer, int32_t releaseFence) {
1529	// Virtual Display Only.
1530	return HWC2_ERROR_NONE;
1531	}
1532
1533	void PhysicalDevice::updateHotplugState(bool connected) {
1534	Mutex::Autolock _l(mLock);
1535
1536	mConnectorPresent = connected;
1537	// if plug out, need reinit
1538	if (!connected)
1539	memset(&mHdrCapabilities, 0, sizeof(hdr_capabilities_t));
1540	}
1541
1542	int32_t PhysicalDevice::getLineValue(const char *lineStr, const char *magicStr) {
1543	int len = 0;
1544	char value[100] = {0};
1545	const char *pos = NULL;
1546
1547	if ((NULL == lineStr) || (NULL == magicStr)) {
1548	ETRACE("line string: %s, magic string: %s\n", lineStr, magicStr);
1549	return 0;
1550	}
1551
1552	if (NULL != (pos = strstr(lineStr, magicStr))) {
1553	pos = pos + strlen(magicStr);
1554	const char* start = pos;
1555	while (*start != '\n' && (strlen(start) > 0))
1556	start++;
1557
1558	len = start - pos;
1559	strncpy(value, pos, len);
1560	value[len] = '\0';
1561	return atoi(value);
1562	}
1563
1564	return 0;
1565	}
1566
1567	/*******************************************
1568	* cat /sys/class/amhdmitx/amhdmitx0/hdr_cap
1569	* Supported EOTF:
1570	* Traditional SDR: 1
1571	* Traditional HDR: 0
1572	* SMPTE ST 2084: 1
1573	* Future EOTF: 0
1574	* Supported SMD type1: 1
1575	* Luminance Data
1576	* Max: 0
1577	* Avg: 0
1578	* Min: 0
1579	* cat /sys/class/amhdmitx/amhdmitx0/dv_cap
1580	* DolbyVision1 RX support list:
1581	* 2160p30hz: 1
1582	* global dimming
1583	* colorimetry
1584	* IEEEOUI: 0x00d046
1585	* DM Ver: 1
1586	*******************************************/
1587	int32_t PhysicalDevice::parseHdrCapabilities() {
1588	// DolbyVision1
1589	const char *DV_PATH = "/sys/class/amhdmitx/amhdmitx0/dv_cap";
1590	// HDR
1591	const char *HDR_PATH = "/sys/class/amhdmitx/amhdmitx0/hdr_cap";
1592
1593	char buf[1024+1] = {0};
1594	char* pos = buf;
1595	int fd, len;
1596
1597	memset(&mHdrCapabilities, 0, sizeof(hdr_capabilities_t));
1598	if ((fd = open(DV_PATH, O_RDONLY)) < 0) {
1599	ETRACE("open %s fail.", DV_PATH);
1600	goto exit;
1601	}
1602
1603	len = read(fd, buf, 1024);
1604	if (len < 0) {
1605	ETRACE("read error: %s, %s\n", DV_PATH, strerror(errno));
1606	goto exit;
1607	}
1608	close(fd);
1609
1610	if ((NULL != strstr(pos, "2160p30hz")) || (NULL != strstr(pos, "2160p60hz")))
1611	mHdrCapabilities.dvSupport = true;
1612	// dobly version parse end
1613
1614	memset(buf, 0, 1024);
1615	if ((fd = open(HDR_PATH, O_RDONLY)) < 0) {
1616	ETRACE("open %s fail.", HDR_PATH);
1617	goto exit;
1618	}
1619
1620	len = read(fd, buf, 1024);
1621	if (len < 0) {
1622	ETRACE("read error: %s, %s\n", HDR_PATH, strerror(errno));
1623	goto exit;
1624	}
1625
1626	pos = strstr(pos, "SMPTE ST 2084: ");
1627	if ((NULL != pos) && ('1' == *(pos + strlen("SMPTE ST 2084: ")))) {
1628	mHdrCapabilities.hdrSupport = true;
1629
1630	mHdrCapabilities.maxLuminance = getLineValue(pos, "Max: ");
1631	mHdrCapabilities.avgLuminance = getLineValue(pos, "Avg: ");
1632	mHdrCapabilities.minLuminance = getLineValue(pos, "Min: ");
1633	}
1634
1635	ITRACE("dolby version support:%d, hdr support:%d max:%d, avg:%d, min:%d\n",
1636	mHdrCapabilities.dvSupport?1:0, mHdrCapabilities.hdrSupport?1:0, mHdrCapabilities.maxLuminance, mHdrCapabilities.avgLuminance, mHdrCapabilities.minLuminance);
1637	exit:
1638	close(fd);
1639	return HWC2_ERROR_NONE;
1640	}
1641
1642	void PhysicalDevice::dump(Dump& d) {
1643	Mutex::Autolock _l(mLock);
1644	d.append("-------------------------------------------------------------"
1645	"----------------------------------------------------------------\n");
1646	d.append("Device Name: %s (%s), (%f, %f)\n", mName,
1647	mConnectorPresent ? "connected" : "disconnected",
1648	mReverseScaleX, mReverseScaleY);
1649
1650	d.append("isSecure : %s\n", mSecure ? "TRUE" : "FALSE");
1651
1652	mDisplayHdmi->dump(d);
1653
1654	#if 0 //all the info already dumped by SurfaceFlinger, comment it.
1655	// dump layer list
1656	d.append(" Layers state:\n");
1657	d.append(" numLayers=%zu\n", mHwcLayers.size());
1658	// d.append(" numChangedTypeLayers=%zu\n", mHwcLayersChangeType.size());
1659	// d.append(" numChangedRequestLayers=%zu\n", mHwcLayersChangeRequest.size());
1660
1661	if (mHwcLayers.size() > 0) {
1662	d.append(
1663	" type | handle | zorder | ds | alpa | tr | blnd |"
1664	" source crop (l,t,r,b) | frame \n"
1665	" -------------+--------------+------------+----+------+----+------+"
1666	"--------------------------------+------------------------\n");
1667	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
1668	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
1669	HwcLayer *layer = mHwcLayers.valueAt(i);
1670	if (layer) layer->dump(d);
1671	}
1672	}
1673	#endif
1674
1675	// HDR info
1676	d.append(" HDR Capabilities:\n");
1677	d.append(" DolbyVision1=%zu\n", mHdrCapabilities.dvSupport?1:0);
1678	d.append(" HDR10=%zu, maxLuminance=%zu, avgLuminance=%zu, minLuminance=%zu\n",
1679	mHdrCapabilities.hdrSupport?1:0, mHdrCapabilities.maxLuminance, mHdrCapabilities.avgLuminance, mHdrCapabilities.minLuminance);
1680	}
1681
1682	} // namespace amlogic
1683	} // namespace android
1684