path: root/hwc2/common/devices/PhysicalDevice.cpp (plain)
blob: 0afbb54d3eff6d267c1671d9ff06961c35c9b2e2

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
31	static int Amvideo_Handle = 0;
32
33	namespace android {
34	namespace amlogic {
35
36	PhysicalDevice::PhysicalDevice(hwc2_display_t id, Hwcomposer& hwc, DeviceControlFactory* controlFactory)
37	: mId(id),
38	mHwc(hwc),
39	mControlFactory(controlFactory),
40	mVsyncObserver(NULL),
41	mIsConnected(false),
42	mSecure(false),
43	mFramebufferHnd(NULL),
44	mSystemControl(NULL),
45	mFbSlot(0),
46	mComposer(NULL),
47	mPriorFrameRetireFence(-1),
48	mClientTargetHnd(NULL),
49	mTargetAcquireFence(-1),
50	mRenderMode(GLES_COMPOSE_MODE),
51	mIsValidated(false),
52	mIsContinuousBuf(true),
53	mDirectRenderLayerId(0),
54	mVideoOverlayLayerId(0),
55	mGE2DClearVideoRegionCount(0),
56	mGE2DComposeFrameCount(0),
57	mDirectComposeFrameCount(0),
58	mInitialized(false)
59	{
60	CTRACE();
61
62	switch (id) {
63	case DEVICE_PRIMARY:
64	mName = "Primary";
65	break;
66	case DEVICE_EXTERNAL:
67	mName = "External";
68	break;
69	default:
70	mName = "Unknown";
71	}
72
73	mHdrCapabilities.init = false;
74	// init Display here.
75	initDisplay();
76
77	// set capacity of layers, layer's changed type, layer's changed request.
78	// mHwcLayersChangeType.setCapacity(LAYER_MAX_NUM_CHANGE_TYPE);
79	// mHwcLayersChangeRequest.setCapacity(LAYER_MAX_NUM_CHANGE_REQUEST);
80	// mHwcGlesLayers.setCapacity(LAYER_MAX_NUM_CHANGE_TYPE);
81	// mHwcLayers.setCapacity(LAYER_MAX_NUM_SUPPORT);
82	#ifdef HWC_ENABLE_SECURE_LAYER
83	// mHwcSecureLayers.setCapacity(LAYER_MAX_NUM_SECURE_PROTECTED);
84	mHwcSecureLayers.clear();
85	#endif
86
87	// clear layers vectors.
88	mHwcLayersChangeType.clear();
89	mHwcLayersChangeRequest.clear();
90	mHwcGlesLayers.clear();
91	mHwcLayers.clear();
92
93	// mGE2DRenderSortedLayerIds.setCapacity(HWC2_MAX_LAYERS);
94	mGE2DRenderSortedLayerIds.clear();
95
96	mHwcCurReleaseFences = mHwcPriorReleaseFences = NULL;
97	}
98
99	PhysicalDevice::~PhysicalDevice()
100	{
101	WARN_IF_NOT_DEINIT();
102	clearFenceList(mHwcCurReleaseFences);
103	clearFenceList(mHwcPriorReleaseFences);
104	}
105
106	bool PhysicalDevice::initialize() {
107	CTRACE();
108
109	if (mId != DEVICE_PRIMARY && mId != DEVICE_EXTERNAL) {
110	ETRACE("invalid device type");
111	return false;
112	}
113
114	// create vsync event observer, we only have soft vsync now...
115	mVsyncObserver = new SoftVsyncObserver(*this);
116	if (!mVsyncObserver || !mVsyncObserver->initialize()) {
117	DEINIT_AND_RETURN_FALSE("failed to create vsync observer");
118	}
119
120	mDisplayHdmi = new DisplayHdmi(mId);
121	mDisplayHdmi->initialize();
122	UeventObserver *observer = Hwcomposer::getInstance().getUeventObserver();
123	if (observer) {
124	observer->registerListener(
125	Utils::getHdcpUeventEnvelope(),
126	hdcpEventListener,
127	this);
128	} else {
129	ETRACE("PhysicalDevice::Uevent observer is NULL");
130	}
131
132	mInitialized = true;
133	return true;
134	}
135
136	void PhysicalDevice::hdcpEventListener(void *data, bool status)
137	{
138	PhysicalDevice *pThis = (PhysicalDevice*)data;
139	if (pThis) {
140	pThis->setSecureStatus(status);
141	}
142	}
143
144	void PhysicalDevice::setSecureStatus(bool status)
145	{
146	DTRACE("hdcp event: %d", status);
147	mSecure = status;
148	}
149
150	void PhysicalDevice::deinitialize() {
151	Mutex::Autolock _l(mLock);
152
153	DEINIT_AND_DELETE_OBJ(mVsyncObserver);
154	DEINIT_AND_DELETE_OBJ(mDisplayHdmi);
155	DEINIT_AND_DELETE_OBJ(mComposer);
156
157	if (mFramebufferContext != NULL) {
158	delete mFramebufferContext;
159	mFramebufferContext = NULL;
160	}
161
162	if (mCursorContext != NULL) {
163	delete mCursorContext;
164	mCursorContext = NULL;
165	}
166
167	mInitialized = false;
168	}
169
170	HwcLayer* PhysicalDevice::getLayerById(hwc2_layer_t layerId) {
171	HwcLayer* layer = NULL;
172	ssize_t index = mHwcLayers.indexOfKey(layerId);
173
174	if (index >= 0) {
175	layer = mHwcLayers.valueFor(layerId);
176	}
177
178	if (!layer) {
179	DTRACE("getLayerById %lld error!", layerId);
180	}
181	return layer;
182	}
183
184	int32_t PhysicalDevice::acceptDisplayChanges() {
185	HwcLayer* layer = NULL;
186
187	for (uint32_t i=0; i<mHwcLayersChangeType.size(); i++) {
188	hwc2_layer_t layerId = mHwcLayersChangeType.keyAt(i);
189	layer = mHwcLayersChangeType.valueAt(i);
190	if (layer) {
191	#ifdef HWC_ENABLE_SECURE_LAYER
192	// deal non secure display.
193	if (!mSecure && !mHwcSecureLayers.isEmpty()) {
194	for (uint32_t j=0; j<mHwcSecureLayers.size(); j++) {
195	hwc2_layer_t secureLayerId = mHwcSecureLayers.keyAt(j);
196	HwcLayer* secureLayer = mHwcSecureLayers.valueAt(j);
197	// deal secure layers release fence and composition type on non secure display.
198	addReleaseFence(secureLayerId, secureLayer->getDuppedAcquireFence());
199	if (layerId == secureLayerId) {
200	if (layer->getCompositionType() != HWC2_COMPOSITION_DEVICE) {
201	layer->setCompositionType(HWC2_COMPOSITION_DEVICE);
202	continue;
203	}
204	}
205	}
206	}
207	#endif
208	if (layer->getCompositionType() == HWC2_COMPOSITION_DEVICE
209	|| layer->getCompositionType() == HWC2_COMPOSITION_SOLID_COLOR) {
210	layer->setCompositionType(HWC2_COMPOSITION_CLIENT);
211	} else if (layer->getCompositionType() == HWC2_COMPOSITION_SIDEBAND) {
212	layer->setCompositionType(HWC2_COMPOSITION_DEVICE);
213	}
214	}
215	}
216	// reset layer changed or requested size to zero.
217	mHwcLayersChangeType.clear();
218	mHwcLayersChangeRequest.clear();
219
220	#ifdef HWC_ENABLE_SECURE_LAYER
221	// deal non secure display device.
222	if (!mHwcSecureLayers.isEmpty()) {
223	mHwcSecureLayers.clear();
224	}
225	#endif
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 remove 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	#ifdef HWC_ENABLE_SECURE_LAYER
291	// deal non secure display.
292	if (!mSecure && !mHwcSecureLayers.isEmpty()) {
293	for (uint32_t j=0; j<mHwcSecureLayers.size(); j++) {
294	hwc2_layer_t secureLayerId = mHwcSecureLayers.keyAt(j);
295	if (layerId == secureLayerId) {
296	if (layer->getCompositionType() != HWC2_COMPOSITION_DEVICE) {
297	outLayers[i] = layerId;
298	outTypes[i] = HWC2_COMPOSITION_DEVICE;
299	continue;
300	}
301	}
302	}
303	}
304	#endif
305
306	if (layer->getCompositionType() == HWC2_COMPOSITION_DEVICE
307	|| layer->getCompositionType() == HWC2_COMPOSITION_SOLID_COLOR) {
308	// change all other device type to client.
309	outLayers[i] = layerId;
310	outTypes[i] = HWC2_COMPOSITION_CLIENT;
311	continue;
312	}
313
314	// sideband stream.
315	if (layer->getCompositionType() == HWC2_COMPOSITION_SIDEBAND
316	&& layer->getSidebandStream()) {
317	// TODO: we just transact SIDEBAND to OVERLAY for now;
318	DTRACE("get HWC_SIDEBAND layer, just change to overlay");
319	outLayers[i] = layerId;
320	outTypes[i] = HWC2_COMPOSITION_DEVICE;
321	continue;
322	}
323	}
324	}
325
326	if (mHwcLayersChangeType.size() > 0) {
327	DTRACE("There are %d layers type has changed.", mHwcLayersChangeType.size());
328	*outNumElements = mHwcLayersChangeType.size();
329	} else {
330	DTRACE("No layers compositon type changed.");
331	}
332	}
333
334	return HWC2_ERROR_NONE;
335	}
336
337	int32_t PhysicalDevice::getClientTargetSupport(
338	uint32_t width,
339	uint32_t height,
340	int32_t /*android_pixel_format_t*/ format,
341	int32_t /*android_dataspace_t*/ dataspace) {
342	framebuffer_info_t* fbInfo = mFramebufferContext->getInfo();
343
344	if (width == fbInfo->info.xres
345	&& height == fbInfo->info.yres
346	&& format == HAL_PIXEL_FORMAT_RGBA_8888
347	&& dataspace == HAL_DATASPACE_UNKNOWN) {
348	return HWC2_ERROR_NONE;
349	}
350
351	DTRACE("fbinfo: [%d x %d], client: [%d x %d]"
352	"format: %d, dataspace: %d",
353	fbInfo->info.xres,
354	fbInfo->info.yres,
355	width, height, format, dataspace);
356
357	// TODO: ?
358	return HWC2_ERROR_UNSUPPORTED;
359	}
360
361	int32_t PhysicalDevice::getColorModes(
362	uint32_t* outNumModes,
363	int32_t* /*android_color_mode_t*/ outModes) {
364
365	if (NULL == outModes) {
366	*outNumModes = 1;
367	} else {
368	*outModes = HAL_COLOR_MODE_NATIVE;
369	}
370
371	return HWC2_ERROR_NONE;
372	}
373
374	int32_t PhysicalDevice::getDisplayAttribute(
375	hwc2_config_t config,
376	int32_t /*hwc2_attribute_t*/ attribute,
377	int32_t* outValue) {
378	Mutex::Autolock _l(mLock);
379
380	if (!mIsConnected) {
381	ETRACE("display %d is not connected.", mId);
382	}
383
384	int ret = mDisplayHdmi->getDisplayAttribute(config, attribute, outValue);
385	if (ret < 0)
386	return HWC2_ERROR_BAD_CONFIG;
387
388	return HWC2_ERROR_NONE;
389	}
390
391	int32_t PhysicalDevice::getDisplayConfigs(
392	uint32_t* outNumConfigs,
393	hwc2_config_t* outConfigs) {
394	Mutex::Autolock _l(mLock);
395
396	return mDisplayHdmi->getDisplayConfigs(outNumConfigs, outConfigs);
397	}
398
399	int32_t PhysicalDevice::getDisplayName(
400	uint32_t* outSize,
401	char* outName) {
402	return HWC2_ERROR_NONE;
403	}
404
405	int32_t PhysicalDevice::getDisplayRequests(
406	int32_t* /*hwc2_display_request_t*/ outDisplayRequests,
407	uint32_t* outNumElements,
408	hwc2_layer_t* outLayers,
409	int32_t* /*hwc2_layer_request_t*/ outLayerRequests) {
410
411	// if outLayers or outTypes were NULL, the number of layers and types which would have been returned.
412	if (NULL == outLayers || NULL == outLayerRequests) {
413	*outNumElements = mHwcLayersChangeRequest.size();
414	} else {
415	for (uint32_t i=0; i<mHwcLayersChangeRequest.size(); i++) {
416	hwc2_layer_t layerId = mHwcLayersChangeRequest.keyAt(i);
417	HwcLayer *layer = mHwcLayersChangeRequest.valueAt(i);
418	if (layer->getCompositionType() == HWC2_COMPOSITION_DEVICE) {
419	// video overlay.
420	if (layerId == mVideoOverlayLayerId) {
421	outLayers[i] = layerId;
422	outLayerRequests[i] = HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET;
423	}
424	/* if (layer->getBufferHandle()) {
425	private_handle_t const* hnd =
426	reinterpret_cast<private_handle_t const*>(layer->getBufferHandle());
427	if (hnd->flags & private_handle_t::PRIV_FLAGS_VIDEO_OVERLAY) {
428	outLayers[i] = layerId;
429	outLayerRequests[i] = HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET;
430	continue;
431	}
432	} */
433	}
434
435	// sideband stream.
436	if ((layer->getCompositionType() == HWC2_COMPOSITION_SIDEBAND && layer->getSidebandStream())
437	//|| layer->getCompositionType() == HWC2_COMPOSITION_SOLID_COLOR
438	|| layer->getCompositionType() == HWC2_COMPOSITION_CURSOR) {
439	// TODO: we just transact SIDEBAND to OVERLAY for now;
440	DTRACE("get HWC_SIDEBAND layer, just change to overlay");
441	outLayers[i] = layerId;
442	outLayerRequests[i] = HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET;
443	continue;
444	}
445	}
446
447	if (mHwcLayersChangeRequest.size() > 0) {
448	DTRACE("There are %d layer requests.", mHwcLayersChangeRequest.size());
449	*outNumElements = mHwcLayersChangeRequest.size();
450	} else {
451	DTRACE("No layer requests.");
452	}
453	}
454
455	return HWC2_ERROR_NONE;
456	}
457
458	int32_t PhysicalDevice::getDisplayType(
459	int32_t* /*hwc2_display_type_t*/ outType) {
460
461	*outType = HWC2_DISPLAY_TYPE_PHYSICAL;
462	return HWC2_ERROR_NONE;
463	}
464
465	int32_t PhysicalDevice::getDozeSupport(
466	int32_t* outSupport) {
467	return HWC2_ERROR_NONE;
468	}
469
470	int32_t PhysicalDevice::getHdrCapabilities(
471	uint32_t* outNumTypes,
472	int32_t* /*android_hdr_t*/ outTypes,
473	float* outMaxLuminance,
474	float* outMaxAverageLuminance,
475	float* outMinLuminance) {
476
477	Mutex::Autolock _l(mLock);
478	if (!mIsConnected) {
479	ETRACE("disp: %llu is not connected", mId);
480	return HWC2_ERROR_BAD_DISPLAY;
481	}
482
483	if (!mHdrCapabilities.init) {
484	parseHdrCapabilities();
485	mHdrCapabilities.init = true;
486	}
487
488	if (NULL == outTypes) {
489	int num = 0;
490	if (mHdrCapabilities.dvSupport) num++;
491	if (mHdrCapabilities.hdrSupport) num++;
492
493	*outNumTypes = num;
494	} else {
495	if (mHdrCapabilities.dvSupport) *outTypes++ = HAL_HDR_DOLBY_VISION;
496	if (mHdrCapabilities.hdrSupport) *outTypes++ = HAL_HDR_HDR10;
497
498	*outMaxLuminance = mHdrCapabilities.maxLuminance;
499	*outMaxAverageLuminance = mHdrCapabilities.avgLuminance;
500	*outMinLuminance = mHdrCapabilities.minLuminance;
501	}
502
503	return HWC2_ERROR_NONE;
504	}
505
506	void PhysicalDevice::swapReleaseFence() {
507	//dumpFenceList(mHwcCurReleaseFences);
508
509	if (mHwcCurReleaseFences == NULL || mHwcPriorReleaseFences == NULL) {
510	if (mHwcCurReleaseFences) {
511	clearFenceList(mHwcPriorReleaseFences);
512	}
513
514	if (mHwcPriorReleaseFences) {
515	clearFenceList(mHwcPriorReleaseFences);
516	}
517
518	mHwcCurReleaseFences = &(mLayerReleaseFences[0]);
519	mHwcPriorReleaseFences = &(mLayerReleaseFences[1]);
520	} else {
521	KeyedVector<hwc2_layer_t, int32_t> * tmp = mHwcCurReleaseFences;
522	clearFenceList(mHwcPriorReleaseFences);
523	mHwcCurReleaseFences = mHwcPriorReleaseFences;
524	mHwcPriorReleaseFences = tmp;
525	}
526	}
527
528
529	void PhysicalDevice::addReleaseFence(hwc2_layer_t layerId, int32_t fenceFd) {
530	ssize_t idx = mHwcCurReleaseFences->indexOfKey(layerId);
531	if (idx >= 0 && idx < mHwcCurReleaseFences->size()) {
532	int32_t oldFence = mHwcCurReleaseFences->valueAt(idx);
533	String8 mergeName("hwc-release");
534	int32_t newFence = HwcFenceControl::merge(mergeName, oldFence, fenceFd);
535	mHwcCurReleaseFences->replaceValueAt(idx, newFence);
536	HwcFenceControl::closeFd(oldFence);
537	HwcFenceControl::closeFd(fenceFd);
538	ETRACE("addReleaseFence:(%d, %d) + %d -> (%d,%d)\n", idx, oldFence, fenceFd, idx, newFence);
539	dumpFenceList(mHwcCurReleaseFences);
540	} else {
541	mHwcCurReleaseFences->add(layerId, fenceFd);
542	}
543	}
544
545	void PhysicalDevice::clearFenceList(KeyedVector<hwc2_layer_t, int32_t> * fenceList) {
546	if (!fenceList || !fenceList->size())
547	return;
548
549	for (int i = 0; i < fenceList->size(); i++) {
550	int32_t fenceFd = fenceList->valueAt(i);
551	HwcFenceControl::closeFd(fenceFd);
552	DTRACE("clearFenceList close fd %d\n", fenceFd);
553	fenceList->replaceValueAt(i, -1);
554	}
555	fenceList->clear();
556	}
557
558	void PhysicalDevice::dumpFenceList(KeyedVector<hwc2_layer_t, int32_t> * fenceList) {
559	if (!fenceList || fenceList->isEmpty())
560	return;
561
562	String8 resultStr("dumpFenceList: ");
563	for (int i = 0; i < fenceList->size(); i++) {
564	hwc2_layer_t layerId = fenceList->keyAt(i);
565	int32_t fenceFd = fenceList->valueAt(i);
566	resultStr.appendFormat("(%lld, %d), ", layerId, fenceFd);
567	}
568
569	ETRACE("%s", resultStr.string());
570	}
571
572	int32_t PhysicalDevice::getReleaseFences(
573	uint32_t* outNumElements,
574	hwc2_layer_t* outLayers,
575	int32_t* outFences) {
576	*outNumElements = mHwcPriorReleaseFences->size();
577
578	if (outLayers && outFences) {
579	for (uint32_t i=0; i<mHwcPriorReleaseFences->size(); i++) {
580	outLayers[i] = mHwcPriorReleaseFences->keyAt(i);
581	outFences[i] = HwcFenceControl::dupFence(mHwcPriorReleaseFences->valueAt(i));
582	}
583	}
584
585	return HWC2_ERROR_NONE;
586	}
587
588	void PhysicalDevice::directCompose(framebuffer_info_t * fbInfo) {
589	HwcLayer* layer = NULL;
590	ssize_t idx = mHwcLayers.indexOfKey(mDirectRenderLayerId);
591	if (idx >= 0) {
592	layer = mHwcLayers.valueAt(idx);
593	if (mTargetAcquireFence > -1) {
594	ETRACE("ERROR:directCompose with mTargetAcquireFence %d\n", mTargetAcquireFence);
595	HwcFenceControl::closeFd(mTargetAcquireFence);
596	}
597
598	mTargetAcquireFence = layer->getDuppedAcquireFence();
599	mClientTargetHnd = layer->getBufferHandle();
600	DTRACE("Hit only one non video overlay layer, handle: %08" PRIxPTR ", fence: %d",
601	intptr_t(mClientTargetHnd), mTargetAcquireFence);
602
603	// fill up fb sync request struct.
604	hwc_frect_t srcCrop = layer->getSourceCrop();
605	hwc_rect_t displayFrame = layer->getDisplayFrame();
606	mFbSyncRequest.xoffset = (unsigned int)srcCrop.left;
607	mFbSyncRequest.yoffset = (unsigned int)srcCrop.top;
608	mFbSyncRequest.width = (unsigned int)(srcCrop.right - srcCrop.left);
609	mFbSyncRequest.height = (unsigned int)(srcCrop.bottom - srcCrop.top);
610	mFbSyncRequest.dst_x = displayFrame.left;
611	mFbSyncRequest.dst_y = displayFrame.top;
612	mFbSyncRequest.dst_w = displayFrame.right - displayFrame.left;
613	mFbSyncRequest.dst_h = displayFrame.bottom - displayFrame.top;
614	return;
615	}
616
617	ETRACE("Didn't find direct compose layer!");
618	}
619
620	#ifdef ENABLE_AML_GE2D_COMPOSER
621	void PhysicalDevice::ge2dCompose(framebuffer_info_t * fbInfo, bool hasVideoOverlay) {
622	if (mGE2DRenderSortedLayerIds.size() > 0) {
623	DTRACE("GE2D compose mFbSlot: %d", mFbSlot);
624	if (hasVideoOverlay) {
625	if (mGE2DClearVideoRegionCount < 3) {
626	mComposer->setVideoOverlayLayerId(mVideoOverlayLayerId);
627	}
628	}
629	if (mTargetAcquireFence > -1) {
630	ETRACE("ERROR:GE2D compose with mTargetAcquireFence %d\n", mTargetAcquireFence);
631	HwcFenceControl::closeFd(mTargetAcquireFence);
632	}
633	mTargetAcquireFence = mComposer->startCompose(mGE2DRenderSortedLayerIds, &mFbSlot, mGE2DComposeFrameCount);
634	for (uint32_t i=0; i<mGE2DRenderSortedLayerIds.size(); i++) {
635	addReleaseFence(mGE2DRenderSortedLayerIds.itemAt(i), HwcFenceControl::dupFence(mTargetAcquireFence));
636	}
637	// HwcFenceControl::traceFenceInfo(mTargetAcquireFence);
638	// dumpLayers(mGE2DRenderSortedLayerIds);
639	if (mGE2DComposeFrameCount < 3) {
640	mGE2DComposeFrameCount++;
641	}
642	mClientTargetHnd = mComposer->getBufHnd();
643	fbInfo->yOffset = mFbSlot;
644	return;
645	}
646
647	ETRACE("Didn't find ge2d compose layers!");
648	}
649	#endif
650
651	int32_t PhysicalDevice::postFramebuffer(int32_t* outRetireFence, bool hasVideoOverlay) {
652	HwcLayer* layer = NULL;
653	void *cbuffer;
654
655	// deal physical display's client target layer
656	framebuffer_info_t fbInfo = *(mFramebufferContext->getInfo());
657	framebuffer_info_t* cbInfo = mCursorContext->getInfo();
658	bool cursorShow = false;
659	bool haveCursorLayer = false;
660	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
661	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
662	layer = mHwcLayers.valueAt(i);
663	if (layer && layer->getCompositionType()== HWC2_COMPOSITION_CURSOR) {
664	private_handle_t *hnd = (private_handle_t *)(layer->getBufferHandle());
665	if (private_handle_t::validate(hnd) < 0) {
666	ETRACE("invalid cursor layer handle.");
667	break;
668	}
669	haveCursorLayer = true;
670	DTRACE("This is a Sprite, hnd->stride is %d, hnd->height is %d", hnd->stride, hnd->height);
671	if (cbInfo->info.xres != (uint32_t)hnd->stride || cbInfo->info.yres != (uint32_t)hnd->height) {
672	ETRACE("disp: %d cursor need to redrew", mId);
673	update_cursor_buffer_locked(cbInfo, hnd->stride, hnd->height);
674	cbuffer = mmap(NULL, hnd->size, PROT_READ|PROT_WRITE, MAP_SHARED, cbInfo->fd, 0);
675	if (cbuffer != MAP_FAILED) {
676	memcpy(cbuffer, hnd->base, hnd->size);
677	munmap(cbuffer, hnd->size);
678	DTRACE("setCursor ok");
679	} else {
680	ETRACE("buffer mmap fail");
681	}
682	}
683	cursorShow = true;
684	break;
685	}
686	}
687
688	if (mRenderMode == GLES_COMPOSE_MODE) {
689	//if no layers to compose, post blank op to osd.
690	if (mHwcGlesLayers.size() == 0) {
691	mClientTargetHnd = NULL;
692	}
693	} else if (mRenderMode == DIRECT_COMPOSE_MODE) { // if only one layer exists, let hwc do her work.
694	directCompose(&fbInfo);
695	}
696	#ifdef ENABLE_AML_GE2D_COMPOSER
697	else if (mRenderMode == GE2D_COMPOSE_MODE) {
698	ge2dCompose(&fbInfo, hasVideoOverlay);
699	}
700	#endif
701	mFbSyncRequest.type = mRenderMode;
702
703	bool needBlankFb0 = false;
704	uint32_t layerNum = mHwcLayers.size();
705	if (hasVideoOverlay && (layerNum == 1 || (layerNum == 2 && haveCursorLayer)))
706	needBlankFb0 = true;
707
708	if (mIsContinuousBuf) {
709	// bit 0 is osd blank flag.
710	if (needBlankFb0) {
711	mFbSyncRequest.op |= OSD_BLANK_OP_BIT;
712	} else {
713	mFbSyncRequest.op &= ~(OSD_BLANK_OP_BIT);
714	}
715	mFramebufferContext->setStatus(needBlankFb0);
716	} else {
717	setOSD0Blank(needBlankFb0);
718	}
719
720	if (!mClientTargetHnd || private_handle_t::validate(mClientTargetHnd) < 0 || mPowerMode == HWC2_POWER_MODE_OFF) {
721	ETRACE("Post blank to screen, mClientTargetHnd(%p, %d), mTargetAcquireFence(%d)",
722	mClientTargetHnd, private_handle_t::validate(mClientTargetHnd), mTargetAcquireFence);
723	*outRetireFence = HwcFenceControl::merge(String8("ScreenBlank"), mPriorFrameRetireFence, mPriorFrameRetireFence);
724	HwcFenceControl::closeFd(mTargetAcquireFence);
725	mTargetAcquireFence = -1;
726	HwcFenceControl::closeFd(mPriorFrameRetireFence);
727	mPriorFrameRetireFence = -1;
728	//for nothing to display, post blank to osd which will signal the last retire fence.
729	mFbSyncRequest.type = DIRECT_COMPOSE_MODE;
730	mFbSyncRequest.op |= OSD_BLANK_OP_BIT;
731	mFramebufferContext->setStatus(true);
732	mPriorFrameRetireFence = hwc_fb_post_with_fence_locked(&fbInfo, &mFbSyncRequest, NULL);
733	} else {
734	*outRetireFence = HwcFenceControl::dupFence(mPriorFrameRetireFence);
735	if (*outRetireFence >= 0) {
736	DTRACE("Get prior frame's retire fence %d", *outRetireFence);
737	} else {
738	ETRACE("No valid prior frame's retire returned. %d ", *outRetireFence);
739	// -1 means no fence, less than -1 is some error
740	*outRetireFence = -1;
741	}
742	HwcFenceControl::closeFd(mPriorFrameRetireFence);
743	mPriorFrameRetireFence = -1;
744
745	// real post framebuffer here.
746	DTRACE("render type: %d", mFbSyncRequest.type);
747	if (!mIsContinuousBuf) {
748	mPriorFrameRetireFence = fb_post_with_fence_locked(&fbInfo, mClientTargetHnd, mTargetAcquireFence);
749	} else {
750	// acquire fence.
751	mFbSyncRequest.in_fen_fd = mTargetAcquireFence;
752	mPriorFrameRetireFence = hwc_fb_post_with_fence_locked(&fbInfo, &mFbSyncRequest, mClientTargetHnd);
753	}
754	mTargetAcquireFence = -1;
755
756	if (mRenderMode == GE2D_COMPOSE_MODE) {
757	mComposer->mergeRetireFence(mFbSlot, HwcFenceControl::dupFence(mPriorFrameRetireFence));
758	} else {
759	if (mComposer && mGE2DComposeFrameCount != 0) {
760	mComposer->removeRetireFence(mFbSlot);
761	}
762
763	if (mRenderMode == DIRECT_COMPOSE_MODE) {
764	addReleaseFence(mDirectRenderLayerId, HwcFenceControl::dupFence(mPriorFrameRetireFence));
765	}
766	}
767
768	// finally we need to update cursor's blank status.
769	if (cbInfo->fd > 0 && cursorShow != mCursorContext->getStatus()) {
770	mCursorContext->setStatus(cursorShow);
771	DTRACE("UPDATE FB1 status to %d", !cursorShow);
772	ioctl(cbInfo->fd, FBIOBLANK, !cursorShow);
773	}
774	}
775
776	if (mRenderMode != GE2D_COMPOSE_MODE) {
777	mGE2DComposeFrameCount = 0;
778	}
779
780	return HWC2_ERROR_NONE;
781	}
782
783	// TODO: need add fence wait.
784	int32_t PhysicalDevice::setOSD0Blank(bool blank) {
785	framebuffer_info_t* fbInfo = mFramebufferContext->getInfo();
786
787	if (fbInfo->fd > 0 && blank != mFramebufferContext->getStatus()) {
788	mFramebufferContext->setStatus(blank);
789	DTRACE("UPDATE FB0 status to %d", blank);
790	ioctl(fbInfo->fd, FBIOBLANK, blank);
791	}
792
793	return HWC2_ERROR_NONE;
794	}
795
796	int32_t PhysicalDevice::presentDisplay(int32_t* outRetireFence) {
797	int32_t err = HWC2_ERROR_NONE;
798	HwcLayer* layer = NULL;
799	bool hasVideoOverlay = false;
800
801	if (mIsValidated) {
802	// TODO: need improve the way to set video axis.
803	#if WITH_LIBPLAYER_MODULE
804	ssize_t index = mHwcLayers.indexOfKey(mVideoOverlayLayerId);
805	if (index >= 0) {
806	layer = mHwcLayers.valueFor(mVideoOverlayLayerId);
807	if (layer != NULL) {
808	layer->presentOverlay();
809	hasVideoOverlay = true;
810	if (mGE2DClearVideoRegionCount < 3) {
811	mGE2DClearVideoRegionCount++;
812	}
813	}
814	} else {
815	mGE2DClearVideoRegionCount = 0;
816	}
817	#endif
818	err = postFramebuffer(outRetireFence, hasVideoOverlay);
819	} else { // display not validate yet.
820	err = HWC2_ERROR_NOT_VALIDATED;
821	}
822
823	// reset layers' acquire fence.
824	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
825	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
826	layer = mHwcLayers.valueAt(i);
827	if (layer != NULL) {
828	layer->resetAcquireFence();
829	}
830	}
831
832	mClientTargetHnd = NULL;
833
834	return err;
835	}
836
837	int32_t PhysicalDevice::setActiveConfig(
838	hwc2_config_t config) {
839	Mutex::Autolock _l(mLock);
840
841	int32_t err = mDisplayHdmi->setActiveConfig(config);
842	if (err == HWC2_ERROR_NONE)
843	mVsyncObserver->setRefreshRate(mDisplayHdmi->getActiveRefreshRate());
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] = reinterpret_cast<private_handle_t const*>(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	DTRACE("layer[%d] zorder: %d, blend: %d, PlaneAlpha: %f, "
951	"mColor: [%d, %d, %d, %d], mDataSpace: %d, format hnd[%d]: %x",
952	i, layer[i]->getZ(), layer[i]->getBlendMode(), layer[i]->getPlaneAlpha(),
953	layer[i]->getColor().r, layer[i]->getColor().g, layer[i]->getColor().b,
954	layer[i]->getColor().a, layer[i]->getDataspace(), i, hnd[i]->format);
955	}
956
957	if (renderMode == DIRECT_COMPOSE_MODE) {
958	switch (hnd[0]->format) {
959	case HAL_PIXEL_FORMAT_RGBA_8888:
960	case HAL_PIXEL_FORMAT_RGBX_8888:
961	case HAL_PIXEL_FORMAT_RGB_888:
962	case HAL_PIXEL_FORMAT_RGB_565:
963	case HAL_PIXEL_FORMAT_BGRA_8888:
964	DTRACE("Layer format match direct composer.");
965	ret = true;
966	break;
967	default:
968	DTRACE("Layer format not support by direct compose");
969	return false;
970	break;
971	}
972	if (layer[0]->isCropped()
973	|| layer[0]->isScaled()
974	|| layer[0]->isOffset()) {
975	DTRACE("direct compose can not process!");
976	return false;
977	}
978	}
979	#ifdef ENABLE_AML_GE2D_COMPOSER
980	else if (renderMode == GE2D_COMPOSE_MODE) {
981	bool yuv420Sp = false;
982	for (int32_t i=0; i<layerNum; i++) {
983	switch (hnd[i]->format) {
984	case HAL_PIXEL_FORMAT_YCrCb_420_SP:
985	yuv420Sp = true;
986	case HAL_PIXEL_FORMAT_RGBA_8888:
987	case HAL_PIXEL_FORMAT_RGBX_8888:
988	case HAL_PIXEL_FORMAT_RGB_888:
989	case HAL_PIXEL_FORMAT_RGB_565:
990	case HAL_PIXEL_FORMAT_BGRA_8888:
991	case HAL_PIXEL_FORMAT_YV12:
992	case HAL_PIXEL_FORMAT_Y8:
993	case HAL_PIXEL_FORMAT_YCbCr_422_SP:
994	case HAL_PIXEL_FORMAT_YCbCr_422_I:
995	DTRACE("Layer format match ge2d composer.");
996	ret = true;
997	break;
998	default:
999	DTRACE("Layer format not support by ge2d");
1000	return false;
1001	break;
1002	}
1003	if (layer[i]->havePlaneAlpha()
1004	|| layer[i]->haveColor()
1005	|| layer[i]->haveDataspace()
1006	|| (layer[i]->isBlended()
1007	&& layer[i]->isScaled())) {
1008	DTRACE("ge2d compose can not process!");
1009	return false;
1010	}
1011	}
1012	#if 0
1013	if (yuv420Sp && HWC2_TWO_LAYERS == layerNum) {
1014	if (Utils::compareRect(sourceCrop[0], sourceCrop[1])
1015	&& Utils::compareRect(sourceCrop[0], displayFrame[0])
1016	&& Utils::compareRect(sourceCrop[1], displayFrame[1])) {
1017	DTRACE("2 layers is same size and have yuv420sp format ge2d compose can not process!");
1018	return false;
1019	}
1020	}
1021	#endif
1022	if (HWC2_TWO_LAYERS == layerNum
1023	&& (!Utils::compareSize(sourceCrop[0], sourceCrop[1])
1024	|| !Utils::compareSize(displayFrame[0], displayFrame[1]))) {
1025	DTRACE("when 2 layer's size is difference, ge2d compose can not process!");
1026	return false;
1027	}
1028	}
1029	#endif
1030
1031	return ret;
1032	}
1033
1034	/*************************************************************
1035	* For direct framebuffer composer:
1036	* 1) only support one layer.
1037	* 2) layer format: rgba, rgbx,rgb565,bgra;
1038	* 3) layer no need scale to display;
1039	* 4) layer has no offset to display;
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	int32_t PhysicalDevice::validateDisplay(uint32_t* outNumTypes,
1114	uint32_t* outNumRequests) {
1115	HwcLayer* layer = NULL;
1116	bool istvp = false;
1117	KeyedVector<hwc2_layer_t, HwcLayer*> composeLayers;
1118	composeLayers.clear();
1119
1120	mRenderMode = GLES_COMPOSE_MODE;
1121	mVideoOverlayLayerId = 0;
1122	mIsContinuousBuf = true;
1123	swapReleaseFence();
1124	memset(&mFbSyncRequest, 0, sizeof(mFbSyncRequest));
1125	mHwcGlesLayers.clear();
1126	mIsValidated = false;
1127
1128	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
1129	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
1130	layer = mHwcLayers.valueAt(i);
1131	if (layer != NULL) {
1132	// Physical Display.
1133	private_handle_t const* hnd =
1134	reinterpret_cast<private_handle_t const*>(layer->getBufferHandle());
1135	if (hnd) {
1136	// continous buffer.
1137	if (!(hnd->flags & private_handle_t::PRIV_FLAGS_CONTINUOUS_BUF
1138	|| hnd->flags & private_handle_t::PRIV_FLAGS_VIDEO_OVERLAY)) {
1139	DTRACE("continous buffer flag is not set, bufhnd: 0x%" PRIxPTR "", intptr_t(layer->getBufferHandle()));
1140	mIsContinuousBuf = false;
1141	}
1142	#ifdef HWC_ENABLE_SECURE_LAYER
1143	// secure or protected layer.
1144	if (!mSecure && (hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_PROTECTED)) {
1145	ETRACE("layer's secure or protected buffer flag is set!");
1146	if (layer->getCompositionType() != HWC2_COMPOSITION_DEVICE) {
1147	mHwcLayersChangeType.add(layerId, layer);
1148	}
1149	mHwcSecureLayers.add(layerId, layer);
1150	continue;
1151	}
1152	#endif
1153	if (layer->getCompositionType() == HWC2_COMPOSITION_DEVICE) {
1154	// video overlay.
1155	if (hnd->flags & private_handle_t::PRIV_FLAGS_VIDEO_OMX) {
1156	set_omx_pts((char*)hnd->base, &Amvideo_Handle);
1157	istvp = true;
1158	}
1159	if (hnd->flags & private_handle_t::PRIV_FLAGS_VIDEO_OVERLAY) {
1160	DTRACE("PRIV_FLAGS_VIDEO_OVERLAY!!!!");
1161	mVideoOverlayLayerId = layerId;
1162	mHwcLayersChangeRequest.add(layerId, layer);
1163	continue;
1164	}
1165
1166	composeLayers.add(layerId, layer);
1167	continue;
1168	}
1169	}
1170
1171	// cursor layer.
1172	if (layer->getCompositionType() == HWC2_COMPOSITION_CURSOR) {
1173	DTRACE("This is a Cursor layer!");
1174	mHwcLayersChangeRequest.add(layerId, layer);
1175	continue;
1176	}
1177
1178	// sideband stream.
1179	if (layer->getCompositionType() == HWC2_COMPOSITION_SIDEBAND
1180	&& layer->getSidebandStream()) {
1181	// TODO: we just transact SIDEBAND to OVERLAY for now;
1182	DTRACE("get HWC_SIDEBAND layer, just change to overlay");
1183	mHwcLayersChangeRequest.add(layerId, layer);
1184	mHwcLayersChangeType.add(layerId, layer);
1185	mVideoOverlayLayerId = layerId;
1186	continue;
1187	}
1188
1189	// solid color.
1190	if (layer->getCompositionType() == HWC2_COMPOSITION_SOLID_COLOR) {
1191	DTRACE("This is a Solid Color layer!");
1192	// mHwcLayersChangeRequest.add(layerId, layer);
1193	// mHwcLayersChangeType.add(layerId, layer);
1194	composeLayers.add(layerId, layer);
1195	continue;
1196	}
1197
1198	if (layer->getCompositionType() == HWC2_COMPOSITION_CLIENT) {
1199	mHwcGlesLayers.add(layerId, layer);
1200	DTRACE("Meet a client layer!");
1201	}
1202	}
1203	}
1204
1205	bool noDevComp = Utils::checkBoolProp("sys.sf.debug.nohwc");
1206	#ifndef USE_CONTINOUS_BUFFER_COMPOSER
1207	DTRACE("No continous buffer composer!");
1208	noDevComp = true;
1209	mIsContinuousBuf = false;
1210	#endif
1211
1212	if (mHwcLayers.size() == 0) {
1213	mIsContinuousBuf = false;
1214	}
1215
1216	// dumpLayers(mHwcLayers);
1217	if (mIsContinuousBuf && !noDevComp && (mHwcGlesLayers.size() == 0)) {
1218	mRenderMode = composersFilter(composeLayers);
1219	} else {
1220	mDirectComposeFrameCount = 0;
1221	}
1222
1223	//DEVICE_COMPOSE layers set to CLIENT_COMPOSE layers.
1224	for (int i=0; i<composeLayers.size(); i++) {
1225	mHwcLayersChangeType.add(composeLayers.keyAt(i), composeLayers.valueAt(i));
1226	mHwcGlesLayers.add(composeLayers.keyAt(i), composeLayers.valueAt(i));
1227	}
1228
1229	if (istvp == false && Amvideo_Handle!=0) {
1230	closeamvideo();
1231	Amvideo_Handle = 0;
1232	}
1233
1234	if (mHwcLayersChangeRequest.size() > 0) {
1235	DTRACE("There are %d layer requests.", mHwcLayersChangeRequest.size());
1236	*outNumRequests = mHwcLayersChangeRequest.size();
1237	}
1238
1239	mIsValidated = true;
1240
1241	if (mHwcLayersChangeType.size() > 0) {
1242	DTRACE("there are %d layer types has changed.", mHwcLayersChangeType.size());
1243	*outNumTypes = mHwcLayersChangeType.size();
1244	return HWC2_ERROR_HAS_CHANGES;
1245	}
1246
1247	return HWC2_ERROR_NONE;
1248	}
1249
1250	int32_t PhysicalDevice::setCursorPosition(hwc2_layer_t layerId, int32_t x, int32_t y) {
1251	HwcLayer* layer = getLayerById(layerId);
1252	if (layer && HWC2_COMPOSITION_CURSOR == layer->getCompositionType()) {
1253	framebuffer_info_t* cbInfo = mCursorContext->getInfo();
1254	fb_cursor cinfo;
1255	if (cbInfo->fd < 0) {
1256	ETRACE("setCursorPosition fd=%d", cbInfo->fd );
1257	}else {
1258	cinfo.hot.x = x;
1259	cinfo.hot.y = y;
1260	DTRACE("setCursorPosition x_pos=%d, y_pos=%d", cinfo.hot.x, cinfo.hot.y);
1261	ioctl(cbInfo->fd, FBIO_CURSOR, &cinfo);
1262	}
1263	} else {
1264	ETRACE("setCursorPosition bad layer.");
1265	return HWC2_ERROR_BAD_LAYER;
1266	}
1267
1268	return HWC2_ERROR_NONE;
1269	}
1270
1271
1272	/*
1273	Operater of framebuffer
1274	*/
1275	int32_t PhysicalDevice::initDisplay() {
1276	if (mIsConnected) return 0;
1277
1278	Mutex::Autolock _l(mLock);
1279
1280	if (!mFramebufferHnd) {
1281	// init framebuffer context.
1282	mFramebufferContext = new FBContext();
1283	framebuffer_info_t* fbInfo = mFramebufferContext->getInfo();
1284	// init information from osd.
1285	fbInfo->displayType = mId;
1286	fbInfo->fbIdx = getOsdIdx(mId);
1287	int32_t err = init_frame_buffer_locked(fbInfo);
1288	int32_t bufferSize = fbInfo->finfo.line_length
1289	* fbInfo->info.yres;
1290	DTRACE("init_frame_buffer get fbinfo->fbIdx (%d) "
1291	"fbinfo->info.xres (%d) fbinfo->info.yres (%d)",
1292	fbInfo->fbIdx, fbInfo->info.xres,
1293	fbInfo->info.yres);
1294	int32_t usage = 0;
1295	private_module_t *grallocModule = Hwcomposer::getInstance().getGrallocModule();
1296	if (mId == HWC_DISPLAY_PRIMARY) {
1297	grallocModule->fb_primary.fb_info = *(fbInfo);
1298	} else if (mId == HWC_DISPLAY_EXTERNAL) {
1299	grallocModule->fb_external.fb_info = *(fbInfo);
1300	usage |= GRALLOC_USAGE_EXTERNAL_DISP;
1301	}
1302	fbInfo->grallocModule = grallocModule;
1303
1304	//Register the framebuffer to gralloc module
1305	mFramebufferHnd = new private_handle_t(
1306	private_handle_t::PRIV_FLAGS_FRAMEBUFFER,
1307	usage, fbInfo->fbSize, 0,
1308	0, fbInfo->fd, bufferSize, 0);
1309	grallocModule->base.registerBuffer(&(grallocModule->base), mFramebufferHnd);
1310	DTRACE("init_frame_buffer get frame size %d usage %d",
1311	bufferSize, usage);
1312	}
1313
1314	mIsConnected = true;
1315
1316	// init cursor framebuffer
1317	mCursorContext = new FBContext();
1318	framebuffer_info_t* cbInfo = mCursorContext->getInfo();
1319	cbInfo->fd = -1;
1320
1321	//init information from cursor framebuffer.
1322	cbInfo->fbIdx = mId*2+1;
1323	if (1 != cbInfo->fbIdx && 3 != cbInfo->fbIdx) {
1324	ETRACE("invalid fb index: %d, need to check!",
1325	cbInfo->fbIdx);
1326	return 0;
1327	}
1328	int32_t err = init_cursor_buffer_locked(cbInfo);
1329	if (err != 0) {
1330	ETRACE("init_cursor_buffer_locked failed, need to check!");
1331	return 0;
1332	}
1333	ITRACE("init_cursor_buffer get cbinfo->fbIdx (%d) "
1334	"cbinfo->info.xres (%d) cbinfo->info.yres (%d)",
1335	cbInfo->fbIdx,
1336	cbInfo->info.xres,
1337	cbInfo->info.yres);
1338
1339	if ( cbInfo->fd >= 0) {
1340	DTRACE("init_cursor_buffer success!");
1341	}else{
1342	DTRACE("init_cursor_buffer fail!");
1343	}
1344
1345	return 0;
1346	}
1347
1348	bool PhysicalDevice::updateDisplayConfigs() {
1349	Mutex::Autolock _l(mLock);
1350	bool ret;
1351
1352	if (!mIsConnected) {
1353	ETRACE("disp: %llu is not connected", mId);
1354	return false;
1355	}
1356
1357	framebuffer_info_t* fbinfo = mFramebufferContext->getInfo();
1358	ret = Utils::checkVinfo(fbinfo);
1359	if (!ret) {
1360	ETRACE("checkVinfo fail");
1361	return false;
1362	}
1363
1364	mDisplayHdmi->updateHotplug(mIsConnected, fbinfo, mFramebufferHnd);
1365	if (mIsConnected)
1366	mVsyncObserver->setRefreshRate(mDisplayHdmi->getActiveRefreshRate());
1367	//ETRACE("updateDisplayConfigs rate:%d", mDisplayHdmi->getActiveRefreshRate());
1368
1369	// check hdcp authentication status when hotplug is happen.
1370	if (mSystemControl == NULL) {
1371	mSystemControl = getSystemControlService();
1372	} else {
1373	DTRACE("already have system control instance.");
1374	}
1375	if (mSystemControl != NULL) {
1376	// mSecure = Utils::checkHdcp();
1377	int status = 0;
1378	mSystemControl->isHDCPTxAuthSuccess(status);
1379	DTRACE("hdcp status: %d", status);
1380	mSecure = (status == 1) ? true : false;
1381	} else {
1382	ETRACE("can't get system control.");
1383	}
1384
1385	return true;
1386	}
1387
1388	sp<ISystemControlService> PhysicalDevice::getSystemControlService()
1389	{
1390	sp<IServiceManager> sm = defaultServiceManager();
1391	if (sm == NULL) {
1392	ETRACE("Couldn't get default ServiceManager\n");
1393	return NULL;
1394	}
1395	sp<IBinder> binder = sm->getService(String16("system_control"));
1396	sp<ISystemControlService> sc = interface_cast<ISystemControlService>(binder);
1397
1398	return sc;
1399	}
1400
1401	void PhysicalDevice::onVsync(int64_t timestamp) {
1402	RETURN_VOID_IF_NOT_INIT();
1403	ATRACE("timestamp = %lld", timestamp);
1404
1405	if (!mIsConnected)
1406	return;
1407
1408	// notify hwc
1409	mHwc.vsync(mId, timestamp);
1410	}
1411
1412	int32_t PhysicalDevice::createVirtualDisplay(
1413	uint32_t width,
1414	uint32_t height,
1415	int32_t* /*android_pixel_format_t*/ format,
1416	hwc2_display_t* outDisplay) {
1417
1418	return HWC2_ERROR_NONE;
1419	}
1420
1421	int32_t PhysicalDevice::destroyVirtualDisplay(
1422	hwc2_display_t display) {
1423
1424	return HWC2_ERROR_NONE;
1425	}
1426
1427	int32_t PhysicalDevice::setOutputBuffer(
1428	buffer_handle_t buffer, int32_t releaseFence) {
1429	// Virtual Display Only.
1430	return HWC2_ERROR_NONE;
1431	}
1432
1433	void PhysicalDevice::updateHotplugState(bool connected) {
1434	Mutex::Autolock _l(mLock);
1435
1436	mIsConnected = connected;
1437	//if plug out, need reinit
1438	if (!connected)
1439	mHdrCapabilities.init = false;
1440	}
1441
1442	int32_t PhysicalDevice::getLineValue(const char *lineStr, const char *magicStr) {
1443	int len = 0;
1444	char value[100] = {0};
1445	char *pos = NULL;
1446
1447	if ((NULL == lineStr) || (NULL == magicStr)) {
1448	ETRACE("line string: %s, magic string: %s\n", lineStr, magicStr);
1449	return 0;
1450	}
1451
1452	if (NULL != (pos = strstr((char *)lineStr, magicStr))) {
1453	pos = pos + strlen(magicStr);
1454	char* start = pos;
1455	while (*start != '\n' && (strlen(start) > 0))
1456	start++;
1457
1458	len = start - pos;
1459	strncpy(value, pos, len);
1460	value[len] = '\0';
1461	return atoi(value);
1462	}
1463
1464	return 0;
1465	}
1466
1467	/*
1468	cat /sys/class/amhdmitx/amhdmitx0/hdr_cap
1469	Supported EOTF:
1470	Traditional SDR: 1
1471	Traditional HDR: 0
1472	SMPTE ST 2084: 1
1473	Future EOTF: 0
1474	Supported SMD type1: 1
1475	Luminance Data
1476	Max: 0
1477	Avg: 0
1478	Min: 0
1479	cat /sys/class/amhdmitx/amhdmitx0/dv_cap
1480	DolbyVision1 RX support list:
1481	2160p30hz: 1
1482	global dimming
1483	colorimetry
1484	IEEEOUI: 0x00d046
1485	DM Ver: 1
1486	*/
1487	int32_t PhysicalDevice::parseHdrCapabilities() {
1488	//DolbyVision1
1489	const char *DV_PATH = "/sys/class/amhdmitx/amhdmitx0/dv_cap";
1490	//HDR
1491	const char *HDR_PATH = "/sys/class/amhdmitx/amhdmitx0/hdr_cap";
1492
1493	char buf[1024+1] = {0};
1494	char* pos = buf;
1495	int fd, len;
1496
1497	memset(&mHdrCapabilities, 0, sizeof(hdr_capabilities_t));
1498	if ((fd = open(DV_PATH, O_RDONLY)) < 0) {
1499	ETRACE("open %s fail.", DV_PATH);
1500	goto exit;
1501	}
1502
1503	len = read(fd, buf, 1024);
1504	if (len < 0) {
1505	ETRACE("read error: %s, %s\n", DV_PATH, strerror(errno));
1506	goto exit;
1507	}
1508	close(fd);
1509
1510	if ((NULL != strstr(pos, "2160p30hz")) || (NULL != strstr(pos, "2160p60hz")))
1511	mHdrCapabilities.dvSupport = true;
1512	//dobly version parse end
1513
1514	memset(buf, 0, 1024);
1515	if ((fd = open(HDR_PATH, O_RDONLY)) < 0) {
1516	ETRACE("open %s fail.", HDR_PATH);
1517	goto exit;
1518	}
1519
1520	len = read(fd, buf, 1024);
1521	if (len < 0) {
1522	ETRACE("read error: %s, %s\n", HDR_PATH, strerror(errno));
1523	goto exit;
1524	}
1525
1526	pos = strstr(pos, "SMPTE ST 2084: ");
1527	if ((NULL != pos) && ('1' == *(pos + strlen("SMPTE ST 2084: ")))) {
1528	mHdrCapabilities.hdrSupport = true;
1529
1530	mHdrCapabilities.maxLuminance = getLineValue(pos, "Max: ");
1531	mHdrCapabilities.avgLuminance = getLineValue(pos, "Avg: ");
1532	mHdrCapabilities.minLuminance = getLineValue(pos, "Min: ");
1533	}
1534
1535	ITRACE("dolby version support:%d, hdr support:%d max:%d, avg:%d, min:%d\n",
1536	mHdrCapabilities.dvSupport?1:0, mHdrCapabilities.hdrSupport?1:0, mHdrCapabilities.maxLuminance, mHdrCapabilities.avgLuminance, mHdrCapabilities.minLuminance);
1537	exit:
1538	close(fd);
1539	return HWC2_ERROR_NONE;
1540	}
1541
1542	void PhysicalDevice::dump(Dump& d) {
1543	Mutex::Autolock _l(mLock);
1544	d.append("-------------------------------------------------------------"
1545	"----------------------------------------------------------------\n");
1546	d.append("Device Name: %s (%s)\n", mName,
1547	mIsConnected ? "connected" : "disconnected");
1548	mDisplayHdmi->dump(d);
1549
1550	// dump layer list
1551	d.append(" Layers state:\n");
1552	d.append(" numLayers=%zu\n", mHwcLayers.size());
1553	// d.append(" numChangedTypeLayers=%zu\n", mHwcLayersChangeType.size());
1554	// d.append(" numChangedRequestLayers=%zu\n", mHwcLayersChangeRequest.size());
1555
1556	if (mHwcLayers.size() > 0) {
1557	d.append(
1558	" type | handle | zorder | ds | alpa | tr | blnd |"
1559	" source crop (l,t,r,b) | frame \n"
1560	" -------------+--------------+------------+----+------+----+------+"
1561	"--------------------------------+------------------------\n");
1562	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
1563	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
1564	HwcLayer *layer = mHwcLayers.valueAt(i);
1565	if (layer) layer->dump(d);
1566	}
1567	}
1568
1569	// HDR info
1570	d.append(" HDR Capabilities:\n");
1571	d.append(" DolbyVision1=%zu\n", mHdrCapabilities.dvSupport?1:0);
1572	d.append(" HDR10=%zu, maxLuminance=%zu, avgLuminance=%zu, minLuminance=%zu\n",
1573	mHdrCapabilities.hdrSupport?1:0, mHdrCapabilities.maxLuminance, mHdrCapabilities.avgLuminance, mHdrCapabilities.minLuminance);
1574	}
1575
1576	} // namespace amlogic
1577	} // namespace android
1578