| /* |
| // Copyright (c) 2014 Intel Corporation |
| // |
| // 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 <HwcTrace.h> |
| #include <DisplayPlane.h> |
| #include <hal_public.h> |
| #include <OMX_IVCommon.h> |
| #include <OMX_IntelVideoExt.h> |
| #include <PlaneCapabilities.h> |
| #include <common/OverlayHardware.h> |
| #include <HwcLayer.h> |
| #include <BufferManager.h> |
| #include <Hwcomposer.h> |
| |
| |
| #define SPRITE_PLANE_MAX_STRIDE_TILED 16384 |
| #define SPRITE_PLANE_MAX_STRIDE_LINEAR 16384 |
| |
| #define OVERLAY_PLANE_MAX_STRIDE_PACKED 4096 |
| #define OVERLAY_PLANE_MAX_STRIDE_LINEAR 8192 |
| |
| namespace android { |
| namespace intel { |
| |
| bool PlaneCapabilities::isFormatSupported(int planeType, HwcLayer *hwcLayer) |
| { |
| uint32_t format = hwcLayer->getFormat(); |
| uint32_t trans = hwcLayer->getLayer()->transform; |
| |
| if (planeType == DisplayPlane::PLANE_SPRITE || planeType == DisplayPlane::PLANE_PRIMARY) { |
| switch (format) { |
| case HAL_PIXEL_FORMAT_BGRA_8888: |
| case HAL_PIXEL_FORMAT_BGRX_8888: |
| case HAL_PIXEL_FORMAT_RGBA_8888: |
| case HAL_PIXEL_FORMAT_RGBX_8888: |
| case HAL_PIXEL_FORMAT_RGB_565: |
| return trans ? false : true; |
| default: |
| VTRACE("unsupported format %#x", format); |
| return false; |
| } |
| } else if (planeType == DisplayPlane::PLANE_OVERLAY) { |
| switch (format) { |
| case HAL_PIXEL_FORMAT_I420: |
| case HAL_PIXEL_FORMAT_YUY2: |
| case HAL_PIXEL_FORMAT_UYVY: |
| // TODO: overlay supports 180 degree rotation |
| if (trans == HAL_TRANSFORM_ROT_180) { |
| WTRACE("180 degree rotation is not supported yet"); |
| } |
| return trans ? false : true; |
| case HAL_PIXEL_FORMAT_YV12: |
| case HAL_PIXEL_FORMAT_NV12: |
| case OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar: |
| case OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar_Tiled: |
| return true; |
| default: |
| VTRACE("unsupported format %#x", format); |
| return false; |
| } |
| } else { |
| ETRACE("invalid plane type %d", planeType); |
| return false; |
| } |
| } |
| |
| bool PlaneCapabilities::isSizeSupported(int planeType, HwcLayer *hwcLayer) |
| { |
| uint32_t format = hwcLayer->getFormat(); |
| uint32_t w = hwcLayer->getBufferWidth(); |
| uint32_t h = hwcLayer->getBufferHeight(); |
| const stride_t& stride = hwcLayer->getBufferStride(); |
| |
| bool isYUVPacked; |
| uint32_t maxStride; |
| |
| if (planeType == DisplayPlane::PLANE_SPRITE || planeType == DisplayPlane::PLANE_PRIMARY) { |
| switch (format) { |
| case HAL_PIXEL_FORMAT_BGRA_8888: |
| case HAL_PIXEL_FORMAT_BGRX_8888: |
| case HAL_PIXEL_FORMAT_RGBA_8888: |
| case HAL_PIXEL_FORMAT_RGBX_8888: |
| case HAL_PIXEL_FORMAT_RGB_565: |
| VTRACE("stride %d", stride.rgb.stride); |
| if (stride.rgb.stride > SPRITE_PLANE_MAX_STRIDE_LINEAR) { |
| VTRACE("too large stride %d", stride.rgb.stride); |
| return false; |
| } |
| return true; |
| default: |
| VTRACE("unsupported format %#x", format); |
| return false; |
| } |
| } else if (planeType == DisplayPlane::PLANE_OVERLAY) { |
| switch (format) { |
| case HAL_PIXEL_FORMAT_YV12: |
| case HAL_PIXEL_FORMAT_I420: |
| case HAL_PIXEL_FORMAT_NV12: |
| case OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar: |
| case OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar_Tiled: |
| isYUVPacked = false; |
| break; |
| case HAL_PIXEL_FORMAT_YUY2: |
| case HAL_PIXEL_FORMAT_UYVY: |
| isYUVPacked = true; |
| break; |
| default: |
| VTRACE("unsupported format %#x", format); |
| return false; |
| } |
| // don't use overlay plane if stride is too big |
| maxStride = OVERLAY_PLANE_MAX_STRIDE_LINEAR; |
| if (isYUVPacked) { |
| maxStride = OVERLAY_PLANE_MAX_STRIDE_PACKED; |
| } |
| |
| if (stride.yuv.yStride > maxStride) { |
| VTRACE("stride %d is too large", stride.yuv.yStride); |
| return false; |
| } |
| |
| hwc_frect_t& srcCrop = hwcLayer->getLayer()->sourceCropf; |
| uint32_t width = srcCrop.right - srcCrop.left; |
| uint32_t height = srcCrop.bottom - srcCrop.top; |
| |
| if (width <= 64 || height <= 64) { |
| DTRACE("width or height of source crop is less than 64, fallback to GLES"); |
| return false; |
| } |
| |
| if ((height & 0x1) || (width & 0x1)){ |
| if (!hwcLayer->isProtected()) { |
| DTRACE("unprotected video content, height or width of source crop is not even, fallback to GLES "); |
| return false; |
| } |
| } |
| |
| return true; |
| } else { |
| ETRACE("invalid plane type %d", planeType); |
| return false; |
| } |
| } |
| |
| bool PlaneCapabilities::isBlendingSupported(int planeType, HwcLayer *hwcLayer) |
| { |
| uint32_t blending = (uint32_t)hwcLayer->getLayer()->blending; |
| uint8_t planeAlpha = hwcLayer->getLayer()->planeAlpha; |
| |
| if (planeType == DisplayPlane::PLANE_SPRITE || planeType == DisplayPlane::PLANE_PRIMARY) { |
| // support premultipled & none blanding |
| switch (blending) { |
| case HWC_BLENDING_NONE: |
| case HWC_BLENDING_PREMULT: |
| // add coverage alpha support for ann |
| case HWC_BLENDING_COVERAGE: |
| return true; |
| default: |
| VTRACE("unsupported blending %#x", blending); |
| return false; |
| } |
| } else if (planeType == DisplayPlane::PLANE_OVERLAY) { |
| // overlay doesn't support blending |
| return (blending == HWC_BLENDING_NONE) ? true : false; |
| } else { |
| ETRACE("invalid plane type %d", planeType); |
| return false; |
| } |
| } |
| |
| bool PlaneCapabilities::isScalingSupported(int planeType, HwcLayer *hwcLayer) |
| { |
| hwc_frect_t& src = hwcLayer->getLayer()->sourceCropf; |
| hwc_rect_t& dest = hwcLayer->getLayer()->displayFrame; |
| uint32_t trans = hwcLayer->getLayer()->transform; |
| |
| int srcW, srcH; |
| int dstW, dstH; |
| |
| srcW = (int)src.right - (int)src.left; |
| srcH = (int)src.bottom - (int)src.top; |
| dstW = dest.right - dest.left; |
| dstH = dest.bottom - dest.top; |
| |
| if (planeType == DisplayPlane::PLANE_SPRITE || planeType == DisplayPlane::PLANE_PRIMARY) { |
| // no scaling is supported |
| return ((srcW == dstW) && (srcH == dstH)) ? true : false; |
| |
| } else if (planeType == DisplayPlane::PLANE_OVERLAY) { |
| // overlay cannot support resolution that bigger than 2047x2047. |
| if ((srcW > INTEL_OVERLAY_MAX_WIDTH - 1) || (srcH > INTEL_OVERLAY_MAX_HEIGHT - 1)) { |
| uint32_t format = hwcLayer->getFormat(); |
| if (format == OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar || |
| format == OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar_Tiled) { |
| // will fall back to GLES if no scaling buffer provided by ved later |
| // so don't return false and print a warning, it's for video format only. |
| WTRACE("source size %dx%d hit overlay resolution limitation.", srcW, srcH); |
| } else { |
| return false; |
| } |
| } |
| |
| if (dstW <= 100 || dstH <= 1 || srcW <= 100 || srcH <= 1) { |
| // Workaround: Overlay flip when height is 1 causes MIPI stall on TNG |
| DTRACE("invalid destination size: %dx%d, fall back to GLES", dstW, dstH); |
| return false; |
| } |
| |
| if (trans == HAL_TRANSFORM_ROT_90 || trans == HAL_TRANSFORM_ROT_270) { |
| int tmp = srcW; |
| srcW = srcH; |
| srcH = tmp; |
| } |
| |
| if (!hwcLayer->isProtected()) { |
| if ((int)src.left & 63) { |
| DTRACE("offset %d is not 64 bytes aligned, fall back to GLES", (int)src.left); |
| return false; |
| } |
| |
| float scaleX = (float)srcW / dstW; |
| float scaleY = (float)srcH / dstH; |
| if (scaleX >= 3 || scaleY >= 3) { |
| DTRACE("overlay rotation with scaling >= 3, fall back to GLES"); |
| return false; |
| } |
| #if 0 |
| if (trans == HAL_TRANSFORM_ROT_90 && (float)srcW / srcH != (float)dstW / dstH) { |
| // FIXME: work aournd for pipe crashing issue, when rotate screen |
| // from 90 to 0 degree (with Sharp 25x16 panel). |
| DTRACE("overlay rotation with uneven scaling, fall back to GLES"); |
| return false; |
| } |
| #endif |
| } |
| |
| return true; |
| } else { |
| ETRACE("invalid plane type %d", planeType); |
| return false; |
| } |
| } |
| |
| bool PlaneCapabilities::isTransformSupported(int planeType, HwcLayer *hwcLayer) |
| { |
| uint32_t trans = hwcLayer->getLayer()->transform; |
| |
| if (planeType == DisplayPlane::PLANE_OVERLAY) { |
| // overlay does not support FLIP_H/FLIP_V |
| switch (trans) { |
| case 0: |
| case HAL_TRANSFORM_ROT_90: |
| case HAL_TRANSFORM_ROT_180: |
| case HAL_TRANSFORM_ROT_270: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| // don't transform any tranform |
| return trans ? false : true; |
| } |
| |
| } // namespace intel |
| } // namespace android |
| |
