/*
 * Copyright (c) 2011 Intel Corporation. All Rights Reserved.
 * Copyright (c) Imagination Technologies Limited, UK
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors:
 *    Elaine Wang <elaine.wang@intel.com>
 *    Zeng Li <zeng.li@intel.com>
 *
 */


#include "psb_drv_video.h"

//#include "pnw_H263ES.h"
#include "pnw_hostcode.h"
#include "hwdefs/topazSC_defs.h"
#include "psb_def.h"
#include "psb_drv_debug.h"
#include "psb_cmdbuf.h"
#include <stdio.h>
#include "psb_output.h"
#include <wsbm/wsbm_manager.h>
#include "pnw_hostheader.h"

#define ALIGN_TO(value, align) ((value + align - 1) & ~(align - 1))
#define PAGE_ALIGN(value) ALIGN_TO(value, 4096)

/*static VAStatus pnw_DetectFrameSkip(context_ENC_p ctx);*/

static void pnw__update_rcdata(
    context_ENC_p psContext,
    PIC_PARAMS *psPicParams,
    IMG_RC_PARAMS *psRCParams);

IMG_UINT32 MVEARegBase[4] = {0x13000, 0x23000, 0x33000, 0x43000}; /* From TopazSC TRM */

/* H264 Zero bias */
//#define ZERO_BIAS

static const IMG_INT8 H263_QPLAMBDA_MAP[31] = {
    0, 0, 1, 1, 2,
    2, 3, 3, 4, 4,
    4, 5, 5, 5, 6,
    6, 6, 7, 7, 7,
    7, 8, 8, 8, 8,
    9, 9, 9, 9, 10, 10
};

// New MP4 Lambda table
static const  IMG_INT8 MPEG4_QPLAMBDA_MAP[31] = {
    0,  0,  1,  2,  3,
    3,  4,  4,  5,  5,
    6,  6,  7,  7,  8,
    8,  9,  9,  10, 10,
    11, 11, 11, 11, 12,
    12, 12, 12, 13, 13, 13
};

// new H.264 Lambda
static const IMG_INT8 H264_QPLAMBDA_MAP[40] = {
    2, 2, 2, 2, 3, 3, 4, 4,
    4, 5, 5, 5, 5, 5, 6, 6,
    6, 7, 7, 7, 8, 8, 9, 11,
    13, 14, 15, 17, 20, 23, 27, 31,
    36, 41, 51, 62, 74, 79, 85, 91
};

static const IMG_INT16 H264_InterIntraBias[27] =
{
    20,20,20,20,20,20,50,
    20,20,20,20,20,20,
    20,25,30,45,80,140,
    200,300,400,500,550,
    600,650,700
};

/*static IMG_INT16 H264InterBias(IMG_INT8 i8QP)
{
    if (i8QP >= 44)
        return 600;
    else if (i8QP <= 35)
        return 20;

    return (70 * (i8QP - 35));
}*/
static IMG_INT16 H264InterBias(IMG_INT8 i8QP)
{
    if (i8QP > 1)
         i8QP = 1;
    else if (i8QP > 51)
        return 51;

    return H264_InterIntraBias[(i8QP + 1)>>1];
}


static IMG_INT16 H264SkipBias(IMG_INT8 i8QP, TH_SKIP_SCALE eSkipScale)
{
    IMG_INT16 i16Lambda;

    // pull out lambda from the table
    i16Lambda = i8QP - 12;
    i16Lambda = (i16Lambda < 0) ? 0 : i16Lambda;
    i16Lambda = H264_QPLAMBDA_MAP[i16Lambda];

    // now do the multiplication to avoid using the actual multiply we will do this with shifts and adds/subtractions it is probable that the compiler would
    // pick up the multiply and optimise appropriatly but we aren't sure
    // * 12 = 8 + *4
    switch (eSkipScale) {
    default:
    case TH_SKIP_0:
        i16Lambda = 0;
        break;
    case TH_SKIP_24:                /* iLambda * 24 == iLambda * 2 * 12   */
        i16Lambda <<= 1;
        /* break deliberatly not used as we want to apply skip12 to skip24*/
    case TH_SKIP_12: /*    iLambda * 12 == iLambda * (8 + 4) == (iLambda * 8) + (iLambda * 4)  == (iLambda << 3) + (iLambda <<2)   */
        i16Lambda = (i16Lambda << 3) + (i16Lambda << 2);
    }
    return i16Lambda;
}

static IMG_INT16 H264Intra4x4Bias(IMG_INT8 i8QP)
{
    IMG_INT16 i16Lambda;

    // pull out lambda from the table
    i16Lambda = i8QP - 12;
    i16Lambda = (i16Lambda < 0) ? 0 : i16Lambda;
    i16Lambda = H264_QPLAMBDA_MAP[i16Lambda];

    i16Lambda *= 120;
    return i16Lambda;
}

static int CalculateDCScaler(IMG_INT iQP, IMG_BOOL bChroma)
{
    IMG_INT     iDCScaler;
    if (!bChroma) {
        if (iQP > 0 && iQP < 5) {
            iDCScaler = 8;
        } else if (iQP > 4 &&     iQP     < 9) {
            iDCScaler = 2 * iQP;
        } else if (iQP > 8 &&     iQP     < 25) {
            iDCScaler = iQP + 8;
        } else {
            iDCScaler = 2 * iQP - 16;
        }
    } else {
        if (iQP > 0 && iQP < 5) {
            iDCScaler = 8;
        } else if (iQP > 4 &&     iQP     < 25) {
            iDCScaler = (iQP + 13) / 2;
        } else {
            iDCScaler = iQP - 6;
        }
    }
    return iDCScaler;
}

static void LoadMPEG4Bias(
    pnw_cmdbuf_p cmdbuf,
    IMG_INT32 i32Core,
    IMG_UINT8 __maybe_unused ui8THSkip
)
{
    IMG_INT16 n;
    IMG_INT16 iX;
    IMG_UINT32 ui32RegVal;
    IMG_UINT8                       uiDCScaleL, uiDCScaleC, uiLambda;
    IMG_INT32 uIPESkipVecBias, iInterMBBias, uSPESkipVecBias, iIntra16Bias;
    IMG_UINT32 count = 0, cmd_word = 0;
    uint32_t *pCount;

    cmd_word = ((MTX_CMDID_SW_WRITEREG & MTX_CMDWORD_ID_MASK) << MTX_CMDWORD_ID_SHIFT) |
               ((i32Core & MTX_CMDWORD_CORE_MASK) <<  MTX_CMDWORD_CORE_SHIFT);
    *cmdbuf->cmd_idx++ = cmd_word;
    pCount = cmdbuf->cmd_idx;
    cmdbuf->cmd_idx++;

    // this should be done for each core....
    pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_SPE_ZERO_THRESH, SPE_ZERO_THRESHOLD);
    for (n = 31; n > 0; n--) {
        iX = n - 12;
        if (iX < 0) {
            iX = 0;
        }
        // Dont Write QP Values To ESB -- IPE will write these values
        // Update the quantization parameter which includes doing Lamda and the Chroma QP

        uiDCScaleL      = CalculateDCScaler(n, IMG_FALSE);
        uiDCScaleC      = CalculateDCScaler(n, IMG_TRUE);
        uiLambda        = MPEG4_QPLAMBDA_MAP[n - 1];

        ui32RegVal = uiDCScaleL;
        ui32RegVal |= (uiDCScaleC) << 8;
        ui32RegVal |= (uiLambda) << 16;
        pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_IPE_LAMBDA_TABLE, ui32RegVal);


        uIPESkipVecBias = TH_SKIP_IPE * uiLambda;
        iInterMBBias            = TH_INTER * (n - TH_INTER_QP);
        if (iInterMBBias < 0)
            iInterMBBias    = 0;
        if (iInterMBBias > TH_INTER_MAX_LEVEL)
            iInterMBBias    = TH_INTER_MAX_LEVEL;
        uSPESkipVecBias = TH_SKIP_SPE * uiLambda;
        iIntra16Bias = 0;

        if (n & 1) {
            pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_IPE_MV_BIAS_TABLE, uIPESkipVecBias);
            pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_SPE_PRED_VECTOR_BIAS_TABLE, uIPESkipVecBias);
            pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_SPE_INTRA16_BIAS_TABLE, iIntra16Bias);
            pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_SPE_INTER_BIAS_TABLE, iInterMBBias);
        }
    }
    *pCount = count;
}

static void LoadH263Bias(
    pnw_cmdbuf_p cmdbuf, IMG_INT32 i32Core, IMG_UINT8 __maybe_unused ui8THSkip)
{
    IMG_INT16 n;
    IMG_INT16 iX;
    IMG_UINT32 ui32RegVal;
    IMG_UINT8                       uiDCScaleL, uiDCScaleC, uiLambda;
    IMG_INT32 uIPESkipVecBias, iInterMBBias, uSPESkipVecBias, iIntra16Bias;
    IMG_UINT32 count = 0, cmd_word = 0;
    uint32_t *pCount;

    cmd_word = ((MTX_CMDID_SW_WRITEREG & MTX_CMDWORD_ID_MASK) << MTX_CMDWORD_ID_SHIFT) |
               ((i32Core & MTX_CMDWORD_CORE_MASK) <<  MTX_CMDWORD_CORE_SHIFT);
    *cmdbuf->cmd_idx++ = cmd_word;
    pCount = cmdbuf->cmd_idx;
    cmdbuf->cmd_idx++;


    // this should be done for each core....
    pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_SPE_ZERO_THRESH, SPE_ZERO_THRESHOLD);
    for (n = 31; n > 0; n--) {
        iX = n - 12;
        if (iX < 0) {
            iX = 0;
        }
        // Dont Write QP Values To ESB -- IPE will write these values
        // Update the quantization parameter which includes doing Lamda and the Chroma QP

        uiDCScaleL      = CalculateDCScaler(n, IMG_FALSE);
        uiDCScaleC      = CalculateDCScaler(n, IMG_TRUE);
        uiLambda        = H263_QPLAMBDA_MAP[n - 1];

        ui32RegVal = uiDCScaleL;
        ui32RegVal |= (uiDCScaleC) << 8;
        ui32RegVal |= (uiLambda) << 16;

        pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_IPE_LAMBDA_TABLE, ui32RegVal);


        uIPESkipVecBias = TH_SKIP_IPE * uiLambda;
        iInterMBBias            = TH_INTER * (n - TH_INTER_QP);
        if (iInterMBBias < 0)
            iInterMBBias    = 0;
        if (iInterMBBias > TH_INTER_MAX_LEVEL)
            iInterMBBias    = TH_INTER_MAX_LEVEL;
        uSPESkipVecBias = TH_SKIP_SPE * uiLambda;
        iIntra16Bias = 0;
        //
        if (n & 1) {
            pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_IPE_MV_BIAS_TABLE, uIPESkipVecBias);
            pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_SPE_PRED_VECTOR_BIAS_TABLE, uIPESkipVecBias);
            pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_SPE_INTRA16_BIAS_TABLE, iIntra16Bias);
            pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_SPE_INTER_BIAS_TABLE, iInterMBBias);
        }
    }
    *pCount = count;
}

static void LoadH264Bias(
    pnw_cmdbuf_p cmdbuf, IMG_INT32 i32Core, IMG_UINT8 ui8THSkip, IMG_INT8 i8QpOff)
{
    IMG_INT8 n;
    IMG_INT8 iX;
    IMG_UINT32 ui32RegVal;
    IMG_UINT32 uIPESkipVecBias, iInterMBBias, uSPESkipVecBias, iIntra16Bias;
    IMG_UINT32 count = 0, cmd_word = 0;
    uint32_t *pCount;

    cmd_word = ((MTX_CMDID_SW_WRITEREG & MTX_CMDWORD_ID_MASK) << MTX_CMDWORD_ID_SHIFT) |
               ((i32Core & MTX_CMDWORD_CORE_MASK) <<  MTX_CMDWORD_CORE_SHIFT);
    *cmdbuf->cmd_idx++ = cmd_word;
    pCount = cmdbuf->cmd_idx;
    cmdbuf->cmd_idx++;


    IMG_BYTE PVR_QP_SCALE_CR[76] = {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
        12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
        28, 29, 29, 30, 31, 32, 32, 33, 34, 34, 35, 35, 36, 36, 37, 37,
        37, 38, 38, 38, 39, 39, 39, 39,
        39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
    };

    for (n = 51; n >= 0; n--) {

        iX = n - 12;
        if (iX < 0)
            iX = 0;

        // Dont Write QP Values To ESB -- IPE will write these values
        // Update the quantization parameter which includes doing Lamda and the Chroma QP
        ui32RegVal = PVR_QP_SCALE_CR[n + 12 + i8QpOff ];
        ui32RegVal |= ((H264_QPLAMBDA_MAP[iX] * 24) / 16) << 8;
        ui32RegVal |= (H264_QPLAMBDA_MAP[iX]) << 16;

#ifdef ZERO_BIAS
        pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_IPE_LAMBDA_TABLE, (2 << 16) | F_ENCODE(3, MVEA_CR_IPE_ALPHA_OR_DC_SCALE_CHR_TABLE) | F_ENCODE(PVR_QP_SCALE_CR[n], MVEA_CR_IPE_QPC_OR_DC_SCALE_LUMA_TABLE));
#else
        pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_IPE_LAMBDA_TABLE, ui32RegVal);
#endif

    }
    for (n = 52; n >= 0; n -= 2) {
        IMG_INT8 qp = n;
        if (qp > 51) qp = 51;

        uIPESkipVecBias = H264SkipBias(qp, ui8THSkip);
        iInterMBBias    = H264InterBias(qp);
        uSPESkipVecBias = H264SkipBias(qp, ui8THSkip);
        iIntra16Bias    = H264Intra4x4Bias(qp);

#ifdef ZERO_BIAS
        pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_IPE_MV_BIAS_TABLE, 0);
        pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_SPE_PRED_VECTOR_BIAS_TABLE, 0);
        pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_SPE_INTRA16_BIAS_TABLE, 0);
        pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_SPE_INTER_BIAS_TABLE, 0);
#else
        pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_IPE_MV_BIAS_TABLE, uIPESkipVecBias);
        pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_SPE_PRED_VECTOR_BIAS_TABLE, uIPESkipVecBias);
        pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_SPE_INTRA16_BIAS_TABLE, iIntra16Bias);
        pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_SPE_INTER_BIAS_TABLE, iInterMBBias);
#endif

    }

    pnw_cmdbuf_insert_reg_write(MVEARegBase[i32Core], MVEA_CR_SPE_ZERO_THRESH, 0);
    *pCount = count;
}


static VAStatus pnw__alloc_context_buffer(context_ENC_p ctx, unsigned char is_JPEG)
{
    int width, height;
    VAStatus vaStatus = VA_STATUS_SUCCESS;

    /* width and height should be source surface's w and h or ?? */
    width = ctx->obj_context->picture_width;
    height = ctx->obj_context->picture_height;

    if (is_JPEG == 0) {
        ctx->pic_params_size  = 256;

        ctx->header_buffer_size = 8 * HEADER_SIZE + MAX_SLICES_PER_PICTURE * HEADER_SIZE;

        ctx->seq_header_ofs = 0;
        ctx->pic_header_ofs = HEADER_SIZE;
        ctx->eoseq_header_ofs = 2 * HEADER_SIZE;
        ctx->eostream_header_ofs = 3 * HEADER_SIZE;
        ctx->aud_header_ofs = 4 * HEADER_SIZE;
        ctx->sei_buf_prd_ofs = 5 * HEADER_SIZE;
        ctx->sei_pic_tm_ofs = 6 * HEADER_SIZE;
        ctx->sei_pic_fpa_ofs = 7 * HEADER_SIZE;
        ctx->slice_header_ofs = 8 * HEADER_SIZE;
        ctx->in_params_ofs = 0;

        ctx->sliceparam_buffer_size = ((sizeof(SLICE_PARAMS) + 15) & 0xfff0) * MAX_SLICES_PER_PICTURE;
        /* All frame share same MTX_CURRENT_IN_PARAMS and above/bellow param
         * create MTX_CURRENT_IN_PARAMS buffer seperately
         * every MB has one MTX_CURRENT_IN_PARAMS structure, and the (N+1) frame can
         * reuse (N) frame's structure
         */
        ctx->in_params_size = ((~0xf) & (15 + 1 + (width + 15) * (height + 15) / (16 * 16))) * sizeof(MTX_CURRENT_IN_PARAMS);
        ctx->below_params_size = ((BELOW_PARAMS_SIZE * width * height / (16 * 16)) + 0xf) & (~0xf);
        ctx->above_params_size = ((width / 16) * 128 + 15) & (~0xf) ;

        vaStatus = psb_buffer_create(ctx->obj_context->driver_data, ctx->in_params_size, psb_bt_cpu_vpu, &ctx->topaz_in_params_I);
        if (VA_STATUS_SUCCESS != vaStatus) {
            return vaStatus;
        }

        vaStatus = psb_buffer_create(ctx->obj_context->driver_data, ctx->in_params_size, psb_bt_cpu_vpu, &ctx->topaz_in_params_P);
        if (VA_STATUS_SUCCESS != vaStatus) {
            psb_buffer_destroy(&ctx->topaz_in_params_I);
            return vaStatus;
        }

        vaStatus = psb_buffer_create(ctx->obj_context->driver_data, ctx->below_params_size * 4, psb_bt_cpu_vpu, &ctx->topaz_below_params);
        if (VA_STATUS_SUCCESS != vaStatus) {
            psb_buffer_destroy(&ctx->topaz_in_params_P);
            psb_buffer_destroy(&ctx->topaz_in_params_I);
            return vaStatus;
        }

        vaStatus = psb_buffer_create(ctx->obj_context->driver_data, ctx->above_params_size * 4, psb_bt_cpu_vpu, &ctx->topaz_above_params);
        if (VA_STATUS_SUCCESS != vaStatus) {
            psb_buffer_destroy(&ctx->topaz_in_params_P);
            psb_buffer_destroy(&ctx->topaz_in_params_I);
            psb_buffer_destroy(&ctx->topaz_below_params);
            return vaStatus;
        }
        ctx->below_params_ofs = 0;
        ctx->above_params_ofs = 0;
    } else {
        /*JPEG encode need three kinds of buffer but doesn't need above/below buffers.*/
        ctx->pic_params_size = (sizeof(JPEG_MTX_QUANT_TABLE) + 0xf) & (~0xf);

        ctx->header_buffer_size = (sizeof(JPEG_MTX_DMA_SETUP) + 0xf) & (~0xf);
        ctx->sliceparam_buffer_size =  16; /* Not used*/
    }
    return vaStatus;
}

unsigned int pnw__get_ipe_control(enum drm_pnw_topaz_codec  eEncodingFormat)
{
    unsigned int RegVal = 0;

    RegVal = F_ENCODE(2, MVEA_CR_IPE_GRID_FINE_SEARCH) |
             F_ENCODE(0, MVEA_CR_IPE_GRID_SEARCH_SIZE) |
             F_ENCODE(1, MVEA_CR_IPE_Y_FINE_SEARCH);

    switch (eEncodingFormat) {
    case IMG_CODEC_H263_NO_RC:
    case IMG_CODEC_H263_VBR:
    case IMG_CODEC_H263_CBR:
        RegVal |= F_ENCODE(0, MVEA_CR_IPE_BLOCKSIZE) | F_ENCODE(0, MVEA_CR_IPE_ENCODING_FORMAT);
        break;
    case IMG_CODEC_MPEG4_NO_RC:
    case IMG_CODEC_MPEG4_VBR:
    case IMG_CODEC_MPEG4_CBR:
        RegVal |= F_ENCODE(1, MVEA_CR_IPE_BLOCKSIZE) | F_ENCODE(1, MVEA_CR_IPE_ENCODING_FORMAT);
    default:
        break;
    case IMG_CODEC_H264_NO_RC:
    case IMG_CODEC_H264_VBR:
    case IMG_CODEC_H264_CBR:
    case IMG_CODEC_H264_VCM:
        RegVal |= F_ENCODE(2, MVEA_CR_IPE_BLOCKSIZE) | F_ENCODE(2, MVEA_CR_IPE_ENCODING_FORMAT);
        break;
    }
    RegVal |= F_ENCODE(6, MVEA_CR_IPE_Y_CANDIDATE_NUM);
    return RegVal;
}


void pnw_DestroyContext(object_context_p obj_context)
{
    context_ENC_p ctx;
    ctx = (context_ENC_p)obj_context->format_data;

    psb_buffer_destroy(&ctx->topaz_in_params_P);
    psb_buffer_destroy(&ctx->topaz_in_params_I);
    psb_buffer_destroy(&ctx->topaz_below_params);
    psb_buffer_destroy(&ctx->topaz_above_params);

    if (NULL != ctx->slice_param_cache)
        free(ctx->slice_param_cache);
    if (NULL == ctx->save_seq_header_p)
        free(ctx->save_seq_header_p);
    free(obj_context->format_data);
    obj_context->format_data = NULL;
}

VAStatus pnw_CreateContext(
    object_context_p obj_context,
    object_config_p __maybe_unused obj_config,
    unsigned char is_JPEG)
{
    int width, height;
    int i;
    unsigned short SearchWidth, SearchHeight, SearchLeftOffset, SearchTopOffset;
    context_ENC_p ctx;
    VAStatus vaStatus;

    width = obj_context->picture_width;
    height = obj_context->picture_height;
    ctx = (context_ENC_p) calloc(1, sizeof(struct context_ENC_s));
    CHECK_ALLOCATION(ctx);

    obj_context->format_data = (void*) ctx;
    ctx->obj_context = obj_context;

    ctx->RawWidth = (unsigned short) width;
    ctx->RawHeight = (unsigned short) height;

    if (is_JPEG == 0) {
        ctx->Width = (unsigned short)(~0xf & (width + 0xf));
        ctx->Height = (unsigned short)(~0xf & (height + 0xf));
    } else {
        /*JPEG only require them are even*/
        ctx->Width = (unsigned short)(~0x1 & (width + 0x1));
        ctx->Height = (unsigned short)(~0x1 & (height + 0x1));
    }

    /* pre-calculated values based on other stream properties */
    SearchHeight = min(MVEA_LRB_SEARCH_HEIGHT, ctx->Height);
    SearchWidth = min(MVEA_LRB_SEARCH_WIDTH, ctx->Width);
    SearchLeftOffset = (((SearchWidth / 2) / 16) * 16);
    SearchTopOffset = (((SearchHeight / 2) / 16) * 16);

    ctx->HeightMinus16MinusLRBTopOffset        = ctx->Height - (SearchTopOffset + 16);
    ctx->HeightMinus32MinusLRBTopOffset        = ctx->Height - (SearchTopOffset + 32);
    ctx->HeightMinusLRB_TopAndBottom_OffsetsPlus16     = ctx->Height - (SearchTopOffset + SearchTopOffset + 16);
    ctx->HeightMinusLRBSearchHeight    = ctx->Height - SearchHeight;

    ctx->FCode = 0;

    ctx->NumCores = 2; /* FIXME Assume there is two encode cores in Penwell, precise value should read from HW */

    ctx->BelowParamsBufIdx = 0;
    ctx->AccessUnitNum = 0;
    ctx->SyncSequencer = 0; /* FIXME Refer to DDK */
    ctx->SliceToCore =  -1;
    ctx->CmdCount = 0xa5a5a5a5 % MAX_TOPAZ_CMD_COUNT;
    ctx->FrmIdx = 0;

    for (i = 0; i < MAX_TOPAZ_CORES; i++) {
        ctx->LastSliceNum[i] = -1;
        ctx->LastSync[0][i] = ~0;
        ctx->LastSync[1][i] = ~0;
    }

    for (i = 0; i < MAX_SLICES_PER_PICTURE; i++) {
        ctx->SliceHeaderReady[i] = IMG_FALSE;
    }

    vaStatus = pnw__alloc_context_buffer(ctx, is_JPEG);

    return vaStatus;
}

VAStatus pnw_BeginPicture(context_ENC_p ctx)
{
    VAStatus vaStatus = VA_STATUS_SUCCESS;
    pnw_cmdbuf_p cmdbuf;
    int ret, i;

    if (ctx->raw_frame_count != 0)
        ctx->previous_src_surface = ctx->src_surface;
    ctx->src_surface = ctx->obj_context->current_render_target;

    /* clear frameskip flag to 0 */
    CLEAR_SURFACE_INFO_skipped_flag(ctx->src_surface->psb_surface);
    ctx->none_vcl_nal = 0;

    /*if (ctx->sRCParams.RCEnable == IMG_TRUE)
     {
     pnw_DetectFrameSkip(ctx);
     if (0 != (GET_SURFACE_INFO_skipped_flag(ctx->src_surface->psb_surface)
            & SURFACE_INFO_SKIP_FLAG_SETTLED))
         ctx->sRCParams.FrameSkip = IMG_TRUE;
     else
         ctx->sRCParams.FrameSkip = IMG_FALSE;
     }*/

    /* Initialise the command buffer */
    ret = pnw_context_get_next_cmdbuf(ctx->obj_context);
    if (ret) {
        drv_debug_msg(VIDEO_DEBUG_GENERAL, "get next cmdbuf fail\n");
        vaStatus = VA_STATUS_ERROR_UNKNOWN;
        return vaStatus;
    }
    cmdbuf = ctx->obj_context->pnw_cmdbuf;
    memset(cmdbuf->cmd_idx_saved, 0, sizeof(cmdbuf->cmd_idx_saved));


    /* map start_pic param */
    vaStatus = psb_buffer_map(&cmdbuf->pic_params, &cmdbuf->pic_params_p);
    if (vaStatus) {
        return vaStatus;
    }
    vaStatus = psb_buffer_map(&cmdbuf->header_mem, &cmdbuf->header_mem_p);
    if (vaStatus) {
        psb_buffer_unmap(&cmdbuf->pic_params);
        return vaStatus;
    }

    vaStatus = psb_buffer_map(&cmdbuf->slice_params, &cmdbuf->slice_params_p);
    if (vaStatus) {
        psb_buffer_unmap(&cmdbuf->pic_params);
        psb_buffer_unmap(&cmdbuf->header_mem);
        return vaStatus;
    }

    /* only map topaz param when necessary */
    cmdbuf->topaz_above_params_p = NULL;
    cmdbuf->topaz_below_params_p = NULL;
    cmdbuf->topaz_in_params_I_p = NULL;
    cmdbuf->topaz_in_params_P_p = NULL;

    if (ctx->obj_context->frame_count == 0) { /* first picture */

        psb_driver_data_p driver_data = ctx->obj_context->driver_data;

        *cmdbuf->cmd_idx++ = ((MTX_CMDID_SW_NEW_CODEC & MTX_CMDWORD_ID_MASK) << MTX_CMDWORD_ID_SHIFT) |
                             (((driver_data->drm_context & MTX_CMDWORD_COUNT_MASK) << MTX_CMDWORD_COUNT_SHIFT));
        pnw_cmdbuf_insert_command_param(ctx->eCodec);
        pnw_cmdbuf_insert_command_param((ctx->Width << 16) | ctx->Height);
    }

    ctx->FrmIdx++;
    ctx->SliceToCore = ctx->ParallelCores - 1;
    /* ctx->AccessUnitNum++;    Move this back to pnw_EndPicture */
    ctx->sRCParams.bBitrateChanged = IMG_FALSE;

    for (i = 0; i < MAX_TOPAZ_CORES; i++)
        ctx->LastSliceNum[i] = -1;

    for (i = 0; i < MAX_SLICES_PER_PICTURE; i++)
        ctx->SliceHeaderReady[i] = IMG_FALSE;

    /*If ParallelCores > 1(H264) and encode one slice per frame, the unnecessary start picture
    *commands will be replaced with MTX_CMDID_PAD and ignored by kernel*/
    cmdbuf->cmd_idx_saved[PNW_CMDBUF_START_PIC_IDX] = cmdbuf->cmd_idx;

    /* insert START_PIC command for each core */
    /* ensure that the master (core #0) will be last to complete this batch */
    for (i = (ctx->ParallelCores - 1); i >= 0; i--) {

        /*
         * the content of PIC_PARAMS is filled when RenderPicture(...,VAEncPictureParameterBufferXXX)
         */
        pnw_cmdbuf_insert_command_package(ctx->obj_context,
                                          i,
                                          MTX_CMDID_START_PIC,
                                          &cmdbuf->pic_params,
                                          i * ctx->pic_params_size);

        /* no RC paramter provided in vaBeginPicture
         * so delay RC param setup into vaRenderPicture(SequenceHeader...)
         */
    }

    ctx->obj_context->slice_count = 0;
    return 0;
}


VAStatus pnw_set_bias(context_ENC_p ctx, int core)
{
    pnw_cmdbuf_p cmdbuf = (pnw_cmdbuf_p)ctx->obj_context->pnw_cmdbuf;
    double flBpp;
    IMG_UINT8 THSkip;

    if (ctx->sRCParams.RCEnable) {
        flBpp = 1.0 * ctx->sRCParams.BitsPerSecond /
                (ctx->sRCParams.FrameRate * ctx->Width * ctx->Height);
    } else {
        flBpp =  0.14;
    }

    if (flBpp <= 0.07) {
        THSkip = TH_SKIP_24;
    } else if (flBpp <= 0.14) {
        THSkip = TH_SKIP_12;
    } else {
        THSkip = TH_SKIP_0;
    }
    switch (ctx->eCodec) {
    case IMG_CODEC_H264_VBR:
    case IMG_CODEC_H264_CBR:
    case IMG_CODEC_H264_VCM:
    case IMG_CODEC_H264_NO_RC:
        LoadH264Bias(cmdbuf, core, THSkip, ctx->sRCParams.QCPOffset);
        break;
    case IMG_CODEC_H263_CBR:
    case IMG_CODEC_H263_NO_RC:
    case IMG_CODEC_H263_VBR:
        LoadH263Bias(cmdbuf, core, THSkip);
        break;
    case IMG_CODEC_MPEG4_NO_RC:
    case IMG_CODEC_MPEG4_CBR:
    case IMG_CODEC_MPEG4_VBR:
        LoadMPEG4Bias(cmdbuf, core, THSkip);
        break;
    default:
        return -1;
        break;
    }
    return 0;
}

VAStatus pnw_RenderPictureParameter(context_ENC_p ctx, int core)
{
    PIC_PARAMS *psPicParams;    /* PIC_PARAMS has been put in pnw_hostcode.h */
    object_surface_p src_surface;
    unsigned int srf_buf_offset;
    object_surface_p rec_surface;
    object_surface_p ref_surface;
    pnw_cmdbuf_p cmdbuf = ctx->obj_context->pnw_cmdbuf;
    VAStatus vaStatus = VA_STATUS_ERROR_UNKNOWN;

    psPicParams = (PIC_PARAMS *)(cmdbuf->pic_params_p + ctx->pic_params_size * core);

    memset(psPicParams, 0, sizeof(PIC_PARAMS));
    /* second frame will reuse some rate control parameters (IN_PARAMS_MP4)
     * so only memset picture parames except IN_PARAMS
     * BUT now IN_RC_PARAMS was reload from the cache, so it now can
     * memset entirE PIC_PARAMS
     */

    /*
    memset(psPicParams, 0, (int)((unsigned char *)&psPicParams->sInParams - (unsigned char *)psPicParams));
    */

    src_surface = ctx->src_surface;
    CHECK_SURFACE(src_surface);

    rec_surface = ctx->dest_surface;
    CHECK_SURFACE(rec_surface);

    /*The fisrt frame always is I frame and the content of reference frame wouldn't be used.
     * But the heights of ref and dest frame should be the same.
     * That allows Topaz to keep its motion vectors up to date, which helps maintain performance */
    if (ctx->obj_context->frame_count == 0)
        ctx->ref_surface = ctx->dest_surface;

    ref_surface = ctx->ref_surface;
    CHECK_SURFACE(rec_surface);

    /* clear frameskip flag */
    CLEAR_SURFACE_INFO_skipped_flag(rec_surface->psb_surface);
    CLEAR_SURFACE_INFO_skipped_flag(ref_surface->psb_surface);

    /* Write video data byte offset into Coded buffer
     * If it is here, it will be a SYNC point, which have performance impact
     * Move to psb__CreateBuffer
     vaStatus = psb_buffer_map(ctx->coded_buf->psb_buffer, &pBuffer);
     if(vaStatus) {
     DEBUG_FAILURE;
     return vaStatus;
     }
     *(IMG_UINT32 *)(pBuffer+8) = 16;
     psb_buffer_unmap(ctx->coded_buf->psb_buffer);
    */

    psPicParams->SrcYStride = src_surface->psb_surface->stride;
    switch (ctx->eFormat) {
    case IMG_CODEC_IYUV:        /* IYUV */
    case IMG_CODEC_PL8:
        psPicParams->SrcUVStride = src_surface->psb_surface->stride / 2;
        psPicParams->SrcUVRowStride = src_surface->psb_surface->stride * 8 / 2;
        break;
    case IMG_CODEC_IMC2:    /* IMC2 */
    case IMG_CODEC_PL12:
        psPicParams->SrcUVStride = src_surface->psb_surface->stride;
        psPicParams->SrcUVRowStride = src_surface->psb_surface->stride * 8;
        break;
    default:
        break;
    }
    psPicParams->SrcYRowStride    = src_surface->psb_surface->stride * 16;
    /* psPicParams->SrcUVRowStride = src_surface->psb_surface->stride * 16 / 2; */

    /* Dest(rec) stride
     * The are now literally Dst stride (not equivalent to 'offset to next row')
     */
#ifdef VA_EMULATOR
    /* only for simulator, va-emulator needs the actually stride for
     * reconstructed frame transfer (va-emulator->driver)
     */
    psPicParams->DstYStride = rec_surface->psb_surface->stride;
    psPicParams->DstUVStride = rec_surface->psb_surface->stride;
#else
    psPicParams->DstYStride = rec_surface->psb_surface->stride;
    psPicParams->DstUVStride = rec_surface->psb_surface->stride;
#endif

    psPicParams->Width  = ctx->Width;
    psPicParams->Height = ctx->Height;
    psPicParams->NumSlices = ctx->sRCParams.Slices;

    psPicParams->IsPerSliceOutput = IMG_FALSE;
    psPicParams->SearchHeight = min(MVEA_LRB_SEARCH_HEIGHT, psPicParams->Height);
    psPicParams->SearchWidth = min(MVEA_LRB_SEARCH_WIDTH, psPicParams->Width);

    /* not sure why we are setting this up here... */
    psPicParams->Flags = 0;
    switch (ctx->eCodec) {
    case IMG_CODEC_H264_NO_RC:
    case IMG_CODEC_H264_VBR:
    case IMG_CODEC_H264_CBR:
    case IMG_CODEC_H264_VCM:
        psPicParams->Flags |= ISH264_FLAGS;
        break;
    case IMG_CODEC_H263_VBR:
    case IMG_CODEC_H263_CBR:
    case IMG_CODEC_H263_NO_RC:
        psPicParams->Flags |= ISH263_FLAGS;
        break;
    case IMG_CODEC_MPEG4_NO_RC:
    case IMG_CODEC_MPEG4_VBR:
    case IMG_CODEC_MPEG4_CBR:
        psPicParams->Flags |= ISMPEG4_FLAGS;
        break;
    default:
        return VA_STATUS_ERROR_UNKNOWN;
    }

    switch (ctx->eCodec) {
    case IMG_CODEC_H264_VBR:
    case IMG_CODEC_MPEG4_VBR:
    case IMG_CODEC_H263_VBR:
        psPicParams->Flags |= ISVBR_FLAGS;
        break;
    case IMG_CODEC_H264_VCM:
        psPicParams->Flags |= (ISVCM_FLAGS | ISCBR_FLAGS);
        break;
    case IMG_CODEC_H263_CBR:
    case IMG_CODEC_H264_CBR:
    case IMG_CODEC_MPEG4_CBR:
        psPicParams->Flags |= ISCBR_FLAGS;
        break;
    case IMG_CODEC_MPEG4_NO_RC:
    case IMG_CODEC_H263_NO_RC:
    case IMG_CODEC_H264_NO_RC:
        break;
    default:
        return VA_STATUS_ERROR_UNKNOWN;
    }

#if 0
    if (ctx->SyncSequencer)
        psPicParams->Flags |= SYNC_SEQUENCER;
#endif

    if (ctx->sRCParams.RCEnable) {
        if (ctx->sRCParams.bDisableFrameSkipping) {
            psPicParams->Flags |= DISABLE_FRAME_SKIPPING;
            drv_debug_msg(VIDEO_DEBUG_GENERAL, "Frame skip is disabled.\n");
        }

        if (ctx->sRCParams.bDisableBitStuffing && IS_H264_ENC(ctx->eCodec)) {
            psPicParams->Flags |= DISABLE_BIT_STUFFING;
            drv_debug_msg(VIDEO_DEBUG_GENERAL, "Bit stuffing is disabled.\n");
        }


        /* for the first frame, will setup RC params in EndPicture */
        if (ctx->raw_frame_count > 0) { /* reuse in_params parameter */
            /* In case, it's changed in a new sequence */
            if (ctx->obj_context->frame_count == 0
               && ctx->in_params_cache.IntraPeriod != ctx->sRCParams.IntraFreq) {
               drv_debug_msg(VIDEO_DEBUG_ERROR,
               "On frame %d, Intra period is changed from %d to %d\n",
               ctx->raw_frame_count, ctx->in_params_cache.IntraPeriod,
               ctx->sRCParams.IntraFreq);
               ctx->in_params_cache.IntraPeriod =  ctx->sRCParams.IntraFreq;
               ctx->in_params_cache.BitsPerGOP =
                    (ctx->sRCParams.BitsPerSecond / ctx->sRCParams.FrameRate)
                    * ctx->sRCParams.IntraFreq;
            }

            psPicParams->Flags &= ~FIRST_FRAME;
            /* reload IN_RC_PARAMS from cache */
            memcpy(&psPicParams->sInParams, &ctx->in_params_cache, sizeof(IN_RC_PARAMS));
        } else {
            psPicParams->Flags |= ISRC_FLAGS;
            psPicParams->Flags |= FIRST_FRAME;
        }
    } else
        psPicParams->sInParams.SeInitQP = ctx->sRCParams.InitialQp;

    /* some relocations have to been done here */
    srf_buf_offset = src_surface->psb_surface->buf.buffer_ofs;
    if (src_surface->psb_surface->buf.type == psb_bt_camera)
        drv_debug_msg(VIDEO_DEBUG_GENERAL, "src surface GPU offset 0x%08x, luma offset 0x%08x\n",
                                 wsbmBOOffsetHint(src_surface->psb_surface->buf.drm_buf), srf_buf_offset);

    RELOC_PIC_PARAMS_PNW(&psPicParams->SrcYBase, srf_buf_offset, &src_surface->psb_surface->buf);
    switch (ctx->eFormat) {
    case IMG_CODEC_IYUV:
    case IMG_CODEC_PL8:
    case IMG_CODEC_PL12:
        RELOC_PIC_PARAMS_PNW(&psPicParams->SrcUBase,
                             srf_buf_offset + src_surface->psb_surface->chroma_offset,
                             &src_surface->psb_surface->buf);

        RELOC_PIC_PARAMS_PNW(&psPicParams->SrcVBase,
                             srf_buf_offset + src_surface->psb_surface->chroma_offset * 5 / 4,
                             &src_surface->psb_surface->buf);

        break;
    case IMG_CODEC_IMC2:
    case IMG_CODEC_NV12:
    default:
        break;
    }

    RELOC_PIC_PARAMS_PNW(&psPicParams->DstYBase, 0, &rec_surface->psb_surface->buf);

    RELOC_PIC_PARAMS_PNW(&psPicParams->DstUVBase,
                         rec_surface->psb_surface->stride * rec_surface->height,
                         &rec_surface->psb_surface->buf);

    RELOC_PIC_PARAMS_PNW(&psPicParams->BelowParamsInBase,
                         ctx->below_params_ofs + ctx->below_params_size *(((ctx->AccessUnitNum) & 0x1)),
                         cmdbuf->topaz_below_params);

    RELOC_PIC_PARAMS_PNW(&psPicParams->BelowParamsOutBase,
                         ctx->below_params_ofs + ctx->below_params_size *(((ctx->AccessUnitNum + 1) & 0x1)),
                         cmdbuf->topaz_below_params);

    RELOC_PIC_PARAMS_PNW(&psPicParams->AboveParamsBase,
                         ctx->above_params_ofs + ctx->above_params_size *(core * 2 + (ctx->AccessUnitNum & 0x1)),
                         cmdbuf->topaz_above_params);

    RELOC_PIC_PARAMS_PNW(&psPicParams->CodedBase, ctx->coded_buf_per_slice * core, ctx->coded_buf->psb_buffer);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "For core %d, above_parmas_off %x\n", core, ctx->above_params_ofs + ctx->above_params_size *(core * 2 + ((ctx->AccessUnitNum) & 0x1)));

   return VA_STATUS_SUCCESS;
}

static VAStatus pnw_SetupRCParam(context_ENC_p ctx)
{
    pnw_cmdbuf_p cmdbuf = ctx->obj_context->pnw_cmdbuf;
    PIC_PARAMS  *psPicParams = (PIC_PARAMS  *)cmdbuf->pic_params_p;
    PIC_PARAMS  *psPicParamsTmp;
    int origin_qp, i;/* in DDK setup_rc will change qp strangly,
                   * just for keep same with DDK
                   */

    origin_qp = ctx->sRCParams.InitialQp;

    psPicParams->Flags |= ISRC_FLAGS;
    pnw__setup_rcdata(ctx, psPicParams, &ctx->sRCParams);

    /* restore it, just keep same with DDK */
    ctx->sRCParams.InitialQp = origin_qp;

    /* Assume IN_RC_PARAMS for each core is identical, and copy for each */
    for (i = (ctx->ParallelCores - 1); i > 0; i--) {
        psPicParamsTmp = (PIC_PARAMS  *)(cmdbuf->pic_params_p + ctx->pic_params_size * i);
        memcpy((unsigned char *)&psPicParamsTmp->sInParams,
               (unsigned char *)&psPicParams->sInParams,
               sizeof(IN_RC_PARAMS));
        psPicParamsTmp->Flags |= psPicParams->Flags;
    }

    /* save IN_RC_PARAMS into the cache */
    memcpy(&ctx->in_params_cache, (unsigned char *)&psPicParams->sInParams, sizeof(IN_RC_PARAMS));
    return VA_STATUS_SUCCESS;
}

VAStatus pnw_EndPicture(context_ENC_p ctx)
{
    VAStatus vaStatus = VA_STATUS_SUCCESS;
    unsigned int i;
    int index;
    pnw_cmdbuf_p cmdbuf = ctx->obj_context->pnw_cmdbuf;
    PIC_PARAMS *psPicParams = (PIC_PARAMS *)cmdbuf->pic_params_p;
    PIC_PARAMS *psPicParamsSlave = NULL;
    unsigned int val = 0;

    ctx->AccessUnitNum++;

    if (ctx->sRCParams.RCEnable) {
        if (ctx->raw_frame_count == 0)
            pnw_SetupRCParam(ctx);
        else  if (ctx->sRCParams.bBitrateChanged) {
            /* Toggle the last bit to make sure encoder firmare recalculate the
               RC params even if the target bitrate isn't changed.*/
            val = ~(ctx->sRCParams.BitsPerSecond & 0x1);
            ctx->sRCParams.BitsPerSecond &= ~1;
            ctx->sRCParams.BitsPerSecond |= (val & 1);

            drv_debug_msg(VIDEO_DEBUG_GENERAL, "bitrate is changed to %d, "
                    "update the rc data accordingly\n", ctx->sRCParams.BitsPerSecond);
            pnw__update_rcdata(ctx, psPicParams, &ctx->sRCParams);
            if (ctx->sRCParams.MinQP)
                psPicParams->sInParams.MinQPVal = ctx->sRCParams.MinQP;
            memcpy(&ctx->in_params_cache, (unsigned char *)&psPicParams->sInParams, sizeof(IN_RC_PARAMS));
            /* Save rate control info in slave core as well */
            for (i = 1; i < ctx->ParallelCores; i++) {
                psPicParamsSlave = (PIC_PARAMS *)(cmdbuf->pic_params_p + ctx->pic_params_size * i);
                memcpy((unsigned char *)&psPicParamsSlave->sInParams,
                        (unsigned char *)&psPicParams->sInParams, sizeof(IN_RC_PARAMS));
	    }
        }
    }

#if TOPAZ_PIC_PARAMS_VERBOSE
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "End Picture for frame %d\n", ctx->raw_frame_count);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "sizeof PIC_PARAMS %d\n", sizeof(PIC_PARAMS));
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "sizeof in_params %d\n", sizeof(psPicParams->sInParams));
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->SrcYBase  0x%08x\n", psPicParams->SrcYBase);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->SrcUBase 0x%08x\n", psPicParams->SrcUBase);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->SrcVBase 0x%08x\n", psPicParams->SrcVBase);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->DstYBase 0x%08x\n", psPicParams->DstYBase);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->DstUVBase 0x%08x\n", psPicParams->DstUVBase);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->SrcYStride 0x%08x\n", psPicParams->SrcYStride);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->SrcUVStride 0x%08x\n", psPicParams->SrcUVStride);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->SrcYRowStride 0x%08x\n", psPicParams->SrcYRowStride);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->SrcUVRowStride 0x%08x\n", psPicParams->SrcUVRowStride);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->DstYStride 0x%08x\n", psPicParams->DstYStride);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->DstUVStride 0x%08x\n", psPicParams->DstUVStride);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->CodedBase 0x%08x\n", psPicParams->CodedBase);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->BelowParamsInBase 0x%08x\n", psPicParams->BelowParamsInBase);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->BelowParamsOutBase 0x%08x\n", psPicParams->BelowParamsOutBase);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->AboveParamsBase 0x%08x\n", psPicParams->AboveParamsBase);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->Width 0x%08x\n", psPicParams->Width);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->Height 0x%08x\n", psPicParams->Height);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->Flags 0x%08x\n", psPicParams->Flags);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->SerachWidth 0x%08x\n", psPicParams->SearchWidth);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->SearchHeight 0x%08x\n", psPicParams->SearchHeight);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "PicParams->NumSlices 0x%08x\n", psPicParams->NumSlices);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->ClockDivBitrate %lld\n", psPicParams->ClockDivBitrate);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->MaxBufferMultClockDivBitrate %d\n",
                             psPicParams->MaxBufferMultClockDivBitrate);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.SeInitQP %d\n", psPicParams->sInParams.SeInitQP);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.MinQPVal %d\n", psPicParams->sInParams.MinQPVal);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.MaxQPVal %d\n", psPicParams->sInParams.MaxQPVal);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.MBPerRow %d\n", psPicParams->sInParams.MBPerRow);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.MBPerFrm %d\n", psPicParams->sInParams.MBPerFrm);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.MBPerBU %d\n", psPicParams->sInParams.MBPerBU);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.BUPerFrm %d\n", psPicParams->sInParams.BUPerFrm);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.IntraPeriod %d\n", psPicParams->sInParams.IntraPeriod);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.BitsPerFrm %d\n", psPicParams->sInParams.BitsPerFrm);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.BitsPerBU %d\n", psPicParams->sInParams.BitsPerBU);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.BitsPerMB %d\n", psPicParams->sInParams.BitsPerMB);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.BitRate %d\n", psPicParams->sInParams.BitRate);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.BufferSize %d\n", psPicParams->sInParams.BufferSize);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.InitialLevel %d\n", psPicParams->sInParams.InitialLevel);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.InitialDelay %d\n", psPicParams->sInParams.InitialDelay);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.ScaleFactor %d\n", psPicParams->sInParams.ScaleFactor);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.VCMBitrateMargin %d\n", psPicParams->sInParams.VCMBitrateMargin);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.HalfFrameRate %d\n", psPicParams->sInParams.HalfFrameRate);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.FCode %d\n", psPicParams->sInParams.FCode);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.BitsPerGOP %d\n", psPicParams->sInParams.BitsPerGOP);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.AvQPVal %d\n", psPicParams->sInParams.AvQPVal);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.MyInitQP %d\n", psPicParams->sInParams.MyInitQP);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.ForeceSkipMargin %d\n", psPicParams->sInParams.ForeceSkipMargin);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.RCScaleFactor %d\n", psPicParams->sInParams.RCScaleFactor);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.TransferRate %d\n", psPicParams->sInParams.TransferRate);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psPicParams->sInParams.MaxFrameSize %d\n", psPicParams->sInParams.MaxFrameSize);
#endif
    /* save current settings */
    ctx->previous_ref_surface = ctx->ref_surface;
    ctx->previous_dest_surface = ctx->dest_surface; /* reconstructed surface */
    SET_CODEDBUF_INFO(SLICE_NUM, ctx->coded_buf->codedbuf_aux_info,
        ctx->obj_context->slice_count);
    SET_CODEDBUF_INFO(NONE_VCL_NUM, ctx->coded_buf->codedbuf_aux_info,
        ctx->none_vcl_nal);

    for (index = (ctx->ParallelCores - 1); index >= 0; index--) {
        pnw_cmdbuf_insert_command_package(ctx->obj_context,
                                          index,
                                          MTX_CMDID_END_PIC,
                                          NULL,
                                          0);
    }
    psb_buffer_unmap(&cmdbuf->pic_params);
    psb_buffer_unmap(&cmdbuf->header_mem);
    psb_buffer_unmap(&cmdbuf->slice_params);

    /* unmap MTX_CURRENT_IN_PARAMS buffer only when it is mapped */
    if (cmdbuf->topaz_in_params_I_p != NULL) {
        psb_buffer_unmap(cmdbuf->topaz_in_params_I);
        cmdbuf->topaz_in_params_I_p = NULL;
    }

    if (cmdbuf->topaz_in_params_P_p != NULL) {
        psb_buffer_unmap(cmdbuf->topaz_in_params_P);
        cmdbuf->topaz_in_params_P_p = NULL;
    }

    if (cmdbuf->topaz_above_params_p != NULL) {
        psb_buffer_unmap(cmdbuf->topaz_above_params);
        cmdbuf->topaz_above_params_p = NULL;
    }

    if (cmdbuf->topaz_below_params_p != NULL) {
        psb_buffer_unmap(cmdbuf->topaz_below_params);
        cmdbuf->topaz_below_params_p = NULL;
    }

    if (pnw_context_flush_cmdbuf(ctx->obj_context)) {
        vaStatus = VA_STATUS_ERROR_UNKNOWN;
    }
    ctx->raw_frame_count++;
    return vaStatus;
}

static void pnw__setup_busize(context_ENC_p ctx)
{
    unsigned int old_busize = ctx->sRCParams.BUSize;
    int slices = ctx->obj_context->slice_count;

    /* it is called at EndPicture, we should now the Slice number */
    //ctx->Slices = ctx->obj_context->slice_count;

    /* if no BU size is given then pick one ourselves */
    if (ctx->sRCParams.BUSize != 0)  { /* application provided BUSize */
        IMG_UINT32 MBs, MBsperSlice, MBsLastSlice;
        IMG_UINT32 BUs;
        IMG_INT32  SliceHeight;
        IMG_UINT32 MaxSlicesPerPipe, MaxMBsPerPipe, MaxBUsPerPipe;

        MBs     = ctx->Height * ctx->Width / (16 * 16);

        SliceHeight     = ctx->Height / slices;
        /* SliceHeight += 15; */
        SliceHeight &= ~15;

        MBsperSlice     = (SliceHeight * ctx->Width) / (16 * 16);
        MBsLastSlice    = MBs - (MBsperSlice * (slices - 1));

        /* they have given us a basic unit so validate it */
        if (ctx->sRCParams.BUSize < 6) {
            drv_debug_msg(VIDEO_DEBUG_ERROR, "ERROR: Basic unit size too small, must be greater than 6\n");
            ctx->sRCParams.BUSize = 0; /* need repatch */;
        }
        if (ctx->sRCParams.BUSize > MBsperSlice) {
            drv_debug_msg(VIDEO_DEBUG_ERROR, "ERROR: Basic unit size too large, must be less than the number of macroblocks in a slice\n");
            ctx->sRCParams.BUSize = 0; /* need repatch */;
        }
        if (ctx->sRCParams.BUSize > MBsLastSlice) {
            drv_debug_msg(VIDEO_DEBUG_ERROR, "ERROR: Basic unit size too large, must be less than number of macroblocks in the last slice\n");
            ctx->sRCParams.BUSize = 0; /* need repatch */;
        }

        if (ctx->sRCParams.BUSize != 0) {
            BUs = MBsperSlice / ctx->sRCParams.BUSize;
            if ((BUs * ctx->sRCParams.BUSize) != MBsperSlice)   {
                drv_debug_msg(VIDEO_DEBUG_ERROR, "ERROR: Basic unit size not an integer divisor of MB's in a slice");
                ctx->sRCParams.BUSize = 0; /* need repatch */;
            }
        }
        if (ctx->sRCParams.BUSize != 0) {
            BUs = MBsLastSlice / ctx->sRCParams.BUSize;
            if ((BUs * ctx->sRCParams.BUSize) != MBsLastSlice)   {
                drv_debug_msg(VIDEO_DEBUG_ERROR, "ERROR: Basic unit size not an integer divisor of MB's in a slice");
                ctx->sRCParams.BUSize = 0; /* need repatch */;
            }
        }

        if (ctx->sRCParams.BUSize != 0) {
            // check if the number of BUs per pipe is greater than 200
            MaxSlicesPerPipe = (slices + ctx->ParallelCores - 1) / ctx->ParallelCores;
            MaxMBsPerPipe = (MBsperSlice * (MaxSlicesPerPipe - 1)) + MBsLastSlice;
            MaxBUsPerPipe = (MaxMBsPerPipe + ctx->sRCParams.BUSize - 1) / ctx->sRCParams.BUSize;
            if (MaxBUsPerPipe > 200) {
                drv_debug_msg(VIDEO_DEBUG_ERROR, "ERROR: Basic unit size too small. There must be less than 200 basic units per slice");
                ctx->sRCParams.BUSize = 0; /* need repatch */;
            }
        }
    }

    if (ctx->sRCParams.BUSize == 0)  {
        IMG_UINT32 MBs, MBsperSlice, MBsLastSlice;
        IMG_UINT32 BUsperSlice, BUsLastSlice;
        IMG_UINT32 MaxSlicesPerPipe, MaxMBsPerPipe, MaxBUsPerPipe;
        IMG_INT32  SliceHeight;
        IMG_UINT32 BUSize = 6;

        MBs     = ctx->Height * ctx->Width / (16 * 16);

        SliceHeight     = ctx->Height / slices;
        /* SliceHeight += 15; */
        SliceHeight &= ~15;

        MBsperSlice     = (SliceHeight * ctx->Width) / (16 * 16);
        MBsLastSlice = MBs - (MBsperSlice * (slices - 1));

        /* Check number of BUs to be encoded on one pipe is less than maximum number allowed 200  */
        MaxSlicesPerPipe = (slices + ctx->ParallelCores - 1) / ctx->ParallelCores;
        MaxMBsPerPipe = (MBsperSlice * (MaxSlicesPerPipe - 1)) + MBsLastSlice;
        MaxBUsPerPipe = (MaxMBsPerPipe + BUSize - 1) / BUSize;

        while (MaxBUsPerPipe > 200)  {
            BUSize++;
            MaxBUsPerPipe = (MaxMBsPerPipe + BUSize - 1) / BUSize;
        }

        /* Check whether there are integeral number of BUs in the slices  */
        BUsperSlice = MBsperSlice / BUSize;
        BUsLastSlice = MBsLastSlice / BUSize;
        while ((BUsperSlice*BUSize != MBsperSlice) ||
               (BUsLastSlice*BUSize != MBsLastSlice)) {
            BUSize++;
            BUsperSlice = MBsperSlice / BUSize;
            BUsLastSlice = MBsLastSlice / BUSize;
        }

        ctx->sRCParams.BUSize = BUSize;
    /*
        ctx->sRCParams.InitialLevel = (3 * ctx->sRCParams.BufferSize) >> 4;
        ctx->sRCParams.InitialDelay = (13 * ctx->sRCParams.BufferSize) >> 4;
    */
    }

    if (ctx->sRCParams.BUSize != old_busize)
        drv_debug_msg(VIDEO_DEBUG_GENERAL, "Patched Basic unit to %d (original=%d)\n", ctx->sRCParams.BUSize, old_busize);
}


static void pnw__update_rcdata(
    context_ENC_p psContext,
    PIC_PARAMS *psPicParams,
    IMG_RC_PARAMS *psRCParams)
{
    double      L1, L2, L3, L4, L5, L6, flBpp;
    IMG_INT16           i16TempQP;
    IMG_INT32   i32BufferSizeInFrames = 0;

    flBpp = 1.0 * psRCParams->BitsPerSecond
            / (psRCParams->FrameRate * psContext->Width * psContext->Height);

    if (psContext->Width <= 176) {
        /* for very small franes we need to adjust the calculations */
        flBpp = flBpp / 2.0;
    }

    psPicParams->sInParams.IntraPeriod =  psRCParams->IntraFreq;
    psPicParams->sInParams.BitRate = psRCParams->BitsPerSecond;
    psPicParams->sInParams.BitsPerFrm = (psRCParams->BitsPerSecond + psRCParams->FrameRate / 2) / psRCParams->FrameRate;
    psPicParams->sInParams.BitsPerGOP = (psRCParams->BitsPerSecond / psRCParams->FrameRate) * psRCParams->IntraFreq;
    psPicParams->sInParams.BitsPerBU    = psPicParams->sInParams.BitsPerFrm / (4 * psPicParams->sInParams.BUPerFrm);
    psPicParams->sInParams.BitsPerMB    = psPicParams->sInParams.BitsPerBU / psRCParams->BUSize;
    psPicParams->sInParams.TransferRate = psRCParams->BitsPerSecond / psRCParams->FrameRate;

    i32BufferSizeInFrames = psRCParams->BufferSize / psPicParams->sInParams.BitsPerFrm;

    /* select thresholds and initial Qps etc that are codec dependent */
    switch (psContext->eCodec) {
    case IMG_CODEC_H264_CBR:
    case IMG_CODEC_H264_VCM:
    case IMG_CODEC_H264_VBR:
        L1 = 0.1;
        L2 = 0.15;
        L3 = 0.2;

        /* Set MaxQP to avoid blocky image in low bitrate */
        /* RCScaleFactor indicates the size of GOP for rate control */
        if (psContext->eCodec == IMG_CODEC_H264_VCM) {
            psPicParams->sInParams.MaxQPVal = 51;
            psPicParams->sInParams.RCScaleFactor = 16;
        }
        else {
            psPicParams->sInParams.MaxQPVal = 51;
            psPicParams->sInParams.RCScaleFactor = 16;
        }

        /* Setup MAX and MIN Quant Values */
        if (flBpp >= 0.50)
            i16TempQP = 4;
        else
            i16TempQP = (unsigned int)(26 - (40 * flBpp));

        psPicParams->sInParams.MinQPVal = (max(min(psPicParams->sInParams.MaxQPVal, i16TempQP), 0));

        L1 = 0.050568;
        L2 = 0.202272;
        L3 = 0.40454321;
        L4 = 0.80908642;
        L5 = 1.011358025;
        if (flBpp < L1)
            psPicParams->sInParams.SeInitQP = (IMG_UINT8)(47 - 78.10 * flBpp);

        else if (flBpp >= L1 && flBpp < L2)
            psPicParams->sInParams.SeInitQP = (IMG_UINT8)(45 - 66.67 * flBpp);

        else if (flBpp >= L2 && flBpp < L3)
            psPicParams->sInParams.SeInitQP = (IMG_UINT8)(36 - 24.72 * flBpp);

        else if (flBpp >= L3 && flBpp < L4)
            psPicParams->sInParams.SeInitQP = (IMG_UINT8)(34 - 19.78 * flBpp);

        else if (flBpp >= L4 && flBpp < L5)
            psPicParams->sInParams.SeInitQP = (IMG_UINT8)(27 - 9.89 * flBpp);

        else if (flBpp >= L5 && flBpp < 4)
            psPicParams->sInParams.SeInitQP = (IMG_UINT8)(20 - 4.95 * flBpp);
        else
            psPicParams->sInParams.SeInitQP = psPicParams->sInParams.MinQPVal;

        if (psPicParams->sInParams.SeInitQP < psPicParams->sInParams.MinQPVal)
            psPicParams->sInParams.SeInitQP = psPicParams->sInParams.MinQPVal;

        break;

    case IMG_CODEC_MPEG4_CBR:
    case IMG_CODEC_MPEG4_VBR:
    case IMG_CODEC_H263_CBR:
    case IMG_CODEC_H263_VBR:
        psPicParams->sInParams.RCScaleFactor = 16;
        psPicParams->sInParams.MaxQPVal  = 31;

        if (psContext->Width <= 176) {
            L1 = 0.043;
            L2 = 0.085;
            L3 = 0.126;
            L4 = 0.168;
            L5 = 0.336;
            L6 = 0.505;
        } else if (psContext->Width == 352) {
            L1 = 0.065;
            L2 = 0.085;
            L3 = 0.106;
            L4 = 0.126;
            L5 = 0.168 ;
            L6 = 0.210;
        } else {
            L1 = 0.051;
            L2 = 0.0770;
            L3 = 0.096;
            L4 = 0.145;
            L5 = 0.193;
            L6 = 0.289;
        }

        /* Calculate Initial QP if it has not been specified */
        if (flBpp < L1)
            psPicParams->sInParams.SeInitQP = 31;

        else if (flBpp >= L1 && flBpp < L2)
            psPicParams->sInParams.SeInitQP = 26;

        else if (flBpp >= L2 && flBpp < L3)
            psPicParams->sInParams.SeInitQP = 22;

        else if (flBpp >= L3 && flBpp < L4)
            psPicParams->sInParams.SeInitQP = 18;

        else if (flBpp >= L4 && flBpp < L5)
            psPicParams->sInParams.SeInitQP = 14;

        else if (flBpp >= L5 && flBpp < L6)
            psPicParams->sInParams.SeInitQP = 10;
        else
            psPicParams->sInParams.SeInitQP = 8;

        psPicParams->sInParams.AvQPVal =  psPicParams->sInParams.SeInitQP;

        if (flBpp >= 0.25
                && (psContext->eCodec == IMG_CODEC_MPEG4_CBR ||
                    psContext->eCodec == IMG_CODEC_MPEG4_VBR)) {
            psPicParams->sInParams.MinQPVal = 1;
        } else {
            psPicParams->sInParams.MinQPVal = 4;
        }
        break;

    default:
        /* the NO RC cases will fall here */
        break;
    }

    /* Set up Input Parameters that are mode dependent */
    switch (psContext->eCodec) {
    case IMG_CODEC_H264_NO_RC:
    case IMG_CODEC_H263_NO_RC:
    case IMG_CODEC_MPEG4_NO_RC:
        return ;

    case IMG_CODEC_H264_VCM:
        psPicParams->Flags      |= (ISVCM_FLAGS | ISCBR_FLAGS);
        if (psContext->Height >= 480) {
            /* for SD and above we can target 95% (122/128) of maximum bitrate */
            psPicParams->sInParams.VCMBitrateMargin = 122;
        } else {
            /* for less and SD we target 99% of maximum bitrate */
            psPicParams->sInParams.VCMBitrateMargin = 127;
        }
        if (i32BufferSizeInFrames < 15) {
            /* when we have a very small window size we reduce the target
             * further to avoid too much skipping */
            psPicParams->sInParams.VCMBitrateMargin -= 5;
        }
        psPicParams->sInParams.ForeceSkipMargin = 0; /* start skipping MBs when within 500 bits of slice or frame limit */
        if (psRCParams->BitsPerSecond < 1000000) {      // 1 Mbits/s
            psPicParams->sInParams.ScaleFactor = 0;
        } else if (psRCParams->BitsPerSecond < 2000000) { // 2 Mbits/s
            psPicParams->sInParams.ScaleFactor = 1;
        } else if (psRCParams->BitsPerSecond < 4000000) { // 4 Mbits/s
            psPicParams->sInParams.ScaleFactor = 2;
        } else if (psRCParams->BitsPerSecond < 8000000) { // 8 Mbits/s
            psPicParams->sInParams.ScaleFactor = 3;
        } else {
            psPicParams->sInParams.ScaleFactor = 4;
        }

        psPicParams->sInParams.BufferSize = i32BufferSizeInFrames;

        break;
    case IMG_CODEC_H264_CBR:
        psPicParams->Flags |= ISCBR_FLAGS;
        /* ------------------- H264 CBR RC ------------------- */
        /* Initialize the parameters of fluid flow traffic model. */
        psPicParams->sInParams.BufferSize = psRCParams->BufferSize;

        /* HRD consideration - These values are used by H.264 reference code. */
        if (psRCParams->BitsPerSecond < 1000000) {      /* 1 Mbits/s */
            psPicParams->sInParams.ScaleFactor = 0;
        } else if (psRCParams->BitsPerSecond < 2000000) { /* 2 Mbits/s */
            psPicParams->sInParams.ScaleFactor = 1;
        } else if (psRCParams->BitsPerSecond < 4000000) { /* 4 Mbits/s */
            psPicParams->sInParams.ScaleFactor = 2;
        } else if (psRCParams->BitsPerSecond < 8000000) { /* 8 Mbits/s */
            psPicParams->sInParams.ScaleFactor = 3;
        } else {
            psPicParams->sInParams.ScaleFactor = 4;
        }
        break;

    case IMG_CODEC_MPEG4_CBR:
    case IMG_CODEC_H263_CBR:
        psPicParams->Flags |= ISCBR_FLAGS;

        flBpp  = 256 * (psRCParams->BitsPerSecond / psContext->Width);
        flBpp /= (psContext->Height * psRCParams->FrameRate);

        if ((psPicParams->sInParams.MBPerFrm > 1024 && flBpp < 16) || (psPicParams->sInParams.MBPerFrm <= 1024 && flBpp < 24))
            psPicParams->sInParams.HalfFrameRate = 1;
        else
            psPicParams->sInParams.HalfFrameRate = 0;

        if (psPicParams->sInParams.HalfFrameRate >= 1) {
            psPicParams->sInParams.SeInitQP = 31;
            psPicParams->sInParams.AvQPVal = 31;
            psPicParams->sInParams.MyInitQP = 31;
        }

        psPicParams->sInParams.BufferSize = psRCParams->BufferSize;
        if (psPicParams->sInParams.BufferSize > 112 * 16384) // Simple Profile L5 Constraints
            psPicParams->sInParams.BufferSize = 112 * 16384;
        break;

    case IMG_CODEC_MPEG4_VBR:
    case IMG_CODEC_H263_VBR:
    case IMG_CODEC_H264_VBR:
        psPicParams->Flags |= ISVBR_FLAGS;

        psPicParams->sInParams.MBPerBU  = psPicParams->sInParams.MBPerFrm;
        psPicParams->sInParams.BUPerFrm = 1;

        /* Initialize the parameters of fluid flow traffic model. */
        psPicParams->sInParams.BufferSize = psRCParams->BufferSize;

        if (psContext->eCodec != IMG_CODEC_H264_VBR) {
            if (psPicParams->sInParams.BufferSize >  112 * 16384)
                psPicParams->sInParams.BufferSize = 112 * 16384; // Simple Profile L5 Constraints
        }

        /* These scale factor are used only for rate control to avoid overflow */
        /* in fixed-point calculation these scale factors are decided by bit rate */
        if (psRCParams->BitsPerSecond < 640000) {
            psPicParams->sInParams.ScaleFactor  = 2;                                            /* related to complexity */
        } else if (psRCParams->BitsPerSecond < 2000000) {
            psPicParams->sInParams.ScaleFactor  = 4;
        } else {
            psPicParams->sInParams.ScaleFactor  = 6;
        }
        break;
    default:
        break;
    }

    psPicParams->sInParams.MyInitQP     = psPicParams->sInParams.SeInitQP;

#if 0
    if (psContext->SyncSequencer)
        psPicParams->Flags |= SYNC_SEQUENCER;
#endif

    psPicParams->sInParams.InitialDelay = psRCParams->InitialDelay;
    psPicParams->sInParams.InitialLevel = psRCParams->InitialLevel;
    psRCParams->InitialQp = psPicParams->sInParams.SeInitQP;

    drv_debug_msg(VIDEO_DEBUG_GENERAL, "InitQP %d, minQP %d, maxQP %d\n",
            psPicParams->sInParams.SeInitQP,
            psPicParams->sInParams.MinQPVal,
            psPicParams->sInParams.MaxQPVal);

    /* The rate control uses this value to adjust the reaction rate
       to larger than expected frames in long GOPS*/

    return;
}


/***********************************************************************************
 * Function Name      : SetupRCData
 * Inputs             :
 * Outputs            :
 * Returns            :
 * Description        : Sets up RC Data
 ************************************************************************************/
void pnw__setup_rcdata(
    context_ENC_p psContext,
    PIC_PARAMS *psPicParams,
    IMG_RC_PARAMS *psRCParams)
{
    IMG_UINT8   ui8InitialSeInitQP;

    /* frameskip is always cleared, specially handled at vaEndPicture */
    psRCParams->FrameSkip = 0;

    if (!psRCParams->BitsPerSecond)
        psRCParams->BitsPerSecond = 64000;
    /*
        if (psRCParams->BitsPerSecond > max_bitrate)
            psRCParams->BitsPerSecond = max_bitrate;
    */
    if (!psRCParams->FrameRate)
        psRCParams->FrameRate = 30;

    pnw__setup_busize(psContext); /* calculate BasicUnitSize */

    psPicParams->sInParams.SeInitQP = psRCParams->InitialQp;

    psPicParams->sInParams.MBPerRow = (psContext->Width >> 4);
    psPicParams->sInParams.MBPerBU = psRCParams->BUSize;
    psPicParams->sInParams.MBPerFrm     = (psContext->Width >> 4) * (psContext->Height >> 4);
    psPicParams->sInParams.BUPerFrm     = (psPicParams->sInParams.MBPerFrm) / psRCParams->BUSize;
    psPicParams->sInParams.AvQPVal = psRCParams->InitialQp;
    psPicParams->sInParams.MyInitQP     = psRCParams->InitialQp;
    psPicParams->sInParams.MaxFrameSize = psRCParams->BitsPerSecond / psRCParams->FrameRate;

    ui8InitialSeInitQP = psPicParams->sInParams.SeInitQP;

    pnw__update_rcdata(psContext, psPicParams, psRCParams);

    /*If MinQP has been set, restore this value rather than
     *the calculated value set by UpdateRCData()*/
    if (psRCParams->MinQP) {
        psPicParams->sInParams.MinQPVal = (IMG_UINT8)psRCParams->MinQP;
    }

    /*If SeInitQP has been set, restore this value and other
     * dependant variables rather than the calculated values set by UpdateRCData()*/
    if (ui8InitialSeInitQP) {
        psPicParams->sInParams.SeInitQP = ui8InitialSeInitQP;
        psPicParams->sInParams.MyInitQP = ui8InitialSeInitQP;
        psRCParams->InitialQp = ui8InitialSeInitQP;
    }

    /* HRD parameters are meaningless without a bitrate
     * HRD parameters are not supported in VCM mode */
    if (psRCParams->BitsPerSecond == 0 || psContext->eCodec == IMG_CODEC_H264_VCM)
         psContext->bInserHRDParams = IMG_FALSE;

    if (psContext->bInserHRDParams) {
        psPicParams->ClockDivBitrate = (90000 * 0x100000000LL);
        psPicParams->ClockDivBitrate /= psRCParams->BitsPerSecond;
        psPicParams->MaxBufferMultClockDivBitrate = (IMG_UINT32)
                (((IMG_UINT64)(psRCParams->BufferSize) * (IMG_UINT64) 90000)
                 / (IMG_UINT64) psRCParams->BitsPerSecond);
    }
    return ;
}

static void pnw__setup_qpvalue_h264(
    MTX_CURRENT_IN_PARAMS * psCurrent,
    IMG_BYTE bySliceQP)
{
    /* H.264 QP scaling tables */
    IMG_BYTE HOST_PVR_QP_SCALE_CR[52] = {
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
        12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
        28, 29, 29, 30, 31, 32, 32, 33, 34, 34, 35, 35, 36, 36, 37, 37,
        37, 38, 38, 38, 39, 39, 39, 39
    };

    psCurrent->bySliceQP = bySliceQP;
    psCurrent->bySliceQPC = HOST_PVR_QP_SCALE_CR[psCurrent->bySliceQP];
}


static void pnw__setup_qpvalues_mpeg4(
    MTX_CURRENT_IN_PARAMS * psCurrent,
    IMG_BYTE bySliceQP)
{
    psCurrent->bySliceQP =      bySliceQP;
}

static void pnw__setup_slice_row_params(
    context_ENC_p ctx,
    IMG_BOOL IsIntra,
    IMG_UINT16 CurrentRowY,
    IMG_INT16 SliceStartRowY,
    IMG_INT16 SliceHeight,
    IMG_BOOL VectorsValid,
    int bySliceQP)
{
    /* Note: CurrentRowY and SliceStartRowY are now in pixels (not MacroBlocks)
     * - saves needless multiplications and divisions
     */
    MTX_CURRENT_IN_PARAMS *psCurrent;
    pnw_cmdbuf_p cmdbuf = ctx->obj_context->pnw_cmdbuf;

    IMG_INT16   iPos, iYPos, srcY;
    IMG_UINT16  ui16tmp;
    IMG_UINT16 ui16SearchWidth, ui16SearchHeight, ui16SearchLeftOffset, ui16SearchTopOffset, ui16CurBlockX;

    if (IsIntra && cmdbuf->topaz_in_params_I_p == NULL) {
        VAStatus vaStatus = psb_buffer_map(cmdbuf->topaz_in_params_I, &cmdbuf->topaz_in_params_I_p);
        if (vaStatus != VA_STATUS_SUCCESS) {
            drv_debug_msg(VIDEO_DEBUG_ERROR, "map topaz MTX_CURRENT_IN_PARAMS failed\n");
            return;
        }
    }

    if ((!IsIntra) && cmdbuf->topaz_in_params_P_p == NULL) {
        VAStatus vaStatus = psb_buffer_map(cmdbuf->topaz_in_params_P, &cmdbuf->topaz_in_params_P_p);
        if (vaStatus != VA_STATUS_SUCCESS) {
            drv_debug_msg(VIDEO_DEBUG_ERROR, "map topaz MTX_CURRENT_IN_PARAMS failed\n");
            return;
        }
    }

    if (IsIntra)
        psCurrent = (MTX_CURRENT_IN_PARAMS*)(cmdbuf->topaz_in_params_I_p + ctx->in_params_ofs);
    else
        psCurrent = (MTX_CURRENT_IN_PARAMS*)(cmdbuf->topaz_in_params_P_p + ctx->in_params_ofs);

    psCurrent += (CurrentRowY  * (ctx->Width) / 256);

    // Note: CurrentRowY and iSliceStartRowY are now in pixels (not MacroBlocks) - saves needless multiplications and divisions

    ui16SearchHeight = min(MVEA_LRB_SEARCH_HEIGHT, ctx->Height);
    ui16SearchWidth = min(MVEA_LRB_SEARCH_WIDTH, ctx->Width);
    ui16SearchLeftOffset = (((ui16SearchWidth / 2) / 16) * 16); // this is the amount of data that gets preloaded
    ui16SearchTopOffset = (((ui16SearchHeight / 2) / 16) * 16);
    ui16CurBlockX = MVEA_LRB_SEARCH_WIDTH - (ui16SearchLeftOffset + 16); // this is our block position relative to the start of the LRB

    if ((iYPos = srcY = CurrentRowY - ui16SearchTopOffset) < 0)
        srcY = 0;
    else if (iYPos > ctx->HeightMinusLRB_TopAndBottom_OffsetsPlus16)
        srcY = ctx->HeightMinusLRBSearchHeight;


    /*DDK 243 removed this block of code.*/
    /*if((ctx->eCodec==IMG_CODEC_H263_NO_RC)||(ctx->eCodec==IMG_CODEC_H263_CBR)||(ctx->eCodec==IMG_CODEC_H263_VBR))
      ui16tmp = CurrentRowY;
      else*/
    ui16tmp = (CurrentRowY != SliceStartRowY);

    for (iPos = 0; iPos < ctx->Width; iPos += 16, psCurrent++) {
        memset(psCurrent, 0, sizeof(MTX_CURRENT_IN_PARAMS));
        psCurrent->MVValid = 0;
        psCurrent->ParamsValid = 0;

        if (SliceStartRowY) {
            psCurrent->MVValid = VECTORS_ABOVE_VALID;
        }
        /* Setup the parameters and motion vectors*/
        if (ui16tmp) {
            psCurrent->MVValid = VECTORS_ABOVE_VALID | DO_INTRA_PRED;
            psCurrent->ParamsValid |= PARAMS_ABOVE_VALID;

            if (iPos + 16 < ctx->Width) {
                psCurrent->ParamsValid |= PARAMS_ABOVER_VALID;
                psCurrent->MVValid |= /*VECTORS_LEFT_VALID; //*/(1 << 2); /* Vectors left valid define looks wrong*/
            }

            if (iPos > 0 && (iPos < ctx->Width)) {
                psCurrent->ParamsValid |= PARAMS_ABOVEL_VALID;
                psCurrent->MVValid |= VECTORS_ABOVE_LEFT_VALID; //(1<<0)
            }
        } else {
            // are we the first MB in a new slice?
            if (iPos == 0) {
                if ((ctx->eCodec == IMG_CODEC_H263_NO_RC) || (ctx->eCodec == IMG_CODEC_H263_CBR) || (ctx->eCodec == IMG_CODEC_H263_VBR)) {
                    if (iYPos == -ui16SearchTopOffset)
                        psCurrent->ParamsValid |= MB_START_OF_SLICE;// OPTI?
                } else {
                    psCurrent->ParamsValid |= MB_START_OF_SLICE;// OPTI?
                }
            }
        }
        /*DDK 243 removed this block of code.*/
        /*if((ctx->eCodec==IMG_CODEC_H263_NO_RC) || (ctx->eCodec==IMG_CODEC_H263_CBR)||(ctx->eCodec==IMG_CODEC_H263_VBR))
          {
        // clear the above params valid bits
        psCurrent->ParamsValid &=~(PARAMS_ABOVEL_VALID|PARAMS_ABOVER_VALID|PARAMS_ABOVE_VALID); // OPTI
        }*/
        // Have to fill in the right hand row of 4x4 vectors into the the left block
        if (iPos) {
            psCurrent->MVValid |= DO_INTRA_PRED | (1 << 3); /*MV_VALID define looks wrong?! so use hard coded value for now*/
            psCurrent->ParamsValid |= 8; //(1<<3)
        }
        if (iPos == ctx->Width - 16) {
            // indicate the last MB in a row
            psCurrent->ParamsValid |= MB_END_OF_ROW;
            // are we the last mb in the slice?
            if (iYPos == (SliceStartRowY + SliceHeight - (ui16SearchTopOffset + 16))) {
                psCurrent->ParamsValid |= MB_END_OF_SLICE;
                if (iYPos == ctx->HeightMinus16MinusLRBTopOffset) {
                    psCurrent->ParamsValid |= MB_END_OF_PICTURE;
                }
            }
        }
        // And now the below block
        // should do some kind of check to see if we are the first inter block, as otherwise the vectors will be invalid!
        if (VectorsValid) {
            if (iYPos < ctx->HeightMinus16MinusLRBTopOffset) {
                psCurrent->MVValid |= VECTORS_BELOW_VALID; //(1<<4)

                if (iYPos < ctx->HeightMinus32MinusLRBTopOffset) {
                    psCurrent->MVValid |= VECTORS_2BELOW_VALID; //(1<<5)
                }
            }
        }

        /*Set up IPEMin and Max for coordinate X in the search reference region*/
        /*And set up flags in SPEMax when needed*/
        if (iPos <= ui16SearchLeftOffset) {
            psCurrent->IPEMin[0] = ui16CurBlockX - iPos;
            psCurrent->RealEdge |= SPE_EDGE_LEFT;
        } else {
            psCurrent->IPEMin[0] = ui16CurBlockX / 16;
        }

        if ((iPos + ui16SearchLeftOffset + 16) > ctx->Width) {
            psCurrent->IPEMax[0] = (ui16CurBlockX - 1 + ctx->Width) - iPos; //(112 - 1) - ((iPos + 48+16) - ctx->psVideo->ui16Width);
            psCurrent->RealEdge |= SPE_EDGE_RIGHT;
        } else {
            psCurrent->IPEMax[0] = (ui16CurBlockX + 16 + ui16SearchLeftOffset) - 1 - 3; //(112 - 1) - 3;
        }

        /*Set up IPEMin and Max for Y coordinate in the search reference region*/
        /*And set up flags in SPEMax when needed*/
        if (iYPos <= 0) {
            psCurrent->IPEMin[1] = 0;
            psCurrent->RealEdge |= SPE_EDGE_TOP;
        } else {
            psCurrent->IPEMin[1] = 3;
        }

        //Max Y
        if (iYPos > ctx->HeightMinusLRB_TopAndBottom_OffsetsPlus16) {
            psCurrent->IPEMax[1] = ui16SearchHeight - 1;
            psCurrent->RealEdge |= ui16SearchHeight - 4;
        } else {
            psCurrent->IPEMax[1] = ui16SearchHeight - 4;
        }

        psCurrent->CurBlockAddr = ((ui16CurBlockX) / 16);
        psCurrent->CurBlockAddr |= ((IMG_UINT8)(((iYPos + ui16SearchTopOffset) - srcY) / 16) << 4);

        /* Setup the control register values
           These will get setup and transferred to a different location within the macroblock parameter structure.
           They are then read out of the esb by the mtx and used to control the hardware units
           */
        psCurrent->IPEControl = ctx->IPEControl;

        switch (ctx->eCodec) {
        case IMG_CODEC_H263_NO_RC:
        case IMG_CODEC_H263_VBR:
        case IMG_CODEC_H263_CBR:
            pnw__setup_qpvalues_mpeg4(psCurrent, bySliceQP);
            psCurrent->JMCompControl = F_ENCODE(2, MVEA_CR_JMCOMP_MODE);
            psCurrent->VLCControl = F_ENCODE(3, TOPAZ_VLC_CR_CODEC) | F_ENCODE(IsIntra ? 0 : 1, TOPAZ_VLC_CR_SLICE_CODING_TYPE);
            break;
        case IMG_CODEC_MPEG4_NO_RC:
        case IMG_CODEC_MPEG4_VBR:
        case IMG_CODEC_MPEG4_CBR:
            pnw__setup_qpvalues_mpeg4(psCurrent, bySliceQP);
            psCurrent->JMCompControl = F_ENCODE(1, MVEA_CR_JMCOMP_MODE) | F_ENCODE(1, MVEA_CR_JMCOMP_AC_ENABLE);
            psCurrent->VLCControl = F_ENCODE(2, TOPAZ_VLC_CR_CODEC) | F_ENCODE(IsIntra ? 0 : 1, TOPAZ_VLC_CR_SLICE_CODING_TYPE);
            break;
        default:
        case IMG_CODEC_H264_NO_RC:
        case IMG_CODEC_H264_VBR:
        case IMG_CODEC_H264_CBR:
        case IMG_CODEC_H264_VCM:
            pnw__setup_qpvalue_h264(psCurrent, bySliceQP);
            psCurrent->JMCompControl = F_ENCODE(0, MVEA_CR_JMCOMP_MODE);
            psCurrent->VLCControl = F_ENCODE(1, TOPAZ_VLC_CR_CODEC) | F_ENCODE(IsIntra ? 0 : 1, TOPAZ_VLC_CR_SLICE_CODING_TYPE);
            break;
        }
    }

    // now setup the dummy end of frame macroblock.
    if ((CurrentRowY + 16) >= ctx->Height) {
        memset(psCurrent, 0, sizeof(MTX_CURRENT_IN_PARAMS));
        psCurrent->MVValid = DO_INTRA_PRED;
        psCurrent->ParamsValid = 0;
        psCurrent->RealEdge = 0;
    }
}

void pnw_setup_slice_params(
    context_ENC_p  ctx,
    IMG_UINT16 YSliceStartPos,
    IMG_UINT16 SliceHeight,
    IMG_BOOL IsIntra,
    IMG_BOOL  VectorsValid,
    int bySliceQP)
{
    IMG_UINT16 Rows, CurrentRowY;

    Rows = SliceHeight / 16;
    CurrentRowY = YSliceStartPos;

    while (Rows) {
        pnw__setup_slice_row_params(
            ctx,
            IsIntra,
            CurrentRowY,
            YSliceStartPos,
            SliceHeight,
            VectorsValid, bySliceQP);

        CurrentRowY += 16;
        Rows--;
    }

}


IMG_UINT32 pnw__send_encode_slice_params(
    context_ENC_p ctx,
    IMG_BOOL IsIntra,
    IMG_UINT16 CurrentRow,
    IMG_UINT8  DeblockIDC,
    IMG_UINT32 FrameNum,
    IMG_UINT16 SliceHeight,
    IMG_UINT16 CurrentSlice)
{
    SLICE_PARAMS *psSliceParams;
    IMG_INT16 RowOffset;
    IMG_UINT16 SearchHeight, SearchTopOffset;

    psb_buffer_p psCoded;
    object_surface_p ref_surface;
    psb_buffer_p psRef;
    pnw_cmdbuf_p cmdbuf = ctx->obj_context->pnw_cmdbuf;


    drv_debug_msg(VIDEO_DEBUG_GENERAL, "Send encode slice parmas, Is Intra:%d, CurrentRow:%d" \
                             "DeblockIDC:%d, FrameNum:%d, SliceHeight:%d, CurrentSlice:%d\n",
                             IsIntra, CurrentRow, DeblockIDC, FrameNum, SliceHeight, CurrentSlice);

    ref_surface = ctx->ref_surface;
    psRef = &ctx->ref_surface->psb_surface->buf;
    psCoded = ctx->coded_buf->psb_buffer;

    psSliceParams = (SLICE_PARAMS *)(cmdbuf->slice_params_p +
                                     CurrentSlice * ((sizeof(SLICE_PARAMS) + 15) & 0xfff0));

    psSliceParams->SliceHeight = SliceHeight;
    psSliceParams->SliceStartRowNum = CurrentRow / 16;
    psSliceParams->ScanningIntraParams = (1 << SCANNING_INTRA_WIDTH_SHIFT) |
        (1 << SCANNING_INTRA_STEP_SHIFT);

    /* We want multiple ones of these so we can submit multiple slices without having to wait for the next */
    psSliceParams->Flags = 0;
    psSliceParams->HostCtx = 0xdafed123;

#ifdef VA_EMULATOR
    psSliceParams->RefYStride = ref_surface->psb_surface->stride;
    psSliceParams->RefUVStride = ref_surface->psb_surface->stride;
    psSliceParams->RefYRowStride =  ref_surface->psb_surface->stride * 16;
    psSliceParams->RefUVRowStride = ref_surface->psb_surface->stride * 16 / 2;
#else
    psSliceParams->RefYStride = ref_surface->psb_surface->stride;
    psSliceParams->RefUVStride = ref_surface->psb_surface->stride;
    psSliceParams->RefYRowStride =  ref_surface->psb_surface->stride * 16;
    psSliceParams->RefUVRowStride = ref_surface->psb_surface->stride * 16 / 2;
#endif
    psSliceParams->NumAirMBs = ctx->num_air_mbs;
    psSliceParams->AirThreshold = ctx->air_threshold;

    if (ctx->eCodec == IMG_CODEC_H264_VCM && ctx->max_slice_size == 0)
        psSliceParams->MaxSliceSize = ctx->Width * ctx->Height * 12 / 2;
    else
        psSliceParams->MaxSliceSize = ctx->max_slice_size;
    psSliceParams->FCode = ctx->FCode;/* Not clear yet, This field is not appare in firmware doc */

    SearchHeight = min(MVEA_LRB_SEARCH_HEIGHT, ctx->Height);
    SearchTopOffset = (((SearchHeight / 2) / 16) * 16);

    RowOffset = CurrentRow - SearchTopOffset;
    if (RowOffset <= 0)
        RowOffset = 0;
    if (RowOffset > (ctx->Height - SearchHeight))
        RowOffset = (ctx->Height - SearchHeight);
    if (!IsIntra) {
        psSliceParams->Flags |= ISINTER_FLAGS;
    }

    switch (DeblockIDC) {
    case 0:
        psSliceParams->Flags |= DEBLOCK_FRAME;
        break;
    case 2:
        psSliceParams->Flags |= DEBLOCK_SLICE;
        break;
    case 1:
    default:
        // do nothing
        break;
    }

    switch (ctx->eCodec) {
    case IMG_CODEC_H263_NO_RC:
    case IMG_CODEC_H263_VBR:
    case IMG_CODEC_H263_CBR:
        psSliceParams->Flags |= ISH263_FLAGS;
        break;
    case IMG_CODEC_MPEG4_NO_RC:
    case IMG_CODEC_MPEG4_VBR:
    case IMG_CODEC_MPEG4_CBR:
        psSliceParams->Flags |= ISMPEG4_FLAGS;
        break;
    case IMG_CODEC_H264_NO_RC:
    case IMG_CODEC_H264_CBR:
    case IMG_CODEC_H264_VCM:
    case IMG_CODEC_H264_VBR:
        psSliceParams->Flags |= ISH264_FLAGS;
        break;
    default:
        psSliceParams->Flags |= ISH264_FLAGS;
        printf("No format specified defaulting to h.264\n");
        break;
    }
    /* we should also setup the interleaving requirements based on the source format */
    if (ctx->eFormat == IMG_CODEC_PL12) /* FIXME contrary with old DDK, take notice */
        psSliceParams->Flags |= INTERLEAVE_TARGET;

    cmdbuf = ctx->obj_context->pnw_cmdbuf;

    RELOC_SLICE_PARAMS_PNW(&(psSliceParams->RefYBase), 256 * RowOffset / 16, psRef);
    RELOC_SLICE_PARAMS_PNW(&(psSliceParams->RefUVBase),
                           ref_surface->psb_surface->stride * ref_surface->height + (RowOffset * 128 / 16),
                           psRef);
    if (IsIntra)
        RELOC_SLICE_PARAMS_PNW(&(psSliceParams->InParamsBase),
                               ctx->in_params_ofs,
                               //((CurrentRow * (ctx->Width)) / 256 + ctx->obj_context->slice_count) * sizeof(MTX_CURRENT_IN_PARAMS),
                               cmdbuf->topaz_in_params_I);
    else
        RELOC_SLICE_PARAMS_PNW(&(psSliceParams->InParamsBase),
                               ctx->in_params_ofs,
                               //((CurrentRow * (ctx->Width)) / 256 + ctx->obj_context->slice_count) * sizeof(MTX_CURRENT_IN_PARAMS),
                               cmdbuf->topaz_in_params_P);

#if  TOPAZ_PIC_PARAMS_VERBOSE
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "sizeof psSliceParams %d\n", sizeof(*psSliceParams));
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "sizeof MTX_CURRENT_IN_PARAMS %d\n", sizeof(MTX_CURRENT_IN_PARAMS));
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->SliceStartRowNum %d\n", psSliceParams->SliceStartRowNum);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->SliceHeight %d\n", psSliceParams->SliceHeight);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->RefYBase %x\n", psSliceParams->RefYBase);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->RefUVBase %x\n", psSliceParams->RefUVBase);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->RefYStride %d\n", psSliceParams->RefYStride);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->RefUVStride %d\n", psSliceParams->RefUVStride);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->RefYRowStride %d\n", psSliceParams->RefYRowStride);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->RefUVRowStride %d\n", psSliceParams->RefUVRowStride);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->HostCtx %x\n", psSliceParams->HostCtx);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->Flags %x\n", psSliceParams->Flags);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->MaxSliceSize %d\n",  psSliceParams->MaxSliceSize);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->FCode %x\n", psSliceParams->FCode);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->InParamsBase %x\n", psSliceParams->InParamsBase);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->NumAirMBs %d\n", psSliceParams->NumAirMBs);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->AirThreshold %x\n", psSliceParams->AirThreshold);
    drv_debug_msg(VIDEO_DEBUG_GENERAL, "psSliceParams->ScanningIntraParams %x\n", psSliceParams->ScanningIntraParams);
#endif

    pnw_cmdbuf_insert_command_package(ctx->obj_context,
                                      ctx->SliceToCore,
                                      MTX_CMDID_ENCODE_SLICE,
                                      &cmdbuf->slice_params,
                                      CurrentSlice *((sizeof(SLICE_PARAMS) + 15) & 0xfff0));


    return 0;
}


/*
 * Function Name      : Reset_EncoderParams
 * Description        : Reset Above & Below Params at the Start of Intra frame
 */
void pnw_reset_encoder_params(context_ENC_p ctx)
{
    unsigned char *Add_Below, *Add_Above;
    pnw_cmdbuf_p cmdbuf = ctx->obj_context->pnw_cmdbuf;

    /* all frames share the same Topaz param, in_param/aboveparam/bellow
     * map it only when necessary
     */
    if (cmdbuf->topaz_above_params_p == NULL) {
        VAStatus vaStatus = psb_buffer_map(cmdbuf->topaz_above_params, &cmdbuf->topaz_above_params_p);
        if (vaStatus != VA_STATUS_SUCCESS) {
            drv_debug_msg(VIDEO_DEBUG_ERROR, "map topaz MTX_CURRENT_IN_PARAMS failed\n");
            return;
        }
    }

    if (cmdbuf->topaz_below_params_p == NULL) {
        VAStatus vaStatus = psb_buffer_map(cmdbuf->topaz_below_params, &cmdbuf->topaz_below_params_p);
        if (vaStatus != VA_STATUS_SUCCESS) {
            drv_debug_msg(VIDEO_DEBUG_ERROR, "map topaz MTX_CURRENT_IN_PARAMS failed\n");
            return;
        }
    }

    Add_Below = cmdbuf->topaz_below_params_p +
                ctx->below_params_ofs;

    memset(Add_Below, 0, ctx->below_params_size * 4);

    Add_Above = cmdbuf->topaz_above_params_p + ctx->above_params_ofs;
    memset(Add_Above, 0, ctx->above_params_size * MAX_TOPAZ_CORES);
}