| /* |
| * Copyright (C) 2012 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <aidl/android/hardware/graphics/common/BufferUsage.h> |
| #include <utils/Errors.h> |
| #include <linux/videodev2.h> |
| #include <sys/mman.h> |
| #include <hardware/hwcomposer_defs.h> |
| #include <hardware/exynos/ion.h> |
| |
| #include "BrightnessController.h" |
| #include "ExynosLayer.h" |
| #include "ExynosResourceManager.h" |
| #include "ExynosHWCDebug.h" |
| #include "ExynosExternalDisplay.h" |
| |
| #include "VendorVideoAPI.h" |
| |
| /** |
| * ExynosLayer implementation |
| */ |
| |
| using AidlBufferUsage = ::aidl::android::hardware::graphics::common::BufferUsage; |
| |
| ExynosLayer::ExynosLayer(ExynosDisplay* display) |
| : ExynosMPPSource(MPP_SOURCE_LAYER, this), |
| mDisplay(display), |
| mCompositionType(HWC2_COMPOSITION_INVALID), |
| mRequestedCompositionType(HWC2_COMPOSITION_INVALID), |
| mExynosCompositionType(HWC2_COMPOSITION_INVALID), |
| mValidateCompositionType(HWC2_COMPOSITION_INVALID), |
| mPrevValidateCompositionType(HWC2_COMPOSITION_INVALID), |
| mValidateExynosCompositionType(HWC2_COMPOSITION_INVALID), |
| mOverlayInfo(0x0), |
| mSupportedMPPFlag(0x0), |
| mFps(0), |
| mOverlayPriority(ePriorityLow), |
| mGeometryChanged(0x0), |
| mWindowIndex(0), |
| mCompressionInfo({COMP_TYPE_NONE, 0}), |
| mAcquireFence(-1), |
| mPrevAcquireFence(-1), |
| mReleaseFence(-1), |
| mFrameCount(0), |
| mLastFrameCount(0), |
| mLastFpsTime(0), |
| mNextLastFrameCount(0), |
| mNextLastFpsTime(0), |
| mLastLayerBuffer(NULL), |
| mLayerBuffer(NULL), |
| mLastUpdateTime(0), |
| mDamageNum(0), |
| mBlending(HWC2_BLEND_MODE_NONE), |
| mPlaneAlpha(1.0), |
| mTransform(0), |
| mZOrder(0), |
| mDataSpace(HAL_DATASPACE_UNKNOWN), |
| mLayerFlag(0x0), |
| mIsHdrLayer(false), |
| mBufferHasMetaParcel(false), |
| mMetaParcelFd(-1) { |
| memset(&mDisplayFrame, 0, sizeof(mDisplayFrame)); |
| memset(&mSourceCrop, 0, sizeof(mSourceCrop)); |
| mVisibleRegionScreen.numRects = 0; |
| mVisibleRegionScreen.rects = NULL; |
| memset(&mColor, 0, sizeof(mColor)); |
| memset(&mPreprocessedInfo, 0, sizeof(mPreprocessedInfo)); |
| mCheckMPPFlag.clear(); |
| mCheckMPPFlag.reserve(MPP_LOGICAL_TYPE_NUM); |
| mMetaParcel = NULL; |
| mDamageRects.clear(); |
| } |
| |
| ExynosLayer::~ExynosLayer() { |
| if (mMetaParcel != NULL) { |
| munmap(mMetaParcel, sizeof(ExynosVideoMeta)); |
| mMetaParcel = NULL; |
| } |
| |
| if (mMetaParcelFd >= 0) { |
| close(mMetaParcelFd); |
| mMetaParcelFd = -1; |
| } |
| |
| if (mAcquireFence >= 0) { |
| mAcquireFence = |
| fence_close(mAcquireFence, mDisplay, FENCE_TYPE_SRC_ACQUIRE, FENCE_IP_UNDEFINED); |
| } |
| |
| if (mPrevAcquireFence != -1) |
| mPrevAcquireFence = fence_close(mPrevAcquireFence, mDisplay, FENCE_TYPE_SRC_ACQUIRE, |
| FENCE_IP_UNDEFINED); |
| } |
| |
| /** |
| * @return float |
| */ |
| float ExynosLayer::checkFps(bool increaseCount) { |
| uint32_t frameDiff; |
| mFrameCount += increaseCount ? 1 : 0; |
| |
| nsecs_t now = systemTime(); |
| if (mLastFpsTime == 0) { // Initialize values |
| mLastFpsTime = now; |
| mNextLastFpsTime = now; |
| // TODO(b/268474771): set the initial FPS to the correct peak refresh rate |
| mFps = 120; |
| return mFps; |
| } |
| |
| nsecs_t diff = now - mNextLastFpsTime; |
| // Update mLastFrameCount for every 5s, to ensure that FPS calculation is only based on |
| // frames in the past at most 10s. |
| if (diff >= kLayerFpsStableTimeNs) { |
| mLastFrameCount = mNextLastFrameCount; |
| mNextLastFrameCount = mFrameCount; |
| |
| mLastFpsTime = mNextLastFpsTime; |
| mNextLastFpsTime = now; |
| } |
| |
| bool wasLowFps = (mFps < LOW_FPS_THRESHOLD) ? true : false; |
| |
| if (mFrameCount >= mLastFrameCount) |
| frameDiff = (mFrameCount - mLastFrameCount); |
| else |
| frameDiff = (mFrameCount + (UINT_MAX - mLastFrameCount)); |
| |
| diff = now - mLastFpsTime; |
| mFps = (frameDiff * float(s2ns(1))) / diff; |
| |
| bool nowLowFps = (mFps < LOW_FPS_THRESHOLD) ? true : false; |
| |
| if ((mDisplay->mDisplayControl.handleLowFpsLayers) && |
| (wasLowFps != nowLowFps)) |
| setGeometryChanged(GEOMETRY_LAYER_FPS_CHANGED); |
| |
| return mFps; |
| } |
| |
| /** |
| * @return float |
| */ |
| float ExynosLayer::getFps() { |
| return mFps; |
| } |
| |
| int32_t ExynosLayer::doPreProcess() |
| { |
| overlay_priority priority = ePriorityLow; |
| mIsHdrLayer = false; |
| mBufferHasMetaParcel = false; |
| mLayerFlag = 0x0; |
| |
| mPreprocessedInfo.preProcessed = false; |
| mPreprocessedInfo.sourceCrop = mSourceCrop; |
| mPreprocessedInfo.displayFrame = mDisplayFrame; |
| mPreprocessedInfo.interlacedType = V4L2_FIELD_NONE; |
| mPreprocessedInfo.sdrDimRatio = mBrightness; |
| |
| if (mCompositionType == HWC2_COMPOSITION_SOLID_COLOR) { |
| mLayerFlag |= EXYNOS_HWC_DIM_LAYER; |
| } else { |
| mLayerFlag &= ~(EXYNOS_HWC_DIM_LAYER); |
| } |
| |
| if (mLayerBuffer == NULL) { |
| if (mOverlayPriority != priority) |
| setGeometryChanged(GEOMETRY_LAYER_PRIORITY_CHANGED); |
| |
| mOverlayPriority = priority; |
| return NO_ERROR; |
| } |
| |
| VendorGraphicBufferMeta gmeta(mLayerBuffer); |
| |
| mPreprocessedInfo.mUsePrivateFormat = false; |
| mPreprocessedInfo.mPrivateFormat = gmeta.format; |
| |
| if (isFormatYUV(gmeta.format)) { |
| mPreprocessedInfo.sourceCrop.top = (int)mSourceCrop.top; |
| mPreprocessedInfo.sourceCrop.left = (int)mSourceCrop.left; |
| mPreprocessedInfo.sourceCrop.bottom = (int)(mSourceCrop.bottom + 0.9); |
| mPreprocessedInfo.sourceCrop.right = (int)(mSourceCrop.right + 0.9); |
| mPreprocessedInfo.preProcessed = true; |
| } |
| |
| if (isFormatYUV(gmeta.format)) { |
| |
| ExynosVideoMeta *metaData = NULL; |
| int priv_fd = -1; |
| |
| if (gmeta.flags & VendorGraphicBufferMeta::PRIV_FLAGS_USES_2PRIVATE_DATA) |
| priv_fd = gmeta.fd1; |
| else if (gmeta.flags & VendorGraphicBufferMeta::PRIV_FLAGS_USES_3PRIVATE_DATA) |
| priv_fd = gmeta.fd2; |
| |
| if (priv_fd >= 0) { |
| |
| metaData = (ExynosVideoMeta*)mmap(0, sizeof(ExynosVideoMeta), PROT_READ|PROT_WRITE, MAP_SHARED, priv_fd, 0); |
| |
| if (metaData == NULL) { |
| HWC_LOGE(mDisplay, "Layer's metadata is NULL!!"); |
| } else if (metaData == MAP_FAILED) { |
| HWC_LOGE(mDisplay, "Layer's metadata map failed!!"); |
| } else { |
| mBufferHasMetaParcel = true; |
| if ((metaData->eType & VIDEO_INFO_TYPE_HDR_STATIC) || |
| (metaData->eType & VIDEO_INFO_TYPE_HDR_DYNAMIC)) { |
| if (allocMetaParcel() == NO_ERROR) { |
| mMetaParcel->eType = metaData->eType; |
| if (metaData->eType & VIDEO_INFO_TYPE_HDR_STATIC) { |
| mMetaParcel->sHdrStaticInfo = metaData->sHdrStaticInfo; |
| HDEBUGLOGD(eDebugLayer, "HWC2: Static metadata min(%d), max(%d)", |
| mMetaParcel->sHdrStaticInfo.sType1.mMinDisplayLuminance, |
| mMetaParcel->sHdrStaticInfo.sType1.mMaxDisplayLuminance); |
| } |
| if (metaData->eType & VIDEO_INFO_TYPE_HDR_DYNAMIC) { |
| /* Reserved field for dynamic meta data */ |
| /* Currently It's not be used not only HWC but also OMX */ |
| mMetaParcel->sHdrDynamicInfo = metaData->sHdrDynamicInfo; |
| HDEBUGLOGD(eDebugLayer, "HWC2: Layer has dynamic metadata"); |
| } |
| } |
| } |
| if (metaData->eType & VIDEO_INFO_TYPE_INTERLACED) { |
| mPreprocessedInfo.interlacedType = metaData->data.dec.nInterlacedType; |
| if (mPreprocessedInfo.interlacedType == V4L2_FIELD_INTERLACED_BT) { |
| if ((int)mSourceCrop.left < (int)(gmeta.stride)) { |
| mPreprocessedInfo.sourceCrop.left = (int)mSourceCrop.left + gmeta.stride; |
| mPreprocessedInfo.sourceCrop.right = (int)mSourceCrop.right + gmeta.stride; |
| } |
| } |
| if (mPreprocessedInfo.interlacedType == V4L2_FIELD_INTERLACED_TB || |
| mPreprocessedInfo.interlacedType == V4L2_FIELD_INTERLACED_BT) { |
| mPreprocessedInfo.sourceCrop.top = (int)(mSourceCrop.top)/2; |
| mPreprocessedInfo.sourceCrop.bottom = (int)(mSourceCrop.bottom)/2; |
| } |
| } |
| if (metaData->eType & VIDEO_INFO_TYPE_CHECK_PIXEL_FORMAT) { |
| mPreprocessedInfo.mUsePrivateFormat = true; |
| mPreprocessedInfo.mPrivateFormat = metaData->nPixelFormat; |
| } |
| munmap(metaData, sizeof(ExynosVideoMeta)); |
| } |
| } |
| mPreprocessedInfo.preProcessed = true; |
| } |
| |
| exynos_image src_img; |
| exynos_image dst_img; |
| setSrcExynosImage(&src_img); |
| setDstExynosImage(&dst_img); |
| ExynosMPP *exynosMPPVG = nullptr; |
| if (isFormatYUV(gmeta.format)) { |
| auto otfMPPs = ExynosResourceManager::getOtfMPPs(); |
| auto mpp_it = std::find_if(otfMPPs.begin(), otfMPPs.end(), |
| [&src_img](auto m) { return m->isSrcFormatSupported(src_img); }); |
| exynosMPPVG = mpp_it == otfMPPs.end() ? nullptr : *mpp_it; |
| } |
| |
| /* Set HDR Flag */ |
| if(hasHdrInfo(src_img)) mIsHdrLayer = true; |
| |
| if (isFormatYUV(gmeta.format) && exynosMPPVG) { |
| /* |
| * layer's sourceCrop should be aligned |
| */ |
| uint32_t srcCropXAlign = exynosMPPVG->getSrcXOffsetAlign(src_img); |
| uint32_t srcCropYAlign = exynosMPPVG->getSrcYOffsetAlign(src_img); |
| uint32_t srcCropWidthAlign = exynosMPPVG->getSrcWidthAlign(src_img); |
| uint32_t srcCropHeightAlign = exynosMPPVG->getSrcHeightAlign(src_img); |
| mPreprocessedInfo.sourceCrop.left = pixel_align((int)mPreprocessedInfo.sourceCrop.left, srcCropXAlign); |
| mPreprocessedInfo.sourceCrop.top = pixel_align((int)mPreprocessedInfo.sourceCrop.top, srcCropYAlign); |
| mPreprocessedInfo.sourceCrop.right = mPreprocessedInfo.sourceCrop.left + |
| pixel_align_down(WIDTH(mPreprocessedInfo.sourceCrop), srcCropWidthAlign); |
| mPreprocessedInfo.sourceCrop.bottom = mPreprocessedInfo.sourceCrop.top + |
| pixel_align_down(HEIGHT(mPreprocessedInfo.sourceCrop), srcCropHeightAlign); |
| mPreprocessedInfo.preProcessed = true; |
| } |
| |
| if (exynosMPPVG && ((getDrmMode(mLayerBuffer) != NO_DRM) || |
| (mIsHdrLayer == true))) |
| { |
| if ((mDisplay->mDisplayControl.adjustDisplayFrame == true) && |
| ((mSupportedMPPFlag & (MPP_LOGICAL_DPP_G | MPP_LOGICAL_DPP_VG | MPP_LOGICAL_DPP_VGFS | MPP_LOGICAL_DPP_VGRFS)) == 0)) |
| { |
| /* |
| * M2mMPP should be used for DRM, HDR video |
| * layer's displayFrame is the source of DPP |
| */ |
| uint32_t cropWidthAlign = exynosMPPVG->getSrcCropWidthAlign(src_img); |
| uint32_t cropHeightAlign = exynosMPPVG->getSrcCropHeightAlign(src_img); |
| |
| mPreprocessedInfo.displayFrame.right = mDisplayFrame.left + |
| pixel_align(WIDTH(mDisplayFrame), cropWidthAlign); |
| mPreprocessedInfo.displayFrame.bottom = mDisplayFrame.top + |
| pixel_align(HEIGHT(mDisplayFrame), cropHeightAlign); |
| |
| if (mPreprocessedInfo.displayFrame.right > (int)(mDisplay->mXres)) { |
| mPreprocessedInfo.displayFrame.left = mDisplay->mXres - |
| pixel_align(WIDTH(mPreprocessedInfo.displayFrame), cropWidthAlign); |
| mPreprocessedInfo.displayFrame.right = mDisplay->mXres; |
| } |
| |
| if (mPreprocessedInfo.displayFrame.bottom > (int)(mDisplay->mYres)) { |
| mPreprocessedInfo.displayFrame.top = mDisplay->mYres - |
| pixel_align_down(HEIGHT(mPreprocessedInfo.displayFrame), cropHeightAlign); |
| mPreprocessedInfo.displayFrame.bottom = mDisplay->mYres; |
| } |
| } |
| |
| uint32_t minDstWidth = exynosMPPVG->getDstMinWidth(dst_img); |
| uint32_t minDstHeight = exynosMPPVG->getDstMinHeight(dst_img); |
| if ((uint32_t)WIDTH(mDisplayFrame) < minDstWidth) { |
| ALOGI("%s DRM layer displayFrame width %d is smaller than otf minWidth %d", |
| mDisplay->mDisplayName.c_str(), |
| WIDTH(mDisplayFrame), minDstWidth); |
| mPreprocessedInfo.displayFrame.right = mDisplayFrame.left + |
| pixel_align(WIDTH(mDisplayFrame), minDstWidth); |
| |
| if (mPreprocessedInfo.displayFrame.right > (int)(mDisplay->mXres)) { |
| mPreprocessedInfo.displayFrame.left = mDisplay->mXres - |
| pixel_align(WIDTH(mPreprocessedInfo.displayFrame), minDstWidth); |
| mPreprocessedInfo.displayFrame.right = mDisplay->mXres; |
| } |
| } |
| if ((uint32_t)HEIGHT(mDisplayFrame) < minDstHeight) { |
| ALOGI("%s DRM layer displayFrame height %d is smaller than vpp minHeight %d", |
| mDisplay->mDisplayName.c_str(), |
| HEIGHT(mDisplayFrame), minDstHeight); |
| mPreprocessedInfo.displayFrame.bottom = mDisplayFrame.top + |
| pixel_align(HEIGHT(mDisplayFrame), minDstHeight); |
| |
| if (mPreprocessedInfo.displayFrame.bottom > (int)(mDisplay->mYres)) { |
| mPreprocessedInfo.displayFrame.top = mDisplay->mYres - |
| pixel_align(HEIGHT(mPreprocessedInfo.displayFrame), minDstHeight); |
| mPreprocessedInfo.displayFrame.bottom = mDisplay->mYres; |
| } |
| } |
| mPreprocessedInfo.preProcessed = true; |
| } |
| |
| if (VendorGraphicBufferMeta::get_usage(mLayerBuffer) & |
| toUnderlying(AidlBufferUsage::FRONT_BUFFER)) { |
| priority = ePriorityMax; |
| } else if (getDrmMode(mLayerBuffer) != NO_DRM) { |
| priority = ePriorityMax; |
| } else if (mIsHdrLayer) { |
| if (isFormatRgb(gmeta.format)) |
| priority = ePriorityMax; |
| else |
| priority = ePriorityHigh; |
| } else if (isFormatYUV(gmeta.format)) { |
| priority = ePriorityHigh; |
| } else if ((mDisplay->mDisplayControl.cursorSupport == true) && |
| (mCompositionType == HWC2_COMPOSITION_CURSOR)) { |
| priority = ePriorityMid; |
| } else { |
| priority = ePriorityLow; |
| } |
| |
| if (mOverlayPriority != priority) |
| setGeometryChanged(GEOMETRY_LAYER_PRIORITY_CHANGED); |
| |
| mOverlayPriority = priority; |
| |
| return NO_ERROR; |
| } |
| |
| int32_t ExynosLayer::setCursorPosition(int32_t x, int32_t y) { |
| return mDisplay->setCursorPositionAsync(x, y); |
| } |
| |
| |
| int32_t ExynosLayer::setLayerBuffer(buffer_handle_t buffer, int32_t acquireFence) { |
| |
| /* TODO : Exception here ? */ |
| //TODO mGeometryChanged here |
| |
| uint64_t internal_format = 0; |
| |
| if (mDisplay->mPlugState == false) |
| buffer = NULL; |
| |
| if (buffer != NULL) { |
| if (VendorGraphicBufferMeta::get_fd(buffer,0) < 0) |
| return HWC2_ERROR_BAD_LAYER; |
| } |
| |
| VendorGraphicBufferMeta gmeta(mLayerBuffer); |
| internal_format = gmeta.format; |
| |
| if ((mLayerBuffer == NULL) || (buffer == NULL)) |
| setGeometryChanged(GEOMETRY_LAYER_UNKNOWN_CHANGED); |
| else { |
| if (getDrmMode(VendorGraphicBufferMeta::get_producer_usage(mLayerBuffer)) != getDrmMode(gmeta.producer_usage)) |
| setGeometryChanged(GEOMETRY_LAYER_DRM_CHANGED); |
| if (VendorGraphicBufferMeta::get_format(mLayerBuffer) != gmeta.format) |
| setGeometryChanged(GEOMETRY_LAYER_FORMAT_CHANGED); |
| if ((VendorGraphicBufferMeta::get_usage(buffer) & |
| toUnderlying(AidlBufferUsage::FRONT_BUFFER)) != |
| (VendorGraphicBufferMeta::get_usage(mLayerBuffer) & |
| toUnderlying(AidlBufferUsage::FRONT_BUFFER))) |
| setGeometryChanged(GEOMETRY_LAYER_FRONT_BUFFER_USAGE_CHANGED); |
| } |
| |
| { |
| Mutex::Autolock lock(mDisplay->mDRMutex); |
| mLayerBuffer = buffer; |
| checkFps(mLastLayerBuffer != mLayerBuffer); |
| if (mLayerBuffer != mLastLayerBuffer) { |
| mLastUpdateTime = systemTime(CLOCK_MONOTONIC); |
| if (mRequestedCompositionType != HWC2_COMPOSITION_REFRESH_RATE_INDICATOR) |
| mDisplay->mBufferUpdates++; |
| } |
| } |
| mPrevAcquireFence = |
| fence_close(mPrevAcquireFence, mDisplay, FENCE_TYPE_SRC_ACQUIRE, FENCE_IP_UNDEFINED); |
| mAcquireFence = fence_close(mAcquireFence, mDisplay, FENCE_TYPE_SRC_ACQUIRE, FENCE_IP_UNDEFINED); |
| |
| mAcquireFence = hwcCheckFenceDebug(mDisplay, FENCE_TYPE_SRC_ACQUIRE, FENCE_IP_LAYER, acquireFence); |
| mPrevAcquireFence = hwcCheckFenceDebug(mDisplay, FENCE_TYPE_SRC_ACQUIRE, FENCE_IP_LAYER, |
| hwc_dup(mAcquireFence, mDisplay, FENCE_TYPE_SRC_ACQUIRE, |
| FENCE_IP_LAYER, true)); |
| if (mReleaseFence >= 0) |
| HWC_LOGE(NULL, "Layer's release fence is not initialized"); |
| mReleaseFence = -1; |
| #ifdef DISABLE_FENCE |
| if (mAcquireFence >= 0) |
| fence_close(mAcquireFence); |
| mAcquireFence = -1; |
| #endif |
| |
| /* Set Compression Information from GraphicBuffer */ |
| uint32_t prevCompressionType = mCompressionInfo.type; |
| mCompressionInfo = getCompressionInfo(mLayerBuffer); |
| if (mCompressionInfo.type != prevCompressionType) |
| setGeometryChanged(GEOMETRY_LAYER_COMPRESSED_CHANGED); |
| |
| if (buffer != NULL) { |
| /* |
| * HAL_DATASPACE_V0_JFIF = HAL_DATASPACE_STANDARD_BT601_625 | |
| * HAL_DATASPACE_TRANSFER_SMPTE_170M | HAL_DATASPACE_RANGE_FULL, |
| */ |
| if (gmeta.format == HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_M_FULL) |
| setLayerDataspace(HAL_DATASPACE_V0_JFIF); |
| } else { |
| setLayerDataspace(HAL_DATASPACE_UNKNOWN); |
| } |
| |
| HDEBUGLOGD(eDebugFence, |
| "layers bufferHandle: %p, mDataSpace: 0x%8x, acquireFence: %d, compressionType: " |
| "0x%x, internal_format: 0x%" PRIx64 "", |
| mLayerBuffer, mDataSpace, mAcquireFence, mCompressionInfo.type, internal_format); |
| |
| return 0; |
| } |
| |
| |
| int32_t ExynosLayer::setLayerSurfaceDamage(hwc_region_t damage) { |
| |
| mDamageNum = damage.numRects; |
| mDamageRects.clear(); |
| |
| if (mDamageNum == 0) return 0; |
| |
| for (size_t i = 0; i<mDamageNum; i++){ |
| mDamageRects.push_back(damage.rects[i]); |
| } |
| |
| return 0; |
| } |
| |
| int32_t ExynosLayer::setLayerBlendMode(int32_t /*hwc2_blend_mode_t*/ mode) { |
| |
| //TODO mGeometryChanged here |
| if (mode < 0) |
| return HWC2_ERROR_BAD_PARAMETER; |
| if (mBlending != mode) |
| setGeometryChanged(GEOMETRY_LAYER_BLEND_CHANGED); |
| mBlending = mode; |
| return HWC2_ERROR_NONE; |
| } |
| |
| |
| int32_t ExynosLayer::setLayerColor(hwc_color_t color) { |
| /* TODO : Implementation here */ |
| mColor = color; |
| return 0; |
| } |
| |
| int32_t ExynosLayer::setLayerCompositionType(int32_t /*hwc2_composition_t*/ type) { |
| |
| if (type < 0) |
| return HWC2_ERROR_BAD_PARAMETER; |
| |
| // FIXME: HWC2_COMPOSITION_SCREENSHOT is not defined in AOSP |
| // HWC guys should fix this. |
| #if 0 |
| if (mDisplay->mType == HWC_DISPLAY_PRIMARY) |
| if (type == HWC2_COMPOSITION_SCREENSHOT) |
| type = HWC2_COMPOSITION_DEVICE; |
| #endif |
| |
| if (type != mCompositionType) { |
| setGeometryChanged(GEOMETRY_LAYER_TYPE_CHANGED); |
| } |
| |
| mCompositionType = type; |
| mRequestedCompositionType = type; |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| int32_t ExynosLayer::setLayerDataspace(int32_t /*android_dataspace_t*/ dataspace) { |
| android_dataspace currentDataSpace = (android_dataspace_t)dataspace; |
| if ((mLayerBuffer != NULL) && (VendorGraphicBufferMeta::get_format(mLayerBuffer) == HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_M_FULL)) |
| currentDataSpace = HAL_DATASPACE_V0_JFIF; |
| else { |
| /* Change legacy dataspace */ |
| switch (dataspace) { |
| case HAL_DATASPACE_SRGB_LINEAR: |
| currentDataSpace = HAL_DATASPACE_V0_SRGB_LINEAR; |
| break; |
| case HAL_DATASPACE_SRGB: |
| currentDataSpace = HAL_DATASPACE_V0_SRGB; |
| break; |
| case HAL_DATASPACE_JFIF: |
| currentDataSpace = HAL_DATASPACE_V0_JFIF; |
| break; |
| case HAL_DATASPACE_BT601_625: |
| currentDataSpace = HAL_DATASPACE_V0_BT601_625; |
| break; |
| case HAL_DATASPACE_BT601_525: |
| currentDataSpace = HAL_DATASPACE_V0_BT601_525; |
| break; |
| case HAL_DATASPACE_BT709: |
| currentDataSpace = HAL_DATASPACE_V0_BT709; |
| break; |
| default: |
| currentDataSpace = (android_dataspace)dataspace; |
| break; |
| } |
| } |
| |
| if (currentDataSpace != mDataSpace) { |
| setGeometryChanged(GEOMETRY_LAYER_DATASPACE_CHANGED); |
| // invalidate metadata if dataspace is changed. need metadata update |
| // to be after dataspace update. |
| if (mMetaParcel != nullptr) { |
| mMetaParcel->eType = VIDEO_INFO_TYPE_INVALID; |
| } |
| } |
| mDataSpace = currentDataSpace; |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| int32_t ExynosLayer::setLayerDisplayFrame(hwc_rect_t frame) { |
| |
| if ((frame.left != mDisplayFrame.left) || |
| (frame.top != mDisplayFrame.top) || |
| (frame.right != mDisplayFrame.right) || |
| (frame.bottom != mDisplayFrame.bottom)) |
| setGeometryChanged(GEOMETRY_LAYER_DISPLAYFRAME_CHANGED); |
| mDisplayFrame = frame; |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| int32_t ExynosLayer::setLayerPlaneAlpha(float alpha) { |
| if (alpha < 0.0f || alpha > 1.0f) { |
| ALOGE("%s: invalid alpha %f", __func__, alpha); |
| return HWC2_ERROR_BAD_PARAMETER; |
| } |
| |
| if ((mPlaneAlpha != alpha) && ((mPlaneAlpha == 0.0) || (alpha == 0.0))) |
| setGeometryChanged(GEOMETRY_LAYER_IGNORE_CHANGED); |
| |
| mPlaneAlpha = alpha; |
| |
| if (mPlaneAlpha > 0.0) |
| mLayerFlag &= ~(EXYNOS_HWC_IGNORE_LAYER); |
| else |
| mLayerFlag |= EXYNOS_HWC_IGNORE_LAYER; |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| int32_t ExynosLayer::setLayerSidebandStream(const native_handle_t* __unused stream) { |
| return HWC2_ERROR_NONE; |
| } |
| |
| int32_t ExynosLayer::setLayerSourceCrop(hwc_frect_t crop) { |
| if ((crop.left != mSourceCrop.left) || |
| (crop.top != mSourceCrop.top) || |
| (crop.right != mSourceCrop.right) || |
| (crop.bottom != mSourceCrop.bottom)) { |
| setGeometryChanged(GEOMETRY_LAYER_SOURCECROP_CHANGED); |
| mSourceCrop = crop; |
| } |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| int32_t ExynosLayer::setLayerTransform(int32_t /*hwc_transform_t*/ transform) { |
| |
| if (mTransform != transform) { |
| setGeometryChanged(GEOMETRY_LAYER_TRANSFORM_CHANGED); |
| mTransform = transform; |
| } |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| int32_t ExynosLayer::setLayerVisibleRegion(hwc_region_t visible) { |
| |
| mVisibleRegionScreen = visible; |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| int32_t ExynosLayer::setLayerZOrder(uint32_t z) { |
| if (mZOrder != z) { |
| setGeometryChanged(GEOMETRY_LAYER_ZORDER_CHANGED); |
| mZOrder = z; |
| } |
| return HWC2_ERROR_NONE; |
| } |
| |
| int32_t ExynosLayer::setLayerPerFrameMetadata(uint32_t numElements, |
| const int32_t* /*hw2_per_frame_metadata_key_t*/ keys, const float* metadata) |
| { |
| if (allocMetaParcel() != NO_ERROR) |
| return -1; |
| unsigned int multipliedVal = 50000; |
| mMetaParcel->eType = |
| static_cast<ExynosVideoInfoType>(mMetaParcel->eType | VIDEO_INFO_TYPE_HDR_STATIC); |
| for (uint32_t i = 0; i < numElements; i++) { |
| HDEBUGLOGD(eDebugLayer, "HWC2: setLayerPerFrameMetadata key(%d), value(%7.5f)", |
| keys[i], metadata[i]); |
| switch (keys[i]) { |
| case HWC2_DISPLAY_RED_PRIMARY_X: |
| mMetaParcel->sHdrStaticInfo.sType1.mR.x = |
| (unsigned int)(metadata[i] * multipliedVal); |
| break; |
| case HWC2_DISPLAY_RED_PRIMARY_Y: |
| mMetaParcel->sHdrStaticInfo.sType1.mR.y = |
| (unsigned int)(metadata[i] * multipliedVal); |
| break; |
| case HWC2_DISPLAY_GREEN_PRIMARY_X: |
| mMetaParcel->sHdrStaticInfo.sType1.mG.x = |
| (unsigned int)(metadata[i] * multipliedVal); |
| break; |
| case HWC2_DISPLAY_GREEN_PRIMARY_Y: |
| mMetaParcel->sHdrStaticInfo.sType1.mG.y = |
| (unsigned int)(metadata[i] * multipliedVal); |
| break; |
| case HWC2_DISPLAY_BLUE_PRIMARY_X: |
| mMetaParcel->sHdrStaticInfo.sType1.mB.x = |
| (unsigned int)(metadata[i] * multipliedVal); |
| break; |
| case HWC2_DISPLAY_BLUE_PRIMARY_Y: |
| mMetaParcel->sHdrStaticInfo.sType1.mB.y = |
| (unsigned int)(metadata[i] * multipliedVal); |
| break; |
| case HWC2_WHITE_POINT_X: |
| mMetaParcel->sHdrStaticInfo.sType1.mW.x = |
| (unsigned int)(metadata[i] * multipliedVal); |
| break; |
| case HWC2_WHITE_POINT_Y: |
| mMetaParcel->sHdrStaticInfo.sType1.mW.y = |
| (unsigned int)(metadata[i] * multipliedVal); |
| break; |
| case HWC2_MAX_LUMINANCE: |
| mMetaParcel->sHdrStaticInfo.sType1.mMaxDisplayLuminance = |
| (unsigned int)(metadata[i] * 10000); |
| break; |
| case HWC2_MIN_LUMINANCE: |
| mMetaParcel->sHdrStaticInfo.sType1.mMinDisplayLuminance = |
| (unsigned int)(metadata[i] * 10000); |
| break; |
| case HWC2_MAX_CONTENT_LIGHT_LEVEL: |
| /* Should be checked */ |
| mMetaParcel->sHdrStaticInfo.sType1.mMaxContentLightLevel = |
| (unsigned int)(metadata[i]); |
| break; |
| case HWC2_MAX_FRAME_AVERAGE_LIGHT_LEVEL: |
| /* Should be checked */ |
| mMetaParcel->sHdrStaticInfo.sType1.mMaxFrameAverageLightLevel = |
| (unsigned int)(metadata[i]); |
| break; |
| default: |
| return HWC2_ERROR_UNSUPPORTED; |
| } |
| } |
| return NO_ERROR; |
| } |
| |
| int32_t ExynosLayer::setLayerPerFrameMetadataBlobs(uint32_t numElements, const int32_t* keys, const uint32_t* sizes, |
| const uint8_t* metadata) |
| { |
| const uint8_t *metadata_start = metadata; |
| for (uint32_t i = 0; i < numElements; i++) { |
| HDEBUGLOGD(eDebugLayer, "HWC2: setLayerPerFrameMetadataBlobs key(%d)", keys[i]); |
| switch (keys[i]) { |
| case HWC2_HDR10_PLUS_SEI: |
| if (allocMetaParcel() == NO_ERROR) { |
| mMetaParcel->eType = |
| static_cast<ExynosVideoInfoType>(mMetaParcel->eType | VIDEO_INFO_TYPE_HDR_DYNAMIC); |
| ExynosHdrDynamicInfo *info = &(mMetaParcel->sHdrDynamicInfo); |
| Exynos_parsing_user_data_registered_itu_t_t35(info, (void*)metadata_start, |
| sizes[i]); |
| } else { |
| ALOGE("Layer has no metaParcel!"); |
| return HWC2_ERROR_UNSUPPORTED; |
| } |
| break; |
| default: |
| return HWC2_ERROR_BAD_PARAMETER; |
| } |
| metadata_start += sizes[i]; |
| } |
| return HWC2_ERROR_NONE; |
| } |
| |
| int32_t ExynosLayer::setLayerColorTransform(const float* matrix) |
| { |
| mLayerColorTransform.enable = true; |
| for (uint32_t i = 0; i < TRANSFORM_MAT_SIZE; i++) |
| { |
| mLayerColorTransform.mat[i] = matrix[i]; |
| } |
| |
| return 0; |
| } |
| |
| int32_t ExynosLayer::setLayerGenericMetadata(hwc2_layer_t __unused layer, |
| uint32_t __unused keyLength, const char* __unused key, |
| bool __unused mandatory, uint32_t __unused valueLength, const uint8_t* __unused value) |
| { |
| return HWC2_ERROR_UNSUPPORTED; |
| } |
| |
| int32_t ExynosLayer::setLayerBrightness(float brightness) { |
| if (mDisplay->mType == HWC_DISPLAY_EXTERNAL && mDisplay->mBrightnessController == nullptr) { |
| if (brightness == 1.0f) { |
| return HWC2_ERROR_NONE; |
| } else { |
| HWC_LOGE(mDisplay, "[ExternalDisplay layer] setLayerBrightness != 1.0"); |
| return HWC2_ERROR_BAD_PARAMETER; |
| } |
| } |
| |
| if (mDisplay->mBrightnessController == nullptr || |
| !mDisplay->mBrightnessController->validateLayerBrightness(brightness)) { |
| return HWC2_ERROR_BAD_PARAMETER; |
| } |
| |
| if (mBrightness != brightness) { |
| // Trigger display validation in case client composition is needed. |
| setGeometryChanged(GEOMETRY_LAYER_WHITEPOINT_CHANGED); |
| mBrightness = brightness; |
| } |
| return HWC2_ERROR_NONE; |
| } |
| |
| int32_t ExynosLayer::setLayerBlockingRegion(const std::vector<hwc_rect_t>& blockingRegion) { |
| hwc_rect_t maxRect; |
| |
| for (auto rect : blockingRegion) { |
| maxRect = std::max(maxRect, rect, [](const hwc_rect_t& lhs, const hwc_rect_t& rhs) { |
| return rectSize(lhs) < rectSize(rhs); |
| }); |
| } |
| |
| mBlockingRect = maxRect; |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| void ExynosLayer::resetValidateData() |
| { |
| mValidateCompositionType = HWC2_COMPOSITION_INVALID; |
| mOtfMPP = NULL; |
| mM2mMPP = NULL; |
| mOverlayInfo = 0x0; |
| mWindowIndex = 0; |
| } |
| |
| int32_t ExynosLayer::setSrcExynosImage(exynos_image *src_img) |
| { |
| buffer_handle_t handle = mLayerBuffer; |
| if (isDimLayer()) { |
| src_img->format = HAL_PIXEL_FORMAT_RGBA_8888; |
| src_img->usageFlags = 0xb00; |
| src_img->bufferHandle = 0; |
| |
| src_img->x = 0; |
| src_img->y = 0; |
| |
| if (mDisplay != NULL) { |
| src_img->fullWidth = src_img->w = mDisplay->mXres; |
| src_img->fullHeight = src_img->h = mDisplay->mYres; |
| } else { |
| src_img->fullWidth = src_img->w = 1440; |
| src_img->fullHeight = src_img->h = 2560; |
| } |
| |
| src_img->layerFlags = mLayerFlag; |
| src_img->acquireFenceFd = mAcquireFence; |
| src_img->releaseFenceFd = -1; |
| src_img->dataSpace = HAL_DATASPACE_V0_SRGB; |
| src_img->blending = mBlending; |
| src_img->transform = mTransform; |
| src_img->compressionInfo = mCompressionInfo; |
| src_img->planeAlpha = mPlaneAlpha; |
| src_img->zOrder = mZOrder; |
| |
| |
| return NO_ERROR; |
| } |
| |
| if (handle == NULL) { |
| src_img->fullWidth = 0; |
| src_img->fullHeight = 0; |
| src_img->format = 0; |
| src_img->usageFlags = 0x0; |
| src_img->bufferHandle = handle; |
| } else { |
| VendorGraphicBufferMeta gmeta(handle); |
| |
| if ((mPreprocessedInfo.interlacedType == V4L2_FIELD_INTERLACED_TB) || |
| (mPreprocessedInfo.interlacedType == V4L2_FIELD_INTERLACED_BT)) |
| { |
| src_img->fullWidth = (gmeta.stride * 2); |
| src_img->fullHeight = pixel_align_down((gmeta.vstride / 2), 2); |
| } else { |
| src_img->fullWidth = gmeta.stride; |
| // The BW VDEC will generate AFBC streams based on the initial requested height |
| // instead of the adjusted vstride from gralloc. |
| src_img->fullHeight = (isAFBC32x8(mCompressionInfo) && |
| (gmeta.producer_usage & VendorGraphicBufferUsage::BW)) |
| ? gmeta.height |
| : gmeta.vstride; |
| } |
| if (!mPreprocessedInfo.mUsePrivateFormat) |
| src_img->format = gmeta.format; |
| else |
| src_img->format = mPreprocessedInfo.mPrivateFormat; |
| src_img->usageFlags = gmeta.producer_usage; |
| src_img->bufferHandle = handle; |
| } |
| src_img->x = (int)mPreprocessedInfo.sourceCrop.left; |
| src_img->y = (int)mPreprocessedInfo.sourceCrop.top; |
| src_img->w = (int)mPreprocessedInfo.sourceCrop.right - (int)mPreprocessedInfo.sourceCrop.left; |
| src_img->h = (int)mPreprocessedInfo.sourceCrop.bottom - (int)mPreprocessedInfo.sourceCrop.top; |
| if ((mPreprocessedInfo.interlacedType == V4L2_FIELD_INTERLACED_TB) || |
| (mPreprocessedInfo.interlacedType == V4L2_FIELD_INTERLACED_BT)) |
| { |
| while ((src_img->h % 2 != 0) || |
| (src_img->h > src_img->fullHeight)) { |
| src_img->h -= 1; |
| } |
| } |
| src_img->layerFlags = mLayerFlag; |
| src_img->acquireFenceFd = mAcquireFence; |
| src_img->releaseFenceFd = -1; |
| |
| src_img->dataSpace = mDataSpace; |
| if(src_img->dataSpace == HAL_DATASPACE_UNKNOWN) |
| src_img->dataSpace = HAL_DATASPACE_V0_SRGB; |
| |
| src_img->blending = mBlending; |
| src_img->transform = mTransform; |
| src_img->compressionInfo = mCompressionInfo; |
| src_img->planeAlpha = mPlaneAlpha; |
| src_img->zOrder = mZOrder; |
| /* Copy HDR metadata */ |
| memset(&(src_img->metaParcel), 0, sizeof(src_img->metaParcel)); |
| src_img->metaType = VIDEO_INFO_TYPE_INVALID; |
| if (mMetaParcel != NULL) { |
| memcpy(&(src_img->metaParcel), mMetaParcel, sizeof(src_img->metaParcel)); |
| src_img->metaType = mMetaParcel->eType; |
| src_img->hasMetaParcel = true; |
| } else { |
| src_img->hasMetaParcel = false; |
| } |
| |
| src_img->needColorTransform = mLayerColorTransform.enable; |
| src_img->needPreblending = mNeedPreblending; |
| |
| return NO_ERROR; |
| } |
| |
| int32_t ExynosLayer::setDstExynosImage(exynos_image *dst_img) |
| { |
| buffer_handle_t handle = mLayerBuffer; |
| |
| if (handle == NULL) { |
| dst_img->usageFlags = 0x0; |
| } else { |
| dst_img->usageFlags = VendorGraphicBufferMeta::get_producer_usage(handle); |
| } |
| |
| if (isDimLayer()) { |
| dst_img->usageFlags = 0xb00; |
| } |
| |
| dst_img->format = DEFAULT_MPP_DST_FORMAT; |
| dst_img->x = mPreprocessedInfo.displayFrame.left; |
| dst_img->y = mPreprocessedInfo.displayFrame.top; |
| dst_img->w = (mPreprocessedInfo.displayFrame.right - mPreprocessedInfo.displayFrame.left); |
| dst_img->h = (mPreprocessedInfo.displayFrame.bottom - mPreprocessedInfo.displayFrame.top); |
| dst_img->layerFlags = mLayerFlag; |
| dst_img->acquireFenceFd = -1; |
| dst_img->releaseFenceFd = -1; |
| dst_img->bufferHandle = NULL; |
| dst_img->dataSpace = HAL_DATASPACE_UNKNOWN; |
| if (mDisplay != NULL) { |
| dst_img->fullWidth = mDisplay->mXres; |
| dst_img->fullHeight = mDisplay->mYres; |
| if (mDisplay->mColorMode != HAL_COLOR_MODE_NATIVE) { |
| dst_img->dataSpace = colorModeToDataspace(mDisplay->mColorMode); |
| } else { |
| if (hasHdrInfo(mDataSpace)) { |
| android_dataspace hdrDataSpace = |
| (android_dataspace)(HAL_DATASPACE_STANDARD_DCI_P3 | HAL_DATASPACE_TRANSFER_GAMMA2_2 | HAL_DATASPACE_RANGE_LIMITED); |
| if (mDisplay->mType == HWC_DISPLAY_EXTERNAL) { |
| ExynosExternalDisplay *externalDisplay = (ExynosExternalDisplay*)mDisplay; |
| if (externalDisplay->mExternalHdrSupported == true) |
| dst_img->dataSpace = HAL_DATASPACE_UNKNOWN; |
| else |
| dst_img->dataSpace = hdrDataSpace; |
| } else { |
| dst_img->dataSpace = hdrDataSpace; |
| } |
| } |
| } |
| } else { |
| HWC_LOGE(NULL, "mDisplay is NULL"); |
| } |
| dst_img->blending = mBlending; |
| dst_img->transform = 0; |
| dst_img->compressionInfo.type = COMP_TYPE_NONE; |
| dst_img->planeAlpha = mPlaneAlpha; |
| dst_img->zOrder = mZOrder; |
| |
| /* Copy HDR metadata */ |
| memset(&(dst_img->metaParcel), 0, sizeof(dst_img->metaParcel)); |
| dst_img->metaType = VIDEO_INFO_TYPE_INVALID; |
| if (mMetaParcel != NULL) { |
| memcpy(&(dst_img->metaParcel), mMetaParcel, sizeof(dst_img->metaParcel)); |
| dst_img->metaType = mMetaParcel->eType; |
| dst_img->hasMetaParcel = true; |
| } else { |
| dst_img->hasMetaParcel = false; |
| } |
| |
| return NO_ERROR; |
| } |
| |
| int32_t ExynosLayer::resetAssignedResource() |
| { |
| int32_t ret = NO_ERROR; |
| if (mM2mMPP != NULL) { |
| HDEBUGLOGD(eDebugResourceManager, "\t\t %s mpp is reset", mM2mMPP->mName.c_str()); |
| mM2mMPP->resetAssignedState(this); |
| mM2mMPP = NULL; |
| } |
| if (mOtfMPP != NULL) { |
| HDEBUGLOGD(eDebugResourceManager, "\t\t %s mpp is reset", mOtfMPP->mName.c_str()); |
| mOtfMPP->resetAssignedState(); |
| mOtfMPP = NULL; |
| } |
| return ret; |
| } |
| |
| bool ExynosLayer::checkBtsCap(const uint32_t bts_refresh_rate) { |
| if (mOtfMPP == nullptr) return true; |
| |
| exynos_image src_img; |
| exynos_image dst_img; |
| setSrcExynosImage(&src_img); |
| setDstExynosImage(&dst_img); |
| if (mOtfMPP->checkSpecificRestriction(bts_refresh_rate, src_img, dst_img)) { |
| return false; |
| } |
| |
| const bool isPerpendicular = !!(src_img.transform & HAL_TRANSFORM_ROT_90); |
| const uint32_t srcWidth = isPerpendicular ? src_img.h : src_img.w; |
| const uint32_t srcHeight = isPerpendicular ? src_img.w : src_img.h; |
| const bool scaleDown = (srcWidth > dst_img.w || srcHeight > dst_img.h); |
| |
| if (!scaleDown) return true; |
| |
| const float resolution = float(src_img.w) * float(src_img.h) * bts_refresh_rate / 1000; |
| |
| return mOtfMPP->checkDownscaleCap(resolution, float(dst_img.h) / float(mDisplay->mYres)); |
| } |
| |
| void ExynosLayer::setSrcAcquireFence() { |
| if (mAcquireFence == -1 && mPrevAcquireFence != -1) { |
| mAcquireFence = hwcCheckFenceDebug(mDisplay, FENCE_TYPE_SRC_ACQUIRE, FENCE_IP_LAYER, |
| hwc_dup(mPrevAcquireFence, mDisplay, |
| FENCE_TYPE_SRC_ACQUIRE, FENCE_IP_LAYER)); |
| } else if (mAcquireFence != -1) { |
| setFenceInfo(mAcquireFence, mDisplay, FENCE_TYPE_SRC_ACQUIRE, FENCE_IP_LAYER, |
| HwcFenceDirection::FROM); |
| } |
| } |
| |
| void ExynosLayer::dump(String8& result) |
| { |
| int format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED; |
| int32_t fd, fd1, fd2; |
| uint64_t unique_id; |
| if (mLayerBuffer != NULL) |
| { |
| VendorGraphicBufferMeta gmeta(mLayerBuffer); |
| format = gmeta.format; |
| fd = gmeta.fd; |
| fd1 = gmeta.fd1; |
| fd2 = gmeta.fd2; |
| unique_id = gmeta.unique_id; |
| } else { |
| format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED; |
| fd = -1; |
| fd1 = -1; |
| fd2 = -1; |
| unique_id = 0; |
| } |
| |
| { |
| TableBuilder tb; |
| tb.add("zOrder", mZOrder) |
| .add("priority", mOverlayPriority); |
| if (mCompositionType == HWC2_COMPOSITION_SOLID_COLOR) { |
| tb.add("color", std::vector<uint64_t>({mColor.r, mColor.g, mColor.b, mColor.a}), true); |
| } else { |
| tb.add("handle", mLayerBuffer) |
| .add("fd", std::vector<int>({fd, fd1, fd2})) |
| .add("compression", getCompressionStr(mCompressionInfo).c_str()); |
| } |
| tb.add("format", getFormatStr(format, mCompressionInfo.type).c_str()) |
| .add("dataSpace", mDataSpace, true) |
| .add("colorTr", mLayerColorTransform.enable) |
| .add("blend", mBlending, true) |
| .add("planeAlpha", mPlaneAlpha) |
| .add("fps", mFps); |
| result.append(tb.build().c_str()); |
| } |
| |
| result.append(TableBuilder() |
| .add("sourceCrop", |
| std::vector<double>({mPreprocessedInfo.sourceCrop.left, |
| mPreprocessedInfo.sourceCrop.top, |
| mPreprocessedInfo.sourceCrop.right, |
| mPreprocessedInfo.sourceCrop.bottom})) |
| .add("dispFrame", |
| std::vector<int>({mPreprocessedInfo.displayFrame.left, |
| mPreprocessedInfo.displayFrame.top, |
| mPreprocessedInfo.displayFrame.right, |
| mPreprocessedInfo.displayFrame.bottom})) |
| .add("blockRect", |
| std::vector<int>({mBlockingRect.left, mBlockingRect.top, |
| mBlockingRect.right, mBlockingRect.bottom})) |
| .add("tr", mTransform, true) |
| .add("windowIndex", mWindowIndex) |
| .add("type", mCompositionType) |
| .add("exynosType", mExynosCompositionType) |
| .add("validateType", mValidateCompositionType) |
| .add("overlayInfo", mOverlayInfo, true) |
| .add("GrallocBufferId", unique_id) |
| .build() |
| .c_str()); |
| |
| result.append(TableBuilder() |
| .add("MPPFlag", mSupportedMPPFlag, true) |
| .add("dim ratio", mPreprocessedInfo.sdrDimRatio) |
| .build() |
| .c_str()); |
| |
| if ((mDisplay != NULL) && (mDisplay->mResourceManager != NULL)) { |
| result.appendFormat("MPPFlags for otfMPP\n"); |
| for (uint32_t i = 0; i < mDisplay->mResourceManager->getOtfMPPSize(); i++) { |
| result.appendFormat("[%s: 0x%" PRIx64 "] ", mDisplay->mResourceManager->getOtfMPP(i)->mName.c_str(), |
| mCheckMPPFlag[mDisplay->mResourceManager->getOtfMPP(i)->mLogicalType]); |
| } |
| result.appendFormat("\n"); |
| result.appendFormat("MPPFlags for m2mMPP\n"); |
| for (uint32_t i = 0; i < mDisplay->mResourceManager->getM2mMPPSize(); i++) { |
| result.appendFormat("[%s: 0x%" PRIx64 "] ", mDisplay->mResourceManager->getM2mMPP(i)->mName.c_str(), |
| mCheckMPPFlag[mDisplay->mResourceManager->getM2mMPP(i)->mLogicalType]); |
| if ((i!=0) && (i%4==0)) result.appendFormat("\n"); |
| } |
| result.appendFormat("\n"); |
| } |
| result.appendFormat("acquireFence: %d\n", mAcquireFence); |
| if ((mOtfMPP == NULL) && (mM2mMPP == NULL)) |
| result.appendFormat("\tresource is not assigned.\n"); |
| if (mOtfMPP != NULL) |
| result.appendFormat("\tassignedMPP: %s\n", mOtfMPP->mName.c_str()); |
| if (mM2mMPP != NULL) |
| result.appendFormat("\tassignedM2mMPP: %s\n", mM2mMPP->mName.c_str()); |
| result.appendFormat("\tdump midImg\n"); |
| dumpExynosImage(result, mMidImg); |
| |
| } |
| |
| void ExynosLayer::printLayer() |
| { |
| int format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED; |
| int32_t fd, fd1, fd2; |
| String8 result; |
| if (mLayerBuffer != NULL) |
| { |
| VendorGraphicBufferMeta gmeta(mLayerBuffer); |
| format = gmeta.format; |
| fd = gmeta.fd; |
| fd1 = gmeta.fd1; |
| fd2 = gmeta.fd2; |
| } else { |
| format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED; |
| fd = -1; |
| fd1 = -1; |
| fd2 = -1; |
| } |
| result.appendFormat("handle: %p [fd: %d, %d, %d], acquireFence: %d, tr: 0x%2x, compression: " |
| "%s, dataSpace: 0x%8x, format: %s\n", |
| mLayerBuffer, fd, fd1, fd2, mAcquireFence, mTransform, |
| getCompressionStr(mCompressionInfo).c_str(), mDataSpace, |
| getFormatStr(format, mCompressionInfo.type).c_str()); |
| result.appendFormat("\tblend: 0x%4x, planeAlpha: %3.1f, zOrder: %d, color[0x%2x, 0x%2x, 0x%2x, 0x%2x]\n", |
| mBlending, mPlaneAlpha, mZOrder, mColor.r, mColor.g, mColor.b, mColor.a); |
| result.appendFormat("\tfps: %.2f, priority: %d, windowIndex: %d\n", mFps, mOverlayPriority, |
| mWindowIndex); |
| result.appendFormat("\tsourceCrop[%7.1f,%7.1f,%7.1f,%7.1f], dispFrame[%5d,%5d,%5d,%5d]\n", |
| mSourceCrop.left, mSourceCrop.top, mSourceCrop.right, mSourceCrop.bottom, |
| mDisplayFrame.left, mDisplayFrame.top, mDisplayFrame.right, mDisplayFrame.bottom); |
| result.appendFormat("\ttype: %2d, exynosType: %2d, validateType: %2d\n", |
| mCompositionType, mExynosCompositionType, mValidateCompositionType); |
| result.appendFormat("\toverlayInfo: 0x%8x, supportedMPPFlag: 0x%8x, geometryChanged: 0x%" PRIx64 "\n", |
| mOverlayInfo, mSupportedMPPFlag, mGeometryChanged); |
| |
| if ((mDisplay != NULL) && (mDisplay->mResourceManager != NULL)) { |
| result.appendFormat("MPPFlags for otfMPP\n"); |
| for (uint32_t i = 0; i < mDisplay->mResourceManager->getOtfMPPSize(); i++) { |
| result.appendFormat("[%s: 0x%" PRIx64 "] ", mDisplay->mResourceManager->getOtfMPP(i)->mName.c_str(), |
| mCheckMPPFlag[mDisplay->mResourceManager->getOtfMPP(i)->mLogicalType]); |
| } |
| result.appendFormat("\n"); |
| result.appendFormat("MPPFlags for m2mMPP\n"); |
| for (uint32_t i = 0; i < mDisplay->mResourceManager->getM2mMPPSize(); i++) { |
| result.appendFormat("[%s: 0x%" PRIx64 "] ", mDisplay->mResourceManager->getM2mMPP(i)->mName.c_str(), |
| mCheckMPPFlag[mDisplay->mResourceManager->getM2mMPP(i)->mLogicalType]); |
| if ((i!=0) && (i%4==0)) result.appendFormat("\n"); |
| } |
| result.appendFormat("\n"); |
| } |
| |
| ALOGD("%s", result.c_str()); |
| result.clear(); |
| |
| if ((mOtfMPP == NULL) && (mM2mMPP == NULL)) |
| ALOGD("\tresource is not assigned."); |
| if (mOtfMPP != NULL) |
| ALOGD("\tassignedMPP: %s", mOtfMPP->mName.c_str()); |
| if (mM2mMPP != NULL) |
| ALOGD("\tassignedM2mMPP: %s", mM2mMPP->mName.c_str()); |
| ALOGD("\t++ dump midImg ++"); |
| dumpExynosImage(result, mMidImg); |
| ALOGD("%s", result.c_str()); |
| |
| } |
| |
| void ExynosLayer::setGeometryChanged(uint64_t changedBit) |
| { |
| mLastUpdateTime = systemTime(CLOCK_MONOTONIC); |
| mGeometryChanged |= changedBit; |
| if (mRequestedCompositionType != HWC2_COMPOSITION_REFRESH_RATE_INDICATOR) |
| mDisplay->setGeometryChanged(changedBit); |
| } |
| |
| int ExynosLayer::allocMetaParcel() |
| { |
| /* Already allocated */ |
| if ((mMetaParcelFd >= 0) && |
| (mMetaParcel != NULL)) |
| return NO_ERROR; |
| |
| if (mMetaParcelFd < 0) { |
| int ionFd = exynos_ion_open(); |
| if (ionFd >= 0) { |
| mMetaParcelFd = exynos_ion_alloc(ionFd, sizeof(ExynosVideoMeta), EXYNOS_ION_HEAP_SYSTEM_MASK, 0); |
| if (mMetaParcelFd < 0) { |
| ALOGE("Failed to ion alloc for metadata parcel"); |
| return -1; |
| } |
| exynos_ion_close(ionFd); |
| } else { |
| ALOGE("Failed to open ion fd"); |
| return -1; |
| } |
| } |
| |
| mMetaParcel = |
| (ExynosVideoMeta*)mmap(0, sizeof(ExynosVideoMeta), PROT_READ|PROT_WRITE, MAP_SHARED, mMetaParcelFd, 0); |
| if (mMetaParcel == NULL) { |
| ALOGE("Failed to map metadata parcel"); |
| return -1; |
| } |
| |
| return NO_ERROR; |
| } |
| |
| bool ExynosLayer::isDimLayer() |
| { |
| if (mLayerFlag & EXYNOS_HWC_DIM_LAYER) |
| return true; |
| return false; |
| } |
