/*
* 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:
* Edward Lin <edward.lin@intel.com>
*
*/
#include <unistd.h>
#include <stdio.h>
#include <memory.h>
#include <wsbm/wsbm_manager.h>
#include "tng_picmgmt.h"
#include "psb_drv_debug.h"
#define MASK_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_0 0x0000007F
#define SHIFT_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_0 0
#define MASK_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_1 0x00007F00
#define SHIFT_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_1 8
#define MASK_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_2 0x007F0000
#define SHIFT_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_2 16
#define MASK_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_3 0x7F000000
#define SHIFT_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_3 24
#define MASK_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0 0x00003FFF
#define SHIFT_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0 0
#define MASK_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1 0x3FFF0000
#define SHIFT_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1 16
/************************* MTX_CMDID_PICMGMT *************************/
VAStatus tng_picmgmt_update(context_ENC_p ctx, IMG_PICMGMT_TYPE eType, unsigned int ref)
{
//VAStatus vaStatus = VA_STATUS_SUCCESS;
IMG_UINT32 ui32CmdData = 0;
//IMG_V_SetNextRefType eFrameType
//IMG_V_SkipFrame bProcess
//IMG_V_EndOfStream ui32FrameCount
//IMG_PICMGMT_FLUSH ui32FrameCount
ui32CmdData = F_ENCODE(eType, MTX_MSG_PICMGMT_SUBTYPE) |
F_ENCODE(ref, MTX_MSG_PICMGMT_DATA);
/* Send PicMgmt Command */
tng_cmdbuf_insert_command(ctx->obj_context, ctx->ui32StreamID,
MTX_CMDID_PICMGMT | MTX_CMDID_PRIORITY,
ui32CmdData, 0, 0);
return VA_STATUS_SUCCESS;
}
/*!
******************************************************************************
*
* Picture management functions
*
******************************************************************************/
void tng__picmgmt_long_term_refs(context_ENC_p __maybe_unused ctx, IMG_UINT32 __maybe_unused ui32FrameNum)
{
#ifdef _TNG_ENABLE_PITMGMT_
IMG_BOOL bIsLongTermRef;
IMG_BOOL bUsesLongTermRef0;
IMG_BOOL bUsesLongTermRef1;
IMG_UINT32 ui32FrameCnt;
// Determine frame position in source stream
// This assumes there are no IDR frames after the first one
if (ui32FrameNum == 0) {
// Initial IDR frame
ui32FrameCnt = 0;
} else if (((ui32FrameNum - 1) % (ctx->sRCParams.ui16BFrames + 1)) == 0) {
// I or P frame
ui32FrameCnt = ui32FrameNum + ctx->sRCParams.ui16BFrames;
if (ui32FrameCnt >= ctx->ui32Framecount) ui32FrameCnt = ctx->ui32Framecount - 1;
} else {
// B frame
// This will be incorrect for hierarchical B-pictures
ui32FrameCnt = ui32FrameNum - 1;
}
// Decide if the current frame should be used as a long-term reference
bIsLongTermRef = ctx->ui32LongTermRefFreq ?
(ui32FrameCnt % ctx->ui32LongTermRefFreq == 0) :
IMG_FALSE;
// Decide if the current frame should refer to a long-term reference
bUsesLongTermRef0 = ctx->ui32LongTermRefUsageFreq ?
(ui32FrameCnt % ctx->ui32LongTermRefUsageFreq == ctx->ui32LongTermRefUsageOffset) :
IMG_FALSE;
bUsesLongTermRef1 = IMG_FALSE;
if (bIsLongTermRef || bUsesLongTermRef0 || bUsesLongTermRef1) {
// Reconstructed/reference frame to be written to host buffer
// Send the buffer to be used as reference
tng__send_ref_frames(ctx, 0, bIsLongTermRef);
if (bIsLongTermRef) ctx->byCurBufPointer = (ctx->byCurBufPointer + 1) % 3;
}
#endif
}
static VAStatus tng__H264ES_CalcCustomQuantSp(IMG_UINT8 list, IMG_UINT8 param, IMG_UINT8 customQuantQ)
{
// Derived from sim/topaz/testbench/tests/mved1_tests.c
IMG_UINT32 mfflat[2][16] = {
{
13107, 8066, 13107, 8066,
8066, 5243, 8066, 5243,
13107, 8066, 13107, 8066,
8066, 5243, 8066, 5243
}, // 4x4
{
13107, 12222, 16777, 12222,
12222, 11428, 15481, 11428,
16777, 15481, 20972, 15481,
12222, 11428, 15481, 11428
} // 8x8
};
IMG_UINT8 uVi[2][16] = {
{
20, 26, 20, 26,
26, 32, 26, 32,
20, 26, 20, 26,
26, 32, 26, 32
}, // 4x4
{
20, 19, 25, 19,
19, 18, 24, 18,
25, 24, 32, 24,
19, 18, 24, 18
} // 8x8
};
int mfnew;
double fSp;
int uSp;
if (customQuantQ == 0) customQuantQ = 1;
mfnew = (mfflat[list][param] * 16) / customQuantQ;
fSp = ((double)(mfnew * uVi[list][param])) / (double)(1 << 22);
fSp = (fSp * 100000000.0f) / 100000000.0f;
uSp = (IMG_UINT16)(fSp * 65536);
return uSp & 0x03FFF;
}
static VAStatus tng__set_custom_scaling_values(
context_ENC_p ctx,
IMG_UINT8* aui8Sl4x4IntraY,
IMG_UINT8* aui8Sl4x4IntraCb,
IMG_UINT8* aui8Sl4x4IntraCr,
IMG_UINT8* aui8Sl4x4InterY,
IMG_UINT8* aui8Sl4x4InterCb,
IMG_UINT8* aui8Sl4x4InterCr,
IMG_UINT8* aui8Sl8x8IntraY,
IMG_UINT8* aui8Sl8x8InterY)
{
IMG_UINT8 *pui8QuantMem;
IMG_UINT32 *pui32QuantReg;
IMG_UINT8 *apui8QuantTables[8];
IMG_UINT32 ui32Table, ui32Val;
psb_buffer_p pCustomBuf = NULL;
IMG_UINT32 custom_quant_size = 0;
// Scanning order for coefficients, see section 8.5.5 of H.264 specification
// Note that even for interlaced mode, hardware takes the scaling values as if frame zig-zag scanning were being used
IMG_UINT8 aui8ZigZagScan4x4[16] = {
0, 1, 5, 6,
2, 4, 7, 12,
3, 8, 11, 13,
9, 10, 14, 15
};
IMG_UINT8 aui8ZigZagScan8x8[64] = {
0, 1, 5, 6, 14, 15, 27, 28,
2, 4, 7, 13, 16, 26, 29, 42,
3, 8, 12, 17, 25, 30, 41, 43,
9, 11, 18, 24, 31, 40, 44, 53,
10, 19, 23, 32, 39, 45, 52, 54,
20, 22, 33, 38, 46, 51, 55, 60,
21, 34, 37, 47, 50, 56, 59, 61,
35, 36, 48, 49, 57, 58, 62, 63
};
if (ctx == NULL) {
return VA_STATUS_ERROR_UNKNOWN;
}
if (ctx->bCustomScaling == IMG_FALSE) {
return VA_STATUS_ERROR_UNKNOWN;
}
pCustomBuf = &(ctx->ctx_mem[ctx->ui32StreamID].bufs_custom_quant);
custom_quant_size = ctx->ctx_mem_size.custom_quant;
/* Copy quantization values (in header order) */
pui8QuantMem = (IMG_UINT8*)(pCustomBuf);
memcpy(pui8QuantMem, aui8Sl4x4IntraY, 16);
memcpy(pui8QuantMem + 16, aui8Sl4x4IntraCb, 16);
memcpy(pui8QuantMem + 32, aui8Sl4x4IntraCr, 16);
memcpy(pui8QuantMem + 48, aui8Sl4x4InterY, 16);
memcpy(pui8QuantMem + 64, aui8Sl4x4InterCb, 16);
memcpy(pui8QuantMem + 80, aui8Sl4x4InterCr, 16);
memcpy(pui8QuantMem + 96, aui8Sl8x8IntraY, 64);
memcpy(pui8QuantMem + 160, aui8Sl8x8InterY, 64);
/* Create quantization register values */
/* Assign based on the order values are written to registers */
apui8QuantTables[0] = aui8Sl4x4IntraY;
apui8QuantTables[1] = aui8Sl4x4InterY;
apui8QuantTables[2] = aui8Sl4x4IntraCb;
apui8QuantTables[3] = aui8Sl4x4InterCb;
apui8QuantTables[4] = aui8Sl4x4IntraCr;
apui8QuantTables[5] = aui8Sl4x4InterCr;
apui8QuantTables[6] = aui8Sl8x8IntraY;
apui8QuantTables[7] = aui8Sl8x8InterY;
/* H264COMP_CUSTOM_QUANT_SP register values "psCustomQuantRegs4x4Sp"*/
pui8QuantMem = (IMG_UINT8*)(pCustomBuf + custom_quant_size);
pui32QuantReg = (IMG_UINT32 *)pui8QuantMem;
for (ui32Table = 0; ui32Table < 6; ui32Table++) {
for (ui32Val = 0; ui32Val < 16; ui32Val += 4) {
*pui32QuantReg = F_ENCODE(tng__H264ES_CalcCustomQuantSp(0, ui32Val, apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0)
| F_ENCODE(tng__H264ES_CalcCustomQuantSp(0, ui32Val + 1, apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val + 1]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1);
pui32QuantReg++;
*pui32QuantReg = F_ENCODE(tng__H264ES_CalcCustomQuantSp(0, ui32Val + 2, apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val + 2]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0)
| F_ENCODE(tng__H264ES_CalcCustomQuantSp(0, ui32Val + 3, apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val + 3]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1);
pui32QuantReg++;
}
}
/*psCustomQuantRegs8x8Sp*/
pui8QuantMem = (IMG_UINT8*)(pCustomBuf + custom_quant_size + custom_quant_size);
pui32QuantReg = (IMG_UINT32 *)pui8QuantMem;
for (; ui32Table < 8; ui32Table++) {
for (ui32Val = 0; ui32Val < 64; ui32Val += 8) {
*pui32QuantReg = F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1), apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0)
| F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1) + 1, apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 1]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1);
pui32QuantReg++;
*pui32QuantReg = F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1) + 2, apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 2]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0)
| F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1) + 3, apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 3]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1);
pui32QuantReg++;
*pui32QuantReg = F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1), apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 4]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0)
| F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1) + 1, apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 5]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1);
pui32QuantReg++;
*pui32QuantReg = F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1) + 2, apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 6]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0)
| F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1) + 3, apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 7]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1);
pui32QuantReg++;
}
}
/* H264COMP_CUSTOM_QUANT_Q register values "psCustomQuantRegs4x4Q" */
pui8QuantMem = (IMG_UINT8*)(pCustomBuf + custom_quant_size + custom_quant_size + custom_quant_size);
pui32QuantReg = (IMG_UINT32 *)pui8QuantMem;
for (ui32Table = 0; ui32Table < 6; ui32Table++) {
for (ui32Val = 0; ui32Val < 16; ui32Val += 4) {
*pui32QuantReg = F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_0)
| F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val + 1]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_1)
| F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val + 2]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_2)
| F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val + 3]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_3);
pui32QuantReg++;
}
}
/*psCustomQuantRegs8x8Q)*/
pui8QuantMem = (IMG_UINT8*)(pCustomBuf + custom_quant_size + custom_quant_size + custom_quant_size + custom_quant_size);
pui32QuantReg = (IMG_UINT32 *)pui8QuantMem;
for (; ui32Table < 8; ui32Table++) {
for (ui32Val = 0; ui32Val < 64; ui32Val += 8) {
*pui32QuantReg = F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_0)
| F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 1]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_1)
| F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 2]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_2)
| F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 3]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_3);
pui32QuantReg++;
*pui32QuantReg = F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 4]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_0)
| F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 5]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_1)
| F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 6]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_2)
| F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 7]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_3);
pui32QuantReg++;
}
}
if (ctx->bPpsScaling)
ctx->bInsertPicHeader = IMG_TRUE;
return VA_STATUS_SUCCESS;
}
void tng__picmgmt_custom_scaling(context_ENC_p ctx, IMG_UINT32 ui32FrameNum)
{
if (ui32FrameNum % ctx->ui32PpsScalingCnt == 0) {
// Swap inter and intra scaling lists on alternating picture parameter sets
if (ui32FrameNum % (ctx->ui32PpsScalingCnt * 2) == 0) {
tng__set_custom_scaling_values(
ctx,
ctx->aui8CustomQuantParams4x4[0],
ctx->aui8CustomQuantParams4x4[1],
ctx->aui8CustomQuantParams4x4[2],
ctx->aui8CustomQuantParams4x4[3],
ctx->aui8CustomQuantParams4x4[4],
ctx->aui8CustomQuantParams4x4[5],
ctx->aui8CustomQuantParams8x8[0],
ctx->aui8CustomQuantParams8x8[1]);
} else {
tng__set_custom_scaling_values(
ctx,
ctx->aui8CustomQuantParams4x4[3],
ctx->aui8CustomQuantParams4x4[4],
ctx->aui8CustomQuantParams4x4[5],
ctx->aui8CustomQuantParams4x4[0],
ctx->aui8CustomQuantParams4x4[1],
ctx->aui8CustomQuantParams4x4[2],
ctx->aui8CustomQuantParams8x8[1],
ctx->aui8CustomQuantParams8x8[0]);
}
}
}
/************************* MTX_CMDID_PROVIDE_BUFFER *************************/
IMG_UINT32 tng_send_codedbuf(
context_ENC_p ctx,
IMG_UINT32 ui32SlotIndex)
{
context_ENC_frame_buf *ps_buf = &(ctx->ctx_frame_buf);
object_buffer_p object_buffer = ps_buf->coded_buf;
IMG_UINT32 ui32Offset = 0;
drv_debug_msg(VIDEO_DEBUG_GENERAL,
"%s slot 1 = %x\n", __FUNCTION__, ui32SlotIndex);
if ((ctx->ui8PipesToUse == 2) && ((ui32SlotIndex & 1) == 1))
ui32Offset = object_buffer->size >> 1;
tng_cmdbuf_insert_command(
ctx->obj_context, ctx->ui32StreamID,
MTX_CMDID_PROVIDE_CODED_BUFFER,
F_ENCODE(object_buffer->size, MTX_MSG_PROVIDE_CODED_BUFFER_SIZE) |
F_ENCODE(ui32SlotIndex, MTX_MSG_PROVIDE_CODED_BUFFER_SLOT),
object_buffer->psb_buffer, tng_align_KB(ui32Offset));
drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s end\n", __FUNCTION__);
return VA_STATUS_SUCCESS;
}
static VAStatus tng__set_component_offsets(
context_ENC_p ctx,
object_surface_p obj_surface_p,
IMG_FRAME * psFrame
)
{
IMG_FORMAT eFormat;
IMG_UINT16 ui16Width;
IMG_UINT16 ui16Stride;
IMG_UINT16 ui16PictureHeight;
if (!ctx)
return VA_STATUS_ERROR_UNKNOWN;
// if source slot is NULL then it's just a next portion of slices
if (psFrame == IMG_NULL)
return VA_STATUS_ERROR_UNKNOWN;
eFormat = ctx->eFormat;
ui16Width = obj_surface_p->width;
ui16PictureHeight = obj_surface_p->height;
ui16Stride = obj_surface_p->psb_surface->stride;
drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s eFormat = %d, w = %d, h = %d, stride = %d\n",
__FUNCTION__, eFormat, ui16Width, ui16PictureHeight, ui16Stride);
// 3 Components: Y, U, V
// Y component is always at the beginning
psFrame->i32YComponentOffset = 0;
psFrame->ui16SrcYStride = ui16Stride;
// Assume for now that field 0 comes first
psFrame->i32Field0YOffset = 0;
psFrame->i32Field0UOffset = 0;
psFrame->i32Field0VOffset = 0;
switch (eFormat) {
case IMG_CODEC_YUV:
psFrame->ui16SrcUVStride = ui16Stride / 2; // ui16SrcUStride
psFrame->i32UComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcUBase
psFrame->i32VComponentOffset = ui16Stride * ui16PictureHeight + (ui16Stride / 2) * (ui16PictureHeight / 2); // ui16SrcVBase
break;
case IMG_CODEC_PL8:
psFrame->ui16SrcUVStride = ui16Stride / 2; // ui16SrcUStride
psFrame->i32UComponentOffset = 0; // ui16SrcUBase
psFrame->i32VComponentOffset = 0; // ui16SrcVBase
break;
case IMG_CODEC_PL12:
psFrame->ui16SrcUVStride = ui16Stride; // ui16SrcUStride
//FIXME
psFrame->i32UComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcUBase
psFrame->i32VComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcVBase
break;
case IMG_CODEC_YV12: /* YV12 */
psFrame->ui16SrcUVStride = ui16Stride / 2; // ui16SrcUStride
psFrame->i32UComponentOffset = ui16Stride * ui16PictureHeight + (ui16Stride / 2) * (ui16PictureHeight / 2); // ui16SrcUBase
psFrame->i32VComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcVBase
break;
case IMG_CODEC_IMC2: /* IMC2 */
psFrame->ui16SrcUVStride = ui16Stride; // ui16SrcUStride
psFrame->i32UComponentOffset = ui16Stride * ui16PictureHeight + (ui16Stride / 2); // ui16SrcUBase
psFrame->i32VComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcVBase
break;
case IMG_CODEC_422_YUV:
psFrame->ui16SrcUVStride = ui16Stride; // ui16SrcUStride
psFrame->i32UComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcUBase
psFrame->i32VComponentOffset = ui16Stride * ui16PictureHeight + (ui16Stride / 2) * ui16PictureHeight; // ui16SrcVBase
break;
case IMG_CODEC_422_YV12: /* YV16 */
psFrame->ui16SrcUVStride = ui16Stride; // ui16SrcUStride
psFrame->i32UComponentOffset = ui16Stride * ui16PictureHeight + (ui16Stride / 2) * ui16PictureHeight; // ui16SrcUBase
psFrame->i32VComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcVBase
break;
case IMG_CODEC_422_PL8:
psFrame->ui16SrcUVStride = ui16Stride; // ui16SrcUStride
psFrame->i32UComponentOffset = 0; // ui16SrcUBase
psFrame->i32VComponentOffset = 0; // ui16SrcVBase
break;
case IMG_CODEC_422_IMC2: /* IMC2 */
psFrame->ui16SrcUVStride = ui16Stride * 2; // ui16SrcUStride
psFrame->i32UComponentOffset = ui16Stride * ui16PictureHeight + (ui16Stride / 2); // ui16SrcUBase
psFrame->i32VComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcVBase
break;
case IMG_CODEC_422_PL12:
psFrame->ui16SrcUVStride = ui16Stride * 2; // ui16SrcUStride
psFrame->i32UComponentOffset = 0; // ui16SrcUBase
psFrame->i32VComponentOffset = 0; // ui16SrcVBase
break;
case IMG_CODEC_Y0UY1V_8888:
case IMG_CODEC_Y0VY1U_8888:
case IMG_CODEC_UY0VY1_8888:
case IMG_CODEC_VY0UY1_8888:
psFrame->ui16SrcUVStride = ui16Stride; // ui16SrcUStride
psFrame->i32UComponentOffset = 0; // ui16SrcUBase
psFrame->i32VComponentOffset = 0; // ui16SrcVBase
break;
default:
break;
}
if (ctx->bIsInterlaced) {
if (ctx->bIsInterleaved) {
switch (eFormat) {
case IMG_CODEC_IMC2:
case IMG_CODEC_422_IMC2:
psFrame->i32VComponentOffset *= 2;
psFrame->i32UComponentOffset = psFrame->i32VComponentOffset + (ui16Stride / 2);
break;
default:
psFrame->i32UComponentOffset *= 2;
psFrame->i32VComponentOffset *= 2;
break;
}
psFrame->i32Field1YOffset = psFrame->i32Field0YOffset + psFrame->ui16SrcYStride;
psFrame->i32Field1UOffset = psFrame->i32Field0UOffset + psFrame->ui16SrcUVStride;
psFrame->i32Field1VOffset = psFrame->i32Field0VOffset + psFrame->ui16SrcUVStride;
psFrame->ui16SrcYStride *= 2; // ui16SrcYStride
psFrame->ui16SrcUVStride *= 2; // ui16SrcUStride
if (!ctx->bTopFieldFirst) {
IMG_INT32 i32Temp;
i32Temp = psFrame->i32Field1YOffset;
psFrame->i32Field1YOffset = psFrame->i32Field0YOffset;
psFrame->i32Field0YOffset = i32Temp;
i32Temp = psFrame->i32Field1UOffset;
psFrame->i32Field1UOffset = psFrame->i32Field0UOffset;
psFrame->i32Field0UOffset = i32Temp;
i32Temp = psFrame->i32Field1VOffset;
psFrame->i32Field1VOffset = psFrame->i32Field0VOffset;
psFrame->i32Field0VOffset = i32Temp;
}
} else {
IMG_UINT32 ui32YFieldSize, ui32CFieldSize;
switch (eFormat) {
case IMG_CODEC_Y0UY1V_8888:
case IMG_CODEC_UY0VY1_8888:
case IMG_CODEC_Y0VY1U_8888:
case IMG_CODEC_VY0UY1_8888:
ui32YFieldSize = ui16PictureHeight * ui16Stride * 2;
ui32CFieldSize = ui32YFieldSize;
break;
case IMG_CODEC_PL8:
ui32YFieldSize = ui16PictureHeight * ui16Stride;
ui32CFieldSize = ui16PictureHeight * ui16Stride / 4;
break;
case IMG_CODEC_PL12:
ui32YFieldSize = ui16PictureHeight * ui16Stride;
ui32CFieldSize = ui16PictureHeight * ui16Stride / 2;
break;
case IMG_CODEC_422_YUV:
case IMG_CODEC_422_YV12:
case IMG_CODEC_422_IMC2:
ui32YFieldSize = ui16PictureHeight * ui16Stride * 2;
ui32CFieldSize = ui32YFieldSize;
break;
case IMG_CODEC_422_PL8:
ui32YFieldSize = ui16PictureHeight * ui16Stride;
ui32CFieldSize = ui16PictureHeight * ui16Stride / 2;
break;
case IMG_CODEC_422_PL12:
ui32YFieldSize = ui16PictureHeight * ui16Stride;
ui32CFieldSize = ui32YFieldSize;
break;
default:
ui32YFieldSize = ui16PictureHeight * ui16Stride * 3 / 2;
ui32CFieldSize = ui32YFieldSize;
break;
}
psFrame->i32Field1YOffset = ui32YFieldSize;
psFrame->i32Field1UOffset = ui32CFieldSize;
psFrame->i32Field1VOffset = ui32CFieldSize;
}
} else {
psFrame->i32Field1YOffset = psFrame->i32Field0YOffset;
psFrame->i32Field1UOffset = psFrame->i32Field0UOffset;
psFrame->i32Field1VOffset = psFrame->i32Field0VOffset;
}
drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s i32YComponentOffset = %d, i32UComponentOffset = %d, i32VComponentOffset = %d\n",
__FUNCTION__, (int)(psFrame->i32YComponentOffset), (int)(psFrame->i32UComponentOffset), (int)(psFrame->i32VComponentOffset));
return VA_STATUS_SUCCESS;
}
IMG_UINT32 tng_send_source_frame(
context_ENC_p ctx,
IMG_UINT32 ui32SlotIndex,
IMG_UINT32 ui32DisplayOrder)
{
VAStatus vaStatus = VA_STATUS_SUCCESS;
context_ENC_frame_buf *ps_buf = &(ctx->ctx_frame_buf);
IMG_FRAME sSrcFrame;
IMG_FRAME *psSrcFrame = &sSrcFrame;
tng_cmdbuf_p cmdbuf = ctx->obj_context->tng_cmdbuf;
IMG_SOURCE_BUFFER_PARAMS *psSrcBufParams = NULL;
object_surface_p src_surface = ps_buf->src_surface;
unsigned int frame_mem_index = 0;
unsigned int srf_buf_offset = src_surface->psb_surface->buf.buffer_ofs;
drv_debug_msg(VIDEO_DEBUG_GENERAL,
"%s: ui32SlotIndex = %d, ui32DisplayOrder = %d\n",
__FUNCTION__, ui32SlotIndex, ui32DisplayOrder);
if (cmdbuf->frame_mem_index >= COMM_CMD_FRAME_BUF_NUM) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Error: frame_mem buffer index overflow\n", __FUNCTION__);
cmdbuf->frame_mem_index = 0;
}
vaStatus = psb_buffer_map(&cmdbuf->frame_mem, &(cmdbuf->frame_mem_p));
if (vaStatus) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: map frame buf\n", __FUNCTION__);
return vaStatus;
}
frame_mem_index = cmdbuf->frame_mem_index * cmdbuf->mem_size;
psSrcBufParams = (IMG_SOURCE_BUFFER_PARAMS *)(cmdbuf->frame_mem_p + frame_mem_index);
memset(psSrcBufParams, 0, sizeof(IMG_SOURCE_BUFFER_PARAMS));
memset(psSrcFrame, 0, sizeof(IMG_FRAME));
tng__set_component_offsets(ctx, src_surface, psSrcFrame);
drv_debug_msg(VIDEO_DEBUG_GENERAL,
"%s: cmdbuf->frame_mem_index = %d, frame_mem_index = 0x%08x, cmdbuf->frame_mem_p = 0x%08x\n",
__FUNCTION__, cmdbuf->frame_mem_index, frame_mem_index, cmdbuf->frame_mem_p);
drv_debug_msg(VIDEO_DEBUG_GENERAL,
"%s: frame_mem_index = %d, psBufferParams = 0x%08x\n",
__FUNCTION__, frame_mem_index, (unsigned int)psSrcBufParams);
/* Prepare ProvideBuffer data */
{
psSrcBufParams->ui8SlotNum = (IMG_UINT8)(ui32SlotIndex & 0xff);
psSrcBufParams->ui8DisplayOrderNum = (IMG_UINT8)(ui32DisplayOrder & 0xff);
psSrcBufParams->ui32HostContext = (IMG_UINT32)ctx;
#ifdef _TNG_RELOC_
TNG_RELOC_CMDBUF_FRAMES(
&(psSrcBufParams->ui32PhysAddrYPlane_Field0),
srf_buf_offset + psSrcFrame->i32YComponentOffset + psSrcFrame->i32Field0YOffset,
&(src_surface->psb_surface->buf));
TNG_RELOC_CMDBUF_FRAMES(
&(psSrcBufParams->ui32PhysAddrUPlane_Field0),
srf_buf_offset + psSrcFrame->i32UComponentOffset + psSrcFrame->i32Field0UOffset,
&(src_surface->psb_surface->buf));
TNG_RELOC_CMDBUF_FRAMES(
&(psSrcBufParams->ui32PhysAddrVPlane_Field0),
srf_buf_offset + psSrcFrame->i32VComponentOffset + psSrcFrame->i32Field0VOffset,
&(src_surface->psb_surface->buf));
TNG_RELOC_CMDBUF_FRAMES(
&(psSrcBufParams->ui32PhysAddrYPlane_Field1),
srf_buf_offset + psSrcFrame->i32YComponentOffset + psSrcFrame->i32Field1YOffset,
&(src_surface->psb_surface->buf));
TNG_RELOC_CMDBUF_FRAMES(
&(psSrcBufParams->ui32PhysAddrUPlane_Field1),
srf_buf_offset + psSrcFrame->i32UComponentOffset + psSrcFrame->i32Field1UOffset,
&(src_surface->psb_surface->buf));
TNG_RELOC_CMDBUF_FRAMES(
&(psSrcBufParams->ui32PhysAddrVPlane_Field1),
srf_buf_offset + psSrcFrame->i32VComponentOffset + psSrcFrame->i32Field1VOffset,
&(src_surface->psb_surface->buf));
#else
tng_cmdbuf_set_phys(&(psSrcBufParams->ui32PhysAddrYPlane_Field0), 0,
&(src_surface->psb_surface->buf),
srf_buf_offset + psSrcFrame->i32YComponentOffset + psSrcFrame->i32Field0YOffset, 0);
tng_cmdbuf_set_phys(&(psSrcBufParams->ui32PhysAddrUPlane_Field0), 0,
&(src_surface->psb_surface->buf),
srf_buf_offset + psSrcFrame->i32UComponentOffset + psSrcFrame->i32Field0UOffset, 0);
tng_cmdbuf_set_phys(&(psSrcBufParams->ui32PhysAddrVPlane_Field0), 0,
&(src_surface->psb_surface->buf),
srf_buf_offset + psSrcFrame->i32VComponentOffset + psSrcFrame->i32Field0VOffset, 0);
tng_cmdbuf_set_phys(&(psSrcBufParams->ui32PhysAddrYPlane_Field1), 0,
&(src_surface->psb_surface->buf),
srf_buf_offset + psSrcFrame->i32YComponentOffset + psSrcFrame->i32Field1YOffset, 0);
tng_cmdbuf_set_phys(&(psSrcBufParams->ui32PhysAddrUPlane_Field1), 0,
&(src_surface->psb_surface->buf),
srf_buf_offset + psSrcFrame->i32UComponentOffset + psSrcFrame->i32Field1UOffset, 0);
tng_cmdbuf_set_phys(&(psSrcBufParams->ui32PhysAddrVPlane_Field1), 0,
&(src_surface->psb_surface->buf),
srf_buf_offset + psSrcFrame->i32VComponentOffset + psSrcFrame->i32Field1VOffset, 0);
#endif
}
drv_debug_msg(VIDEO_DEBUG_GENERAL,
"%s slot_idx = %d, frame_count = %d\n", __FUNCTION__,
(int)(ui32SlotIndex), (int)(ctx->ui32FrameCount[ctx->ui32StreamID]));
drv_debug_msg(VIDEO_DEBUG_GENERAL,
"%s: YPlane_Field0 = 0x%08x, UPlane_Field0 = 0x%08x, VPlane_Field0 = 0x%08x\n",
__FUNCTION__, (unsigned int)(psSrcBufParams->ui32PhysAddrYPlane_Field0),
(unsigned int)(psSrcBufParams->ui32PhysAddrUPlane_Field0),
(unsigned int)(psSrcBufParams->ui32PhysAddrVPlane_Field0));
drv_debug_msg(VIDEO_DEBUG_GENERAL,
"%s: YPlane_Field1 = 0x%08x, UPlane_Field1 = 0x%08x, VPlane_Field1 = 0x%08x\n",
__FUNCTION__, (unsigned int)(psSrcBufParams->ui32PhysAddrYPlane_Field1),
(unsigned int)(psSrcBufParams->ui32PhysAddrUPlane_Field1),
(unsigned int)(psSrcBufParams->ui32PhysAddrVPlane_Field1));
/* Send ProvideBuffer Command */
tng_cmdbuf_insert_command(ctx->obj_context, ctx->ui32StreamID,
MTX_CMDID_PROVIDE_SOURCE_BUFFER,
0, &(cmdbuf->frame_mem), frame_mem_index);
++(cmdbuf->frame_mem_index);
psb_buffer_unmap(&cmdbuf->frame_mem);
return 0;
}
IMG_UINT32 tng_send_rec_frames(
context_ENC_p ctx,
IMG_INT8 i8HeaderSlotNum,
IMG_BOOL bLongTerm)
{
//VAStatus vaStatus = VA_STATUS_SUCCESS;
unsigned int srf_buf_offset;
context_ENC_frame_buf *ps_buf = &(ctx->ctx_frame_buf);
object_surface_p rec_surface = ps_buf->rec_surface;
IMG_UINT32 ui32CmdData = 0;
srf_buf_offset = rec_surface->psb_surface->buf.buffer_ofs;
/* Send ProvideBuffer Command */
ui32CmdData = F_ENCODE(IMG_BUFFER_RECON, MTX_MSG_PROVIDE_REF_BUFFER_USE) |
F_ENCODE(i8HeaderSlotNum, MTX_MSG_PROVIDE_REF_BUFFER_SLOT) |
F_ENCODE(bLongTerm, MTX_MSG_PROVIDE_REF_BUFFER_LT);
tng_cmdbuf_insert_command(ctx->obj_context, ctx->ui32StreamID,
MTX_CMDID_PROVIDE_REF_BUFFER,
ui32CmdData, &(rec_surface->psb_surface->buf), 0);
return 0;
}
IMG_UINT32 tng_send_ref_frames(
context_ENC_p ctx,
IMG_UINT32 ui32refindex,
IMG_BOOL __maybe_unused bLongTerm)
{
//VAStatus vaStatus = VA_STATUS_SUCCESS;
unsigned int srf_buf_offset;
context_ENC_frame_buf *ps_buf = &(ctx->ctx_frame_buf);
object_surface_p ref_surface = ps_buf->ref_surface[ui32refindex];
IMG_UINT32 ui32CmdData = 0;
#ifdef _TNG_FRAMES_
if (ui32RefIndex == 0) {
ref_surface = ps_buf->ref_surface;
ui32CmdData = F_ENCODE(IMG_BUFFER_REF0, MTX_MSG_PROVIDE_REF_BUFFER_USE) |
F_ENCODE(bLongTerm, MTX_MSG_PROVIDE_REF_BUFFER_LT);
} else {
ref_surface = ps_buf->ref_surface1;
ui32CmdData = F_ENCODE(IMG_BUFFER_REF1, MTX_MSG_PROVIDE_REF_BUFFER_USE) |
F_ENCODE(bLongTerm, MTX_MSG_PROVIDE_REF_BUFFER_LT);
}
#endif
srf_buf_offset = ref_surface->psb_surface->buf.buffer_ofs;
/* Send ProvideBuffer Command */
tng_cmdbuf_insert_command(ctx->obj_context, ctx->ui32StreamID,
MTX_CMDID_PROVIDE_REF_BUFFER,
ui32CmdData, &(ref_surface->psb_surface->buf), 0);
return VA_STATUS_SUCCESS;
}