| /* INTEL CONFIDENTIAL |
| * Copyright (c) 2013 Intel Corporation. All rights reserved. |
| * Copyright (c) Imagination Technologies Limited, UK |
| * |
| * The source code contained or described herein and all documents |
| * related to the source code ("Material") are owned by Intel |
| * Corporation or its suppliers or licensors. Title to the |
| * Material remains with Intel Corporation or its suppliers and |
| * licensors. The Material contains trade secrets and proprietary |
| * and confidential information of Intel or its suppliers and |
| * licensors. The Material is protected by worldwide copyright and |
| * trade secret laws and treaty provisions. No part of the Material |
| * may be used, copied, reproduced, modified, published, uploaded, |
| * posted, transmitted, distributed, or disclosed in any way without |
| * Intel's prior express written permission. |
| * |
| * No license under any patent, copyright, trade secret or other |
| * intellectual property right is granted to or conferred upon you |
| * by disclosure or delivery of the Materials, either expressly, by |
| * implication, inducement, estoppel or otherwise. Any license |
| * under such intellectual property rights must be express and |
| * approved by Intel in writing. |
| * |
| * Authors: |
| * Yao Cheng <yao.cheng@intel.com> |
| * |
| */ |
| //#define LOG_NDEBUG 0 |
| |
| #include "va/va.h" |
| #include "va/va_vpp.h" |
| #include "va/va_drmcommon.h" |
| #include "JPEGDecoder.h" |
| #include "ImageDecoderTrace.h" |
| #include <string.h> |
| #include <sys/types.h> |
| #include <time.h> |
| #include "JPEGCommon_Gen.h" |
| |
| int fourcc2PixelFormat(uint32_t fourcc) |
| { |
| switch(fourcc) { |
| case VA_FOURCC_YV12: |
| return HAL_PIXEL_FORMAT_YV12; |
| case VA_FOURCC_422H: |
| return HAL_PIXEL_FORMAT_YCbCr_422_H_INTEL; |
| case VA_FOURCC_YUY2: |
| return HAL_PIXEL_FORMAT_YCbCr_422_I; |
| case VA_FOURCC_NV12: |
| return HAL_PIXEL_FORMAT_NV12_TILED_INTEL; |
| case VA_FOURCC_RGBA: |
| return HAL_PIXEL_FORMAT_RGBA_8888; |
| case VA_FOURCC_IMC3: |
| return HAL_PIXEL_FORMAT_IMC3; |
| case VA_FOURCC_444P: |
| return HAL_PIXEL_FORMAT_444P; |
| case VA_FOURCC_422V: |
| case VA_FOURCC_411P: |
| default: |
| return -1; |
| } |
| } |
| uint32_t pixelFormat2Fourcc(int pixel_format) |
| { |
| switch(pixel_format) { |
| case HAL_PIXEL_FORMAT_YV12: |
| return VA_FOURCC_YV12; |
| case HAL_PIXEL_FORMAT_YCbCr_422_H_INTEL: |
| return VA_FOURCC_422H; |
| case HAL_PIXEL_FORMAT_YCbCr_422_I: |
| return VA_FOURCC_YUY2; |
| case HAL_PIXEL_FORMAT_NV12_TILED_INTEL: |
| return VA_FOURCC_NV12; |
| case HAL_PIXEL_FORMAT_RGBA_8888: |
| return VA_FOURCC_RGBA; |
| case HAL_PIXEL_FORMAT_444P: |
| return VA_FOURCC_444P; |
| case HAL_PIXEL_FORMAT_IMC3: |
| return VA_FOURCC_IMC3; |
| default: |
| return 0; |
| } |
| } |
| |
| //#define LOG_TAG "ImageDecoder" |
| |
| #define JD_CHECK(err, label) \ |
| if (err) { \ |
| ETRACE("%s::%d: failed: %d", __PRETTY_FUNCTION__, __LINE__, err); \ |
| goto label; \ |
| } |
| |
| #define JD_CHECK_RET(err, label, retcode) \ |
| if (err) { \ |
| status = retcode; \ |
| ETRACE("%s::%d: failed: %d", __PRETTY_FUNCTION__, __LINE__, err); \ |
| goto label; \ |
| } |
| |
| bool JpegDecoder::jpegColorFormatSupported(JpegInfo &jpginfo) const |
| { |
| return (jpginfo.image_color_fourcc == VA_FOURCC_IMC3) || |
| (jpginfo.image_color_fourcc == VA_FOURCC_422H) || |
| (jpginfo.image_color_fourcc == VA_FOURCC_444P); |
| } |
| |
| JpegDecodeStatus JpegDecoder::createSurfaceDrm(int width, int height, int pixel_format, unsigned long boname, int stride, VASurfaceID *surf_id) |
| { |
| VAStatus st; |
| VASurfaceAttrib attrib_list; |
| VASurfaceAttribExternalBuffers vaSurfaceExternBuf; |
| uint32_t fourcc = pixelFormat2Fourcc(pixel_format); |
| vaSurfaceExternBuf.pixel_format = fourcc; |
| VTRACE("%s extBuf.pixel_format is %s", __FUNCTION__, fourcc2str(NULL, fourcc)); |
| vaSurfaceExternBuf.width = width; |
| vaSurfaceExternBuf.height = height; |
| vaSurfaceExternBuf.pitches[0] = stride; |
| vaSurfaceExternBuf.buffers = &boname; |
| vaSurfaceExternBuf.num_buffers = 1; |
| vaSurfaceExternBuf.flags = VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM; |
| attrib_list.type = VASurfaceAttribExternalBufferDescriptor; |
| attrib_list.flags = VA_SURFACE_ATTRIB_SETTABLE; |
| attrib_list.value.type = VAGenericValueTypePointer; |
| attrib_list.value.value.p = (void *)&vaSurfaceExternBuf; |
| |
| st = vaCreateSurfaces(mDisplay, |
| fourcc2VaFormat(fourcc), |
| width, |
| height, |
| surf_id, |
| 1, |
| &attrib_list, |
| 1); |
| VTRACE("%s createSurface DRM for vaformat %u, fourcc %s", __FUNCTION__, fourcc2VaFormat(fourcc), fourcc2str(NULL, fourcc)); |
| if (st != VA_STATUS_SUCCESS) { |
| ETRACE("%s: vaCreateSurfaces returns %d", __PRETTY_FUNCTION__, st); |
| return JD_RESOURCE_FAILURE; |
| } |
| return JD_SUCCESS; |
| } |
| |
| JpegDecodeStatus JpegDecoder::createSurfaceGralloc(int width, int height, int pixel_format, buffer_handle_t handle, int stride, VASurfaceID *surf_id) |
| { |
| unsigned long boname; |
| hw_module_t const* module = NULL; |
| alloc_device_t *allocdev = NULL; |
| struct gralloc_module_t *gralloc_module = NULL; |
| JpegDecodeStatus st; |
| |
| uint32_t fourcc = pixelFormat2Fourcc(pixel_format); |
| VTRACE("enter %s, pixel_format 0x%x, fourcc %s", __FUNCTION__, pixel_format, fourcc2str(NULL, fourcc)); |
| if ((fourcc != VA_FOURCC_422H) || |
| (fourcc != VA_FOURCC_YUY2) || |
| (fourcc != VA_FOURCC_RGBA)){ |
| VASurfaceAttrib attrib; |
| attrib.type = VASurfaceAttribPixelFormat; |
| attrib.flags = VA_SURFACE_ATTRIB_SETTABLE; |
| attrib.value.type = VAGenericValueTypeInteger; |
| attrib.value.value.i = fourcc; |
| VAStatus va_status = vaCreateSurfaces(mDisplay, |
| fourcc2VaFormat(fourcc), |
| width, |
| height, |
| surf_id, |
| 1, |
| &attrib, |
| 1); |
| VTRACE("%s createSurface for %s", __FUNCTION__, fourcc2str(NULL, fourcc)); |
| if (va_status != VA_STATUS_SUCCESS) |
| return JD_RESOURCE_FAILURE; |
| return JD_SUCCESS; |
| } |
| |
| int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module); |
| if (err) { |
| ETRACE("%s failed to get gralloc module", __PRETTY_FUNCTION__); |
| st = JD_RESOURCE_FAILURE; |
| } |
| JD_CHECK(err, cleanup); |
| gralloc_module = (struct gralloc_module_t *)module; |
| err = gralloc_open(module, &allocdev); |
| if (err) { |
| ETRACE("%s failed to open alloc device", __PRETTY_FUNCTION__); |
| st = JD_RESOURCE_FAILURE; |
| } |
| JD_CHECK(err, cleanup); |
| err = gralloc_module->perform(gralloc_module, |
| INTEL_UFO_GRALLOC_MODULE_PERFORM_GET_BO_NAME, |
| handle, |
| &boname); |
| if (err) { |
| ETRACE("%s failed to get boname via gralloc->perform", __PRETTY_FUNCTION__); |
| st = JD_RESOURCE_FAILURE; |
| } |
| JD_CHECK(err, cleanup); |
| VTRACE("YAO %s fourcc %s luma_stride is %d", __FUNCTION__, |
| fourcc2str(NULL, fourcc), stride); |
| |
| gralloc_close(allocdev); |
| return createSurfaceDrm(width, height, pixel_format, boname, stride, surf_id); |
| cleanup: |
| if (allocdev) |
| gralloc_close(allocdev); |
| return st; |
| } |
| |
| |
| |
| |
| |
