| /* Copyright (c) 2012 - 2017, The Linux Foundation. All rights reserved. |
| * |
| * redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * * redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * * neither the name of The Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * this software is provided "as is" and any express or implied |
| * warranties, including, but not limited to, the implied warranties of |
| * merchantability, fitness for a particular purpose and non-infringement |
| * are disclaimed. in no event shall the copyright owner or contributors |
| * be liable for any direct, indirect, incidental, special, exemplary, or |
| * consequential damages (including, but not limited to, procurement of |
| * substitute goods or services; loss of use, data, or profits; or |
| * business interruption) however caused and on any theory of liability, |
| * whether in contract, strict liability, or tort (including negligence |
| * or otherwise) arising in any way out of the use of this software, even |
| * if advised of the possibility of such damage. |
| * |
| */ |
| |
| #include <C2DColorConverter.h> |
| |
| C2DColorConverter::C2DColorConverter() |
| : mC2DLibHandle(NULL), |
| mAdrenoUtilsHandle(NULL) |
| { |
| |
| enabled = true; |
| mSrcSurface = 0; |
| mDstSurface = 0; |
| |
| mSrcWidth = 0; |
| mSrcHeight = 0; |
| mSrcStride = 0; |
| mDstWidth = 0; |
| mDstHeight = 0; |
| mSrcFormat = NO_COLOR_FORMAT; |
| mDstFormat = NO_COLOR_FORMAT; |
| mSrcSurfaceDef = NULL; |
| mDstSurfaceDef = NULL; |
| |
| mConversionNeeded = false; |
| |
| pthread_mutex_init(&mLock, NULL); |
| |
| mC2DLibHandle = dlopen("libC2D2.so", RTLD_NOW); |
| if (!mC2DLibHandle) { |
| ALOGE("%s: ERROR: could not dlopen libc2d2.so: %s. C2D is disabled.", |
| __FUNCTION__, dlerror()); |
| enabled = false; |
| return; |
| } |
| mAdrenoUtilsHandle = dlopen("libadreno_utils.so", RTLD_NOW); |
| if (!mAdrenoUtilsHandle) { |
| ALOGE("%s: ERROR: could not dlopen libadreno_utils.so: %s.. C2D is disabled.", |
| __FUNCTION__, dlerror()); |
| enabled = false; |
| return; |
| } |
| |
| mC2DCreateSurface = (LINK_c2dCreateSurface)dlsym(mC2DLibHandle, "c2dCreateSurface"); |
| mC2DUpdateSurface = (LINK_c2dUpdateSurface)dlsym(mC2DLibHandle, "c2dUpdateSurface"); |
| mC2DReadSurface = (LINK_c2dReadSurface)dlsym(mC2DLibHandle, "c2dReadSurface"); |
| mC2DDraw = (LINK_c2dDraw)dlsym(mC2DLibHandle, "c2dDraw"); |
| mC2DFlush = (LINK_c2dFlush)dlsym(mC2DLibHandle, "c2dFlush"); |
| mC2DFinish = (LINK_c2dFinish)dlsym(mC2DLibHandle, "c2dFinish"); |
| mC2DWaitTimestamp = (LINK_c2dWaitTimestamp)dlsym(mC2DLibHandle, "c2dWaitTimestamp"); |
| mC2DDestroySurface = (LINK_c2dDestroySurface)dlsym(mC2DLibHandle, "c2dDestroySurface"); |
| mC2DMapAddr = (LINK_c2dMapAddr)dlsym(mC2DLibHandle, "c2dMapAddr"); |
| mC2DUnMapAddr = (LINK_c2dUnMapAddr)dlsym(mC2DLibHandle, "c2dUnMapAddr"); |
| |
| if (!mC2DCreateSurface || !mC2DUpdateSurface || !mC2DReadSurface |
| || !mC2DDraw || !mC2DFlush || !mC2DFinish || !mC2DWaitTimestamp |
| || !mC2DDestroySurface || !mC2DMapAddr || !mC2DUnMapAddr) { |
| ALOGE("%s: dlsym ERROR. C2D is disabled. mC2DCreateSurface[%p] mC2DUpdateSurface[%p] " |
| "mC2DReadSurface[%p] mC2DDraw[%p] mC2DFlush[%p] mC2DFinish[%p] mC2DWaitTimestamp[%p] " |
| "mC2DDestroySurface[%p] mC2DMapAddr[%p] mC2DUnMapAddr[%p]", __FUNCTION__, |
| mC2DCreateSurface, mC2DUpdateSurface, mC2DReadSurface, mC2DDraw, mC2DFlush, mC2DFinish, |
| mC2DWaitTimestamp, mC2DDestroySurface, mC2DMapAddr, mC2DUnMapAddr); |
| enabled = false; |
| return; |
| } |
| |
| mAdrenoComputeFmtAlignedWidthAndHeight = (LINK_adreno_compute_fmt_aligned_width_and_height)dlsym(mAdrenoUtilsHandle, "compute_fmt_aligned_width_and_height"); |
| if (!mAdrenoComputeFmtAlignedWidthAndHeight) { |
| ALOGE("%s: dlsym compute_aligned_width_and_height ERROR. C2D is disabled.", __FUNCTION__); |
| enabled = false; |
| return; |
| } |
| } |
| |
| C2DColorConverter::~C2DColorConverter() |
| { |
| if (enabled) { |
| |
| if (mDstSurface) { |
| mC2DDestroySurface(mDstSurface); |
| mDstSurface = 0; |
| } |
| if (mSrcSurface) { |
| mC2DDestroySurface(mSrcSurface); |
| mSrcSurface = 0; |
| } |
| |
| if (mSrcSurfaceDef) { |
| if (isYUVSurface(mSrcFormat)) { |
| delete ((C2D_YUV_SURFACE_DEF *)mSrcSurfaceDef); |
| } else { |
| delete ((C2D_RGB_SURFACE_DEF *)mSrcSurfaceDef); |
| } |
| } |
| |
| if (mDstSurfaceDef) { |
| if (isYUVSurface(mDstFormat)) { |
| delete ((C2D_YUV_SURFACE_DEF *)mDstSurfaceDef); |
| } else { |
| delete ((C2D_RGB_SURFACE_DEF *)mDstSurfaceDef); |
| } |
| } |
| mSrcSurfaceDef = NULL; |
| mDstSurfaceDef = NULL; |
| } |
| |
| if (mC2DLibHandle) { |
| dlclose(mC2DLibHandle); |
| } |
| if (mAdrenoUtilsHandle) { |
| dlclose(mAdrenoUtilsHandle); |
| } |
| |
| } |
| |
| bool C2DColorConverter::isPropChanged(size_t srcWidth, size_t srcHeight, size_t dstWidth, |
| size_t dstHeight, ColorConvertFormat srcFormat, |
| ColorConvertFormat dstFormat, int32_t flags, |
| size_t srcStride) |
| { |
| return (mSrcWidth != srcWidth || |
| mSrcHeight != srcHeight || |
| mDstWidth != dstWidth || |
| mDstHeight != dstHeight || |
| mSrcFormat != srcFormat || |
| mDstFormat != dstFormat || |
| mSrcStride != srcStride || |
| (mFlags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) != |
| (flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED)); |
| } |
| |
| bool C2DColorConverter::setResolution(size_t srcWidth, size_t srcHeight, |
| size_t dstWidth, size_t dstHeight, |
| ColorConvertFormat srcFormat, |
| ColorConvertFormat dstFormat, |
| int32_t flags, size_t srcStride) |
| { |
| int32_t retval = -1; |
| if (enabled) { |
| pthread_mutex_lock(&mLock); |
| mSrcWidth = srcWidth; |
| mSrcHeight = srcHeight; |
| mSrcStride = srcStride; |
| mDstWidth = dstWidth; |
| mDstHeight = dstHeight; |
| mSrcFormat = srcFormat; |
| mDstFormat = dstFormat; |
| mSrcSize = calcSize(srcFormat, srcWidth, srcHeight); |
| mDstSize = calcSize(dstFormat, dstWidth, dstHeight); |
| mSrcYSize = calcYSize(srcFormat, srcWidth, srcHeight); |
| mDstYSize = calcYSize(dstFormat, dstWidth, dstHeight); |
| |
| mFlags = flags; // can be used for rotation |
| |
| retval = getDummySurfaceDef(srcFormat, srcWidth, srcHeight, true); |
| retval |= getDummySurfaceDef(dstFormat, dstWidth, dstHeight, false); |
| |
| if (retval == 0) { |
| memset((void*)&mBlit,0,sizeof(C2D_OBJECT)); |
| mBlit.source_rect.x = 0 << 16; |
| mBlit.source_rect.y = 0 << 16; |
| mBlit.source_rect.width = srcWidth << 16; |
| mBlit.source_rect.height = srcHeight << 16; |
| mBlit.target_rect.x = 0 << 16; |
| mBlit.target_rect.y = 0 << 16; |
| mBlit.target_rect.width = dstWidth << 16; |
| mBlit.target_rect.height = dstHeight << 16; |
| mBlit.config_mask = C2D_ALPHA_BLEND_NONE | |
| C2D_NO_BILINEAR_BIT | |
| C2D_NO_ANTIALIASING_BIT | |
| C2D_TARGET_RECT_BIT; |
| mBlit.surface_id = mSrcSurface; |
| } |
| |
| pthread_mutex_unlock(&mLock); |
| } |
| |
| return retval == 0? true:false; |
| } |
| |
| |
| bool C2DColorConverter::convertC2D(int srcFd, void *srcBase, void * srcData, |
| int dstFd, void *dstBase, void * dstData) |
| { |
| C2D_STATUS ret; |
| uint8_t *srcMappedGpuAddr = nullptr; |
| uint8_t *dstMappedGpuAddr = nullptr; |
| bool status = false; |
| |
| if (enabled) { |
| pthread_mutex_lock(&mLock); |
| if (srcFd < 0 || dstFd < 0 |
| || srcData == NULL || dstData == NULL |
| || srcBase == NULL || dstBase == NULL) { |
| ALOGE("%s: Color conversion failed. Incorrect input parameters", __FUNCTION__); |
| status = false; |
| } else { |
| |
| srcMappedGpuAddr = (uint8_t *)getMappedGPUAddr(srcFd, srcData, mSrcSize); |
| if (!srcMappedGpuAddr) { |
| pthread_mutex_unlock(&mLock); |
| return false; |
| } |
| |
| if (isYUVSurface(mSrcFormat)) { |
| ret = updateYUVSurfaceDef(srcMappedGpuAddr, srcBase, srcData, true); |
| } else { |
| ret = updateRGBSurfaceDef(srcMappedGpuAddr, srcData, true); |
| } |
| |
| if (ret == C2D_STATUS_OK) { |
| |
| dstMappedGpuAddr = (uint8_t *)getMappedGPUAddr(dstFd, dstData, mDstSize); |
| if (!dstMappedGpuAddr) { |
| unmapGPUAddr((unsigned long)srcMappedGpuAddr); |
| pthread_mutex_unlock(&mLock); |
| return false; |
| } |
| |
| if (isYUVSurface(mDstFormat)) { |
| ret = updateYUVSurfaceDef(dstMappedGpuAddr, dstBase, dstData, false); |
| } else { |
| ret = updateRGBSurfaceDef(dstMappedGpuAddr, dstData, false); |
| } |
| |
| if (ret == C2D_STATUS_OK) { |
| |
| mBlit.surface_id = mSrcSurface; |
| ret = mC2DDraw(mDstSurface, C2D_TARGET_ROTATE_0, 0, 0, 0, &mBlit, 1); |
| mC2DFinish(mDstSurface); |
| |
| if (ret == C2D_STATUS_OK) { |
| bool unmappedSrcSuccess; |
| unmappedSrcSuccess = unmapGPUAddr((unsigned long)srcMappedGpuAddr); |
| |
| bool unmappedDstSuccess; |
| unmappedDstSuccess = unmapGPUAddr((unsigned long)dstMappedGpuAddr); |
| |
| if (!unmappedSrcSuccess || !unmappedDstSuccess) { |
| ALOGE("%s: unmapping GPU address failed (%d:%d)", __FUNCTION__, |
| unmappedSrcSuccess, unmappedDstSuccess); |
| status = false; |
| } else { |
| status = true; |
| } |
| } else { |
| ALOGE("%s: C2D Draw failed (%d)", __FUNCTION__, ret); |
| status = false; |
| } |
| } else { |
| ALOGE("%s: Update dst surface def failed (%d)", __FUNCTION__, ret); |
| unmapGPUAddr((unsigned long)srcMappedGpuAddr); |
| unmapGPUAddr((unsigned long)dstMappedGpuAddr); |
| status = false; |
| } |
| } else { |
| ALOGE("%s: Update src surface def failed (%d)", __FUNCTION__, ret); |
| unmapGPUAddr((unsigned long)srcMappedGpuAddr); |
| status = false; |
| } |
| } |
| |
| pthread_mutex_unlock(&mLock); |
| } |
| |
| return status; |
| } |
| |
| bool C2DColorConverter::isYUVSurface(ColorConvertFormat format) |
| { |
| switch (format) { |
| case YCbCr420Tile: |
| case YCbCr420SP: |
| case YCbCr420P: |
| case YCrCb420P: |
| case NV12_2K: |
| case NV12_128m: |
| case NV12_UBWC: |
| case TP10_UBWC: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| int32_t C2DColorConverter::getDummySurfaceDef(ColorConvertFormat format, |
| size_t width, size_t height, |
| bool isSource) |
| { |
| void *surfaceDef = NULL; |
| C2D_SURFACE_TYPE hostSurfaceType; |
| C2D_STATUS ret; |
| |
| if (isSource){ |
| if (mSrcSurface) { |
| mC2DDestroySurface(mSrcSurface); |
| mSrcSurface = 0; |
| } |
| } else if (mDstSurface) { |
| mC2DDestroySurface(mDstSurface); |
| mDstSurface = 0; |
| } |
| |
| if (isYUVSurface(format)) { |
| C2D_YUV_SURFACE_DEF **surfaceYUVDef = (C2D_YUV_SURFACE_DEF **) |
| (isSource ? &mSrcSurfaceDef : &mDstSurfaceDef); |
| if (*surfaceYUVDef == NULL) { |
| *surfaceYUVDef = (C2D_YUV_SURFACE_DEF *) |
| calloc(1, sizeof(C2D_YUV_SURFACE_DEF)); |
| if (*surfaceYUVDef == NULL) { |
| ALOGE("%s: surfaceYUVDef allocation failed", __FUNCTION__); |
| return -1; |
| } |
| } else { |
| memset(*surfaceYUVDef, 0, sizeof(C2D_YUV_SURFACE_DEF)); |
| } |
| (*surfaceYUVDef)->format = getC2DFormat(format); |
| (*surfaceYUVDef)->width = width; |
| (*surfaceYUVDef)->height = height; |
| (*surfaceYUVDef)->plane0 = (void *)0xaaaaaaaa; |
| (*surfaceYUVDef)->phys0 = (void *)0xaaaaaaaa; |
| (*surfaceYUVDef)->stride0 = calcStride(format, width); |
| (*surfaceYUVDef)->plane1 = (void *)0xaaaaaaaa; |
| (*surfaceYUVDef)->phys1 = (void *)0xaaaaaaaa; |
| (*surfaceYUVDef)->stride1 = calcStride(format, width); |
| (*surfaceYUVDef)->stride2 = calcStride(format, width); |
| (*surfaceYUVDef)->phys2 = NULL; |
| (*surfaceYUVDef)->plane2 = NULL; |
| |
| if (format == YCbCr420P || |
| format == YCrCb420P) { |
| ALOGI("%s: half stride for Cb Cr planes \n", __FUNCTION__); |
| (*surfaceYUVDef)->stride1 = calcStride(format, width) / 2; |
| (*surfaceYUVDef)->phys2 = (void *)0xaaaaaaaa; |
| (*surfaceYUVDef)->stride2 = calcStride(format, width) / 2; |
| } |
| |
| surfaceDef = *surfaceYUVDef; |
| hostSurfaceType = C2D_SURFACE_YUV_HOST; |
| } else { |
| C2D_RGB_SURFACE_DEF **surfaceRGBDef = (C2D_RGB_SURFACE_DEF **) |
| (isSource ? &mSrcSurfaceDef : &mDstSurfaceDef); |
| if (*surfaceRGBDef == NULL) { |
| *surfaceRGBDef = (C2D_RGB_SURFACE_DEF *) |
| calloc(1, sizeof(C2D_RGB_SURFACE_DEF)); |
| if (*surfaceRGBDef == NULL) { |
| ALOGE("%s: surfaceRGBDef allocation failed", __FUNCTION__); |
| return -1; |
| } |
| } else { |
| memset(*surfaceRGBDef, 0, sizeof(C2D_RGB_SURFACE_DEF)); |
| } |
| (*surfaceRGBDef)->format = getC2DFormat(format); |
| |
| if (mFlags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) |
| (*surfaceRGBDef)->format |= C2D_FORMAT_UBWC_COMPRESSED; |
| (*surfaceRGBDef)->width = width; |
| (*surfaceRGBDef)->height = height; |
| (*surfaceRGBDef)->buffer = (void *)0xaaaaaaaa; |
| (*surfaceRGBDef)->phys = (void *)0xaaaaaaaa; |
| (*surfaceRGBDef)->stride = calcStride(format, width); |
| |
| surfaceDef = *surfaceRGBDef; |
| hostSurfaceType = C2D_SURFACE_RGB_HOST; |
| } |
| |
| ret = mC2DCreateSurface(isSource ? &mSrcSurface : |
| &mDstSurface, |
| isSource ? C2D_SOURCE : C2D_TARGET, |
| (C2D_SURFACE_TYPE)(hostSurfaceType |
| | C2D_SURFACE_WITH_PHYS |
| | C2D_SURFACE_WITH_PHYS_DUMMY), |
| surfaceDef); |
| return (int32_t) ret; |
| } |
| |
| C2D_STATUS C2DColorConverter::updateYUVSurfaceDef(uint8_t *gpuAddr, void *base, |
| void *data, bool isSource) |
| { |
| if (isSource) { |
| C2D_YUV_SURFACE_DEF * srcSurfaceDef = (C2D_YUV_SURFACE_DEF *)mSrcSurfaceDef; |
| srcSurfaceDef->plane0 = data; |
| srcSurfaceDef->phys0 = gpuAddr + ((uint8_t *)data - (uint8_t *)base); |
| srcSurfaceDef->plane1 = (uint8_t *)data + mSrcYSize; |
| srcSurfaceDef->phys1 = (uint8_t *)srcSurfaceDef->phys0 + mSrcYSize; |
| if (srcSurfaceDef->format & C2D_COLOR_FORMAT_420_I420 || |
| srcSurfaceDef->format & C2D_COLOR_FORMAT_420_YV12) { |
| srcSurfaceDef->plane2 = (uint8_t *)srcSurfaceDef->plane1 + mSrcYSize/4; |
| srcSurfaceDef->phys2 = (uint8_t *)srcSurfaceDef->phys1 + mSrcYSize/4; |
| } |
| return mC2DUpdateSurface(mSrcSurface, C2D_SOURCE, |
| (C2D_SURFACE_TYPE)(C2D_SURFACE_YUV_HOST | C2D_SURFACE_WITH_PHYS), |
| &(*srcSurfaceDef)); |
| } else { |
| C2D_YUV_SURFACE_DEF * dstSurfaceDef = (C2D_YUV_SURFACE_DEF *)mDstSurfaceDef; |
| dstSurfaceDef->plane0 = data; |
| dstSurfaceDef->phys0 = gpuAddr + ((uint8_t *)data - (uint8_t *)base); |
| dstSurfaceDef->plane1 = (uint8_t *)data + mDstYSize; |
| dstSurfaceDef->phys1 = (uint8_t *)dstSurfaceDef->phys0 + mDstYSize; |
| if (dstSurfaceDef->format & C2D_COLOR_FORMAT_420_I420 || |
| dstSurfaceDef->format & C2D_COLOR_FORMAT_420_YV12) { |
| dstSurfaceDef->plane2 = (uint8_t *)dstSurfaceDef->plane1 + mDstYSize/4; |
| dstSurfaceDef->phys2 = (uint8_t *)dstSurfaceDef->phys1 + mDstYSize/4; |
| } |
| |
| return mC2DUpdateSurface(mDstSurface, C2D_TARGET, |
| (C2D_SURFACE_TYPE)(C2D_SURFACE_YUV_HOST | C2D_SURFACE_WITH_PHYS), |
| &(*dstSurfaceDef)); |
| } |
| } |
| |
| C2D_STATUS C2DColorConverter::updateRGBSurfaceDef(uint8_t *gpuAddr, void * data, bool isSource) |
| { |
| if (isSource) { |
| C2D_RGB_SURFACE_DEF * srcSurfaceDef = (C2D_RGB_SURFACE_DEF *)mSrcSurfaceDef; |
| srcSurfaceDef->buffer = data; |
| srcSurfaceDef->phys = gpuAddr; |
| return mC2DUpdateSurface(mSrcSurface, C2D_SOURCE, |
| (C2D_SURFACE_TYPE)(C2D_SURFACE_RGB_HOST | C2D_SURFACE_WITH_PHYS), |
| &(*srcSurfaceDef)); |
| } else { |
| C2D_RGB_SURFACE_DEF * dstSurfaceDef = (C2D_RGB_SURFACE_DEF *)mDstSurfaceDef; |
| dstSurfaceDef->buffer = data; |
| ALOGV("%s: dstSurfaceDef->buffer = %p", __FUNCTION__, data); |
| dstSurfaceDef->phys = gpuAddr; |
| return mC2DUpdateSurface(mDstSurface, C2D_TARGET, |
| (C2D_SURFACE_TYPE)(C2D_SURFACE_RGB_HOST | C2D_SURFACE_WITH_PHYS), |
| &(*dstSurfaceDef)); |
| } |
| } |
| |
| uint32_t C2DColorConverter::getC2DFormat(ColorConvertFormat format) |
| { |
| switch (format) { |
| case RGB565: |
| return C2D_COLOR_FORMAT_565_RGB; |
| case RGBA8888: |
| return C2D_COLOR_FORMAT_8888_RGBA | C2D_FORMAT_SWAP_ENDIANNESS | C2D_FORMAT_PREMULTIPLIED; |
| case RGBA8888_UBWC: |
| return C2D_COLOR_FORMAT_8888_RGBA | |
| C2D_FORMAT_SWAP_ENDIANNESS | |
| C2D_FORMAT_PREMULTIPLIED | |
| C2D_FORMAT_UBWC_COMPRESSED; |
| case YCbCr420Tile: |
| return (C2D_COLOR_FORMAT_420_NV12 | C2D_FORMAT_MACROTILED); |
| case YCbCr420SP: |
| case NV12_2K: |
| case NV12_128m: |
| return C2D_COLOR_FORMAT_420_NV12; |
| case YCbCr420P: |
| return C2D_COLOR_FORMAT_420_I420; |
| case YCrCb420P: |
| return C2D_COLOR_FORMAT_420_YV12; |
| case NV12_UBWC: |
| return C2D_COLOR_FORMAT_420_NV12 | C2D_FORMAT_UBWC_COMPRESSED; |
| case TP10_UBWC: |
| return C2D_COLOR_FORMAT_420_TP10 | C2D_FORMAT_UBWC_COMPRESSED; |
| default: |
| ALOGW("%s: Format not supported , %d", __FUNCTION__, format); |
| return -1; |
| } |
| } |
| |
| size_t C2DColorConverter::calcStride(ColorConvertFormat format, size_t width) |
| { |
| switch (format) { |
| case RGB565: |
| return ALIGN(width, ALIGN32) * 2; // RGB565 has width as twice |
| case RGBA8888: |
| if (mSrcStride) |
| return mSrcStride * 4; |
| else |
| return ALIGN(width, ALIGN32) * 4; |
| case YCbCr420Tile: |
| return ALIGN(width, ALIGN128); |
| case YCbCr420SP: |
| return ALIGN(width, ALIGN16); |
| case NV12_2K: |
| return ALIGN(width, ALIGN16); |
| case NV12_128m: |
| return ALIGN(width, ALIGN128); |
| case YCbCr420P: |
| return ALIGN(width, ALIGN16); |
| case YCrCb420P: |
| return ALIGN(width, ALIGN16); |
| case NV12_UBWC: |
| return VENUS_Y_STRIDE(COLOR_FMT_NV12_UBWC, width); |
| case TP10_UBWC: |
| return VENUS_Y_STRIDE(COLOR_FMT_NV12_BPP10_UBWC, width); |
| default: |
| ALOGW("%s: Format not supported , %d", __FUNCTION__, format); |
| return 0; |
| } |
| } |
| |
| size_t C2DColorConverter::calcYSize(ColorConvertFormat format, size_t width, size_t height) |
| { |
| switch (format) { |
| case YCbCr420SP: |
| return (ALIGN(width, ALIGN16) * height); |
| case YCbCr420P: |
| return ALIGN(width, ALIGN16) * height; |
| case YCrCb420P: |
| return ALIGN(width, ALIGN16) * height; |
| case YCbCr420Tile: |
| return ALIGN(ALIGN(width, ALIGN128) * ALIGN(height, ALIGN32), ALIGN8K); |
| case NV12_2K: { |
| size_t alignedw = ALIGN(width, ALIGN16); |
| size_t lumaSize = ALIGN(alignedw * height, ALIGN2K); |
| return lumaSize; |
| } |
| case NV12_128m: |
| return ALIGN(width, ALIGN128) * ALIGN(height, ALIGN32); |
| case NV12_UBWC: |
| return ALIGN( VENUS_Y_STRIDE(COLOR_FMT_NV12_UBWC, width) * |
| VENUS_Y_SCANLINES(COLOR_FMT_NV12_UBWC, height), ALIGN4K) + |
| ALIGN( VENUS_Y_META_STRIDE(COLOR_FMT_NV12_UBWC, width) * |
| VENUS_Y_META_SCANLINES(COLOR_FMT_NV12_UBWC, height), ALIGN4K); |
| case TP10_UBWC: |
| return ALIGN( VENUS_Y_STRIDE(COLOR_FMT_NV12_BPP10_UBWC, width) * |
| VENUS_Y_SCANLINES(COLOR_FMT_NV12_BPP10_UBWC, height), ALIGN4K) + |
| ALIGN( VENUS_Y_META_STRIDE(COLOR_FMT_NV12_BPP10_UBWC, width) * |
| VENUS_Y_META_SCANLINES(COLOR_FMT_NV12_BPP10_UBWC, height), ALIGN4K); |
| default: |
| ALOGW("%s: Format not supported , %d", __FUNCTION__, format); |
| return 0; |
| } |
| } |
| |
| size_t C2DColorConverter::calcSize(ColorConvertFormat format, size_t width, size_t height) |
| { |
| int32_t alignedw = 0; |
| int32_t alignedh = 0; |
| int32_t size = 0; |
| int32_t tile_mode = 0; |
| int32_t raster_mode = 0; |
| int32_t padding_threshold = 512; /* hardcode for RGB formats */ |
| int32_t bpp = 0; |
| |
| switch (format) { |
| case RGB565: |
| bpp = 2; |
| mAdrenoComputeFmtAlignedWidthAndHeight(width, height, |
| 0, ADRENO_PIXELFORMAT_B5G6R5, |
| 1, tile_mode, raster_mode, |
| padding_threshold, |
| &alignedw, &alignedh); |
| ALOGV("%s: alignedw %d alignedh %d", __FUNCTION__,alignedw, alignedh); |
| size = alignedw * alignedh * bpp; |
| size = ALIGN(size, ALIGN4K); |
| break; |
| case RGBA8888: |
| bpp = 4; |
| mAdrenoComputeFmtAlignedWidthAndHeight(width, height, |
| 0, ADRENO_PIXELFORMAT_R8G8B8A8 , |
| 1, tile_mode, raster_mode, |
| padding_threshold, |
| &alignedw, &alignedh); |
| ALOGV("%s: alignedw %d alignedh %d", __FUNCTION__,alignedw, alignedh); |
| if (mSrcStride) |
| size = mSrcStride * alignedh * bpp; |
| else |
| size = alignedw * alignedh * bpp; |
| size = ALIGN(size, ALIGN4K); |
| break; |
| case YCbCr420SP: |
| alignedw = ALIGN(width, ALIGN16); |
| size = ALIGN((alignedw * height) + (ALIGN(width/2, ALIGN32) * (height/2) * 2), ALIGN4K); |
| break; |
| case YCbCr420P: |
| alignedw = ALIGN(width, ALIGN16); |
| size = ALIGN((alignedw * height) + (ALIGN(width/2, ALIGN16) * (height/2) * 2), ALIGN4K); |
| break; |
| case YCrCb420P: |
| alignedw = ALIGN(width, ALIGN16); |
| size = ALIGN((alignedw * height) + (ALIGN(width/2, ALIGN16) * (height/2) * 2), ALIGN4K); |
| break; |
| case YCbCr420Tile: |
| alignedw = ALIGN(width, ALIGN128); |
| alignedh = ALIGN(height, ALIGN32); |
| size = ALIGN(alignedw * alignedh, ALIGN8K) + ALIGN(alignedw * ALIGN(height/2, ALIGN32), ALIGN8K); |
| break; |
| case NV12_2K: { |
| alignedw = ALIGN(width, ALIGN16); |
| size_t lumaSize = ALIGN(alignedw * height, ALIGN2K); |
| size_t chromaSize = ALIGN((alignedw * height)/2, ALIGN2K); |
| size = ALIGN(lumaSize + chromaSize, ALIGN4K); |
| ALOGV("%s: NV12_2k, width = %zu, height = %zu, size = %d", |
| __FUNCTION__, width, height, size); |
| } |
| break; |
| case NV12_128m: |
| alignedw = ALIGN(width, ALIGN128); |
| alignedh = ALIGN(height, ALIGN32); |
| size = ALIGN(alignedw * alignedh + (alignedw * ALIGN(height/2, ALIGN16)), ALIGN4K); |
| break; |
| case NV12_UBWC: |
| size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12_UBWC, width, height); |
| break; |
| case TP10_UBWC: |
| size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12_BPP10_UBWC, width, height); |
| break; |
| default: |
| ALOGW("%s: Format not supported , %d", __FUNCTION__, format); |
| break; |
| } |
| return size; |
| } |
| /* |
| * Tells GPU to map given buffer and returns a physical address of mapped buffer |
| */ |
| void * C2DColorConverter::getMappedGPUAddr(int bufFD, void *bufPtr, size_t bufLen) |
| { |
| C2D_STATUS status; |
| void *gpuaddr = NULL; |
| |
| status = mC2DMapAddr(bufFD, bufPtr, bufLen, 0, KGSL_USER_MEM_TYPE_ION, |
| &gpuaddr); |
| if (status != C2D_STATUS_OK) { |
| ALOGE("%s: c2dMapAddr failed: status %d fd %d ptr %p len %zu flags %d", |
| __FUNCTION__, status, bufFD, bufPtr, bufLen, KGSL_USER_MEM_TYPE_ION); |
| return NULL; |
| } |
| ALOGV("%s: c2d mapping created: gpuaddr %p fd %d ptr %p len %zu", |
| __FUNCTION__, gpuaddr, bufFD, bufPtr, bufLen); |
| |
| return gpuaddr; |
| } |
| |
| bool C2DColorConverter::unmapGPUAddr(unsigned long gAddr) |
| { |
| |
| C2D_STATUS status = mC2DUnMapAddr((void*)gAddr); |
| |
| if (status != C2D_STATUS_OK) |
| ALOGE("%s: c2dUnMapAddr failed: status %d gpuaddr %08lx", |
| __FUNCTION__, status, gAddr); |
| |
| return (status == C2D_STATUS_OK); |
| } |
| |
| int32_t C2DColorConverter::getBuffSize(int32_t port) |
| { |
| if (enabled) { |
| if (port == C2D_INPUT) { |
| return calcSize(mSrcFormat, mSrcWidth, mSrcHeight); |
| } else if (port == C2D_OUTPUT) { |
| return calcSize(mDstFormat, mDstWidth, mDstHeight); |
| } |
| } |
| return 0; |
| } |
| |
| bool C2DColorConverter::getBuffFilledLen(int32_t port, unsigned int &filled_length) |
| { |
| bool ret = false; |
| C2DBuffReq req; |
| if (enabled) { |
| ret = getBuffReq(port, &req); |
| if (ret && req.bpp.denominator > 0) { |
| filled_length = (req.stride * req.sliceHeight * req.bpp.numerator); |
| filled_length /= req.bpp.denominator; |
| } |
| } |
| |
| return ret; |
| } |
| |
| bool C2DColorConverter::getBuffReq(int32_t port, C2DBuffReq *req) { |
| if (!req |
| || (port != C2D_INPUT |
| && port != C2D_OUTPUT)) return false; |
| |
| memset(req, 0, sizeof(C2DBuffReq)); |
| if (port == C2D_INPUT) { |
| req->width = mSrcWidth; |
| req->height = mSrcHeight; |
| req->stride = calcStride(mSrcFormat, mSrcWidth); |
| req->sliceHeight = mSrcHeight; |
| req->lumaAlign = calcLumaAlign(mSrcFormat); |
| req->sizeAlign = calcSizeAlign(mSrcFormat); |
| req->size = calcSize(mSrcFormat, mSrcWidth, mSrcHeight); |
| req->bpp = calcBytesPerPixel(mSrcFormat); |
| ALOGV("%s: input req->size = %d", __FUNCTION__, req->size); |
| } else if (port == C2D_OUTPUT) { |
| req->width = mDstWidth; |
| req->height = mDstHeight; |
| req->stride = calcStride(mDstFormat, mDstWidth); |
| req->sliceHeight = mDstHeight; |
| req->lumaAlign = calcLumaAlign(mDstFormat); |
| req->sizeAlign = calcSizeAlign(mDstFormat); |
| req->size = calcSize(mDstFormat, mDstWidth, mDstHeight); |
| req->bpp = calcBytesPerPixel(mDstFormat); |
| ALOGV("%s: output req->size = %d", __FUNCTION__, req->size); |
| } |
| return true; |
| } |
| |
| size_t C2DColorConverter::calcLumaAlign(ColorConvertFormat format) { |
| if (!isYUVSurface(format)) return 1; //no requirement |
| |
| switch (format) { |
| case NV12_2K: |
| return ALIGN2K; |
| case NV12_128m: |
| return 1; |
| case NV12_UBWC: |
| case TP10_UBWC: |
| return ALIGN4K; |
| default: |
| ALOGW("%s: unknown format (%d) passed for luma alignment number.", |
| __FUNCTION__, format); |
| return 1; |
| } |
| } |
| |
| size_t C2DColorConverter::calcSizeAlign(ColorConvertFormat format) { |
| if (!isYUVSurface(format)) return 1; //no requirement |
| |
| switch (format) { |
| case YCbCr420SP: //OR NV12 |
| case YCbCr420P: |
| case NV12_2K: |
| case NV12_128m: |
| case NV12_UBWC: |
| case TP10_UBWC: |
| return ALIGN4K; |
| default: |
| ALOGW("%s: unknown format (%d) passed for size alignment number", |
| __FUNCTION__, format); |
| return 1; |
| } |
| } |
| |
| C2DBytesPerPixel C2DColorConverter::calcBytesPerPixel(ColorConvertFormat format) { |
| C2DBytesPerPixel bpp; |
| bpp.numerator = 0; |
| bpp.denominator = 1; |
| |
| switch (format) { |
| case RGB565: |
| bpp.numerator = 2; |
| break; |
| case RGBA8888: |
| case RGBA8888_UBWC: |
| bpp.numerator = 4; |
| break; |
| case YCbCr420SP: |
| case YCbCr420P: |
| case YCrCb420P: |
| case YCbCr420Tile: |
| case NV12_2K: |
| case NV12_128m: |
| case NV12_UBWC: |
| case TP10_UBWC: |
| bpp.numerator = 3; |
| bpp.denominator = 2; |
| break; |
| default: |
| ALOGW("%s: unknown format (%d) passed.", __FUNCTION__, format); |
| break; |
| } |
| return bpp; |
| } |
| |
| int32_t C2DColorConverter::dumpOutput(char * filename, char mode) { |
| int fd; |
| size_t stride, sliceHeight; |
| if (!filename) return -1; |
| |
| int flags = O_RDWR | O_CREAT; |
| if (mode == 'a') { |
| flags |= O_APPEND; |
| } |
| |
| if ((fd = open(filename, flags)) < 0) { |
| ALOGE("%s: open dump file failed w/ errno %s", __FUNCTION__, strerror(errno)); |
| return -1; |
| } |
| |
| int ret = 0; |
| if (isYUVSurface(mDstFormat)) { |
| C2D_YUV_SURFACE_DEF * dstSurfaceDef = (C2D_YUV_SURFACE_DEF *)mDstSurfaceDef; |
| uint8_t * base = (uint8_t *)dstSurfaceDef->plane0; |
| stride = dstSurfaceDef->stride0; |
| sliceHeight = dstSurfaceDef->height; |
| /* dump luma */ |
| for (size_t i = 0; i < sliceHeight; i++) { |
| ret = write(fd, base, mDstWidth); //will work only for the 420 ones |
| if (ret < 0) goto cleanup; |
| base += stride; |
| } |
| |
| if (mDstFormat == YCbCr420P || |
| mDstFormat == YCrCb420P) { |
| ALOGI("%s: Dump Cb and Cr separately for Planar\n", __FUNCTION__); |
| //dump Cb/Cr |
| base = (uint8_t *)dstSurfaceDef->plane1; |
| stride = dstSurfaceDef->stride1; |
| for (size_t i = 0; i < sliceHeight/2;i++) { //will work only for the 420 ones |
| ret = write(fd, base, mDstWidth/2); |
| if (ret < 0) goto cleanup; |
| base += stride; |
| } |
| |
| //dump Cr/Cb |
| base = (uint8_t *)dstSurfaceDef->plane2; |
| stride = dstSurfaceDef->stride2; |
| |
| for (size_t i = 0; i < sliceHeight/2;i++) { //will work only for the 420 ones |
| ret = write(fd, base, mDstWidth/2); |
| if (ret < 0) goto cleanup; |
| base += stride; |
| } |
| |
| } else { |
| /* dump chroma */ |
| base = (uint8_t *)dstSurfaceDef->plane1; |
| stride = dstSurfaceDef->stride1; |
| for (size_t i = 0; i < sliceHeight/2;i++) { //will work only for the 420 ones |
| ret = write(fd, base, mDstWidth); |
| if (ret < 0) goto cleanup; |
| base += stride; |
| } |
| } |
| } else { |
| C2D_RGB_SURFACE_DEF * dstSurfaceDef = (C2D_RGB_SURFACE_DEF *)mDstSurfaceDef; |
| uint8_t * base = (uint8_t *)dstSurfaceDef->buffer; |
| stride = dstSurfaceDef->stride; |
| sliceHeight = dstSurfaceDef->height; |
| |
| ALOGI("%s: rgb surface base is %p", __FUNCTION__, base); |
| ALOGI("%s: rgb surface dumpsslice height is %lu\n", |
| __FUNCTION__, (unsigned long)sliceHeight); |
| ALOGI("%s: rgb surface dump stride is %lu\n", |
| __FUNCTION__, (unsigned long)stride); |
| |
| int bpp = 1; //bytes per pixel |
| if (mDstFormat == RGB565) { |
| bpp = 2; |
| } else if (mDstFormat == RGBA8888 || mDstFormat == RGBA8888_UBWC) { |
| bpp = 4; |
| } |
| |
| int count = 0; |
| for (size_t i = 0; i < sliceHeight; i++) { |
| ret = write(fd, base, mDstWidth*bpp); |
| if (ret < 0) { |
| ALOGI("%s: write failed, count = %d\n", __FUNCTION__, count); |
| goto cleanup; |
| } |
| base += stride; |
| count += stride; |
| } |
| } |
| cleanup: |
| if (ret < 0) { |
| ALOGE("%s: file write failed w/ errno %s", __FUNCTION__, strerror(errno)); |
| } |
| close(fd); |
| return ret < 0 ? ret : 0; |
| } |
