/* INTEL CONFIDENTIAL
* Copyright (c) 2013 Intel Corporation.  All rights reserved.
*
* 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>
*
*/

#include "JPEGBlitter.h"
#include "JPEGCommon_Gen.h"
#include "JPEGDecoder.h"
#include <utils/Timers.h>
#include <va/va.h>
#include <va/va_tpi.h>
#include "ImageDecoderTrace.h"

#include <cm/cm_rt.h>
#ifdef NDEBUG
#undef NDEBUG
#endif
#include <assert.h>

#define NV12_INTERMEDIATE 0
#define PRE_INIT_CM 1
#define BLIT_METHOD_CM 1 // 0 for VA+GpuCopy method, 1 for pure CM method
#define DUMP_RGBA 0

#define CM_KERNEL_FUNC_NAME yuv_tiled_to_rgba_linear

#define JD_CHECK(err, label) \
        if (err) { \
            ETRACE("%s::%d: failed: %d", __FUNCTION__, __LINE__, err); \
            goto label; \
        }

#define JD_CHECK_RET(err, label, retcode) \
        if (err) { \
            status = retcode; \
            ETRACE("%s::%d: failed: %d", __FUNCTION__, __LINE__, err); \
            goto label; \
        }

#define JD_CM_CHECK_RET(err, label, retcode) \
        if (err) { \
            status = retcode; \
            ETRACE("CM %s::%d: failed: 0x%08x", __FUNCTION__, __LINE__, err); \
            goto label; \
        }

const VAProcColorStandardType fourcc2ColorStandard(uint32_t fourcc)
{
    switch(fourcc) {
    case VA_FOURCC_NV12:
    case VA_FOURCC_YUY2:
    case VA_FOURCC_UYVY:
    case VA_FOURCC('4','0','0','P'):
    case VA_FOURCC_411P:
    case VA_FOURCC_411R:
    case VA_FOURCC_IMC3:
    case VA_FOURCC_422H:
    case VA_FOURCC_422V:
    case VA_FOURCC_444P:
    case VA_FOURCC_YV12:
        return VAProcColorStandardBT601;
    default:
        return VAProcColorStandardNone;
    }
}

static JpegDecodeStatus vaVppBlit(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));
    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(in_fourcc, str),
        in_rect->x, in_rect->y, in_rect->width, in_rect->height,
        fourcc2str(out_fourcc, str + 5),
        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)
{
    char fourccstr[10];
    ALOGD("%s, in %s, out %s", __FUNCTION__, fourcc2str(in_fourcc, fourccstr), fourcc2str(out_fourcc, fourccstr + 5));
    if (((in_fourcc == VA_FOURCC_422H) ||
        (in_fourcc == VA_FOURCC_444P) ||
        (in_fourcc == VA_FOURCC_IMC3) ||
        (in_fourcc == VA_FOURCC_411P) ||
        (in_fourcc == VA_FOURCC_422V) ||
        (in_fourcc == VA_FOURCC_NV12) ||
        (in_fourcc == VA_FOURCC_YUY2) ||
        (in_fourcc == VA_FOURCC_UYVY) ||
        (in_fourcc == VA_FOURCC_YV12) ||
        (in_fourcc == VA_FOURCC_BGRA) ||
        (in_fourcc == VA_FOURCC_RGBA))
        &&
        ((out_fourcc == VA_FOURCC_422H) ||
        (out_fourcc == VA_FOURCC_444P) ||
        (out_fourcc == VA_FOURCC_IMC3) ||
        (out_fourcc == VA_FOURCC_411P) ||
        (out_fourcc == VA_FOURCC_422V) ||
        (out_fourcc == VA_FOURCC_NV12) ||
        (out_fourcc == VA_FOURCC_YV12) ||
        (out_fourcc == VA_FOURCC_YUY2) ||
        (out_fourcc == VA_FOURCC_UYVY) ||
        (out_fourcc == VA_FOURCC_BGRA) ||
        (out_fourcc == VA_FOURCC_RGBA))) {
        return vaVppBlit(display, context, in_surf, in_rect, in_fourcc,
               out_surf, out_rect, out_fourcc);
    }
    else {
        return JD_INPUT_FORMAT_UNSUPPORTED;
    }
}

static CmDevice *pDev = NULL;
static CmProgram *pProgram = NULL;
static CmKernel *pKernel = NULL;
static Mutex cmLock;
void JpegBlitter::init(JpegDecoder &dec)
{
    if (!mInitialized) {
        Mutex::Autolock autoLock(mLock);
        if (!mInitialized) {
            mDecoder = &dec;
#if PRE_INIT_CM
            nsecs_t t1, t2;
            t1 = t2 = systemTime();
#if BLIT_METHOD_CM
#define ISA_FILE "/system/lib/libjpeg_cm_genx.isa"
            if (!pDev || !pProgram) {
                VTRACE("%s waiting for cm lock", __FUNCTION__);
                Mutex::Autolock autoCmLock(cmLock);
                VTRACE("%s got cm lock", __FUNCTION__);
                if (!pDev || !pProgram) {
                    ITRACE("%s CM is not initialized yet, pre-init it", __FUNCTION__);
                    UINT ver;
                    INT result;
                    FILE* pIsaFile = NULL;
                    int codeSize;
                    BYTE* pIsaBytes = NULL;
                    result = CreateCmDevice(pDev, ver, mDisplay);
                    if (result != CM_SUCCESS) {
                        ETRACE("%s CreateCmDevice failed: %d", __FUNCTION__, result);
                        VTRACE("%s release cm lock", __FUNCTION__);
                        abort();
                    }

                    pIsaFile = fopen(ISA_FILE, "rb");
                    if (pIsaFile==NULL) {
                        ETRACE("%s fopen failed", __FUNCTION__);
                        DestroyCmDevice(pDev);
                        VTRACE("%s release cm lock", __FUNCTION__);
                        abort();
                    }
                    fseek (pIsaFile, 0, SEEK_END);
                    codeSize = ftell (pIsaFile);
                    rewind(pIsaFile);
                    if (codeSize==0) {
                        ETRACE("%s codesize failed", __FUNCTION__);
                        DestroyCmDevice(pDev);
                        fclose(pIsaFile);
                        VTRACE("%s release cm lock", __FUNCTION__);
                        abort();
                    }
                    pIsaBytes = (BYTE*) malloc(codeSize);
                    if (pIsaBytes==NULL) {
                        ETRACE("%s malloc failed", __FUNCTION__);
                        DestroyCmDevice(pDev);
                        fclose(pIsaFile);
                        abort();
                    }
                    if (fread(pIsaBytes, 1, codeSize, pIsaFile) != codeSize) {
                        ETRACE("%s fread failed", __FUNCTION__);
                        free(pIsaBytes);
                        DestroyCmDevice(pDev);
                        fclose(pIsaFile);
                        VTRACE("%s release cm lock", __FUNCTION__);
                        abort();
                    }
                    fclose(pIsaFile);
                    pIsaFile = NULL;

                    result = pDev->LoadProgram(pIsaBytes, codeSize, pProgram);
                    if (result != CM_SUCCESS) {
                        ETRACE("%s LoadProgram failed: %d", __FUNCTION__, result);
                        free(pIsaBytes);
                        DestroyCmDevice(pDev);
                        VTRACE("%s release cm lock", __FUNCTION__);
                        abort();
                    }
                    free(pIsaBytes);
                    pIsaBytes = NULL;

                    t2 = systemTime();
                    VTRACE("%s CM pre-init succeded, took %.2f ms", __FUNCTION__, (t2-t1)/1000000.0);
                }
                VTRACE("%s release cm lock", __FUNCTION__);
            }
#else
            if (!pDev) {
                ITRACE("%s CM is not initialized yet, pre-init it", __FUNCTION__);
                UINT ver;
                INT result;
                result = CreateCmDevice(pDev, ver, mDisplay);
                if (result != CM_SUCCESS || !pDev) {
                    ETRACE("%s CreateCmDevice returns %d", __FUNCTION__, result);
                    abort();
                }
                t2 = systemTime();
                VTRACE("%s CM pre-init succeded, took %.2f ms", __FUNCTION__, (t2-t1)/1000000.0);
            }
#endif
#endif
            mInitialized = true;
        }
    }
}

void JpegBlitter::deinit()
{
    if (mInitialized) {
        Mutex::Autolock autoLock(mLock);
        if (mInitialized) {
#if PRE_INIT_CM
#if BLIT_METHOD_CM
            //if (pIsaBytes && pProgram && pDev) {
            //    free(pIsaBytes);
            //    pDev->DestroyProgram(pProgram);
            //    DestroyCmDevice(pDev);
            //}
#endif
#endif
            mInitialized = false;
        }
    }
}

JpegDecodeStatus JpegBlitter::blit(RenderTarget &src, RenderTarget &dst, int scale_factor)
{
    assert(mInitialized);
    if (mDecoder == NULL)
        return JD_UNINITIALIZED;
    JpegDecodeStatus st;
    uint32_t src_fourcc, dst_fourcc;
    char tmp[10];
    src_fourcc = src.pixel_format;
    dst_fourcc = dst.pixel_format;
    VASurfaceID src_surf = mDecoder->getSurfaceID(src);
    if (src_surf == VA_INVALID_ID) {
        ETRACE("%s invalid src %s target", __FUNCTION__, fourcc2str(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(src_fourcc, tmp), fourcc2str(dst_fourcc, tmp + 5));
    st = vaBlit(mDecoder->mDisplay, mContextId, src_surf, &src.rect, src_fourcc,
                dst_surf, &dst.rect, dst_fourcc);

    return st;
}

static JpegDecodeStatus blitToLinearRgba_va_gpucopy(JpegDecoder *decoder,
        VADisplay dp, VAContextID ctx, RenderTarget &src,
        uint8_t *sysmem, uint32_t width, uint32_t height, int scale_factor)
{
    CmQueue *pQueue = NULL;
    CmSurface2D *pSurf= NULL;
    CmEvent *pEvent = NULL;
    INT result;
    UINT ver;
    RenderTarget target;
    VASurfaceID surf;
    nsecs_t t1, t2, t3, t4;
    target.type = RenderTarget::INTERNAL_BUF;
    target.pixel_format = VA_FOURCC_RGBA;
    target.handle = generateHandle();
    target.width = aligned_width(width, SURF_TILING_Y);
    target.height = aligned_height(height, SURF_TILING_Y);
    target.stride = aligned_width(width, SURF_TILING_Y);
    target.rect.x = target.rect.y = 0;
    target.rect.width = width;
    target.rect.height = height;
    VASurfaceID src_surf = decoder->getSurfaceID(src);
    if (src_surf == VA_INVALID_ID) {
        ETRACE("%s invalid src %s target", __FUNCTION__, fourcc2str(src.pixel_format));
        return JD_INVALID_RENDER_TARGET;
    }
    JpegDecodeStatus st = decoder->createSurfaceFromRenderTarget(target, &surf);
    if (st != JD_SUCCESS || surf == VA_INVALID_ID) {
        ETRACE("%s failed to create surface for RGBA linear target", __FUNCTION__);
        return JD_RESOURCE_FAILURE;
    }
    st = vaBlit(dp, ctx, src_surf, &src.rect, src.pixel_format,
                surf, &target.rect, target.pixel_format);
    if (st != JD_SUCCESS) {
        ETRACE("%s failed to VA blit to RGBA", __FUNCTION__);
        return JD_RESOURCE_FAILURE;
    }

#if DUMP_RGBA
    uint8_t *data;
    uint32_t offsets[3];
    uint32_t pitches[3];
    JpegDecoder::MapHandle hnd = decoder->mapData(target, (void**)&data, offsets, pitches);
    assert(hnd);
    char fname[128];
    sprintf(fname, "/sdcard/%dx%d.rgba", target.stride, target.height);
    FILE *fdump = fopen(fname, "wb");
    assert(fdump);
    fwrite(data, 4, target.height * target.stride, fdump);
    fclose(fdump);
    decoder->unmapData(target, hnd);
#endif

    if (st) {
        ETRACE("%s: failed to blit to RGBA linear", __FUNCTION__);
        decoder->destroySurface(target);
        return JD_BLIT_FAILURE;
    }

    t1 = systemTime();
#if PRE_INIT_CM
#else
    result = CreateCmDevice(pDev, ver, dp);
    if (result != CM_SUCCESS || !pDev) {
        ETRACE("%s CmCreateSurface2D returns %d", __FUNCTION__, result);
        return JD_BLIT_FAILURE;
    }
#endif
    result = pDev->CreateSurface2D(surf, pSurf);
    if (result != CM_SUCCESS || !pSurf) {
        ETRACE("%s CmCreateSurface2D returns %d", __FUNCTION__, result);
        DestroyCmDevice(pDev );
        return JD_BLIT_FAILURE;
    }
    result = pDev->CreateQueue( pQueue);
    if (result != CM_SUCCESS || !pQueue) {
        ETRACE("%s CmCreateQueue returns %d", __FUNCTION__, result);
        pDev->DestroySurface(pSurf);
        DestroyCmDevice( pDev );
        return JD_BLIT_FAILURE;
    }
    t2 = systemTime();
    result = pQueue->EnqueueCopyGPUToCPU(pSurf, sysmem, pEvent);
    if (result != CM_SUCCESS) {
        ETRACE("%s CmEnqueueCopyGPUToCPU returns %d", __FUNCTION__, result);
        pDev->DestroySurface(pSurf);
        DestroyCmDevice( pDev );
        return JD_BLIT_FAILURE;
    }
    t3 = systemTime();
    result = pDev->DestroySurface(pSurf);
    if (result != CM_SUCCESS) {
        WTRACE("%s CmDestroySurface returns %d", __FUNCTION__, result);
    }
#if PRE_INIT_CM
    assert(pDev);
#else
    result = DestroyCmDevice(pDev);
    if (result != CM_SUCCESS) {
        WTRACE("%s DestroyCmDevice failed %d", __FUNCTION__, result);
    }
#endif
    t4 = systemTime();
    st = decoder->destroySurface(target);
    if (st) {
        WTRACE("%s: failed to destroy VA surface", __FUNCTION__);
    }
    ITRACE("%s: cm GpuCopy took %.2f+%.2f+%.2f ms", __FUNCTION__,
        (t2 - t1)/1000000.0,
        (t3 - t2)/1000000.0,
        (t4 - t3)/1000000.0);
    return st;
}

JpegDecodeStatus JpegBlitter::getRgbaTile(RenderTarget &src,
                                     uint8_t *sysmem,
                                     int left, int top, int width, int height, int scale_factor)
{
#define ISA_FILE "/system/lib/libjpeg_cm_genx.isa"
#define CM_GPU_TASK_WIDTH 8
#define CM_GPU_TASK_HEIGHT 8
    VASurfaceID srcVaId;

    srcVaId = mDecoder->getSurfaceID(src);
    JpegDecodeStatus status = JD_SUCCESS;
    uint32_t aligned_w = width;//aligned_width(width, SURF_TILING_Y);
    uint32_t aligned_h = height;//aligned_height(height, SURF_TILING_Y);

    CmThreadSpace *pThreadSpace = NULL;
    CmTask *pKernelArray = NULL;
    CmQueue *pQueue = NULL;
    CmSurface2D *pInSurf= NULL;
    SurfaceIndex *pInSurfId = NULL;
    CmBufferUP *pOutBuf = NULL;
    SurfaceIndex *pOutBufId = NULL;
    CmEvent *pEvent = NULL;
    UINT ver;
    int threadswidth, threadsheight;
    INT result;
    DWORD dwTimeOutMs = -1;
    uint32_t cm_in_fourcc;
    threadswidth = aligned_w/CM_GPU_TASK_WIDTH;
    threadsheight = aligned_h/CM_GPU_TASK_HEIGHT;
    nsecs_t t1, t2, t3, t4, t5, t6, t7;
    VTRACE("%s before holding cm lock", __FUNCTION__);
    Mutex::Autolock autoLock(cmLock);
    VTRACE("%s got cm lock", __FUNCTION__);
    t1 = t2 = t3 = t4 = t5 = t6 = t7 = systemTime();

#if PRE_INIT_CM
    assert(pDev && pProgram);
#else
    FILE* pIsaFile = NULL;
    int codeSize;
    BYTE* pIsaBytes = NULL;
    result = CreateCmDevice(pDev, ver, dp);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);

    pIsaFile = fopen(ISA_FILE, "rb");
    if (pIsaFile==NULL) {
        ETRACE("%s fopen failed", __FUNCTION__);
        DestroyCmDevice(pDev);
        VTRACE("%s release cm lock", __FUNCTION__);
        return JD_BLIT_FAILURE;
    }
    fseek (pIsaFile, 0, SEEK_END);
    codeSize = ftell (pIsaFile);
    rewind(pIsaFile);
    if (codeSize==0) {
        ETRACE("%s codesize failed", __FUNCTION__);
        DestroyCmDevice(pDev);
        fclose(pIsaFile);
        VTRACE("%s release cm lock", __FUNCTION__);
        return JD_BLIT_FAILURE;
    }
    pIsaBytes = (BYTE*) malloc(codeSize);
    if (pIsaBytes==NULL) {
        ETRACE("%s malloc failed", __FUNCTION__);
        DestroyCmDevice(pDev);
        fclose(pIsaFile);
        VTRACE("%s release cm lock", __FUNCTION__);
        return JD_BLIT_FAILURE;
    }
    if (fread(pIsaBytes, 1, codeSize, pIsaFile) != codeSize) {
        ETRACE("%s fread failed", __FUNCTION__);
        free(pIsaFile);
        fclose(pIsaFile);
        DestroyCmDevice(pDev);
        VTRACE("%s release cm lock", __FUNCTION__);
        return JD_BLIT_FAILURE;
    }
    fclose(pIsaFile);
    pIsaFile = NULL;

    result = pDev->LoadProgram(pIsaBytes, codeSize, pProgram);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    free(pIsaBytes);
    pIsaBytes = NULL;
    VTRACE("%s cm init succeded", __FUNCTION__);
#endif

    t2 = systemTime();
    // create thread space
    result = pDev->CreateKernel(pProgram, CM_KERNEL_FUNCTION(yuv_tiled_to_rgba_tile), pKernel);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);

    result = pDev->CreateSurface2D(srcVaId, pInSurf);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pInSurf->GetIndex(pInSurfId);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    // create bufferUp from dst ptr
    result = pDev->CreateBufferUP(aligned_w * aligned_h * 4, sysmem, pOutBuf);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pOutBuf->GetIndex(pOutBufId);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);

    result = pDev->CreateQueue( pQueue);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pDev->CreateThreadSpace(threadswidth, threadsheight, pThreadSpace);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pKernel->SetThreadCount( threadswidth* threadsheight );
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    // enqueue csc
    pKernel->SetKernelArg(0,sizeof(SurfaceIndex),pInSurfId);
    pKernel->SetKernelArg(1,sizeof(SurfaceIndex),pOutBufId);
    pKernel->SetKernelArg(2,sizeof(int),&left);
    pKernel->SetKernelArg(3,sizeof(int),&top);
    pKernel->SetKernelArg(4,sizeof(int),&aligned_w);
    pKernel->SetKernelArg(5,sizeof(int),&aligned_h);

    cm_in_fourcc = src.pixel_format;

    pKernel->SetKernelArg(6,sizeof(uint32_t),&cm_in_fourcc);
    result = pDev->CreateTask(pKernelArray);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pKernelArray->AddKernel (pKernel);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pQueue->Enqueue(pKernelArray, pEvent, pThreadSpace);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    // wait kernel finish
    t3 = systemTime();
    result = pEvent->WaitForTaskFinished(dwTimeOutMs);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    //event = NULL;//(BlitEvent)pEvent;
    t4 = systemTime();

cleanup:
    // destroy thread space/house cleaning
    if (pOutBuf) pDev->DestroyBufferUP(pOutBuf);
    t5 = systemTime();
    if (pInSurf) pDev->DestroySurface(pInSurf);
    t6 = systemTime();
    if (pKernelArray) pDev->DestroyTask(pKernelArray);
    if (pThreadSpace) pDev->DestroyThreadSpace(pThreadSpace);
    if (pKernel) pDev->DestroyKernel(pKernel);
#if PRE_INIT_CM
#else
    if (pProgram) pDev->DestroyProgram(pProgram);
    if (pDev) DestroyCmDevice(pDev);
#endif
    t7 = systemTime();

    VTRACE("%s blit with CM %ux%u took %.2f + %.2f + %.2f + %.2f + %.2f + %.2f ms", __FUNCTION__,
        width, height,
        (t2 - t1)/1000000.0,
        (t3 - t2)/1000000.0,
        (t4 - t3)/1000000.0,
        (t5 - t4)/1000000.0,
        (t6 - t5)/1000000.0,
        (t7 - t6)/1000000.0);
    VTRACE("%s release cm lock", __FUNCTION__);
    return status;
}


static JpegDecodeStatus blitToLinearRgba_cm(JpegDecoder *decoder,
        VADisplay dp, VAContextID ctx, RenderTarget &src, uint8_t *sysmem, uint32_t width, uint32_t height,
        BlitEvent &event, int scale_factor)
{
#define ISA_FILE "/system/lib/libjpeg_cm_genx.isa"
#define CM_GPU_TASK_WIDTH 32
#define CM_GPU_TASK_HEIGHT 8
    VASurfaceID srcVaId;
    Mutex::Autolock autoLock(cmLock);

    srcVaId = decoder->getSurfaceID(src);
    JpegDecodeStatus status = JD_SUCCESS;
    uint32_t aligned_in_w = aligned_width(width, SURF_TILING_Y);
    uint32_t aligned_in_h = aligned_height(height, SURF_TILING_Y);
    uint32_t aligned_out_w = aligned_width(width/scale_factor, SURF_TILING_Y);
    uint32_t aligned_out_h = aligned_height(height/scale_factor, SURF_TILING_Y);

#if NV12_INTERMEDIATE
    RenderTarget nv12_target;
    VASurfaceID nv12_surf_id;
    VASurfaceID nv12_surf;
    nv12_target.type = RenderTarget::INTERNAL_BUF;
    nv12_target.pixel_format = VA_FOURCC_NV12;
    nv12_target.handle = generateHandle();
    nv12_target.width = aligned_in_w;
    nv12_target.height = aligned_in_h;
    nv12_target.stride = aligned_in_w;
    nv12_target.rect.x = nv12_target.rect.y = 0;
    nv12_target.rect.width = width;
    nv12_target.rect.height = height;
    status = decoder->createSurfaceFromRenderTarget(nv12_target, &nv12_surf_id);
    if (status != JD_SUCCESS || nv12_surf_id == VA_INVALID_ID) {
        ETRACE("%s failed to create surface for NV12 target", __FUNCTION__);
        return JD_RESOURCE_FAILURE;
    }
    vaBlit(dp, ctx, srcVaId, &src.rect, src.pixel_format,
        nv12_surf_id, &nv12_target.rect, VA_FOURCC_NV12);
    srcVaId = nv12_surf_id;
#endif

    CmThreadSpace *pThreadSpace = NULL;
    CmTask *pKernelArray = NULL;
    CmQueue *pQueue = NULL;
    CmSurface2D *pInSurf= NULL;
    SurfaceIndex *pInSurfId = NULL;
    CmBufferUP *pOutBuf = NULL;
    SurfaceIndex *pOutBufId = NULL;
    CmEvent *pEvent = NULL;
    UINT ver;
    int threadswidth, threadsheight;
    INT result;
    DWORD dwTimeOutMs = -1;
    uint32_t cm_in_fourcc;
    threadswidth = aligned_in_w/CM_GPU_TASK_WIDTH;
    threadsheight = aligned_in_h/CM_GPU_TASK_HEIGHT;
    nsecs_t t1, t2, t3, t4, t5, t6, t7, t8, t9, t10;
    VTRACE("%s before holding cm lock", __FUNCTION__);
    VTRACE("%s got cm lock", __FUNCTION__);
    t1 = t2 = t3 = t4 = t5 = t6 = t7 = t8 = t9 = t10 = systemTime();

#if PRE_INIT_CM
    assert(pDev && pProgram);
#else
    FILE* pIsaFile = NULL;
    int codeSize;
    BYTE* pIsaBytes = NULL;
    result = CreateCmDevice(pDev, ver, dp);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);

    pIsaFile = fopen(ISA_FILE, "rb");
    if (pIsaFile==NULL) {
        ETRACE("%s fopen failed", __FUNCTION__);
        DestroyCmDevice(pDev);
        VTRACE("%s release cm lock", __FUNCTION__);
        return JD_BLIT_FAILURE;
    }
    fseek (pIsaFile, 0, SEEK_END);
    codeSize = ftell (pIsaFile);
    rewind(pIsaFile);
    if (codeSize==0) {
        ETRACE("%s codesize failed", __FUNCTION__);
        DestroyCmDevice(pDev);
        fclose(pIsaFile);
        VTRACE("%s release cm lock", __FUNCTION__);
        return JD_BLIT_FAILURE;
    }
    pIsaBytes = (BYTE*) malloc(codeSize);
    if (pIsaBytes==NULL) {
        ETRACE("%s malloc failed", __FUNCTION__);
        DestroyCmDevice(pDev);
        fclose(pIsaFile);
        VTRACE("%s release cm lock", __FUNCTION__);
        return JD_BLIT_FAILURE;
    }
    if (fread(pIsaBytes, 1, codeSize, pIsaFile) != codeSize) {
        ETRACE("%s fread failed", __FUNCTION__);
        free(pIsaFile);
        fclose(pIsaFile);
        DestroyCmDevice(pDev);
        VTRACE("%s release cm lock", __FUNCTION__);
        return JD_BLIT_FAILURE;
    }
    fclose(pIsaFile);
    pIsaFile = NULL;

    result = pDev->LoadProgram(pIsaBytes, codeSize, pProgram);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    free(pIsaBytes);
    pIsaBytes = NULL;
    VTRACE("%s cm init succeded", __FUNCTION__);
#endif

    // create thread space
    result = pDev->CreateKernel(pProgram, CM_KERNEL_FUNCTION(CM_KERNEL_FUNC_NAME), pKernel);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);

    VTRACE("Creating CmSurface from VASurface %d", srcVaId);
    t2 = systemTime();
    result = pDev->CreateSurface2D(srcVaId, pInSurf);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);

    result = pInSurf->GetIndex(pInSurfId);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    // create bufferUp from dst ptr
    VTRACE("CmSurfaceID got");
    t3 = systemTime();
    result = pDev->CreateBufferUP(aligned_out_w * aligned_out_h * 4, sysmem, pOutBuf);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pOutBuf->GetIndex(pOutBufId);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    t4 = systemTime();
    result = pDev->CreateQueue( pQueue);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pDev->CreateThreadSpace(threadswidth, threadsheight, pThreadSpace);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pKernel->SetThreadCount( threadswidth* threadsheight );
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    // enqueue csc
    pKernel->SetKernelArg(0,sizeof(SurfaceIndex),pInSurfId);
    pKernel->SetKernelArg(1,sizeof(SurfaceIndex),pOutBufId);
    pKernel->SetKernelArg(2,sizeof(int),&aligned_out_w);
#if NV12_INTERMEDIATE
    cm_in_fourcc = VA_FOURCC_NV12;
#else
    cm_in_fourcc = src.pixel_format;
#endif
    pKernel->SetKernelArg(3,sizeof(uint32_t),&cm_in_fourcc);
    pKernel->SetKernelArg(4,sizeof(int), &scale_factor);
    result = pDev->CreateTask(pKernelArray);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pKernelArray->AddKernel (pKernel);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pQueue->Enqueue(pKernelArray, pEvent, pThreadSpace);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    // wait kernel finish
    t5 = systemTime();
    result = pEvent->WaitForTaskFinished(dwTimeOutMs);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    event = NULL;//(BlitEvent)pEvent;
    t6 = systemTime();

cleanup:
#if NV12_INTERMEDIATE
    if (nv12_surf_id != VA_INVALID_ID) decoder->destroySurface(nv12_target);
#endif
    // destroy thread space/house cleaning
    if (pOutBuf) pDev->DestroyBufferUP(pOutBuf);
    t7 = systemTime();
    if (pInSurf) pDev->DestroySurface(pInSurf);
    t8 = systemTime();
    if (pKernelArray) pDev->DestroyTask(pKernelArray);
    if (pThreadSpace) pDev->DestroyThreadSpace(pThreadSpace);
    if (pKernel) pDev->DestroyKernel(pKernel);
#if PRE_INIT_CM
#else
    if (pProgram) pDev->DestroyProgram(pProgram);
    if (pDev) DestroyCmDevice(pDev);
#endif
    t9 = systemTime();

    VTRACE("%s blit with CM %ux%u(%dx) took %.2f + %.2f + %.2f + %.2f + %.2f + %.2f + %.2f + %.2f ms", __FUNCTION__,
        width, height, scale_factor,
        (t2 - t1)/1000000.0,
        (t3 - t2)/1000000.0,
        (t4 - t3)/1000000.0,
        (t5 - t4)/1000000.0,
        (t6 - t5)/1000000.0,
        (t7 - t6)/1000000.0,
        (t8 - t7)/1000000.0,
        (t9 - t8)/1000000.0);
    VTRACE("%s release cm lock", __FUNCTION__);
    return status;
}

JpegDecodeStatus JpegBlitter::blitToLinearRgba(RenderTarget &src,
                                               uint8_t *sysmem,
                                               uint32_t width, uint32_t height,
                                               BlitEvent &event, int scale_factor)
{
    Mutex::Autolock autoLock(mDecoder->mLock);
#if BLIT_METHOD_CM
    return blitToLinearRgba_cm(mDecoder, mDecoder->mDisplay, mContextId, src, sysmem, width, height, event, scale_factor);
#else
    return blitToLinearRgba_va_gpucopy(mDecoder, mDecoder->mDisplay, mContextId, src, sysmem, width, height, scale_factor);
#endif
}

JpegDecodeStatus JpegBlitter::blitToCameraSurfaces(RenderTarget &src,
                                                   buffer_handle_t dst_nv12,
                                                   buffer_handle_t dst_yuy2,
                                                   uint8_t *dst_nv21,
                                                   uint8_t *dst_yv12,
                                                   uint32_t width, uint32_t height,
                                                   BlitEvent &event)
{
#define CM_GPU_TASK_WIDTH 32
#define CM_GPU_TASK_HEIGHT 8
    VASurfaceID srcVaId, nv12_surf_id, yuy2_surf_id;
    srcVaId = nv12_surf_id = yuy2_surf_id = VA_INVALID_ID;
    srcVaId = mDecoder->getSurfaceID(src);
    JpegDecodeStatus status = JD_SUCCESS;
    uint32_t aligned_w = aligned_width(width, SURF_TILING_Y);
    uint32_t aligned_h = aligned_height(height, SURF_TILING_Y);

    CmThreadSpace *pThreadSpace = NULL;
    CmTask *pKernelArray = NULL;
    CmQueue *pQueue = NULL;
    CmSurface2D *pInSurf= NULL;
    SurfaceIndex *pInSurfId = NULL;
    CmSurface2D *pOutNV12Surf= NULL;
    SurfaceIndex *pOutNV12SurfId = NULL;
    CmSurface2D *pOutYUY2Surf= NULL;
    SurfaceIndex *pOutYUY2SurfId = NULL;
    CmBufferUP *pOutNV21Surf = NULL;
    SurfaceIndex *pOutNV21SurfId = NULL;
    CmBufferUP *pOutYV12Surf = NULL;
    SurfaceIndex *pOutYV12SurfId = NULL;
    uint8_t do_nv21, do_yv12;
    do_nv21 = do_yv12 = 0;
    CmEvent *pEvent = NULL;
    RenderTarget nv12_target, yuy2_target;
    UINT ver;
    int threadswidth, threadsheight;
    INT result;
    DWORD dwTimeOutMs = -1;
    uint32_t cm_in_fourcc;
    threadswidth = aligned_w/CM_GPU_TASK_WIDTH;
    threadsheight = aligned_h/CM_GPU_TASK_HEIGHT;
    nsecs_t t1, t2, t3, t4, t5;
    t1 = t2 = t3 = t4 = t5 = systemTime();
    VTRACE("%s before holding cm lock", __FUNCTION__);
    Mutex::Autolock autoLock(cmLock);

#if PRE_INIT_CM
    assert(pDev && pProgram);
#else
    result = CreateCmDevice(pDev, ver, dp);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);

    pIsaFile = fopen(ISA_FILE, "rb");
    if (pIsaFile==NULL) {
        ETRACE("%s fopen failed", __FUNCTION__);
        DestroyCmDevice(pDev);
        return JD_BLIT_FAILURE;
    }
    fseek (pIsaFile, 0, SEEK_END);
    codeSize = ftell (pIsaFile);
    rewind(pIsaFile);
    if (codeSize==0) {
        ETRACE("%s codesize failed", __FUNCTION__);
        DestroyCmDevice(pDev);
        fclose(pIsaFile);
        return JD_BLIT_FAILURE;
    }
    pIsaBytes = (BYTE*) malloc(codeSize);
    if (pIsaBytes==NULL) {
        ETRACE("%s malloc failed", __FUNCTION__);
        DestroyCmDevice(pDev);
        fclose(pIsaFile);
        return JD_BLIT_FAILURE;
    }
    if (fread(pIsaBytes, 1, codeSize, pIsaFile) != codeSize) {
        ETRACE("%s fread failed", __FUNCTION__);
        free(pIsaFile);
        fclose(pIsaFile);
        DestroyCmDevice(pDev);
        return JD_BLIT_FAILURE;
    }
    fclose(pIsaFile);
    pIsaFile = NULL;

    result = pDev->LoadProgram(pIsaBytes, codeSize, pProgram);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    free(pIsaBytes);
    pIsaBytes = NULL;
    VTRACE("%s cm init succeded", __FUNCTION__);
#endif

    t2 = systemTime();
    // create thread space
    result = pDev->CreateKernel(pProgram, CM_KERNEL_FUNCTION(yuv422h_tiled_to_camera_surfaces), pKernel);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);

    // src surface
    result = pDev->CreateSurface2D(srcVaId, pInSurf);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pInSurf->GetIndex(pInSurfId);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    // dst nv12 + yuy2
    nv12_target.handle = (int)dst_nv12;
    nv12_target.type = RenderTarget::ANDROID_GRALLOC;
    nv12_target.height = aligned_height(height, SURF_TILING_Y);
    nv12_target.width = aligned_width(width, SURF_TILING_Y);
    nv12_target.pixel_format = VA_FOURCC_NV12;
    nv12_target.stride = nv12_target.width;
    nv12_target.rect.x = nv12_target.rect.y = 0;
    nv12_target.rect.width = nv12_target.width;
    nv12_target.rect.height = nv12_target.height;
    mDecoder->createSurfaceFromRenderTarget(nv12_target, &nv12_surf_id);
    yuy2_target.handle = (int)dst_yuy2;
    yuy2_target.type = RenderTarget::ANDROID_GRALLOC;
    yuy2_target.height = aligned_height(height, SURF_TILING_Y);
    yuy2_target.width = aligned_width(width, SURF_TILING_Y);
    yuy2_target.pixel_format = VA_FOURCC_YUY2;
    yuy2_target.stride = yuy2_target.width * 2;
    yuy2_target.rect.x = yuy2_target.rect.y = 0;
    yuy2_target.rect.width = yuy2_target.width;
    yuy2_target.rect.height = yuy2_target.height;
    mDecoder->createSurfaceFromRenderTarget(yuy2_target, &yuy2_surf_id);
    result = pDev->CreateSurface2D(nv12_surf_id, pOutNV12Surf);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pOutNV12Surf->GetIndex(pOutNV12SurfId);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pDev->CreateSurface2D(yuy2_surf_id, pOutYUY2Surf);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pOutYUY2Surf->GetIndex(pOutYUY2SurfId);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    // dst nv21
    if (dst_nv21) {
        result = pDev->CreateBufferUP(aligned_w * aligned_h * 3 / 2, dst_nv21, pOutNV21Surf);
        JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
        result = pOutNV21Surf->GetIndex(pOutNV21SurfId);
        JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
        do_nv21 = 1;
    }
    else {
        pOutNV21SurfId = pInSurfId;
        do_nv21 = 0;
    }
    // dst yv12
    if (dst_yv12) {
        result = pDev->CreateBufferUP(aligned_w * aligned_h * 3 / 2, dst_yv12, pOutYV12Surf);
        JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
        result = pOutYV12Surf->GetIndex(pOutYV12SurfId);
        JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
        do_yv12 = 1;
    }
    else {
        pOutYV12SurfId = pInSurfId;
        do_yv12 = 0;
    }
    result = pDev->CreateQueue( pQueue);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pDev->CreateThreadSpace(threadswidth, threadsheight, pThreadSpace);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pKernel->SetThreadCount( threadswidth* threadsheight );
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    // enqueue csc
    pKernel->SetKernelArg(0,sizeof(SurfaceIndex),pInSurfId);
    pKernel->SetKernelArg(1,sizeof(SurfaceIndex),pOutNV12SurfId);
    pKernel->SetKernelArg(2,sizeof(SurfaceIndex),pOutYUY2SurfId);
    pKernel->SetKernelArg(3,sizeof(SurfaceIndex),pOutNV21SurfId);
    pKernel->SetKernelArg(4,sizeof(SurfaceIndex),pOutYV12SurfId);
    pKernel->SetKernelArg(5,sizeof(int),&aligned_h);
    pKernel->SetKernelArg(6,sizeof(int),&aligned_w);
    pKernel->SetKernelArg(7,sizeof(uint8_t),&do_nv21);
    pKernel->SetKernelArg(8,sizeof(uint8_t),&do_yv12);
    result = pDev->CreateTask(pKernelArray);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pKernelArray->AddKernel (pKernel);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    result = pQueue->Enqueue(pKernelArray, pEvent, pThreadSpace);
    JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    // wait kernel finish
    t3 = systemTime();
    //result = pEvent->WaitForTaskFinished(dwTimeOutMs);
    //JD_CM_CHECK_RET(result, cleanup, JD_BLIT_FAILURE);
    event = (BlitEvent)pEvent;
    t4 = systemTime();

cleanup:
    // destroy thread space/house cleaning
    if (pOutYV12Surf) pDev->DestroyBufferUP(pOutYV12Surf);
    if (pOutNV21Surf) pDev->DestroyBufferUP(pOutNV21Surf);
    if (pOutYUY2Surf) pDev->DestroySurface(pOutYUY2Surf);
    if (pOutNV12Surf) pDev->DestroySurface(pOutNV12Surf);
    if (pInSurf) pDev->DestroySurface(pInSurf);
    if (nv12_surf_id != VA_INVALID_ID) mDecoder->destroySurface(nv12_target);
    if (yuy2_surf_id != VA_INVALID_ID) mDecoder->destroySurface(yuy2_target);
    if (pKernelArray) pDev->DestroyTask(pKernelArray);
    if (pThreadSpace) pDev->DestroyThreadSpace(pThreadSpace);
    if (pKernel) pDev->DestroyKernel(pKernel);
#if PRE_INIT_CM
#else
    if (pIsaBytes) free(pIsaBytes);
    if (pIsaFile) fclose(pIsaFile);
    if (pProgram) pDev->DestroyProgram(pProgram);
    if (pDev) DestroyCmDevice(pDev);
#endif
    t5 = systemTime();
    VTRACE("%s blit with CM took %.2f + %.2f + %.2f + %.2f ms", __FUNCTION__,
        (t2 - t1)/1000000.0,
        (t3 - t2)/1000000.0,
        (t4 - t3)/1000000.0,
        (t5 - t4)/1000000.0);
    return status;
}

void JpegBlitter::syncBlit(BlitEvent &event)
{
    nsecs_t now = systemTime();
    DWORD dwTimeOutMs = -1;
    CmEvent *pEvent = (CmEvent*)event;
    UINT64 executionTime;
    if (event == NULL)
        return;
    INT result = pEvent->WaitForTaskFinished(dwTimeOutMs);
    if (result != CM_SUCCESS) {
        ETRACE("%s: Failed to sync blit event", __FUNCTION__);
    }
    else {
        event = NULL;
        VTRACE("%s: syncBlit took %.2f ms", __FUNCTION__, (systemTime()-now)/1000000.0);
    }
}