/* INTEL CONFIDENTIAL
* Copyright (c) 2012, 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:
*    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)
 *
 */

#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_android.h>
#include "va/va_dec_jpeg.h"
#include <utils/Timers.h>
#ifdef NDEBUG
#undef NDEBUG
#endif

#include <assert.h>
#include <utils/Vector.h>
static Mutex jdlock;
static VADisplay display = NULL;
static VAConfigID vpCfgId = VA_INVALID_ID;
static VAContextID vpCtxId = VA_INVALID_ID;

#define DUMP_DECODE 0
#define DUMP_RGBA 0
#define RGBA_DUMP_FILE_PATTERN "/sdcard/jpeg_%dx%d_from_%s.rgba"
#define DECODE_DUMP_FILE_PATTERN "/sdcard/jpeg_%dx%d.%s"

using namespace android;

struct jdva_private
{
    JpegInfo jpg_info;
    android::Vector<uint8_t> inputs;
    JpegDecoder *decoder;
    RenderTarget dec_buffer;
    uint8_t* rgba_out;
    BlitEvent blit_event;
    int tile_read_x;
    int tile_read_y;
    int tile_read_width;
    int tile_read_height;
    int scale_factor;
};

#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; \
        }

static void libva_vp_pre_init_locked()
{
    if (display == NULL && vpCfgId == VA_INVALID_ID && vpCtxId == VA_INVALID_ID) {
        Display dpy;
        int va_major_version, va_minor_version;
        VAConfigAttrib  vpp_attrib;
        VAStatus st;
        display = vaGetDisplay(&dpy);
        st = vaInitialize(display, &va_major_version, &va_minor_version);
        assert(st == VA_STATUS_SUCCESS);
        vpp_attrib.type  = VAConfigAttribRTFormat;
        vpp_attrib.value = VA_RT_FORMAT_YUV420;
        st = vaCreateConfig(display, VAProfileNone,
                                    VAEntrypointVideoProc,
                                    &vpp_attrib,
                                    1, &vpCfgId);
        assert(st == VA_STATUS_SUCCESS);
        st = vaCreateContext(display, vpCfgId, 1920, 1080, 0, NULL, 0, &vpCtxId);
        assert(st == VA_STATUS_SUCCESS);
    }
}

/* clear the global VA context
 * actually it's not needed
 * when the process terminates, the drm fd will be closed by kernel and the VA
 * context will be automatically released
 */
static void libva_vp_post_deinit_locked()
{
    // DO NOTHING
}

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;

    Mutex::Autolock autoLock(jdlock);

    if (display == NULL || vpCfgId == VA_INVALID_ID || vpCtxId == VA_INVALID_ID) {
        libva_vp_pre_init_locked();
    }

    if (jd_libva_ptr->initialized) {
        ALOGW("%s HW decode already initialized", __FUNCTION__);
        return DECODE_NOT_STARTED;
    }

    {
        if (!(jd_libva_ptr->initialized)) {
            jdva_private *priv = new jdva_private;
            memset(&priv->jpg_info, 0, sizeof(JpegInfo));
            priv->jpg_info.use_vector_input = true;
            memset(&priv->dec_buffer, 0, sizeof(RenderTarget));
            priv->rgba_out = NULL;
            priv->inputs.clear();
            priv->jpg_info.inputs = &priv->inputs;
            jd_libva_ptr->initialized = TRUE;
            jd_libva_ptr->priv = (uint32_t)priv;
            jd_libva_ptr->cap_available= 0x0;
            jd_libva_ptr->cap_available |= JPEG_CAPABILITY_DECODE;
#ifdef GFXGEN
            jd_libva_ptr->cap_available |= JPEG_CAPABILITY_UPSAMPLE | JPEG_CAPABILITY_DOWNSCALE;
#endif
            jd_libva_ptr->cap_enabled = jd_libva_ptr->cap_available;
            if (jd_libva_ptr->cap_available & JPEG_CAPABILITY_UPSAMPLE)
                priv->decoder = new JpegDecoder(display, vpCfgId, vpCtxId, true);
            else
                priv->decoder = new JpegDecoder();
            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->decoder;
            jd_libva_ptr->bitstream_buf = NULL;
            p->inputs.clear();
            delete p;
            jd_libva_ptr->initialized = FALSE;
        }
    }
    return;
}

Decode_Status jdva_fill_input(j_decompress_ptr cinfo, jd_libva_struct * jd_libva_ptr)
{
    jdva_private *p = (jdva_private*)jd_libva_ptr->priv;
    if ((*cinfo->src->fill_input_buffer)(cinfo)) {
        assert(cinfo->src->next_input_byte);
        assert(cinfo->src->bytes_in_buffer);
        p->inputs.appendArray(cinfo->src->next_input_byte, cinfo->src->bytes_in_buffer);
        jd_libva_ptr->file_size += cinfo->src->bytes_in_buffer;
        ALOGV("%s read %d bytes, file_size %u bytes, vector %u bytes", __FUNCTION__, cinfo->src->bytes_in_buffer, jd_libva_ptr->file_size, p->inputs.size());
        cinfo->src->bytes_in_buffer = 0;
    }
    else {
        return DECODE_DRIVER_FAIL;
    }
    return DECODE_SUCCESS;
}

void jdva_drain_input(j_decompress_ptr cinfo, jd_libva_struct * jd_libva_ptr)
{
    nsecs_t now = systemTime();
    jdva_private *p = (jdva_private*)jd_libva_ptr->priv;
    do {
      if ((*cinfo->src->fill_input_buffer)(cinfo)) {
          p->inputs.appendArray(cinfo->src->next_input_byte, cinfo->src->bytes_in_buffer);
          jd_libva_ptr->file_size += cinfo->src->bytes_in_buffer;
      }
      else {
          break;
      }
    } while (cinfo->src->bytes_in_buffer > 0);
    jd_libva_ptr->bitstream_buf = p->inputs.array();
    ALOGV("%s drained input %u bytes took %.2f ms", __FUNCTION__, jd_libva_ptr->file_size,
        (systemTime() - now)/1000000.0);
}

RenderTarget * create_render_target(RenderTarget* target, int width, int height, uint32_t fourcc)
{
    hw_module_t const* module = NULL;
    alloc_device_t *allocdev = NULL;
    struct gralloc_module_t *gralloc_module = NULL;
    buffer_handle_t handle;
    int stride, bpp, err;
    bpp = fourcc2LumaBitsPerPixel(fourcc);
    if (target == NULL) {
        ALOGE("%s malloc new RenderTarget failed", __FUNCTION__);
        return NULL;
    }
    ALOGV("%s created %s target %p", __FUNCTION__, fourcc2str(fourcc), target);
    target->type = RenderTarget::INTERNAL_BUF;
    target->handle = generateHandle();
    target->width = width;
    target->height = height;
    target->pixel_format = fourcc;
    target->rect.x = target->rect.y = 0;
    target->rect.width = target->width;
    target->rect.height = target->height;
    return target;
}

Decode_Status jdva_init_read_tile_scanline(j_decompress_ptr cinfo, jd_libva_struct * jd_libva_ptr, int *x, int *y, int *w, int *h)
{
    if (jd_libva_ptr->cap_enabled & JPEG_CAPABILITY_UPSAMPLE) {
        JpegDecodeStatus st;
        jdva_private * priv = (jdva_private*)jd_libva_ptr->priv;
        if (priv->scale_factor != cinfo->scale_denom) {
            ALOGV("%s scale_denom changed from %d to %d!!!!", __FUNCTION__, priv->scale_factor, cinfo->scale_denom);
        }
        priv->tile_read_x = (*x < cinfo->image_width)? *x: (cinfo->image_width - 1);
        priv->tile_read_y = (*y < cinfo->image_height)? *y: (cinfo->image_height - 1);
        priv->tile_read_width = (priv->tile_read_x + *w < cinfo->image_width)? *w: (cinfo->image_width - priv->tile_read_x);
        priv->tile_read_width /= priv->scale_factor;
        priv->tile_read_height = (priv->tile_read_y + *h < cinfo->image_height)? *h: (cinfo->image_height - priv->tile_read_y);
        priv->tile_read_height /= priv->scale_factor;
        ALOGV("%s, x=%d->%d, y=%d>%d, w=%d->%d, h=%d->%d", __FUNCTION__,
            *x, priv->tile_read_x,
            *y, priv->tile_read_y,
            *w, priv->tile_read_width,
            *h, priv->tile_read_height);
        *x = priv->tile_read_x;
        *y = priv->tile_read_y;
        *w = priv->tile_read_width;
        *h = priv->tile_read_height;
        return DECODE_SUCCESS;
    }
    else {
        // should not be here
        assert(false);
        return DECODE_DRIVER_FAIL;
    }
}
Decode_Status jdva_read_tile_scanline (j_decompress_ptr cinfo, jd_libva_struct * jd_libva_ptr, char ** scanlines, unsigned int* row_ctr)
{
    if (jd_libva_ptr->cap_enabled & JPEG_CAPABILITY_UPSAMPLE) {
        jdva_private *priv = (jdva_private*)jd_libva_ptr->priv;
        *row_ctr = 1;
        memcpy(scanlines[0], priv->rgba_out + priv->tile_read_y * cinfo->image_width * 4 + priv->tile_read_x * 4, priv->tile_read_width * 4);
        priv->tile_read_y++;
        return DECODE_SUCCESS;
    }
    else {
        // should not be here
        assert(false);
        return DECODE_DRIVER_FAIL;
    }
}

void free_render_target(RenderTarget *target)
{
    if (target == NULL)
        return;
    uint32_t fourcc = 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(fourcc), target);
}

Decode_Status jdva_blit(struct jdva_private * priv);

Decode_Status jdva_decode (j_decompress_ptr cinfo, jd_libva_struct * jd_libva_ptr)
{
    JpegDecodeStatus st;
    jdva_private * priv = (jdva_private*)jd_libva_ptr->priv;
    hw_module_t const* module = NULL;
    alloc_device_t *allocdev = NULL;
    struct gralloc_module_t *gralloc_module = NULL;
    buffer_handle_t handle;
    int err;
    char fname[256];
    FILE *fdec;
    uint8_t *data = NULL;
    uint32_t offsets[3];
    uint32_t pitches[3];
    nsecs_t t1, t2, t3;
    JpegDecoder::MapHandle maphandle;
    if (!priv)
        return DECODE_DRIVER_FAIL;

    t1 = systemTime();
    JpegInfo& jpginfo = priv->jpg_info;

    if (jd_libva_ptr->cap_enabled & JPEG_CAPABILITY_DOWNSCALE) {
        priv->scale_factor = cinfo->scale_denom;
        cinfo->min_DCT_scaled_size = DCTSIZE/priv->scale_factor;
        cinfo->output_width = cinfo->image_width/priv->scale_factor;
        cinfo->output_height = cinfo->image_height/priv->scale_factor;
    }
    else {
        priv->scale_factor = 1;
        cinfo->min_DCT_scaled_size = DCTSIZE;
        cinfo->output_width = cinfo->image_width;
        cinfo->output_height = cinfo->image_height;
    }

    jdva_drain_input(cinfo, jd_libva_ptr);
    jpginfo.need_header_only = false;
    st = priv->decoder->parse(jpginfo);
    switch (st) {
    case JD_ERROR_BITSTREAM:
        ALOGE("%s: error parsing bitstream", __FUNCTION__);
        return DECODE_PARSER_FAIL;
    case JD_SUCCESS:
        break;
    default:
        ALOGE("%s: error in driver: parse failed", __FUNCTION__);
        return DECODE_DRIVER_FAIL;
    }

    st = priv->decoder->decode(jpginfo, priv->dec_buffer);
    if (st != JD_SUCCESS) {
        ALOGE("%s: error decoding %s image", __FUNCTION__, fourcc2str(jpginfo.image_color_fourcc));
        return DECODE_DRIVER_FAIL;
    }
#if DUMP_DECODE
    sprintf(fname, DECODE_DUMP_FILE_PATTERN, jpginfo.image_width, jpginfo.image_height, fourcc2str(jpginfo.image_color_fourcc));
    fdec = fopen(fname, "wb");
    if (fdec) {
        maphandle = priv->decoder->mapData(priv->dec_buffer, (void**)&data, offsets, pitches);
        int ss_x, ss_y;
        ss_x = ss_y = -1;
        switch(jpginfo.image_color_fourcc) {
        case VA_FOURCC_411P:
            ss_x = 2;
            ss_y = 0;
            break;
        case VA_FOURCC_IMC3:
            ss_x = 1;
            ss_y = 1;
            break;
        case VA_FOURCC_422V:
            ss_x = 0;
            ss_y = 1;
            break;
        case VA_FOURCC_422H:
            ss_x = 1;
            ss_y = 0;
            break;
        case VA_FOURCC_444P:
            ss_x = 0;
            ss_y = 0;
            break;
        default:
            break;
        }
        for (int r = 0; r < jpginfo.image_height; ++r)
            fwrite(data + offsets[0] + pitches[0] * r, 1, jpginfo.image_width, fdec);
        if (ss_x >=0 && ss_y >=0) {
            for (int r = 0; r < jpginfo.image_height >> ss_y; ++r)
                fwrite(data + offsets[1] + pitches[1] * r, 1, jpginfo.image_width >> ss_x, fdec);
            for (int r = 0; r < jpginfo.image_height >> ss_y; ++r)
                fwrite(data + offsets[2] + pitches[2] * r, 1, jpginfo.image_width >> ss_x, fdec);
        }
        priv->decoder->unmapData(priv->dec_buffer, maphandle);
        fclose(fdec);
        ALOGV("%s Dumped decode surface into %s", __FUNCTION__, fname);
    }
#endif
    t2 = systemTime();

    if (!(jd_libva_ptr->cap_enabled & JPEG_CAPABILITY_UPSAMPLE)) {
        ALOGV("%s decoded %ux%u %s JPEG for %.2f ms", __FUNCTION__,
            priv->jpg_info.image_width, priv->jpg_info.image_height,
            fourcc2str(priv->jpg_info.image_color_fourcc),
            (t2-t1)/1000000.0);
        // TODO: implement
    }
    else {
        priv->rgba_out = (uint8_t*)memalign(0x1000,
            aligned_width(cinfo->output_width, SURF_TILING_Y)
            * aligned_height(cinfo->output_height, SURF_TILING_Y) * 4);
        if (priv->rgba_out == NULL) {
            ALOGE("%s failed to create RGBA buffer", __FUNCTION__);
            return DECODE_MEMORY_FAIL;
        }

        Decode_Status ret;
        {
            Mutex::Autolock autoLock(jdlock);
            ret = jdva_blit(priv);
            if (ret != DECODE_SUCCESS) {
                ALOGE("%s blit %ux%u (%dx scaling) %s failed", __FUNCTION__,
                    priv->jpg_info.image_width, priv->jpg_info.image_height,
                    priv->scale_factor,
                    fourcc2str(priv->jpg_info.image_color_fourcc));
                goto cleanup;
            }
        }
        t3 = systemTime();
        ALOGI("%s decode+blit %ux%u (%dx scaling) %s JPEG for %.2f+%.2f ms", __FUNCTION__,
            priv->jpg_info.image_width, priv->jpg_info.image_height,
            priv->scale_factor,
            fourcc2str(priv->jpg_info.image_color_fourcc),
            (t2-t1)/1000000.0, (t3-t2)/1000000.0);
    }
    return DECODE_SUCCESS;
cleanup:
    if (priv->rgba_out) {
        free(priv->rgba_out);
        priv->rgba_out = NULL;
    }
    return DECODE_DRIVER_FAIL;
}

Decode_Status jdva_read_scanlines (j_decompress_ptr cinfo, jd_libva_struct * jd_libva_ptr, char ** scanlines, unsigned int* row_ctr, unsigned int max_lines)
{
    if (jd_libva_ptr->cap_enabled & JPEG_CAPABILITY_UPSAMPLE) {
        jdva_private *priv = (jdva_private*)jd_libva_ptr->priv;
        uint32_t scanline = cinfo->output_scanline;
        for (*row_ctr = 0; *row_ctr + scanline < cinfo->output_height && *row_ctr < max_lines; ++*row_ctr) {
            memcpy(scanlines[*row_ctr], priv->rgba_out + (scanline + *row_ctr) * aligned_width(cinfo->output_width, SURF_TILING_Y) * 4, cinfo->output_width * 4);
        }
        return DECODE_SUCCESS;
    }
    else {
        // should not be here
        assert(false);
        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;
    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;
    create_render_target(&priv->dec_buffer, jd_libva_ptr->image_width,jd_libva_ptr->image_height,priv->jpg_info.image_color_fourcc);
    if (&priv->dec_buffer == NULL) {
        ALOGE("%s failed to create decode render target", __FUNCTION__);
        return DECODE_MEMORY_FAIL;
    }
    RenderTarget *targets = &priv->dec_buffer;
    st = priv->decoder->init(jd_libva_ptr->image_width, jd_libva_ptr->image_height, &targets, 1);
    if (st != JD_SUCCESS) {
        free_render_target(&priv->dec_buffer);
        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);
        if (priv->rgba_out) {
            free(priv->rgba_out);
            priv->rgba_out = NULL;
        }
    }
  /*
   * 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;
    JpegDecodeStatus st;

    Decode_Status res;
    jpginfo.need_header_only = true;
    do {
        res = jdva_fill_input(cinfo, jd_libva_ptr);
        if (res) {
            return res;
        }
        st = priv->decoder->parse(jpginfo);
    } while (st == JD_INSUFFICIENT_BYTE);
    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; /* set default colorspace for output */
    cinfo->src->bytes_in_buffer = jd_libva_ptr->file_size;
    cinfo->scale_num = cinfo->scale_denom = 1; /* set default value */
    return DECODE_SUCCESS;
}

Decode_Status jdva_blit(struct jdva_private * priv)
{
    JpegDecodeStatus st;
    nsecs_t t1, t2;

    char fname[256];
    FILE *fdec;
    t1 = systemTime();
    st = priv->decoder->blitToLinearRgba(priv->dec_buffer, priv->rgba_out,
        priv->jpg_info.image_width,
        priv->jpg_info.image_height,
        priv->blit_event, priv->scale_factor);
    if (st != JD_SUCCESS) {
        ALOGE("%s: error blitting to RGBA buffer", __FUNCTION__);
        goto cleanup;
    }
    t2 = systemTime();
#if DUMP_RGBA
    sprintf(fname, RGBA_DUMP_FILE_PATTERN, priv->jpg_info.output_width, priv->jpg_info.output_height, fourcc2str(priv->jpg_info.image_color_fourcc));
    fdec = fopen(fname, "wb");
    if (fdec) {
        fwrite(priv->rgba_out, 1, priv->jpg_info.output_width * priv->jpg_info.output_height * 4, fdec);
        fclose(fdec);
        ALOGV("%s Dumped RGBA output into %s", __FUNCTION__, fname);
    }
#endif
    ALOGV("%s blitted %ux%u RGBA from JPEG %s data for %.2f ms", __FUNCTION__,
        priv->jpg_info.image_width, priv->jpg_info.image_height,
        fourcc2str(priv->jpg_info.image_color_fourcc),
        (t2-t1)/1000000.0);
    return DECODE_SUCCESS;
cleanup:
    return DECODE_DRIVER_FAIL;
}