| /* INTEL CONFIDENTIAL |
| * Copyright (c) 2012, 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: |
| * Nana Guo <nana.n.guo@intel.com> |
| * Yao Cheng <yao.cheng@intel.com> |
| * |
| */ |
| |
| /* |
| * Initialize VA API related stuff |
| * |
| * We will check the return value of jva_initialize |
| * to determine which path will be use (SW or HW) |
| * |
| */ |
| //#define LOG_NDEBUG 0 |
| #define LOG_TAG "ImageDecoder" |
| |
| #include <utils/Log.h> |
| #include "JPEGDecoder_libjpeg_wrapper.h" |
| #include <hardware/gralloc.h> |
| #include <utils/threads.h> |
| #include "JPEGDecoder.h" |
| #include <va/va.h> |
| #include "va/va_dec_jpeg.h" |
| |
| #ifdef NDEBUG |
| #undef NDEBUG |
| #endif |
| |
| #include <assert.h> |
| |
| static Mutex jdlock; |
| |
| struct jdva_private |
| { |
| JpegInfo jpg_info; |
| JpegDecoder decoder; |
| RenderTarget dec_buffer; |
| RenderTarget yuy2_buffer; |
| RenderTarget rgba_buffer; |
| }; |
| |
| static int internal_buffer_handle = 0; |
| |
| #define JD_CHECK(err, label) \ |
| if (err) { \ |
| ALOGE("%s::%d: failed: %d", __PRETTY_FUNCTION__, __LINE__, err); \ |
| goto label; \ |
| } |
| |
| #define JD_CHECK_RET(err, label, retcode) \ |
| if (err) { \ |
| status = retcode; \ |
| ALOGE("%s::%d: failed: %d", __PRETTY_FUNCTION__, __LINE__, err); \ |
| goto label; \ |
| } |
| |
| Decode_Status jdva_initialize (jd_libva_struct * jd_libva_ptr) |
| { |
| /* |
| * Please note that we won't check the input parameters to follow the |
| * convention of libjpeg duo to we need these parameters to do error handling, |
| * and if these parameters are invalid, means the whole stack is crashed, so check |
| * them here and return false is meaningless, same situation for all internal methods |
| * related to VA API |
| */ |
| uint32_t va_major_version = 0; |
| uint32_t va_minor_version = 0; |
| VAStatus va_status = VA_STATUS_SUCCESS; |
| Decode_Status status = DECODE_SUCCESS; |
| |
| if (jd_libva_ptr->initialized) { |
| ALOGW("%s HW decode already initialized", __FUNCTION__); |
| return DECODE_NOT_STARTED; |
| } |
| |
| { |
| Mutex::Autolock autoLock(jdlock); |
| if (!(jd_libva_ptr->initialized)) { |
| jdva_private *priv = new jdva_private; |
| memset(&priv->jpg_info, 0, sizeof(JpegInfo)); |
| memset(&priv->dec_buffer, 0, sizeof(RenderTarget)); |
| memset(&priv->yuy2_buffer, 0, sizeof(RenderTarget)); |
| memset(&priv->rgba_buffer, 0, sizeof(RenderTarget)); |
| jd_libva_ptr->initialized = TRUE; |
| jd_libva_ptr->priv = (uint32_t)priv; |
| status = DECODE_SUCCESS; |
| } |
| } |
| cleanup: |
| if (status) { |
| jd_libva_ptr->initialized = TRUE; // make sure we can call into jva_deinitialize() |
| jdva_deinitialize (jd_libva_ptr); |
| return status; |
| } |
| |
| return status; |
| } |
| void jdva_deinitialize (jd_libva_struct * jd_libva_ptr) |
| { |
| if (!(jd_libva_ptr->initialized)) { |
| return; |
| } |
| { |
| Mutex::Autolock autoLock(jdlock); |
| if (jd_libva_ptr->initialized) { |
| jdva_private *p = (jdva_private*)jd_libva_ptr->priv; |
| delete p; |
| jd_libva_ptr->initialized = FALSE; |
| } |
| } |
| ALOGV("jdva_deinitialize finished"); |
| return; |
| } |
| |
| RenderTarget * create_render_target(RenderTarget* target, int width, int height, int pixel_format) |
| { |
| hw_module_t const* module = NULL; |
| alloc_device_t *allocdev = NULL; |
| struct gralloc_module_t *gralloc_module = NULL; |
| buffer_handle_t handle; |
| uint32_t fourcc; |
| int stride, bpp, err; |
| fourcc = pixelFormat2Fourcc(pixel_format); |
| bpp = fourcc2LumaBitsPerPixel(fourcc); |
| if (target == NULL) { |
| ALOGE("%s malloc new RenderTarget failed", __FUNCTION__); |
| return NULL; |
| } |
| ALOGV("%s created %s target %p", __FUNCTION__, fourcc2str(NULL, fourcc), target); |
| if ((fourcc == VA_FOURCC_422H) || |
| (fourcc == VA_FOURCC_YUY2) || |
| (fourcc == VA_FOURCC_RGBA)){ |
| err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module); |
| if (err || !module) { |
| ALOGE("%s failed to get gralloc module", __FUNCTION__); |
| return NULL; |
| } |
| gralloc_module = (struct gralloc_module_t *)module; |
| err = gralloc_open(module, &allocdev); |
| if (err || !allocdev) { |
| ALOGE("%s failed to open alloc device", __FUNCTION__); |
| return NULL; |
| } |
| err = allocdev->alloc(allocdev, |
| width, height, pixel_format, |
| GRALLOC_USAGE_HW_RENDER, |
| &handle, &stride); |
| if (err) { |
| gralloc_close(allocdev); |
| ALOGE("%s failed to allocate surface", __FUNCTION__); |
| return NULL; |
| } |
| target->type = RenderTarget::ANDROID_GRALLOC; |
| target->handle = (int)handle; |
| target->stride = stride * bpp; |
| } |
| else { |
| *((int*)(&target->type)) = RENDERTARGET_INTERNAL_BUFFER; |
| target->handle = internal_buffer_handle++; |
| } |
| target->width = width; |
| target->height = height; |
| target->pixel_format = pixel_format; |
| target->rect.x = target->rect.y = 0; |
| target->rect.width = target->width; |
| target->rect.height = target->height; |
| return target; |
| } |
| |
| void free_render_target(RenderTarget *target) |
| { |
| if (target == NULL) |
| return; |
| uint32_t fourcc = pixelFormat2Fourcc(target->pixel_format); |
| if (target->type == RenderTarget::ANDROID_GRALLOC) { |
| buffer_handle_t handle = (buffer_handle_t)target->handle; |
| hw_module_t const* module = NULL; |
| alloc_device_t *allocdev = NULL; |
| struct gralloc_module_t *gralloc_module = NULL; |
| int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module); |
| if (err || !module) { |
| ALOGE("%s failed to get gralloc module", __FUNCTION__); |
| return; |
| } |
| gralloc_module = (struct gralloc_module_t *)module; |
| err = gralloc_open(module, &allocdev); |
| if (err || !allocdev) { |
| ALOGE("%s failed to get gralloc module", __FUNCTION__); |
| return; |
| } |
| allocdev->free(allocdev, handle); |
| gralloc_close(allocdev); |
| } |
| ALOGV("%s deleting %s target %p", __FUNCTION__, fourcc2str(NULL, fourcc), target); |
| } |
| |
| void dump_yuy2_target(RenderTarget *target, JpegDecoder *decoder, const char *filename) |
| { |
| uint32_t fourcc = pixelFormat2Fourcc(target->pixel_format); |
| assert(fourcc == VA_FOURCC_YUY2); |
| uint8_t *data; |
| uint32_t offsets[3]; |
| uint32_t pitches[3]; |
| JpegDecoder::MapHandle maphandle = decoder->mapData(*target, (void**) &data, offsets, pitches); |
| assert (maphandle.valid); |
| FILE* fpdump = fopen(filename, "wb"); |
| if (fpdump) { |
| // YUYV |
| for (int i = 0; i < target->height; ++i) { |
| fwrite(data + offsets[0] + i * pitches[0], 1, target->width * 2, fpdump); |
| } |
| fclose(fpdump); |
| } |
| else { |
| ALOGW("%s failed to create %s", __FUNCTION__, filename); |
| } |
| decoder->unmapData(*target, maphandle); |
| } |
| |
| void dump_dec_target(RenderTarget *target, JpegDecoder *decoder, const char *filename) |
| { |
| uint32_t fourcc = pixelFormat2Fourcc(target->pixel_format); |
| assert((fourcc == VA_FOURCC_IMC3) || |
| (fourcc == VA_FOURCC_411P) || |
| (fourcc == VA_FOURCC('4','0','0','P')) || |
| (fourcc == VA_FOURCC_422H) || |
| (fourcc == VA_FOURCC_422V) || |
| (fourcc == VA_FOURCC_444P)); |
| uint8_t *data; |
| uint32_t offsets[3]; |
| uint32_t pitches[3]; |
| JpegDecoder::MapHandle maphandle = decoder->mapData(*target, (void**) &data, offsets, pitches); |
| assert (maphandle.valid); |
| FILE* fpdump = fopen(filename, "wb"); |
| if(fpdump) { |
| float hfactor, vfactor; |
| switch (fourcc) { |
| case VA_FOURCC_IMC3: |
| hfactor = 1; |
| vfactor = 0.5; |
| break; |
| case VA_FOURCC_444P: |
| hfactor = vfactor = 1; |
| break; |
| case VA_FOURCC_422H: |
| hfactor = 0.5; |
| vfactor = 1; |
| break; |
| case VA_FOURCC('4','0','0','P'): |
| hfactor = vfactor = 0; |
| break; |
| case VA_FOURCC_411P: |
| hfactor = 0.25; |
| vfactor = 1; |
| break; |
| case VA_FOURCC_422V: |
| hfactor = 0.5; |
| vfactor = 1; |
| break; |
| default: |
| hfactor = vfactor = 1; |
| break; |
| } |
| // Y |
| for (int i = 0; i < target->height; ++i) { |
| fwrite(data + offsets[0] + i * pitches[0], 1, target->width, fpdump); |
| } |
| // U |
| for (int i = 0; i < target->height * vfactor; ++i) { |
| fwrite(data + offsets[1] + i * pitches[1], 1, target->width * hfactor, fpdump); |
| } |
| // V |
| for (int i = 0; i < target->height * vfactor; ++i) { |
| fwrite(data + offsets[2] + i * pitches[2], 1, target->width * hfactor, fpdump); |
| } |
| fclose(fpdump); |
| } |
| else { |
| ALOGW("%s failed to create %s", __FUNCTION__, filename); |
| } |
| decoder->unmapData(*target, maphandle); |
| } |
| |
| |
| Decode_Status jdva_decode (j_decompress_ptr cinfo, jd_libva_struct * jd_libva_ptr) |
| { |
| JpegDecodeStatus st; |
| char **outbuf = jd_libva_ptr->output_image; |
| uint32_t lines = jd_libva_ptr->output_lines; |
| jdva_private * priv = (jdva_private*)jd_libva_ptr->priv; |
| if (!priv) |
| return DECODE_DRIVER_FAIL; |
| |
| JpegInfo& jpginfo = priv->jpg_info; |
| |
| st = priv->decoder.decode(jpginfo, priv->dec_buffer); |
| if (st != JD_SUCCESS) { |
| ALOGE("%s: error decoding %s image", __FUNCTION__, fourcc2str(NULL, jpginfo.image_color_fourcc)); |
| return DECODE_DRIVER_FAIL; |
| } |
| ALOGI("%s successfully decoded JPEG with VAAPI", __FUNCTION__); |
| RenderTarget *src_target = &priv->dec_buffer; |
| //dump_dec_target(src_target, decoder,"/sdcard/dec_dump.yuv"); |
| |
| bool yuy2_csc = false; |
| hw_module_t const* module = NULL; |
| alloc_device_t *allocdev = NULL; |
| struct gralloc_module_t *gralloc_module = NULL; |
| buffer_handle_t handle; |
| int err; |
| uint8_t *data = NULL; |
| uint32_t offsets[3]; |
| uint32_t pitches[3]; |
| JpegDecoder::MapHandle maphandle; |
| FILE *rgbafile = NULL; |
| if (jpginfo.image_color_fourcc != VA_FOURCC_422H) |
| yuy2_csc = true; |
| |
| // CSC to YUY2 if needed |
| if (yuy2_csc) { |
| st = priv->decoder.blit(*src_target, priv->yuy2_buffer); |
| if (st != JD_SUCCESS) { |
| ALOGE("%s: error blitting to YUY2 buffer", __FUNCTION__); |
| goto cleanup; |
| } |
| //dump_yuy2_target(src_target, decoder,"/sdcard/yuy2_dump.yuv"); |
| src_target = &priv->yuy2_buffer; |
| } |
| |
| st = priv->decoder.blit(*src_target, priv->rgba_buffer); |
| if (st != JD_SUCCESS) { |
| ALOGE("%s: error blitting to RGBA buffer", __FUNCTION__); |
| goto cleanup; |
| } |
| maphandle = priv->decoder.mapData(priv->rgba_buffer, (void**) &data, offsets, pitches); |
| |
| //rgbafile = fopen("/sdcard/rgba_dump", "wb"); |
| |
| for (uint32_t i = 0; i < lines; ++i) { |
| if (outbuf[i] != NULL) { |
| //memcpy(outbuf[i], data + offsets[0] + i * pitches[0], 4 * jpginfo.image_width); |
| for (int j = 0; j < priv->rgba_buffer.width; ++j) { |
| // BGRA -> RGBA |
| // R |
| memcpy(outbuf[i] + 4 * j, data + offsets[0] + i * pitches[0] + 4 * j + 2, 1); |
| // G |
| memcpy(outbuf[i] + 4 * j + 1, data + offsets[0] + i * pitches[0] + 4 * j + 1, 1); |
| // B |
| memcpy(outbuf[i] + 4 * j + 2, data + offsets[0] + i * pitches[0] + 4 * j, 1); |
| // A |
| memcpy(outbuf[i] + 4 * j + 3, data + offsets[0] + i * pitches[0] + 4 * j + 3, 1); |
| } |
| } |
| else { |
| ALOGE("%s outbuf line %u is NULL", __FUNCTION__, i); |
| } |
| //if (rgbafile) { |
| // fwrite(data + offsets[0] + i * pitches[0], 1, 4 * rgba_target->width, rgbafile); |
| //} |
| } |
| //if (rgbafile) |
| // fclose(rgbafile); |
| ALOGI("%s successfully blitted RGBA from JPEG %s data", __FUNCTION__, fourcc2str(NULL, priv->jpg_info.image_color_fourcc)); |
| priv->decoder.unmapData(priv->rgba_buffer, maphandle); |
| return DECODE_SUCCESS; |
| |
| cleanup: |
| return DECODE_DRIVER_FAIL; |
| } |
| |
| Decode_Status jdva_create_resource (jd_libva_struct * jd_libva_ptr) |
| { |
| VAStatus va_status = VA_STATUS_SUCCESS; |
| Decode_Status status = DECODE_SUCCESS; |
| RenderTarget *dec_target, *yuy2_target, *rgba_target; |
| dec_target = yuy2_target = rgba_target = NULL; |
| JpegDecodeStatus st; |
| Mutex::Autolock autoLock(jdlock); |
| jdva_private *priv = (jdva_private*)jd_libva_ptr->priv; |
| jd_libva_ptr->image_width = priv->jpg_info.picture_param_buf.picture_width; |
| jd_libva_ptr->image_height = priv->jpg_info.picture_param_buf.picture_height; |
| dec_target = create_render_target(&priv->dec_buffer, jd_libva_ptr->image_width,jd_libva_ptr->image_height,fourcc2PixelFormat(priv->jpg_info.image_color_fourcc)); |
| if (dec_target == NULL) { |
| ALOGE("%s failed to create decode render target", __FUNCTION__); |
| return DECODE_MEMORY_FAIL; |
| } |
| rgba_target = create_render_target(&priv->rgba_buffer, jd_libva_ptr->image_width,jd_libva_ptr->image_height, HAL_PIXEL_FORMAT_RGBA_8888); |
| if (rgba_target == NULL) { |
| ALOGE("%s failed to create YUY2 csc buffer", __FUNCTION__); |
| free_render_target(dec_target); |
| return DECODE_MEMORY_FAIL; |
| } |
| yuy2_target = create_render_target(&priv->yuy2_buffer, jd_libva_ptr->image_width,jd_libva_ptr->image_height, HAL_PIXEL_FORMAT_YCbCr_422_I); |
| if (yuy2_target == NULL) { |
| ALOGE("%s failed to create RGBA csc buffer", __FUNCTION__); |
| free_render_target(dec_target); |
| free_render_target(rgba_target); |
| return DECODE_MEMORY_FAIL; |
| } |
| RenderTarget *targetlist[3] = { dec_target, yuy2_target, rgba_target }; |
| st = priv->decoder.init(jd_libva_ptr->image_width, jd_libva_ptr->image_height, targetlist, 3); |
| if (st != JD_SUCCESS) { |
| free_render_target(dec_target); |
| free_render_target(rgba_target); |
| free_render_target(yuy2_target); |
| ALOGE("%s failed to initialize resources for decoder: %d", __FUNCTION__, st); |
| return DECODE_DRIVER_FAIL; |
| } |
| |
| jd_libva_ptr->resource_allocated = TRUE; |
| ALOGV("%s successfully set up HW decode resource", __FUNCTION__); |
| return status; |
| cleanup: |
| jd_libva_ptr->resource_allocated = FALSE; |
| |
| jdva_deinitialize (jd_libva_ptr); |
| |
| return DECODE_DRIVER_FAIL; |
| } |
| Decode_Status jdva_release_resource (jd_libva_struct * jd_libva_ptr) |
| { |
| Decode_Status status = DECODE_SUCCESS; |
| VAStatus va_status = VA_STATUS_SUCCESS; |
| int i; |
| |
| if (!(jd_libva_ptr->resource_allocated)) { |
| ALOGW("%s decoder resource not yet allocated", __FUNCTION__); |
| return status; |
| } |
| Mutex::Autolock autoLock(jdlock); |
| |
| ALOGV("%s deiniting priv 0x%x", __FUNCTION__, jd_libva_ptr->priv); |
| jdva_private *priv = (jdva_private*)jd_libva_ptr->priv; |
| if (priv) { |
| priv->decoder.deinit(); |
| free_render_target(&priv->dec_buffer); |
| free_render_target(&priv->yuy2_buffer); |
| free_render_target(&priv->rgba_buffer); |
| } |
| /* |
| * It is safe to destroy Surface/Config/Context severl times |
| * and it is also safe even their value is NULL |
| */ |
| |
| cleanup: |
| |
| jd_libva_ptr->resource_allocated = FALSE; |
| |
| return va_status; |
| } |
| Decode_Status jdva_parse_bitstream(j_decompress_ptr cinfo, jd_libva_struct * jd_libva_ptr) |
| { |
| jdva_private * priv = (jdva_private*)jd_libva_ptr->priv; |
| if (!priv) |
| return DECODE_DRIVER_FAIL; |
| JpegInfo& jpginfo = priv->jpg_info; |
| jpginfo.buf = jd_libva_ptr->bitstream_buf; |
| jpginfo.bufsize = jd_libva_ptr->file_size; |
| JpegDecodeStatus st = priv->decoder.parse(jpginfo); |
| if (st != JD_SUCCESS) { |
| ALOGE("%s parser for HW decode failed: %d", __FUNCTION__, st); |
| return DECODE_PARSER_FAIL; |
| } |
| |
| jd_libva_ptr->image_width = jpginfo.image_width; |
| jd_libva_ptr->image_height = jpginfo.image_height; |
| cinfo->original_image_width = jpginfo.picture_param_buf.picture_width; /* nominal image width (from SOF marker) */ |
| cinfo->image_width = jpginfo.picture_param_buf.picture_width; /* nominal image width (from SOF marker) */ |
| cinfo->image_height = jpginfo.picture_param_buf.picture_height; /* nominal image height */ |
| cinfo->num_components = jpginfo.picture_param_buf.num_components; /* # of color components in JPEG image */ |
| cinfo->jpeg_color_space = JCS_YCbCr; /* colorspace of JPEG image */ |
| cinfo->out_color_space = JCS_RGB; /* colorspace for output */ |
| cinfo->src->bytes_in_buffer = jd_libva_ptr->file_size; |
| return DECODE_SUCCESS; |
| } |
| |
