| /* 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 "JPEGBlitter.h" |
| #include "JPEGCommon_Gen.h" |
| #include "JPEGDecoder.h" |
| |
| #include <va/va.h> |
| #include <va/va_tpi.h> |
| #include "ImageDecoderTrace.h" |
| |
| #ifdef NDEBUG |
| #undef NDEBUG |
| #endif |
| |
| #include <assert.h> |
| |
| #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; \ |
| } |
| |
| const VAProcColorStandardType fourcc2ColorStandard(uint32_t fourcc) |
| { |
| switch(fourcc) { |
| case VA_FOURCC_NV12: |
| case VA_FOURCC_YUY2: |
| case VA_FOURCC_422H: |
| case VA_FOURCC_422V: |
| case VA_FOURCC_411P: |
| case VA_FOURCC_411R: |
| case VA_FOURCC_IMC3: |
| case VA_FOURCC_444P: |
| case VA_FOURCC_YV12: |
| return VAProcColorStandardBT601; |
| default: |
| return VAProcColorStandardNone; |
| } |
| } |
| |
| void write_to_file(const char *file, const VAImage *pImg, const uint8_t *pSrc) |
| { |
| FILE *fp = fopen(file, "wb"); |
| if (!fp) { |
| return; |
| } |
| const uint8_t *pY, *pU, *pV, *pYUYV, *pRGBA, *pUV; |
| float h_samp_factor, v_samp_factor; |
| int row, col; |
| char fourccstr[5]; |
| VTRACE("Dumping %s buffer to %s", fourcc2str(fourccstr, pImg->format.fourcc), file); |
| switch (pImg->format.fourcc) { |
| case VA_FOURCC_IMC3: |
| h_samp_factor = 1; |
| v_samp_factor = 0.5; |
| break; |
| case VA_FOURCC_422H: |
| h_samp_factor = 0.5; |
| v_samp_factor = 1; |
| break; |
| case VA_FOURCC_444P: |
| h_samp_factor = 1; |
| v_samp_factor = 1; |
| break; |
| case VA_FOURCC_YUY2: |
| { |
| pYUYV = pSrc + pImg->offsets[0]; |
| VTRACE("YUY2 output width %u stride %u", pImg->width, pImg->pitches[0]); |
| for (row = 0; row < pImg->height; ++row) { |
| fwrite(pYUYV, 2, pImg->width, fp); |
| pYUYV += pImg->pitches[0]; |
| } |
| } |
| fclose(fp); |
| return; |
| case VA_FOURCC_NV12: |
| { |
| pY = pSrc + pImg->offsets[0]; |
| pUV = pSrc + pImg->offsets[1]; |
| VTRACE("NV12 output width %u stride %u, %u", pImg->width, pImg->pitches[0], pImg->pitches[1]); |
| for (row = 0; row < pImg->height; ++row) { |
| fwrite(pY, 1, pImg->width, fp); |
| pY += pImg->pitches[0]; |
| } |
| for (row = 0; row < pImg->height/2; ++row) { |
| fwrite(pUV, 1, pImg->width, fp); |
| pUV += pImg->pitches[1]; |
| } |
| } |
| fclose(fp); |
| return; |
| case VA_FOURCC_RGBA: |
| case VA_FOURCC_BGRA: |
| case VA_FOURCC_ARGB: |
| case VA_FOURCC('A', 'B', 'G', 'R'): |
| { |
| pRGBA = pSrc + pImg->offsets[0]; |
| VTRACE("RGBA output width %u stride %u", pImg->width, pImg->pitches[0]); |
| for (row = 0; row < pImg->height; ++row) { |
| fwrite(pRGBA, 4, pImg->width, fp); |
| pRGBA += pImg->pitches[0]; |
| } |
| } |
| fclose(fp); |
| return; |
| default: |
| // non-supported |
| { |
| char fourccstr[5]; |
| ETRACE("%s: Not-supported input YUV format", fourcc2str(fourccstr, pImg->format.fourcc)); |
| } |
| return; |
| } |
| pY = pSrc + pImg->offsets[0]; |
| pU = pSrc + pImg->offsets[1]; |
| pV = pSrc + pImg->offsets[2]; |
| // Y |
| for (row = 0; row < pImg->height; ++row) { |
| fwrite(pY, 1, pImg->width, fp); |
| pY += pImg->pitches[0]; |
| } |
| // U |
| for (row = 0; row < pImg->height * v_samp_factor; ++row) { |
| fwrite(pU, 1, pImg->width * h_samp_factor, fp); |
| pU += pImg->pitches[1]; |
| } |
| // V |
| for (row = 0; row < pImg->height * v_samp_factor; ++row) { |
| fwrite(pV, 1, pImg->width * h_samp_factor, fp); |
| pV += pImg->pitches[2]; |
| } |
| fclose(fp); |
| } |
| |
| static void write_to_YUY2(uint8_t *pDst, |
| uint32_t dst_w, |
| uint32_t dst_h, |
| uint32_t dst_stride, |
| const VAImage *pImg, |
| const uint8_t *pSrc) |
| { |
| const uint8_t *pY, *pU, *pV; |
| float h_samp_factor, v_samp_factor; |
| int row, col; |
| char fourccstr[5]; |
| uint32_t copy_w = (dst_w < pImg->width)? dst_w: pImg->width; |
| uint32_t copy_h = (dst_h < pImg->height)? dst_h: pImg->height; |
| switch (pImg->format.fourcc) { |
| case VA_FOURCC_IMC3: |
| h_samp_factor = 0.5; |
| v_samp_factor = 0.5; |
| break; |
| case VA_FOURCC_422H: |
| h_samp_factor = 0.5; |
| v_samp_factor = 1; |
| break; |
| case VA_FOURCC_444P: |
| h_samp_factor = 1; |
| v_samp_factor = 1; |
| break; |
| default: |
| // non-supported |
| ETRACE("%s to YUY2: Not-supported input YUV format", fourcc2str(fourccstr, pImg->format.fourcc)); |
| return; |
| } |
| pY = pSrc + pImg->offsets[0]; |
| pU = pSrc + pImg->offsets[1]; |
| pV = pSrc + pImg->offsets[2]; |
| for (row = 0; row < copy_h; ++row) { |
| for (col = 0; col < copy_w; ++col) { |
| // Y |
| *(pDst + 2 * col) = *(pY + col); |
| uint32_t actual_col = h_samp_factor * col; |
| if (col % 2 == 1) { |
| // U |
| *(pDst + 2 * col + 1) = *(pU + actual_col); |
| } |
| else { |
| // V |
| *(pDst + 2 * col + 1) = *(pV + actual_col); |
| } |
| } |
| pDst += dst_stride; |
| pY += pImg->pitches[0]; |
| uint32_t actual_row = row * v_samp_factor; |
| pU = pSrc + pImg->offsets[1] + actual_row * pImg->pitches[1]; |
| pV = pSrc + pImg->offsets[2] + actual_row * pImg->pitches[2]; |
| } |
| } |
| |
| static void dumpSurface(const char* filename, VADisplay display, VASurfaceID surface) |
| { |
| VAStatus st; |
| VAImage img; |
| uint8_t *buf; |
| st = vaDeriveImage(display, surface, &img); |
| if (st) { |
| ETRACE("vaDeriveImage failed with %d", st); |
| return; |
| } |
| uint32_t in_fourcc = img.format.fourcc; |
| VTRACE("Start dumping %s surface to %s", fourcc2str(NULL, in_fourcc), filename); |
| st = vaMapBuffer(display, img.buf, (void **)&buf); |
| if (st) { |
| ETRACE("vaMapBuffer failed with %d", st); |
| vaDestroyImage(display, img.image_id); |
| return; |
| } |
| VTRACE("start write_to_file"); |
| write_to_file(filename, &img, buf); |
| vaUnmapBuffer(display, img.buf); |
| vaDestroyImage(display, img.image_id); |
| } |
| |
| static void dumpGallocBuffer(const char* filename, |
| buffer_handle_t handle, |
| int width, |
| int height, |
| uint32_t fourcc) |
| { |
| // NOT IMPLEMENTED |
| } |
| |
| |
| static JpegDecodeStatus swBlit(VADisplay display, VAContextID context, |
| VASurfaceID in_surf, VARectangle *in_rect, uint32_t in_fourcc, |
| VASurfaceID out_surf, VARectangle *out_rect, uint32_t out_fourcc) |
| { |
| assert(out_fourcc == VA_FOURCC_YUY2); |
| assert((in_fourcc == VA_FOURCC_IMC3) || (in_fourcc == VA_FOURCC_422H) || (in_fourcc == VA_FOURCC_444P)); |
| VAStatus st; |
| char str[10]; |
| JpegDecodeStatus status; |
| VAImage in_img, out_img; |
| in_img.image_id = VA_INVALID_ID; |
| in_img.buf = VA_INVALID_ID; |
| out_img.image_id = VA_INVALID_ID; |
| out_img.buf = VA_INVALID_ID; |
| uint8_t *in_buf, *out_buf; |
| in_buf = out_buf = NULL; |
| st = vaDeriveImage(display, in_surf, &in_img); |
| JD_CHECK_RET(st, cleanup, JD_BLIT_FAILURE); |
| st = vaDeriveImage(display, out_surf, &out_img); |
| JD_CHECK_RET(st, cleanup, JD_BLIT_FAILURE); |
| st = vaMapBuffer(display, in_img.buf, (void **)&in_buf); |
| JD_CHECK_RET(st, cleanup, JD_BLIT_FAILURE); |
| st = vaMapBuffer(display, out_img.buf, (void **)&out_buf); |
| JD_CHECK_RET(st, cleanup, JD_BLIT_FAILURE); |
| VTRACE("%s in: %s, %ux%u, size %u, offset=%u,%u,%u, pitch=%u,%u,%u", __FUNCTION__, |
| fourcc2str(NULL, in_fourcc), |
| in_img.width, |
| in_img.height, |
| in_img.data_size, |
| in_img.offsets[0], in_img.offsets[1], in_img.offsets[2], |
| in_img.pitches[0], in_img.pitches[1], in_img.pitches[2]); |
| VTRACE("%s out: %s, %ux%u, size %u, offset=%u,%u,%u, pitch=%u,%u,%u", __FUNCTION__, |
| fourcc2str(NULL, out_fourcc), |
| out_img.width, |
| out_img.height, |
| out_img.data_size, |
| out_img.offsets[0], out_img.offsets[1], out_img.offsets[2], |
| out_img.pitches[0], out_img.pitches[1], out_img.pitches[2]); |
| write_to_YUY2(out_buf, out_img.width, out_img.height, out_img.pitches[0], &in_img, in_buf); |
| vaUnmapBuffer(display, in_img.buf); |
| vaUnmapBuffer(display, out_img.buf); |
| vaDestroyImage(display, in_img.image_id); |
| vaDestroyImage(display, out_img.image_id); |
| VTRACE("%s Finished SW CSC %s=>%s", __FUNCTION__, fourcc2str(str, in_fourcc), fourcc2str(str + 5, out_fourcc)); |
| return JD_SUCCESS; |
| |
| cleanup: |
| ETRACE("%s failed to do swBlit %s=>%s", __FUNCTION__, fourcc2str(str, in_fourcc), fourcc2str(str + 5, out_fourcc)); |
| if (in_buf != NULL) vaUnmapBuffer(display, in_img.buf); |
| if (out_buf != NULL) vaUnmapBuffer(display, out_img.buf); |
| if (in_img.image_id != VA_INVALID_ID) vaDestroyImage(display, in_img.image_id); |
| if (out_img.image_id != VA_INVALID_ID) vaDestroyImage(display, out_img.image_id); |
| return status; |
| } |
| |
| static JpegDecodeStatus hwBlit(VADisplay display, VAContextID context, |
| VASurfaceID in_surf, VARectangle *in_rect, uint32_t in_fourcc, |
| VASurfaceID out_surf, VARectangle *out_rect, uint32_t out_fourcc) |
| { |
| VAProcPipelineCaps vpp_pipeline_cap ; |
| VABufferID vpp_pipeline_buf = VA_INVALID_ID; |
| VAProcPipelineParameterBuffer vpp_param; |
| VAStatus vpp_status; |
| JpegDecodeStatus status = JD_SUCCESS; |
| char str[10]; |
| nsecs_t t1, t2; |
| |
| memset(&vpp_param, 0, sizeof(VAProcPipelineParameterBuffer)); |
| #if PRE_TOUCH_SURFACE |
| //zeroSurfaces(display, &out_surf, 1); |
| #endif |
| t1 = systemTime(); |
| vpp_param.surface = in_surf; |
| vpp_param.output_region = out_rect; |
| vpp_param.surface_region = in_rect; |
| vpp_param.surface_color_standard = fourcc2ColorStandard(in_fourcc); |
| vpp_param.output_background_color = 0; |
| vpp_param.output_color_standard = fourcc2ColorStandard(out_fourcc); |
| vpp_param.filter_flags = VA_FRAME_PICTURE; |
| vpp_param.filters = NULL; |
| vpp_param.num_filters = 0; |
| vpp_param.forward_references = 0; |
| vpp_param.num_forward_references = 0; |
| vpp_param.backward_references = 0; |
| vpp_param.num_backward_references = 0; |
| vpp_param.blend_state = NULL; |
| vpp_param.rotation_state = VA_ROTATION_NONE; |
| vpp_status = vaCreateBuffer(display, |
| context, |
| VAProcPipelineParameterBufferType, |
| sizeof(VAProcPipelineParameterBuffer), |
| 1, |
| &vpp_param, |
| &vpp_pipeline_buf); |
| JD_CHECK_RET(vpp_status, cleanup, JD_RESOURCE_FAILURE); |
| |
| vpp_status = vaBeginPicture(display, |
| context, |
| out_surf); |
| JD_CHECK_RET(vpp_status, cleanup, JD_BLIT_FAILURE); |
| |
| //Render the picture |
| vpp_status = vaRenderPicture(display, |
| context, |
| &vpp_pipeline_buf, |
| 1); |
| JD_CHECK_RET(vpp_status, cleanup, JD_BLIT_FAILURE); |
| |
| vpp_status = vaEndPicture(display, context); |
| JD_CHECK_RET(vpp_status, cleanup, JD_BLIT_FAILURE); |
| |
| vaDestroyBuffer(display, vpp_pipeline_buf); |
| JD_CHECK_RET(vpp_status, cleanup, JD_BLIT_FAILURE); |
| t2 = systemTime(); |
| VTRACE("Finished HW CSC %s(%d,%d,%u,%u)=>%s(%d,%d,%u,%u) for %f ms", |
| fourcc2str(str, in_fourcc), |
| in_rect->x, in_rect->y, in_rect->width, in_rect->height, |
| fourcc2str(str + 5, out_fourcc), |
| out_rect->x, out_rect->y, out_rect->width, out_rect->height, |
| ns2us(t2 - t1)/1000.0); |
| |
| return JD_SUCCESS; |
| cleanup: |
| if (vpp_pipeline_buf != VA_INVALID_ID) |
| vaDestroyBuffer(display, vpp_pipeline_buf); |
| return status; |
| } |
| |
| static JpegDecodeStatus vaBlit(VADisplay display, VAContextID context, |
| VASurfaceID in_surf, VARectangle *in_rect, uint32_t in_fourcc, |
| VASurfaceID out_surf, VARectangle *out_rect, uint32_t out_fourcc) |
| { |
| if (((in_fourcc == VA_FOURCC_422H) || |
| (in_fourcc == VA_FOURCC_NV12) || |
| (in_fourcc == VA_FOURCC_YUY2) || |
| (in_fourcc == VA_FOURCC_YV12) || |
| (in_fourcc == VA_FOURCC_RGBA)) |
| && |
| ((out_fourcc == VA_FOURCC_422H) || |
| (out_fourcc == VA_FOURCC_NV12) || |
| (out_fourcc == VA_FOURCC_YV12) || |
| (out_fourcc == VA_FOURCC_YUY2) || |
| (out_fourcc == VA_FOURCC_RGBA))) { |
| return hwBlit(display, context, in_surf, in_rect, in_fourcc, |
| out_surf, out_rect, out_fourcc); |
| } |
| else { |
| return swBlit(display, context, in_surf, in_rect, in_fourcc, |
| out_surf, out_rect, out_fourcc); |
| } |
| } |
| |
| JpegDecodeStatus JpegBlitter::blit(RenderTarget &src, RenderTarget &dst) |
| { |
| if (mDecoder == NULL) |
| return JD_UNINITIALIZED; |
| JpegDecodeStatus st; |
| uint32_t src_fourcc, dst_fourcc; |
| char tmp[10]; |
| src_fourcc = pixelFormat2Fourcc(src.pixel_format); |
| dst_fourcc = pixelFormat2Fourcc(dst.pixel_format); |
| VASurfaceID src_surf = mDecoder->getSurfaceID(src); |
| if (src_surf == VA_INVALID_ID) { |
| ETRACE("%s invalid src %s target", __FUNCTION__, fourcc2str(NULL, src_fourcc)); |
| return JD_INVALID_RENDER_TARGET; |
| } |
| VASurfaceID dst_surf = mDecoder->getSurfaceID(dst); |
| if (dst_surf == VA_INVALID_ID) { |
| WTRACE("%s foreign dst target for JpegDecoder, create surface for it, not guaranteed to free it!!!", __FUNCTION__); |
| st = mDecoder->createSurfaceFromRenderTarget(dst, &dst_surf); |
| if (st != JD_SUCCESS || dst_surf == VA_INVALID_ID) { |
| ETRACE("%s failed to create surface for dst target", __FUNCTION__); |
| return JD_RESOURCE_FAILURE; |
| } |
| } |
| |
| VTRACE("%s blitting from %s to %s", __FUNCTION__, fourcc2str(tmp, src_fourcc), fourcc2str(tmp + 5, dst_fourcc)); |
| st = vaBlit(mDecoder->mDisplay, mContextId, src_surf, &src.rect, src_fourcc, |
| dst_surf, &dst.rect, dst_fourcc); |
| |
| return st; |
| } |
| |
