/*
* 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:
* Zeng Li <zeng.li@intel.com>
* Shengquan Yuan <shengquan.yuan@intel.com>
* Binglin Chen <binglin.chen@intel.com>
*
*/
#include "psb_drv_video.h"
#include "lnc_hostcode.h"
#include "hwdefs/topaz_defs.h"
#include "psb_def.h"
#include "psb_cmdbuf.h"
#include <stdio.h>
#include "psb_output.h"
#include <wsbm/wsbm_manager.h>
#include "lnc_hostheader.h"
#include "psb_drv_debug.h"
#define ALIGN_TO(value, align) ((value + align - 1) & ~(align - 1))
#define PAGE_ALIGN(value) ALIGN_TO(value, 4096)
static VAStatus lnc__alloc_context_buffer(context_ENC_p ctx)
{
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;
ctx->pic_params_size = 256;
ctx->header_buffer_size = 4 * 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->slice_header_ofs = 4 * HEADER_SIZE;
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 = (10 + width * height / (16 * 16)) * sizeof(MTX_CURRENT_IN_PARAMS);
ctx->bellow_params_size = BELOW_PARAMS_SIZE * width * height / (16 * 16) * 16;
ctx->above_params_size = (width * height / 16) * 128 + 15;
ctx->topaz_buffer_size = ctx->in_params_size + /* MTX_CURRENT_IN_PARAMS size */
ctx->bellow_params_size + /* above_params */
ctx->above_params_size; /* above_params */
vaStatus = psb_buffer_create(ctx->obj_context->driver_data, ctx->in_params_size, psb_bt_cpu_vpu, &ctx->topaz_in_params_I);
vaStatus |= psb_buffer_create(ctx->obj_context->driver_data, ctx->in_params_size, psb_bt_cpu_vpu, &ctx->topaz_in_params_P);
vaStatus |= psb_buffer_create(ctx->obj_context->driver_data, ctx->above_params_size + ctx->bellow_params_size, psb_bt_cpu_vpu, &ctx->topaz_above_bellow_params);
ctx->in_params_ofs = 0;
ctx->bellow_params_ofs = 0;
ctx->above_params_ofs = ctx->bellow_params_ofs + ctx->bellow_params_size;
return vaStatus;
}
unsigned int lnc__get_ipe_control(enum drm_lnc_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 lnc_DestroyContext(object_context_p obj_context)
{
context_ENC_p ctx;
ctx = (context_ENC_p)obj_context->format_data;
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 lnc_CreateContext(
object_context_p obj_context,
object_config_p obj_config)
{
int width, height;
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));
if (NULL == ctx) {
vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
DEBUG_FAILURE;
return vaStatus;
}
obj_context->format_data = (void*) ctx;
ctx->obj_context = obj_context;
ctx->RawWidth = (unsigned short) width;
ctx->RawHeight = (unsigned short) height;
ctx->Width = (unsigned short)(~0xf & (width + 0xf));
ctx->Height = (unsigned short)(~0xf & (height + 0xf));
ctx->HeightMinus16MinusLRBTopOffset = ctx->Height - (MVEA_LRB_TOP_OFFSET + 16);
ctx->HeightMinus32MinusLRBTopOffset = ctx->Height - (MVEA_LRB_TOP_OFFSET + 32);
ctx->HeightMinusLRB_TopAndBottom_OffsetsPlus16 = ctx->Height - (MVEA_LRB_TOP_OFFSET + MVEA_LRB_TOP_OFFSET + 16);
ctx->HeightMinusLRBSearchHeight = ctx->Height - MVEA_LRB_SEARCH_HEIGHT;
ctx->FCode = 0;
ctx->sRCParams.VCMBitrateMargin = 0;
ctx->sRCParams.BufferSize = 0;
ctx->sRCParams.InitialQp = 0;
ctx->sRCParams.MinQP = 0;
vaStatus = lnc__alloc_context_buffer(ctx);
return vaStatus;
}
VAStatus lnc_BeginPicture(context_ENC_p ctx)
{
VAStatus vaStatus = VA_STATUS_SUCCESS;
lnc_cmdbuf_p cmdbuf;
int ret;
ctx->src_surface = ctx->obj_context->current_render_target;
/* clear frameskip flag to 0 */
CLEAR_SURFACE_INFO_skipped_flag(ctx->src_surface->psb_surface);
/* Initialise the command buffer */
ret = lnc_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->lnc_cmdbuf;
/* 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_in_params_I_p = NULL;
cmdbuf->topaz_in_params_P_p = NULL;
cmdbuf->topaz_above_bellow_params_p = NULL;
if (ctx->obj_context->frame_count == 0) { /* first picture */
psb_driver_data_p driver_data = ctx->obj_context->driver_data;
lnc_cmdbuf_insert_command(cmdbuf, MTX_CMDID_SW_NEW_CODEC, 3, driver_data->drm_context);
lnc_cmdbuf_insert_command_param(cmdbuf, ctx->eCodec);
lnc_cmdbuf_insert_command_param(cmdbuf, (ctx->Width << 16) | ctx->Height);
}
/* insert START_PIC command */
lnc_cmdbuf_insert_command(cmdbuf, MTX_CMDID_START_PIC, 3, ctx->obj_context->frame_count);
/* write the address of structure PIC_PARAMS following command MTX_CMDID_START_PIC
* the content of PIC_PARAMS is filled when RenderPicture(...,VAEncPictureParameterBufferXXX)
*/
RELOC_CMDBUF(cmdbuf->cmd_idx, 0, &cmdbuf->pic_params);
cmdbuf->cmd_idx++;
ctx->initial_qp_in_cmdbuf = cmdbuf->cmd_idx; /* remember the place */
cmdbuf->cmd_idx++;
ctx->obj_context->slice_count = 0;
/* no RC paramter provided in vaBeginPicture
* so delay RC param setup into vaRenderPicture(SequenceHeader...)
*/
return vaStatus;
}
VAStatus lnc_RenderPictureParameter(context_ENC_p ctx)
{
PIC_PARAMS *psPicParams; /* PIC_PARAMS has been put in lnc_hostcode.h */
object_surface_p src_surface;
unsigned int srf_buf_offset;
object_surface_p rec_surface;
object_surface_p ref_surface;
lnc_cmdbuf_p cmdbuf = ctx->obj_context->lnc_cmdbuf;
VAStatus vaStatus = VA_STATUS_ERROR_UNKNOWN;
psPicParams = (PIC_PARAMS *)cmdbuf->pic_params_p;
/* 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;
if (NULL == src_surface) {
vaStatus = VA_STATUS_ERROR_INVALID_SURFACE;
DEBUG_FAILURE;
return vaStatus;
}
rec_surface = ctx->dest_surface;
if (NULL == rec_surface) {
vaStatus = VA_STATUS_ERROR_INVALID_SURFACE;
DEBUG_FAILURE;
return vaStatus;
}
/*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;
if (NULL == ref_surface) {
vaStatus = VA_STATUS_ERROR_INVALID_SURFACE;
DEBUG_FAILURE;
return vaStatus;
}
/* 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 * 16 / 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 * 16;
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;
psPicParams->DstYRowStride = rec_surface->psb_surface->stride * 16;
psPicParams->DstUVRowStride = rec_surface->psb_surface->stride * 16 / 2;
#else
psPicParams->DstYStride = rec_surface->height * 16;
psPicParams->DstUVStride = rec_surface->height * 16 / 2;
psPicParams->DstYRowStride = psPicParams->DstYStride;
psPicParams->DstUVRowStride = psPicParams->DstUVStride;
#endif
psPicParams->InParamsRowStride = (ctx->obj_context->picture_width / 16) * 256;
psPicParams->BelowParamRowStride = (ctx->obj_context->picture_width / 16) * 32;
psPicParams->Width = ctx->Width;
psPicParams->Height = ctx->Height;
/* 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;
/* drop through to CBR case */
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 (ctx->sRCParams.RCEnable) {
/* for the first frame, will setup RC params in EndPicture */
if (ctx->obj_context->frame_count > 0) { /* reuse in_params parameter */
/* reload IN_RC_PARAMS from cache */
memcpy(&psPicParams->sInParams, &ctx->in_params_cache, sizeof(IN_RC_PARAMS));
/* delay these into END_PICTURE timeframe */
/*
psPicParams->sInParams.BitsTransmitted = ctx->sRCParams.BitsTransmitted;
*/
}
} 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(&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(&psPicParams->SrcUBase,
srf_buf_offset + src_surface->psb_surface->chroma_offset,
&src_surface->psb_surface->buf);
RELOC_PIC_PARAMS(&psPicParams->SrcVBase,
srf_buf_offset + src_surface->psb_surface->chroma_offset,
&src_surface->psb_surface->buf);
break;
case IMG_CODEC_IMC2:
case IMG_CODEC_NV12:
break;
}
/*
* Do not forget this!
* MTXWriteMem(MTXData.ui32CCBCtrlAddr + MTX_CCBCTRL_QP, sRCParams.ui32InitialQp);
*/
/* following START_PIC, insert initial QP */
*ctx->initial_qp_in_cmdbuf = ctx->sRCParams.InitialQp;
RELOC_PIC_PARAMS(&psPicParams->DstYBase, 0, &rec_surface->psb_surface->buf);
RELOC_PIC_PARAMS(&psPicParams->DstUVBase,
rec_surface->psb_surface->stride * rec_surface->height,
&rec_surface->psb_surface->buf);
RELOC_PIC_PARAMS(&psPicParams->CodedBase, 0, ctx->coded_buf->psb_buffer);
/* MTX_CURRENT_IN_PARAMS buffer is seperate buffer now */
/*The type of frame will decide psPicParams->InParamsBase should
* use cmdbuf->topaz_in_params_P or cmdbuf->topaz_in_params_I*/
/*RELOC_PIC_PARAMS(&psPicParams->InParamsBase, ctx->in_params_ofs, cmdbuf->topaz_in_params_P);*/
RELOC_PIC_PARAMS(&psPicParams->BelowParamsBase, ctx->bellow_params_ofs, cmdbuf->topaz_above_bellow_params);
RELOC_PIC_PARAMS(&psPicParams->AboveParamsBase, ctx->above_params_ofs, cmdbuf->topaz_above_bellow_params);
return VA_STATUS_SUCCESS;
}
static VAStatus lnc__PatchBitsConsumedInRCParam(context_ENC_p ctx)
{
lnc_cmdbuf_p cmdbuf = ctx->obj_context->lnc_cmdbuf;
/* PIC_PARAMS *psPicParams = cmdbuf->pic_params_p; */
VAStatus vaStatus;
(void)cmdbuf;
/* it will wait until last encode session is done */
/* now it just wait the last session is done and the frame skip
* is */
drv_debug_msg(VIDEO_DEBUG_GENERAL, "will patch bits consumed for rc\n");
if (ctx->pprevious_coded_buf) {
vaStatus = psb_buffer_sync(ctx->pprevious_coded_buf->psb_buffer);
if (vaStatus)
return vaStatus;
}
return VA_STATUS_SUCCESS;
}
static VAStatus lnc_RedoRenderPictureSkippedFrame(context_ENC_p ctx)
{
lnc_cmdbuf_p cmdbuf = ctx->obj_context->lnc_cmdbuf;
VAStatus vaStatus = VA_STATUS_SUCCESS;
int i = 0;
/* reset cmdbuf to skip existing picture/slice DO_HEAD commands */
cmdbuf->cmd_idx = cmdbuf->cmd_idx_saved_frameskip;
switch (ctx->eCodec) {
case IMG_CODEC_H263_CBR: /* H263 don't need picture header/slice header, only reset command buf */
case IMG_CODEC_H263_VBR:
break;
case IMG_CODEC_H264_VBR:
case IMG_CODEC_H264_CBR: /* slice header needs redo */
case IMG_CODEC_H264_VCM: {
/* only need one slice header here */
VAEncSliceParameterBuffer *pBuffer = &ctx->slice_param_cache[i];
unsigned int MBSkipRun, FirstMBAddress;
int deblock_on;
if ((pBuffer->slice_flags.bits.disable_deblocking_filter_idc == 0)
|| (pBuffer->slice_flags.bits.disable_deblocking_filter_idc == 2))
deblock_on = IMG_TRUE;
else
deblock_on = IMG_FALSE;
if (1 /* ctx->sRCParams.RCEnable && ctx->sRCParams.FrameSkip */) /* we know it is true */
MBSkipRun = (ctx->Width * ctx->Height) / 256;
else
MBSkipRun = 0;
FirstMBAddress = (pBuffer->start_row_number * ctx->Width) / 16;
/* Insert Do Header command, relocation is needed */
lnc__H264_prepare_slice_header((IMG_UINT32 *)(cmdbuf->header_mem_p + ctx->slice_header_ofs + i * HEADER_SIZE),
0, /*pBuffer->slice_flags.bits.is_intra*/
pBuffer->slice_flags.bits.disable_deblocking_filter_idc,
ctx->obj_context->frame_count,
FirstMBAddress,
MBSkipRun,
(ctx->obj_context->frame_count == 0),
pBuffer->slice_flags.bits.uses_long_term_ref,
pBuffer->slice_flags.bits.is_long_term_ref,
ctx->idr_pic_id);
lnc_cmdbuf_insert_command(cmdbuf, MTX_CMDID_DO_HEADER, 2, (i << 2) | 2);
RELOC_CMDBUF(cmdbuf->cmd_idx++,
ctx->slice_header_ofs + i * HEADER_SIZE,
&cmdbuf->header_mem);
}
break;
case IMG_CODEC_MPEG4_VBR:
case IMG_CODEC_MPEG4_CBR: /* only picture header need redo */
lnc__MPEG4_prepare_vop_header((IMG_UINT32 *)(cmdbuf->header_mem_p + ctx->pic_header_ofs),
IMG_FALSE /* bIsVOPCoded is false now */,
ctx->MPEG4_vop_time_increment_frameskip, /* In testbench, this should be FrameNum */
4,/* default value is 4,search range */
ctx->MPEG4_picture_type_frameskip,
ctx->MPEG4_vop_time_increment_resolution/* defaule value */);
lnc_cmdbuf_insert_command(cmdbuf, MTX_CMDID_DO_HEADER, 2, 1);
RELOC_CMDBUF(cmdbuf->cmd_idx++, ctx->pic_header_ofs, &cmdbuf->header_mem);
vaStatus = lnc_RenderPictureParameter(ctx);
break;
default:
drv_debug_msg(VIDEO_DEBUG_ERROR, "Non-RC mode should be here for FrameSkip handling\n");
ASSERT(0);
}
return vaStatus;
}
static VAStatus lnc_SetupRCParam(context_ENC_p ctx)
{
lnc_cmdbuf_p cmdbuf = ctx->obj_context->lnc_cmdbuf;
PIC_PARAMS *psPicParams = (PIC_PARAMS *)cmdbuf->pic_params_p;
int origin_qp;/* in DDK setup_rc will change qp strangly,
* just for keep same with DDK
*/
origin_qp = ctx->sRCParams.InitialQp;
drv_debug_msg(VIDEO_DEBUG_GENERAL, "will setup rc data\n");
psPicParams->Flags |= ISRC_FLAGS;
lnc__setup_rcdata(ctx, psPicParams, &ctx->sRCParams);
/* restore it, just keep same with DDK */
ctx->sRCParams.InitialQp = origin_qp;
/* save IN_RC_PARAMS into the cache */
memcpy(&ctx->in_params_cache, (unsigned char *)&psPicParams->sInParams, sizeof(IN_RC_PARAMS));
return VA_STATUS_SUCCESS;
}
static VAStatus lnc_UpdateRCParam(context_ENC_p ctx)
{
int origin_qp;
lnc_cmdbuf_p cmdbuf = ctx->obj_context->lnc_cmdbuf;
PIC_PARAMS *psPicParams = (PIC_PARAMS *)cmdbuf->pic_params_p;
origin_qp = ctx->sRCParams.InitialQp;
drv_debug_msg(VIDEO_DEBUG_GENERAL, "will update rc data\n");
lnc__update_rcdata(ctx, psPicParams, &ctx->sRCParams);
/* set minQP if hosts set minQP */
if (ctx->sRCParams.MinQP)
psPicParams->sInParams.MinQPVal = ctx->sRCParams.MinQP;
/* if seinitqp is set, restore the value hosts want */
if (origin_qp) {
psPicParams->sInParams.SeInitQP = origin_qp;
psPicParams->sInParams.MyInitQP = origin_qp;
ctx->sRCParams.InitialQp = origin_qp;
}
/* save IN_RC_PARAMS into the cache */
memcpy(&ctx->in_params_cache, (unsigned char *)&psPicParams->sInParams, sizeof(IN_RC_PARAMS));
return VA_STATUS_SUCCESS;
}
static VAStatus lnc_PatchRCMode(context_ENC_p ctx)
{
int frame_skip = 0;
drv_debug_msg(VIDEO_DEBUG_GENERAL, "will patch rc data\n");
/* it will ensure previous encode finished */
lnc__PatchBitsConsumedInRCParam(ctx);
/* get frameskip flag */
lnc_surface_get_frameskip(ctx->obj_context->driver_data, ctx->src_surface->psb_surface, &frame_skip);
/* current frame is skipped
* redo RenderPicture with FrameSkip set
*/
if (frame_skip == 1)
lnc_RedoRenderPictureSkippedFrame(ctx);
return VA_STATUS_SUCCESS;
}
VAStatus lnc_EndPicture(context_ENC_p ctx)
{
VAStatus vaStatus = VA_STATUS_SUCCESS;
lnc_cmdbuf_p cmdbuf = ctx->obj_context->lnc_cmdbuf;
if (ctx->sRCParams.RCEnable == IMG_TRUE) {
if (ctx->obj_context->frame_count == 0)
lnc_SetupRCParam(ctx);
else if (ctx->update_rc_control)
lnc_UpdateRCParam(ctx);
else
lnc_PatchRCMode(ctx);
}
ctx->update_rc_control = 0;
/* save current settings */
ctx->previous_src_surface = ctx->src_surface;
ctx->previous_ref_surface = ctx->ref_surface;
ctx->previous_dest_surface = ctx->dest_surface; /* reconstructed surface */
ctx->pprevious_coded_buf = ctx->previous_coded_buf;
ctx->previous_coded_buf = ctx->coded_buf;
lnc_cmdbuf_insert_command(cmdbuf, MTX_CMDID_END_PIC, 3, 0);
lnc_cmdbuf_insert_command_param(cmdbuf, 0);/* two meaningless parameters */
lnc_cmdbuf_insert_command_param(cmdbuf, 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_bellow_params_p != NULL) {
psb_buffer_unmap(cmdbuf->topaz_above_bellow_params);
cmdbuf->topaz_above_bellow_params_p = NULL;
}
if (lnc_context_flush_cmdbuf(ctx->obj_context)) {
vaStatus = VA_STATUS_ERROR_UNKNOWN;
}
return vaStatus;
}
static void lnc__setup_busize(context_ENC_p ctx)
{
unsigned int old_busize = ctx->sRCParams.BUSize;
/* 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;
MBs = ctx->Height * ctx->Width / (16 * 16);
SliceHeight = ctx->Height / ctx->Slices;
/* SliceHeight += 15; */
SliceHeight &= ~15;
MBsperSlice = (SliceHeight * ctx->Width) / (16 * 16);
MBsLastSlice = MBs - (MBsperSlice * (ctx->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 */;
}
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 (BUs > 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 */;
}
BUs = MBsLastSlice / ctx->sRCParams.BUSize;
if (BUs > 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 BUs, BUsperSlice, BUsLastSlice;
IMG_INT32 SliceHeight;
MBs = ctx->Height * ctx->Width / (16 * 16);
SliceHeight = ctx->Height / ctx->Slices;
/* SliceHeight += 15; */
SliceHeight &= ~15;
MBsperSlice = (SliceHeight * ctx->Width) / (16 * 16);
MBsLastSlice = MBs - (MBsperSlice * (ctx->Slices - 1));
/* we have to verify that MBs is divisiable by BU AND that BU is > pipeline length */
if (ctx->sRCParams.BUSize < 6) {
ctx->sRCParams.BUSize = 6;
}
BUs = MBs / ctx->sRCParams.BUSize;
while (BUs*ctx->sRCParams.BUSize != MBs) {
ctx->sRCParams.BUSize++;
BUs = MBs / ctx->sRCParams.BUSize;
}
/* Check number of BUs in the pipe is less than maximum number allowed 200 */
BUsperSlice = MBsperSlice / ctx->sRCParams.BUSize;
BUsLastSlice = MBsLastSlice / ctx->sRCParams.BUSize;
while ((BUsperSlice *(ctx->Slices - 1) + BUsLastSlice) > 200) {
ctx->sRCParams.BUSize++;
BUsperSlice = MBsperSlice / ctx->sRCParams.BUSize;
BUsLastSlice = MBsLastSlice / ctx->sRCParams.BUSize;
}
/* Check whether there are integer number of BUs in the slices */
BUsperSlice = MBsperSlice / ctx->sRCParams.BUSize;
BUsLastSlice = MBsLastSlice / ctx->sRCParams.BUSize;
while ((BUsperSlice*ctx->sRCParams.BUSize != MBsperSlice) ||
(BUsLastSlice*ctx->sRCParams.BUSize != MBsLastSlice)) {
ctx->sRCParams.BUSize++;
BUsperSlice = MBsperSlice / ctx->sRCParams.BUSize;
BUsLastSlice = MBsLastSlice / ctx->sRCParams.BUSize;
}
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);
}
}
/***********************************************************************************
* Function Name : SetupRCData
* Inputs :
* Outputs :
* Returns :
* Description : Sets up RC Data
************************************************************************************/
void lnc__setup_rcdata(
context_ENC_p psContext,
PIC_PARAMS *psPicParams,
IMG_RC_PARAMS *psRCParams)
{
IMG_UINT32 max_bitrate = psContext->Width * psContext->Height * 1.5 * 8 * 60;
IMG_UINT8 InitialSeInitQP = 0;
/* 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;
if (psRCParams->BufferSize == 0) {
if (psRCParams->BitsPerSecond < 256000)
psRCParams->BufferSize = (9 * psRCParams->BitsPerSecond) >> 1;
else
psRCParams->BufferSize = (5 * psRCParams->BitsPerSecond) >> 1;
}
psRCParams->InitialLevel = (3 * psRCParams->BufferSize) >> 4;
psRCParams->InitialDelay = (13 * psRCParams->BufferSize) >> 4;
lnc__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;
InitialSeInitQP = psPicParams->sInParams.SeInitQP;
lnc__update_rcdata(psContext, psPicParams, psRCParams);
/* set minQP if hosts set minQP */
if (psRCParams->MinQP)
psPicParams->sInParams.MinQPVal = psRCParams->MinQP;
/* if seinitqp is set, restore the value hosts want */
if (InitialSeInitQP) {
psPicParams->sInParams.SeInitQP = InitialSeInitQP;
psPicParams->sInParams.MyInitQP = InitialSeInitQP;
psRCParams->InitialQp = InitialSeInitQP;
}
}
void lnc__update_rcdata(context_ENC_p psContext,
PIC_PARAMS *psPicParams,
IMG_RC_PARAMS *psRCParams)
{
double L1, L2, L3, L4, L5, flBpp;
INT16 i16TempQP;
IMG_INT32 i32BufferSizeInFrames;
flBpp = 1.0 * psRCParams->BitsPerSecond / (psRCParams->FrameRate * psContext->Width * psContext->Height);
/* recalculate for small frames */
if (psContext->Width <= 176)
flBpp = flBpp / 2.0;
psPicParams->sInParams.IntraPeriod = psRCParams->IntraFreq;
psPicParams->sInParams.BitRate = psRCParams->BitsPerSecond;
psPicParams->sInParams.IntraPeriod = psRCParams->IntraFreq;
psPicParams->sInParams.BitsPerFrm = psRCParams->BitsPerSecond / psRCParams->FrameRate;
psPicParams->sInParams.BitsPerGOP = psPicParams->sInParams.BitsPerFrm * psRCParams->IntraFreq;
psPicParams->sInParams.BitsPerBU = psPicParams->sInParams.BitsPerFrm / (4 * psPicParams->sInParams.BUPerFrm);
psPicParams->sInParams.BitsPerMB = psPicParams->sInParams.BitsPerBU / psRCParams->BUSize;
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;
psPicParams->sInParams.MaxQPVal = 51;
// Set THSkip Values
if (flBpp <= 0.07)
psPicParams->THSkip = TH_SKIP_24;
else if (flBpp <= 0.14)
psPicParams->THSkip = TH_SKIP_12;
else
psPicParams->THSkip = TH_SKIP_0;
if (flBpp <= 0.3)
psPicParams->Flags |= ISRC_I16BIAS;
// Setup MAX and MIN Quant Values
if (flBpp >= 0.50)
i16TempQP = 4;
else if (flBpp > 0.133)
i16TempQP = (unsigned int)(24 - (40 * flBpp));
else
i16TempQP = (unsigned int)(32 - (100 * flBpp));
psPicParams->sInParams.MinQPVal = (max(min(psPicParams->sInParams.MaxQPVal, i16TempQP), 0));
// Calculate Initial QP if it has not been specified
L1 = 0.050568;
L2 = 0.202272;
L3 = 0.40454321;
L4 = 0.80908642;
L5 = 1.011358025;
if (flBpp < L1)
i16TempQP = (IMG_INT16)(47 - 78.10 * flBpp);
else if (flBpp >= L1 && flBpp < L2)
i16TempQP = (IMG_INT16)(46 - 72.51 * flBpp);
else if (flBpp >= L2 && flBpp < L3)
i16TempQP = (IMG_INT16)(36 - 24.72 * flBpp);
else if (flBpp >= L3 && flBpp < L4)
i16TempQP = (IMG_INT16)(34 - 19.78 * flBpp);
else if (flBpp >= L4 && flBpp < L5)
i16TempQP = (IMG_INT16)(27 - 9.89 * flBpp);
else if (flBpp >= L5)
i16TempQP = (IMG_INT16)(20 - 4.95 * flBpp);
psPicParams->sInParams.SeInitQP = (IMG_UINT8)(max(min(psPicParams->sInParams.MaxQPVal, i16TempQP), 0));
break;
case IMG_CODEC_MPEG4_CBR:
case IMG_CODEC_MPEG4_VBR:
psPicParams->sInParams.MaxQPVal = 31;
if (psContext->Width == 176) {
L1 = 0.1;
L2 = 0.3;
L3 = 0.6;
} else if (psContext->Width == 352) {
L1 = 0.2;
L2 = 0.6;
L3 = 1.2;
} else {
L1 = 0.25;
L2 = 1.4;
L3 = 2.4;
}
// Calculate Initial QP if it has not been specified
if (flBpp <= L1)
psPicParams->sInParams.SeInitQP = 31;
else {
if (flBpp <= L2)
psPicParams->sInParams.SeInitQP = 25;
else
psPicParams->sInParams.SeInitQP = (flBpp <= L3) ? 20 : 10;
}
if (flBpp >= 0.25) {
psPicParams->sInParams.MinQPVal = 1;
} else {
psPicParams->sInParams.MinQPVal = 2;
}
break;
case IMG_CODEC_H263_CBR:
case IMG_CODEC_H263_VBR:
psPicParams->sInParams.MaxQPVal = 31;
if (psContext->Width == 176) {
L1 = 0.1;
L2 = 0.3;
L3 = 0.6;
} else if (psContext->Width == 352) {
L1 = 0.2;
L2 = 0.6;
L3 = 1.2;
} else {
L1 = 0.25;
L2 = 1.4;
L3 = 2.4;
}
// Calculate Initial QP if it has not been specified
if (flBpp <= L1)
psPicParams->sInParams.SeInitQP = 31;
else {
if (flBpp <= L2)
psPicParams->sInParams.SeInitQP = 25;
else
psPicParams->sInParams.SeInitQP = (flBpp <= L3) ? 20 : 10;
}
psPicParams->sInParams.MinQPVal = 3;
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;
/* drop through to CBR case */
/* for SD and above we can target 95% (122/128) of maximum bitrate */
if (psRCParams->VCMBitrateMargin) {
psPicParams->sInParams.VCMBitrateMargin = psRCParams->VCMBitrateMargin;
} else {
if (psContext->Height >= 480)
psPicParams->sInParams.VCMBitrateMargin = 122;
else
psPicParams->sInParams.VCMBitrateMargin = 115; /* for less and SD we target 90% (115/128) of maximum bitrate */
if (i32BufferSizeInFrames < 15)
psPicParams->sInParams.VCMBitrateMargin -= 5;/* when we have a very small window size we reduce the target further to avoid too much skipping */
}
psPicParams->sInParams.ForceSkipMargin = 500;/* start skipping MBs when within 500 bits of slice or frame limit */
// Set a scale factor to avoid overflows in maths
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;
}
if (psRCParams->BitsPerSecond <= 384000)
psPicParams->sInParams.BufferSize = ((psRCParams->BitsPerSecond * 5) >> 1);
else
psPicParams->sInParams.BufferSize = psRCParams->BitsPerSecond * 4;
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 = ((5 * psRCParams->BitsPerSecond) >> 1);
// 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;
psPicParams->sInParams.InitialDelay = psRCParams->InitialDelay;
psPicParams->sInParams.InitialLevel = psRCParams->InitialLevel;
psRCParams->InitialQp = psPicParams->sInParams.SeInitQP;
}
static void lnc__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 lnc__setup_qpvalues_mpeg4(
MTX_CURRENT_IN_PARAMS * psCurrent,
IMG_BYTE bySliceQP)
{
psCurrent->bySliceQP = bySliceQP;
}
static void lnc__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
*/
IMG_INT16 Pos, YPos, srcY;
MTX_CURRENT_IN_PARAMS *psCurrent;
lnc_cmdbuf_p cmdbuf = ctx->obj_context->lnc_cmdbuf;
IMG_UINT16 tmp;
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);
if ((YPos = srcY = CurrentRowY - MVEA_LRB_TOP_OFFSET) < 0)
srcY = 0;
else if (YPos > ctx->HeightMinusLRB_TopAndBottom_OffsetsPlus16)
srcY = ctx->HeightMinusLRBSearchHeight;
tmp = (CurrentRowY != SliceStartRowY);
for (Pos = 0; Pos < (int)ctx->Width; Pos += 16, psCurrent++) {
memset(psCurrent, 0, sizeof(MTX_CURRENT_IN_PARAMS));
psCurrent->MVValid = 0;
psCurrent->ParamsValid = 0;
/* Setup the parameters and motion vectors */
if (tmp) {
psCurrent->MVValid = 66;
psCurrent->ParamsValid |= PARAMS_ABOVE_VALID;
if (Pos + 16 < (int)ctx->Width) {
psCurrent->ParamsValid |= PARAMS_ABOVER_VALID;
psCurrent->MVValid |= 4; /* (1<<2) */
}
if (Pos > 0 && (Pos < (int)ctx->Width)) {
psCurrent->ParamsValid |= PARAMS_ABOVEL_VALID;
psCurrent->MVValid |= 1; /* (1<<0) */
}
}
if ((Pos == 0) && (CurrentRowY == SliceStartRowY)) {
psCurrent->ParamsValid |= MB_START_OF_SLICE;/* OPTI? */
}
/* Have to fill in the right hand row of 4x4 vectors into the the left block */
if (Pos) {
psCurrent->MVValid |= 72; /* (1<<3)+(1<<6) */
psCurrent->ParamsValid |= 8; /* (1<<3) */
}
if (Pos == (int)(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 (YPos == (SliceStartRowY + SliceHeight - (MVEA_LRB_TOP_OFFSET + 16))) {
psCurrent->ParamsValid |= MB_END_OF_SLICE;
if (YPos == 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 (YPos < ctx->HeightMinus16MinusLRBTopOffset) {
psCurrent->MVValid |= 16; /* (1<<4) */
if (YPos < ctx->HeightMinus32MinusLRBTopOffset) {
psCurrent->MVValid |= 32; /* (1<<5) */
}
}
}
/* Set up IPEMin and Max for coordinate X in the search reference region */
/* And set up flags in SPEMax when needed */
if (Pos <= 48) {
psCurrent->IPEMin[0] = 48 - Pos;
psCurrent->RealEdge |= SPE_EDGE_LEFT;
} else {
psCurrent->IPEMin[0] = 3;
}
if ((Pos + 48 + 16) > (int)ctx->Width) {
psCurrent->IPEMax[0] = (47 + ctx->Width) - Pos; /* (112 - 1) - ((Pos + 48+16) - ctx->Width); */
psCurrent->RealEdge |= SPE_EDGE_RIGHT;
} else {
psCurrent->IPEMax[0] = 108; /* (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 (YPos <= 0) {
psCurrent->IPEMin[1] = 0;
psCurrent->RealEdge |= SPE_EDGE_TOP;
} else {
psCurrent->IPEMin[1] = 3;
}
/* Max Y */
if (YPos > ctx->HeightMinusLRB_TopAndBottom_OffsetsPlus16) {
psCurrent->IPEMax[1] = MVEA_LRB_SEARCH_HEIGHT - 1;
psCurrent->RealEdge |= SPE_EDGE_BOTTOM;
} else {
psCurrent->IPEMax[1] = MVEA_LRB_SEARCH_HEIGHT - 4;
}
psCurrent->CurBlockAddr = ((IMG_UINT8)(((YPos + MVEA_LRB_TOP_OFFSET) - srcY) / 16) << 4) | 0x3;
/* 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:
lnc__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:
lnc__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:
lnc__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;
}
}
psCurrent->RealEdge = 0;
}
void lnc_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) {
lnc__setup_slice_row_params(
ctx,
IsIntra,
CurrentRowY,
YSliceStartPos,
SliceHeight,
VectorsValid, bySliceQP);
CurrentRowY += 16;
Rows--;
}
}
IMG_UINT32 lnc__send_encode_slice_params(
context_ENC_p ctx,
IMG_BOOL IsIntra,
IMG_UINT16 CurrentRow,
IMG_BOOL DeblockSlice,
IMG_UINT32 FrameNum,
IMG_UINT16 SliceHeight,
IMG_UINT16 CurrentSlice,
IMG_UINT32 MaxSliceSize)
{
SLICE_PARAMS *psSliceParams;
IMG_UINT16 RowOffset;
psb_buffer_p psCoded;
object_surface_p ref_surface;
psb_buffer_p psRef;
lnc_cmdbuf_p cmdbuf = ctx->obj_context->lnc_cmdbuf;
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;
/* We want multiple ones of these so we can submit multiple slices without having to wait for the next */
psSliceParams->CodedDataPos = 0;
psSliceParams->TotalCoded = 0;
psSliceParams->Flags = 0;
#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->height * 16;
psSliceParams->RefUVStride = ref_surface->height * 8;
psSliceParams->RefYRowStride = psSliceParams->RefYStride;
psSliceParams->RefUVRowStride = psSliceParams->RefUVStride;
#endif
psSliceParams->FCode = ctx->FCode;/* Not clear yet, This field is not appare in firmware doc */
RowOffset = CurrentRow - 32;
if (RowOffset <= 0)
RowOffset = 0;
if (RowOffset > (ctx->Height - 80))
RowOffset = (ctx->Height - 80);
psSliceParams->MaxSliceSize = MaxSliceSize;
psSliceParams->NumAirMBs = ctx->num_air_mbs;
/* DDKv145: 3 lsb of threshold used as spacing between AIR MBs */
psSliceParams->AirThreshold = ctx->air_threshold + (FrameNum & 3) + 2;
if (ctx->autotune_air_flag)
psSliceParams->Flags |= AUTOTUNE_AIR;
if (!IsIntra) {
psSliceParams->Flags |= ISINTER_FLAGS;
}
if (DeblockSlice) {
psSliceParams->Flags |= DEBLOCK_FRAME;
}
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_VBR:
case IMG_CODEC_H264_CBR:
case IMG_CODEC_H264_VCM:
psSliceParams->Flags |= ISH264_FLAGS;
break;
default:
psSliceParams->Flags |= ISH264_FLAGS;
drv_debug_msg(VIDEO_DEBUG_ERROR, "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)
psSliceParams->Flags |= INTERLEAVE_TARGET;
cmdbuf = ctx->obj_context->lnc_cmdbuf;
RELOC_SLICE_PARAMS(&(psSliceParams->RefYBase), 16 * RowOffset, psRef);
RELOC_SLICE_PARAMS(&(psSliceParams->RefUVBase),
ref_surface->psb_surface->stride * ref_surface->height + (RowOffset * 16 / 2),
psRef);
RELOC_SLICE_PARAMS(&(psSliceParams->CodedData), 0, psCoded);
lnc_cmdbuf_insert_command(cmdbuf, MTX_CMDID_ENCODE_SLICE, 2, (CurrentSlice << 2) | (IsIntra & 0x3));
RELOC_CMDBUF(cmdbuf->cmd_idx++,
CurrentSlice *((sizeof(SLICE_PARAMS) + 15) & 0xfff0),
&cmdbuf->slice_params);
return 0;
}
/*
* Function Name : Reset_EncoderParams
* Description : Reset Above & Below Params at the Start of Intra frame
*/
void lnc_reset_encoder_params(context_ENC_p ctx)
{
unsigned char *Add_Below, *Add_Above;
lnc_cmdbuf_p cmdbuf = ctx->obj_context->lnc_cmdbuf;
/* all frames share the same Topaz param, in_param/aboveparam/bellow
* map it only when necessary
*/
if (cmdbuf->topaz_above_bellow_params_p == NULL) {
VAStatus vaStatus = psb_buffer_map(cmdbuf->topaz_above_bellow_params, &cmdbuf->topaz_above_bellow_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_above_bellow_params_p + ctx->bellow_params_ofs;
memset(Add_Below, 0, ctx->bellow_params_size);
Add_Above = cmdbuf->topaz_above_bellow_params_p + ctx->above_params_ofs;
memset(Add_Above, 0, ctx->above_params_size);
}