You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3644 lines
145 KiB
3644 lines
145 KiB
//-----------------------------------------------------------------------------
|
|
// COPYRIGHT (C) 2020 CHIPS&MEDIA INC. ALL RIGHTS RESERVED
|
|
//
|
|
// This file is distributed under BSD 3 clause and LGPL2.1 (dual license)
|
|
// SPDX License Identifier: BSD-3-Clause
|
|
// SPDX License Identifier: LGPL-2.1-only
|
|
//
|
|
// The entire notice above must be reproduced on all authorized copies.
|
|
//
|
|
// Description :
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#include <errno.h>
|
|
#include "vpuapifunc.h"
|
|
#include "wave5_regdefine.h"
|
|
#include "vpuerror.h"
|
|
#include "main_helper.h"
|
|
#include "misc/debug.h"
|
|
#include "cnm_app.h"
|
|
#include "encoder_listener.h"
|
|
#include "decoder_listener.h"
|
|
#include "nc_utils.h"
|
|
#include <mqueue.h>
|
|
#include <pthread.h>
|
|
|
|
#if defined(PLATFORM_NON_OS) || defined (PLATFORM_LINUX)
|
|
#include <getopt.h>
|
|
#endif
|
|
|
|
#if defined(PLATFORM_LINUX) || defined(PLATFORM_QNX) || defined(PLATFORM_NON_OS)
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#define MAX_CODE_BUF_SIZE (512*1024)
|
|
#define MQ_NAME_DATA_TO_ENCODE "/data_to_encode"
|
|
#define MQ_NAME_DATA_TO_DECODE "/data_to_decode"
|
|
|
|
#ifdef PLATFORM_WIN32
|
|
#pragma warning(disable : 4996) //!<< disable waring C4996: The POSIX name for this item is deprecated.
|
|
#endif
|
|
|
|
#define MAX_MQ_SIZE_DEC (10)
|
|
#define MAX_MQ_SIZE_ENC (10)
|
|
|
|
static int32 auto_free_data_for_decode = 0;
|
|
static int32 auto_free_data_for_encode = 0;
|
|
|
|
pthread_mutex_t encoded_lock = PTHREAD_MUTEX_INITIALIZER;
|
|
pthread_mutex_t decoded_lock = PTHREAD_MUTEX_INITIALIZER;
|
|
|
|
static struct CNMComponentConfig enc_config;
|
|
static struct CNMComponentConfig dec_config;
|
|
|
|
const char* EncPicTypeStringH264[] = {
|
|
"IDR/I",
|
|
"P",
|
|
};
|
|
|
|
const char* EncPicTypeStringMPEG4[] = {
|
|
"I",
|
|
"P",
|
|
};
|
|
|
|
void SetDefaultDecTestConfig(TestDecConfig* testConfig)
|
|
{
|
|
osal_memset(testConfig, 0, sizeof(TestDecConfig));
|
|
|
|
testConfig->bitstreamMode = BS_MODE_INTERRUPT;
|
|
testConfig->feedingMode = FEEDING_METHOD_FIXED_SIZE;
|
|
testConfig->streamEndian = VPU_STREAM_ENDIAN;
|
|
testConfig->frameEndian = VPU_FRAME_ENDIAN;
|
|
testConfig->cbcrInterleave = TRUE;
|
|
testConfig->nv21 = FALSE;
|
|
testConfig->renderType = RENDER_DEVICE_NULL;
|
|
testConfig->mapType = COMPRESSED_FRAME_MAP;
|
|
testConfig->enableWTL = TRUE;
|
|
testConfig->wtlMode = FF_FRAME;
|
|
testConfig->wtlFormat = FORMAT_420; //!<< 8 bit YUV
|
|
// testConfig->wtlFormat = FORMAT_422; //!<< 8 bit YUV
|
|
testConfig->wave.av1Format = 0;
|
|
testConfig->fps = 30;
|
|
}
|
|
|
|
void Coda9SetDefaultDecTestConfig(TestDecConfig* testConfig)
|
|
{
|
|
osal_memset(testConfig, 0, sizeof(TestDecConfig));
|
|
|
|
testConfig->bitstreamMode = BS_MODE_INTERRUPT;
|
|
testConfig->feedingMode = FEEDING_METHOD_FIXED_SIZE;
|
|
testConfig->streamEndian = VPU_STREAM_ENDIAN;
|
|
testConfig->frameEndian = VPU_FRAME_ENDIAN;
|
|
testConfig->cbcrInterleave = FALSE;
|
|
testConfig->nv21 = FALSE;
|
|
testConfig->bitFormat = STD_AVC;
|
|
testConfig->renderType = RENDER_DEVICE_NULL;
|
|
testConfig->mapType = LINEAR_FRAME_MAP;
|
|
testConfig->wtlMode = FF_NONE;
|
|
testConfig->enableWTL = FALSE;
|
|
testConfig->wtlFormat = FORMAT_420; //!<< 8 bit YUV
|
|
testConfig->fps = 30;
|
|
|
|
testConfig->coda9.frameCacheBypass = 0;
|
|
testConfig->coda9.frameCacheBurst = 0;
|
|
testConfig->coda9.frameCacheMerge = 3;
|
|
testConfig->coda9.frameCacheWayShape = 15;
|
|
|
|
testConfig->coda9.rotate = 0;
|
|
testConfig->coda9.mirror = 0;
|
|
testConfig->coda9.enableTiled2Linear = FALSE;
|
|
testConfig->coda9.tiled2LinearMode = FF_NONE;
|
|
testConfig->coda9.enableDering = FALSE;
|
|
testConfig->coda9.enableBWB = TRUE;
|
|
}
|
|
|
|
Uint32 randomSeed;
|
|
static BOOL initializedRandom;
|
|
Uint32 GetRandom(
|
|
Uint32 start,
|
|
Uint32 end
|
|
)
|
|
{
|
|
Uint32 range = end-start+1;
|
|
|
|
if (randomSeed == 0) {
|
|
randomSeed = (Uint32)time(NULL);
|
|
VLOG(INFO, "======= RANDOM SEED: %08x ======\n", randomSeed);
|
|
}
|
|
if (initializedRandom == FALSE) {
|
|
srand(randomSeed);
|
|
initializedRandom = TRUE;
|
|
}
|
|
|
|
if (range == 0) {
|
|
VLOG(ERR, "%s:%d RANGE IS 0\n", __FUNCTION__, __LINE__);
|
|
return 0;
|
|
}
|
|
else {
|
|
return ((rand()%range) + start);
|
|
}
|
|
}
|
|
|
|
Int32 LoadFirmware(
|
|
Int32 productId,
|
|
Uint8** retFirmware,
|
|
Uint32* retSizeInWord,
|
|
const char* path
|
|
)
|
|
{
|
|
Int32 nread;
|
|
Uint32 totalRead, allocSize, readSize = WAVE5_MAX_CODE_BUF_SIZE;
|
|
Uint8* firmware = NULL;
|
|
osal_file_t fp;
|
|
|
|
if ((fp=osal_fopen(path, "rb")) == NULL)
|
|
{
|
|
VLOG(ERR, "Failed to open %s\n", path);
|
|
return -1;
|
|
}
|
|
|
|
totalRead = 0;
|
|
if (PRODUCT_ID_W_SERIES(productId)) {
|
|
firmware = (Uint8*)osal_malloc(readSize);
|
|
allocSize = readSize;
|
|
nread = 0;
|
|
while (TRUE) {
|
|
if (allocSize < (totalRead+readSize)) {
|
|
allocSize += 2*nread;
|
|
firmware = (Uint8*)realloc(firmware, allocSize);
|
|
}
|
|
nread = (Int32)osal_fread((void*)&firmware[totalRead], 1, readSize, fp);//lint !e613
|
|
totalRead += nread;
|
|
if (nread < (Int32)readSize)
|
|
break;
|
|
}
|
|
*retSizeInWord = (totalRead+1)/2;
|
|
}
|
|
else {
|
|
Uint16* pusBitCode;
|
|
pusBitCode = (Uint16 *)osal_malloc(MAX_CODE_BUF_SIZE);
|
|
firmware = (Uint8*)pusBitCode;
|
|
if (pusBitCode) {
|
|
Uint32 code;
|
|
while (!osal_feof((FILE*)fp) || totalRead < (MAX_CODE_BUF_SIZE/2)) {
|
|
code = -1;
|
|
if (fscanf((FILE*)fp, "%x", &code) <= 0) {
|
|
/* matching failure or EOF */
|
|
break;
|
|
}
|
|
pusBitCode[totalRead++] = (Uint16)code;
|
|
}
|
|
}
|
|
*retSizeInWord = totalRead;
|
|
}
|
|
|
|
osal_fclose(fp);
|
|
|
|
*retFirmware = firmware;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
void PrintVpuVersionInfo(
|
|
Uint32 core_idx
|
|
)
|
|
{
|
|
Uint32 version;
|
|
Uint32 revision;
|
|
Uint32 productId;
|
|
|
|
VPU_GetVersionInfo(core_idx, &version, &revision, &productId);
|
|
|
|
VLOG(INFO, "VPU coreNum : [%d]\n", core_idx);
|
|
VLOG(INFO, "Firmware : CustomerCode: %04x | version : %d.%d.%d rev.%d\n",
|
|
(Uint32)(version>>16), (Uint32)((version>>(12))&0x0f), (Uint32)((version>>(8))&0x0f), (Uint32)((version)&0xff), revision);
|
|
VLOG(INFO, "Hardware : %04x\n", productId);
|
|
VLOG(INFO, "API : %d.%d.%d\n\n", API_VERSION_MAJOR, API_VERSION_MINOR, API_VERSION_PATCH);
|
|
}
|
|
|
|
BOOL OpenDisplayBufferFile(CodStd codec, char *outputPath, VpuRect rcDisplay, TiledMapType mapType, FILE *fp[])
|
|
{
|
|
char strFile[MAX_FILE_PATH];
|
|
int width;
|
|
int height;
|
|
|
|
width = rcDisplay.right - rcDisplay.left;
|
|
height = rcDisplay.bottom - rcDisplay.top;
|
|
|
|
if (mapType == LINEAR_FRAME_MAP) {
|
|
if ((fp[0]=(FILE*)osal_fopen(outputPath, "wb")) == NULL) {
|
|
VLOG(ERR, "%s:%d failed to open %s\n", __FUNCTION__, __LINE__, outputPath);
|
|
goto ERR_OPEN_DISP_BUFFER_FILE;
|
|
}
|
|
}
|
|
else {
|
|
width = (codec == STD_HEVC || codec == STD_AVS2) ? VPU_ALIGN16(width) : VPU_ALIGN64(width);
|
|
height = (codec == STD_HEVC || codec == STD_AVS2) ? VPU_ALIGN16(height) : VPU_ALIGN64(height);
|
|
sprintf(strFile, "%s_%dx%d_fbc_data_y.bin", outputPath, width, height);
|
|
if ((fp[0]=(FILE*)osal_fopen(strFile, "wb")) == NULL) {
|
|
VLOG(ERR, "%s:%d failed to open %s\n", __FUNCTION__, __LINE__, strFile);
|
|
goto ERR_OPEN_DISP_BUFFER_FILE;
|
|
}
|
|
sprintf(strFile, "%s_%dx%d_fbc_data_c.bin", outputPath, width, height);
|
|
if ((fp[1]=(FILE*)osal_fopen(strFile, "wb")) == NULL) {
|
|
VLOG(ERR, "%s:%d failed to open %s\n", __FUNCTION__, __LINE__, strFile);
|
|
goto ERR_OPEN_DISP_BUFFER_FILE;
|
|
}
|
|
sprintf(strFile, "%s_%dx%d_fbc_table_y.bin", outputPath, width, height);
|
|
if ((fp[2]=(FILE*)osal_fopen(strFile, "wb")) == NULL) {
|
|
VLOG(ERR, "%s:%d failed to open %s\n", __FUNCTION__, __LINE__, strFile);
|
|
goto ERR_OPEN_DISP_BUFFER_FILE;
|
|
}
|
|
sprintf(strFile, "%s_%dx%d_fbc_table_c.bin", outputPath, width, height);
|
|
if ((fp[3]=(FILE*)osal_fopen(strFile, "wb")) == NULL) {
|
|
VLOG(ERR, "%s:%d failed to open %s\n", __FUNCTION__, __LINE__, strFile);
|
|
goto ERR_OPEN_DISP_BUFFER_FILE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
ERR_OPEN_DISP_BUFFER_FILE:
|
|
CloseDisplayBufferFile(fp);
|
|
return FALSE;
|
|
}
|
|
|
|
void CloseDisplayBufferFile(FILE *fp[])
|
|
{
|
|
int i;
|
|
for (i=0; i < OUTPUT_FP_NUMBER; i++) {
|
|
if (fp[i] != NULL) {
|
|
osal_fclose(fp[i]);
|
|
fp[i] = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
Int32 CalculateAuxBufferSize(AUX_BUF_TYPE type, CodStd codStd, Int32 width, Int32 height)
|
|
{
|
|
Int32 size = 0;
|
|
|
|
switch (type) {
|
|
case AUX_BUF_TYPE_MVCOL:
|
|
if (codStd == STD_AVC || codStd == STD_VC1 || codStd == STD_MPEG4 || codStd == STD_H263 || codStd == STD_RV || codStd == STD_AVS) {
|
|
size = VPU_ALIGN32(width)*VPU_ALIGN32(height);
|
|
size = (size * 3) / 2;
|
|
size = (size + 4) / 5;
|
|
size = ((size + 7) / 8) * 8;
|
|
}
|
|
else if (codStd == STD_HEVC) {
|
|
size = WAVE5_DEC_HEVC_MVCOL_BUF_SIZE(width, height);
|
|
}
|
|
else if (codStd == STD_VP9) {
|
|
size = WAVE5_DEC_VP9_MVCOL_BUF_SIZE(width, height);
|
|
}
|
|
else if (codStd == STD_AVS2) {
|
|
size = WAVE5_DEC_AVS2_MVCOL_BUF_SIZE(width, height);
|
|
}
|
|
else if (codStd == STD_AV1) {
|
|
size = WAVE5_DEC_AV1_MVCOL_BUF_SIZE(width, height);
|
|
}
|
|
else {
|
|
size = 0;
|
|
}
|
|
break;
|
|
case AUX_BUF_TYPE_FBC_Y_OFFSET:
|
|
size = WAVE5_FBC_LUMA_TABLE_SIZE(width, height);
|
|
break;
|
|
case AUX_BUF_TYPE_FBC_C_OFFSET:
|
|
size = WAVE5_FBC_CHROMA_TABLE_SIZE(width, height);
|
|
break;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
RetCode GetFBCOffsetTableSize(CodStd codStd, int width, int height, int* ysize, int* csize)
|
|
{
|
|
if (ysize == NULL || csize == NULL)
|
|
return RETCODE_INVALID_PARAM;
|
|
|
|
*ysize = CalculateAuxBufferSize(AUX_BUF_TYPE_FBC_Y_OFFSET, codStd, width, height);
|
|
*csize = CalculateAuxBufferSize(AUX_BUF_TYPE_FBC_C_OFFSET, codStd, width, height);
|
|
|
|
return RETCODE_SUCCESS;
|
|
}
|
|
|
|
RetCode GetPVRICRealSize(CodStd codStd __attribute__((unused)), TiledMapType mapType, FrameBufferFormat format, Uint32 width, Uint32 height, int* ysize, int* csize, Uint32* offset_luma, Uint32* offset_chroma, Uint32 frameWidth, Uint32 frameHeight)
|
|
{
|
|
Uint32 total_tile_num, hdr_size, data_size;
|
|
Uint32 frame_total_tile_num, frame_hdr_size;
|
|
|
|
if (ysize == NULL || csize == NULL)
|
|
return RETCODE_INVALID_PARAM;
|
|
|
|
switch (format) {
|
|
case FORMAT_420:
|
|
total_tile_num = (VPU_ALIGN64(width) >> 6) *(VPU_ALIGN4(height) >> 2);//width
|
|
frame_total_tile_num = (VPU_ALIGN64(frameWidth) >> 6) *(VPU_ALIGN4(frameHeight) >> 2);//width
|
|
break;
|
|
default: /* 10bit */
|
|
total_tile_num = (width+47)/48 * (VPU_ALIGN4(height) >> 2);
|
|
frame_total_tile_num = (frameWidth+47)/48 * (VPU_ALIGN4(frameHeight) >> 2);
|
|
break;
|
|
}
|
|
hdr_size = VPU_ALIGN256(total_tile_num);
|
|
frame_hdr_size = VPU_ALIGN256(frame_total_tile_num);
|
|
|
|
if (frame_hdr_size >= hdr_size) {
|
|
*offset_luma = frame_hdr_size - hdr_size;
|
|
}
|
|
if( mapType == PVRIC_COMPRESSED_FRAME_LOSSLESS_MAP ) {
|
|
data_size = (total_tile_num*256); // byte
|
|
}
|
|
else {
|
|
data_size = (total_tile_num*128); // byte
|
|
}
|
|
*ysize = (hdr_size + data_size);
|
|
|
|
VLOG(INFO, "<%s> Input WidthxHeight : %dx%d \t luma h=%d(%x), d=%d(%x)\n", __FUNCTION__, width, height, hdr_size, hdr_size, data_size, data_size);
|
|
|
|
switch (format) {
|
|
case FORMAT_420:
|
|
total_tile_num = (VPU_ALIGN64(width) >> 6) *(VPU_ALIGN4((height+1)/2) >> 2);
|
|
frame_total_tile_num = (VPU_ALIGN64(frameWidth) >> 6) *(VPU_ALIGN4((frameHeight+1)/2) >> 2);
|
|
break;
|
|
default: /* 10bit */
|
|
total_tile_num = (width+47)/48 * (VPU_ALIGN4((height+1)/2) >> 2);
|
|
frame_total_tile_num = (frameWidth+47)/48 * (VPU_ALIGN4((frameHeight+1)/2) >> 2);
|
|
break;
|
|
}
|
|
hdr_size = VPU_ALIGN256(total_tile_num);
|
|
frame_hdr_size = VPU_ALIGN256(frame_total_tile_num);
|
|
if (frame_hdr_size >= hdr_size) {
|
|
*offset_chroma = frame_hdr_size - hdr_size;
|
|
}
|
|
if( mapType == PVRIC_COMPRESSED_FRAME_LOSSLESS_MAP ) {
|
|
data_size = (total_tile_num*256); // byte
|
|
}
|
|
else {
|
|
data_size = (total_tile_num*128); // byte
|
|
}
|
|
*csize = (hdr_size + data_size);
|
|
|
|
VLOG(INFO, "<%s> chroma h=%d(%x), d=%d(%x)\n", __FUNCTION__, hdr_size, hdr_size, data_size, data_size);
|
|
return RETCODE_SUCCESS;
|
|
}
|
|
|
|
void ProcessVc1MultiResolution(
|
|
Uint8* image,
|
|
Int32 width,
|
|
Int32 height,
|
|
BOOL horz_half,
|
|
BOOL vert_half
|
|
)
|
|
{
|
|
Int32 disX, disY;
|
|
Int32 x, y;
|
|
|
|
if (horz_half == 0 && vert_half == 0) {
|
|
return;
|
|
}
|
|
|
|
disX = horz_half ? ((width+31)&~31)/2 : width;
|
|
disY = vert_half ? ((height+31)&~31)/2 : height;
|
|
|
|
for (y=0; y<height; y++) {
|
|
for (x=0; x<width; x++) {
|
|
if (x >= disX || y >= disY)
|
|
image[x+y*width] = 0;
|
|
}
|
|
}
|
|
|
|
/* Cb */
|
|
image += width * height;
|
|
|
|
width /= 2;
|
|
height /= 2;
|
|
disX /= 2;
|
|
disY /= 2;
|
|
|
|
for (y=0; y<height; y++) {
|
|
for (x=0; x<width; x++) {
|
|
if (x >= disX || y >= disY) image[x+y*width] = 0;
|
|
}
|
|
}
|
|
|
|
/* Cr */
|
|
image += width * height;
|
|
|
|
for (y=0; y<height; y++) {
|
|
for (x=0; x<width; x++) {
|
|
if (x >= disX || y >= disY) image[x+y*width] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
static callback_t decoded_done_callback_ftnptr = NULL;
|
|
static callback_t2 last_frame_decoded_callback_ftnptr = NULL;
|
|
|
|
void nc_register_decode_callback(callback_t cb)
|
|
{
|
|
if (cb) {
|
|
decoded_done_callback_ftnptr = cb;
|
|
}
|
|
else {
|
|
printf("[%s:%d] ... Fail to register decoding callback function \n",__FUNCTION__,__LINE__);
|
|
}
|
|
}
|
|
|
|
void call_decode_done_callback(Uint8* val, Uint32 size)
|
|
{
|
|
if (decoded_done_callback_ftnptr) {
|
|
decoded_done_callback_ftnptr(val, size);
|
|
}
|
|
else {
|
|
printf("[%s:%d] ... decoding callback function is NULL\n",__FUNCTION__,__LINE__);
|
|
}
|
|
}
|
|
|
|
void nc_register_last_frame_decoded_callback(callback_t2 cb)
|
|
{
|
|
if (cb) {
|
|
last_frame_decoded_callback_ftnptr = cb;
|
|
}
|
|
else {
|
|
printf("[%s:%d] ... Fail to register last frame decoded callback function \n",__FUNCTION__,__LINE__);
|
|
}
|
|
}
|
|
|
|
void call_last_frame_decoded_callback()
|
|
{
|
|
if (last_frame_decoded_callback_ftnptr) {
|
|
last_frame_decoded_callback_ftnptr();
|
|
}
|
|
else {
|
|
printf("[%s:%d] ... last frame decoded callback function is NULL\n",__FUNCTION__,__LINE__);
|
|
}
|
|
}
|
|
|
|
void SaveDisplayBufferToFile(DecHandle handle, CodStd codStd, RendererOutInfo* rendererOutInfo, FrameBuffer dispFrame, VpuRect rcDisplay, FILE *fp[])
|
|
{
|
|
Uint32 width;
|
|
Uint32 height;
|
|
Uint32 bpp;
|
|
DecGetFramebufInfo fbInfo;
|
|
CodecInst * pCodecInst;
|
|
pCodecInst = handle;
|
|
if (dispFrame.myIndex < 0)
|
|
return;
|
|
|
|
if (dispFrame.mapType != COMPRESSED_FRAME_MAP) {
|
|
size_t sizeYuv;
|
|
Uint8* pYuv;
|
|
pYuv = GetYUVFromFrameBuffer(handle, &dispFrame, rcDisplay, &width, &height, &bpp, &sizeYuv);
|
|
|
|
if (STD_VC1 == codStd) {
|
|
ProcessVc1MultiResolution(pYuv, rendererOutInfo->pOutInfo->decPicWidth, rendererOutInfo->pOutInfo->decPicHeight, rendererOutInfo->scaleX, rendererOutInfo->scaleY);
|
|
}
|
|
|
|
call_decode_done_callback(pYuv, (Uint32)sizeYuv);
|
|
|
|
osal_free(pYuv);
|
|
}
|
|
else {
|
|
Uint32 lumaTblSize;
|
|
Uint32 chromaTblSize;
|
|
Uint32 lSize;
|
|
Uint32 cSize;
|
|
Uint32 addr;
|
|
Uint32 endian;
|
|
Uint8* buf;
|
|
Uint32 coreIdx = VPU_HANDLE_CORE_INDEX(handle);
|
|
Uint32 productId = VPU_HANDLE_PRODUCT_ID(handle);
|
|
Uint32 cFrameStride;
|
|
|
|
VPU_DecGiveCommand(handle, DEC_GET_FRAMEBUF_INFO, (void*)&fbInfo);
|
|
|
|
width = rcDisplay.right - rcDisplay.left;
|
|
width = (codStd == STD_HEVC || codStd == STD_AVS2) ? VPU_ALIGN16(width) : VPU_ALIGN64(width);
|
|
height = rcDisplay.bottom - rcDisplay.top;
|
|
height = (codStd == STD_HEVC || codStd == STD_AVS2) ? VPU_ALIGN16(height) : VPU_ALIGN64(height);
|
|
|
|
cFrameStride = CalcStride(width, height, dispFrame.format, dispFrame.cbcrInterleave, dispFrame.mapType, (codStd == STD_VP9));
|
|
lSize = CalcLumaSize(pCodecInst, productId, cFrameStride, height, dispFrame.format, dispFrame.cbcrInterleave, dispFrame.mapType, NULL);
|
|
cSize = CalcChromaSize(pCodecInst, productId, cFrameStride, height, dispFrame.format, dispFrame.cbcrInterleave, dispFrame.mapType, NULL) * 2;
|
|
|
|
// Invert the endian because the pixel order register doesn't affect the FBC data.
|
|
endian = (~(Uint32)dispFrame.endian & 0xf) | 0x10;
|
|
|
|
/* Dump Y compressed data */
|
|
if ((buf=(Uint8*)osal_malloc(lSize)) != NULL) {
|
|
vdi_read_memory(coreIdx, dispFrame.bufY, buf, lSize, endian);
|
|
osal_fwrite((void *)buf, sizeof(Uint8), lSize, fp[0]);
|
|
osal_fflush(fp[0]);
|
|
osal_free(buf);
|
|
}
|
|
else {
|
|
VLOG(ERR, "%s:%d Failed to save the luma compressed data!!\n", __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
/* Dump C compressed data */
|
|
if ((buf=(Uint8*)osal_malloc(cSize)) != NULL) {
|
|
vdi_read_memory(coreIdx, dispFrame.bufCb, buf, cSize, endian);
|
|
osal_fwrite((void *)buf, sizeof(Uint8), cSize, fp[1]);
|
|
osal_fflush(fp[1]);
|
|
osal_free(buf);
|
|
}
|
|
else {
|
|
VLOG(ERR, "%s:%d Failed to save the chroma compressed data!!\n", __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
/* Dump Y Offset table */
|
|
GetFBCOffsetTableSize(codStd, (int)width, (int)height, (int*)&lumaTblSize, (int*)&chromaTblSize);
|
|
|
|
addr = fbInfo.vbFbcYTbl[dispFrame.myIndex].phys_addr;
|
|
|
|
if ((buf=(Uint8*)osal_malloc(lumaTblSize)) != NULL) {
|
|
vdi_read_memory(coreIdx, addr, buf, lumaTblSize, endian);
|
|
osal_fwrite((void *)buf, sizeof(Uint8), lumaTblSize, fp[2]);
|
|
osal_fflush(fp[2]);
|
|
osal_free(buf);
|
|
}
|
|
else {
|
|
VLOG(ERR, "%s:%d Failed to save the offset table of luma!\n", __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
/* Dump C Offset table */
|
|
addr = fbInfo.vbFbcCTbl[dispFrame.myIndex].phys_addr;
|
|
|
|
if ((buf=(Uint8*)osal_malloc(chromaTblSize)) != NULL) {
|
|
vdi_read_memory(coreIdx, addr, buf, chromaTblSize, endian);
|
|
osal_fwrite((void *)buf, sizeof(Uint8), chromaTblSize, fp[3]);
|
|
osal_fflush(fp[3]);
|
|
osal_free(buf);
|
|
}
|
|
else {
|
|
VLOG(ERR, "%s:%d Failed to save the offset table of chroma!\n", __FUNCTION__, __LINE__);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void PrintDecSeqWarningMessages(
|
|
Uint32 productId,
|
|
DecInitialInfo* seqInfo
|
|
)
|
|
{
|
|
if (PRODUCT_ID_W_SERIES(productId))
|
|
{
|
|
if (seqInfo->seqInitErrReason&0x00000001) VLOG(WARN, "sps_max_sub_layer_minus1 shall be 0 to 6\n");
|
|
if (seqInfo->seqInitErrReason&0x00000002) VLOG(WARN, "general_reserved_zero_44bits shall be 0.\n");
|
|
if (seqInfo->seqInitErrReason&0x00000004) VLOG(WARN, "reserved_zero_2bits shall be 0\n");
|
|
if (seqInfo->seqInitErrReason&0x00000008) VLOG(WARN, "sub_layer_reserved_zero_44bits shall be 0");
|
|
if (seqInfo->seqInitErrReason&0x00000010) VLOG(WARN, "general_level_idc shall have one of level of Table A.1\n");
|
|
if (seqInfo->seqInitErrReason&0x00000020) VLOG(WARN, "sps_max_dec_pic_buffering[i] <= MaxDpbSize\n");
|
|
if (seqInfo->seqInitErrReason&0x00000040) VLOG(WARN, "trailing bits shall be 1000... pattern, 7.3.2.1\n");
|
|
if (seqInfo->seqInitErrReason&0x00100000) VLOG(WARN, "Not supported or undefined profile: %d\n", seqInfo->profile);
|
|
if (seqInfo->seqInitErrReason&0x00200000) VLOG(WARN, "Spec over level(%d)\n", seqInfo->level);
|
|
}
|
|
}
|
|
|
|
void DisplayDecodedInformationForHevc(
|
|
DecHandle handle,
|
|
Uint32 frameNo,
|
|
BOOL performance,
|
|
DecOutputInfo* decodedInfo
|
|
)
|
|
{
|
|
Int32 logLevel;
|
|
QueueStatusInfo queueStatus;
|
|
PhysicalAddress frameSize = 0, frameStAddr = 0, frameEdAddr = 0;
|
|
|
|
VPU_DecGiveCommand(handle, DEC_GET_QUEUE_STATUS, &queueStatus);
|
|
|
|
if (decodedInfo == NULL) {
|
|
if ( performance == TRUE ) {
|
|
VLOG(INFO, " | FRAME | HOST | SEEK_S SEEK_E SEEK | PARSE_S PARSE_E PARSE | DEC_S DEC_E DEC |\n");
|
|
VLOG(INFO, "I NO T POC NAL DECO DISP DISPFLAG RD_PTR WR_PTR FRM_START FRM_END FRM_SIZE WxH SEQ TEMP | CYCLE | TICK | TICK TICK CYCLE | TICK TICK CYCLE | TICK TICK CYCLE | RQ IQ VCore\n");
|
|
VLOG(INFO, "-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n");
|
|
}
|
|
else {
|
|
VLOG(INFO, "I NO T POC NAL DECO DISP DISPFLAG RD_PTR WR_PTR FRM_START FRM_END FRM_SIZE WxH SEQ TEMP CYCLE ( Seek, Parse, Dec) RQ IQ VCore\n");
|
|
VLOG(INFO, "---------------------------------------------------------------------------------------------------------------------------------------------------------------------\n");
|
|
}
|
|
}
|
|
else {
|
|
logLevel = (decodedInfo->decodingSuccess&0x01) == 0 ? WARN : INFO;
|
|
frameStAddr = decodedInfo->bytePosFrameStart;
|
|
frameEdAddr = decodedInfo->bytePosFrameEnd;
|
|
frameSize = (frameEdAddr > frameStAddr) ? (frameEdAddr - frameStAddr) : (frameStAddr - frameEdAddr);
|
|
// Print informations
|
|
if ( performance == TRUE ) {
|
|
VLOG(logLevel, "%02d %5d %d %4d(%4d) %3d %2d(%2d) %2d(%2d) %08x %08x %08x %08x %08x %8d %4dx%-4d %4d %4d %8d %8d (%6d,%6d,%8d) (%6d,%6d,%8d) (%6d,%6d,%8d) %d %d %d\n",
|
|
handle->instIndex, frameNo, decodedInfo->picType,
|
|
decodedInfo->decodedPOC, decodedInfo->displayPOC, decodedInfo->nalType,
|
|
decodedInfo->indexFrameDecoded, decodedInfo->indexFrameDecodedForTiled,
|
|
decodedInfo->indexFrameDisplay, decodedInfo->indexFrameDisplayForTiled,
|
|
decodedInfo->frameDisplayFlag,decodedInfo->rdPtr, decodedInfo->wrPtr,
|
|
decodedInfo->bytePosFrameStart, decodedInfo->bytePosFrameEnd, frameSize,
|
|
decodedInfo->dispPicWidth, decodedInfo->dispPicHeight, decodedInfo->sequenceNo,
|
|
decodedInfo->temporalId,
|
|
decodedInfo->frameCycle, decodedInfo->decHostCmdTick,
|
|
decodedInfo->decSeekStartTick, decodedInfo->decSeekEndTick, decodedInfo->seekCycle,
|
|
decodedInfo->decParseStartTick, decodedInfo->decParseEndTick, decodedInfo->parseCycle,
|
|
decodedInfo->decDecodeStartTick, decodedInfo->decDecodeEndTick, decodedInfo->DecodedCycle,
|
|
queueStatus.reportQueueCount, queueStatus.instanceQueueCount,
|
|
0
|
|
);
|
|
}
|
|
else {
|
|
VLOG(logLevel, "%02d %5d %d %4d(%4d) %3d %2d(%2d) %2d(%2d) %08x %08x %08x %08x %08x %8d %4dx%-4d %4d %4d %8d(%8d,%8d,%8d) %d %d %d\n",
|
|
handle->instIndex, frameNo, decodedInfo->picType,
|
|
decodedInfo->decodedPOC, decodedInfo->displayPOC, decodedInfo->nalType,
|
|
decodedInfo->indexFrameDecoded, decodedInfo->indexFrameDecodedForTiled,
|
|
decodedInfo->indexFrameDisplay, decodedInfo->indexFrameDisplayForTiled,
|
|
decodedInfo->frameDisplayFlag,decodedInfo->rdPtr, decodedInfo->wrPtr,
|
|
decodedInfo->bytePosFrameStart, decodedInfo->bytePosFrameEnd, frameSize,
|
|
decodedInfo->dispPicWidth, decodedInfo->dispPicHeight, decodedInfo->sequenceNo,
|
|
decodedInfo->temporalId,
|
|
decodedInfo->frameCycle, decodedInfo->seekCycle, decodedInfo->parseCycle, decodedInfo->DecodedCycle,
|
|
queueStatus.reportQueueCount, queueStatus.instanceQueueCount,
|
|
0
|
|
);
|
|
}
|
|
if (logLevel == ERR) {
|
|
VLOG(ERR, "\t>>ERROR REASON: 0x%08x(0x%08x)\n", decodedInfo->errorReason, decodedInfo->errorReasonExt);
|
|
}
|
|
if (decodedInfo->numOfErrMBs) {
|
|
VLOG(WARN, "\t>> ErrorBlock: %d\n", decodedInfo->numOfErrMBs);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DisplayDecodedInformationForAVS2(
|
|
DecHandle handle,
|
|
Uint32 frameNo,
|
|
BOOL performance,
|
|
DecOutputInfo* decodedInfo
|
|
)
|
|
{
|
|
Int32 logLevel;
|
|
QueueStatusInfo queueStatus;
|
|
PhysicalAddress frameSize = 0, frameStAddr = 0, frameEdAddr = 0;
|
|
|
|
VPU_DecGiveCommand(handle, DEC_GET_QUEUE_STATUS, &queueStatus);
|
|
|
|
if (decodedInfo == NULL) {
|
|
if ( performance == TRUE ) {
|
|
VLOG(INFO, " | FRAME | HOST | SEEK_S SEEK_E SEEK | PARSE_S PARSE_E PARSE | DEC_S DEC_E DEC |\n");
|
|
VLOG(INFO, "I NO T POC NAL DECO DISP DISPFLAG RD_PTR WR_PTR FRM_START FRM_END FRM_SIZE WxH SEQ TEMP | CYCLE | TICK | TICK TICK CYCLE | TICK TICK CYCLE | TICK TICK CYCLE | RQ IQ\n");
|
|
} else {
|
|
VLOG(INFO, "I NO T POC NAL DECO DISP DISPFLAG RD_PTR WR_PTR FRM_START FRM_END FRM_SIZE WxH SEQ TEMP CYCLE (Seek, Parse, Dec) RQ IQ\n");
|
|
}
|
|
VLOG(INFO, "------------------------------------------------------------------------------------------------------------\n");
|
|
}
|
|
else {
|
|
logLevel = (decodedInfo->decodingSuccess&0x01) == 0 ? ERR : TRACE;
|
|
frameStAddr = decodedInfo->bytePosFrameStart;
|
|
frameEdAddr = decodedInfo->bytePosFrameEnd;
|
|
frameSize = (frameEdAddr > frameStAddr) ? (frameEdAddr - frameStAddr) : (frameStAddr - frameEdAddr);
|
|
// Print informations
|
|
if (performance == TRUE) {
|
|
VLOG(logLevel, "%02d %5d %d %4d(%4d) %3d %2d(%2d) %2d(%2d) %08x %08x %08x %08x %08x %8d %4dx%-4d %4d %4d %8d %8d (%6d,%6d,%8d) (%6d,%6d,%8d) (%6d,%6d,%8d) %d %d %d\n",
|
|
handle->instIndex, frameNo, decodedInfo->picType,
|
|
decodedInfo->avs2Info.decodedPOI, decodedInfo->avs2Info.displayPOI, decodedInfo->nalType,
|
|
decodedInfo->indexFrameDecoded, decodedInfo->indexFrameDecodedForTiled,
|
|
decodedInfo->indexFrameDisplay, decodedInfo->indexFrameDisplayForTiled,
|
|
decodedInfo->frameDisplayFlag,decodedInfo->rdPtr, decodedInfo->wrPtr,
|
|
decodedInfo->bytePosFrameStart, decodedInfo->bytePosFrameEnd, frameSize,
|
|
decodedInfo->dispPicWidth, decodedInfo->dispPicHeight, decodedInfo->sequenceNo,
|
|
decodedInfo->temporalId,
|
|
decodedInfo->frameCycle, decodedInfo->decHostCmdTick,
|
|
decodedInfo->decSeekStartTick, decodedInfo->decSeekEndTick, decodedInfo->seekCycle,
|
|
decodedInfo->decParseStartTick, decodedInfo->decParseEndTick, decodedInfo->parseCycle,
|
|
decodedInfo->decDecodeStartTick, decodedInfo->decDecodeEndTick, decodedInfo->DecodedCycle,
|
|
queueStatus.reportQueueCount, queueStatus.instanceQueueCount,
|
|
0
|
|
);
|
|
}
|
|
else {
|
|
VLOG(logLevel, "%02d %5d %d %4d(%4d) %3d %2d(%2d) %2d(%2d) %08x %08x %08x %08x %08x %8d %4dx%-4d %4d %4d %8d(%8d,%8d,%8d) %d %d %d\n",
|
|
handle->instIndex, frameNo, decodedInfo->picType,
|
|
decodedInfo->avs2Info.decodedPOI, decodedInfo->avs2Info.displayPOI, decodedInfo->nalType,
|
|
decodedInfo->indexFrameDecoded, decodedInfo->indexFrameDecodedForTiled,
|
|
decodedInfo->indexFrameDisplay, decodedInfo->indexFrameDisplayForTiled,
|
|
decodedInfo->frameDisplayFlag,decodedInfo->rdPtr, decodedInfo->wrPtr,
|
|
decodedInfo->bytePosFrameStart, decodedInfo->bytePosFrameEnd, frameSize,
|
|
decodedInfo->dispPicWidth, decodedInfo->dispPicHeight, decodedInfo->sequenceNo,
|
|
decodedInfo->temporalId,
|
|
decodedInfo->frameCycle, decodedInfo->seekCycle, decodedInfo->parseCycle, decodedInfo->DecodedCycle,
|
|
queueStatus.reportQueueCount, queueStatus.instanceQueueCount,
|
|
0
|
|
);
|
|
}
|
|
if (logLevel == ERR) {
|
|
VLOG(ERR, "\t>>ERROR REASON: 0x%08x(0x%08x)\n", decodedInfo->errorReason, decodedInfo->errorReasonExt);
|
|
}
|
|
if (decodedInfo->numOfErrMBs) {
|
|
VLOG(WARN, "\t>> ErrorBlock: %d\n", decodedInfo->numOfErrMBs);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DisplayDecodedInformationForVP9(
|
|
DecHandle handle,
|
|
Uint32 frameNo,
|
|
BOOL performance,
|
|
DecOutputInfo* decodedInfo)
|
|
{
|
|
Int32 logLevel;
|
|
QueueStatusInfo queueStatus;
|
|
PhysicalAddress frameSize = 0, frameStAddr = 0, frameEdAddr = 0;
|
|
|
|
VPU_DecGiveCommand(handle, DEC_GET_QUEUE_STATUS, &queueStatus);
|
|
|
|
if (decodedInfo == NULL) {
|
|
// Print header
|
|
if ( performance == TRUE ) {
|
|
VLOG(INFO, " | FRAME | HOST | SEEK_S SEEK_E SEEK | PARSE_S PARSE_E PARSE | DEC_S DEC_E DEC |\n");
|
|
VLOG(INFO, "I NO T DECO DISP DISPFLAG RD_PTR WR_PTR FRM_START FRM_END FRM_SIZE WxH SEQ | CYCLE | TICK | TICK TICK CYCLE | TICK TICK CYCLE | TICK TICK CYCLE | RQ IQ\n");
|
|
}
|
|
else {
|
|
VLOG(INFO, "I NO T DECO DISP DISPFLAG RD_PTR WR_PTR FRM_START FRM_END FRM_SIZE WxH SEQ CYCLE (Seek, Parse, Dec) RQ IQ\n");
|
|
}
|
|
VLOG(INFO, "--------------------------------------------------------------------------------------------\n");
|
|
}
|
|
else {
|
|
logLevel = (decodedInfo->decodingSuccess&0x01) == 0 ? ERR : TRACE;
|
|
frameStAddr = decodedInfo->bytePosFrameStart;
|
|
frameEdAddr = decodedInfo->bytePosFrameEnd;
|
|
frameSize = (frameEdAddr > frameStAddr) ? (frameEdAddr - frameStAddr) : (frameStAddr - frameEdAddr);
|
|
// Print informations
|
|
if (performance == TRUE) {
|
|
VLOG(logLevel, "%02d %5d %d %2d(%2d) %2d(%2d) %08x %08x %08x %08x %08x %8d %4dx%-4d %4d %8d %8d (%6d,%6d,%8d) (%6d,%6d,%8d) (%6d,%6d,%8d) %d %d %d\n",
|
|
handle->instIndex, frameNo, decodedInfo->picType,
|
|
decodedInfo->indexFrameDecoded, decodedInfo->indexFrameDecodedForTiled,
|
|
decodedInfo->indexFrameDisplay, decodedInfo->indexFrameDisplayForTiled,
|
|
decodedInfo->frameDisplayFlag,decodedInfo->rdPtr, decodedInfo->wrPtr,
|
|
decodedInfo->bytePosFrameStart, decodedInfo->bytePosFrameEnd, frameSize,
|
|
decodedInfo->dispPicWidth, decodedInfo->dispPicHeight, decodedInfo->sequenceNo,
|
|
decodedInfo->frameCycle, decodedInfo->decHostCmdTick,
|
|
decodedInfo->decSeekStartTick, decodedInfo->decSeekEndTick, decodedInfo->seekCycle,
|
|
decodedInfo->decParseStartTick, decodedInfo->decParseEndTick, decodedInfo->parseCycle,
|
|
decodedInfo->decDecodeStartTick, decodedInfo->decDecodeEndTick, decodedInfo->DecodedCycle,
|
|
queueStatus.reportQueueCount, queueStatus.instanceQueueCount,
|
|
0
|
|
);
|
|
}
|
|
else {
|
|
VLOG(logLevel, "%02d %5d %d %2d(%2d) %2d(%2d) %08x %08x %08x %08x %08x %8d %4dx%-4d %4d %8d (%8d,%8d,%8d) %d %d %d\n",
|
|
handle->instIndex, frameNo, decodedInfo->picType,
|
|
decodedInfo->indexFrameDecoded, decodedInfo->indexFrameDecodedForTiled,
|
|
decodedInfo->indexFrameDisplay, decodedInfo->indexFrameDisplayForTiled,
|
|
decodedInfo->frameDisplayFlag,decodedInfo->rdPtr, decodedInfo->wrPtr,
|
|
decodedInfo->bytePosFrameStart, decodedInfo->bytePosFrameEnd, frameSize,
|
|
decodedInfo->dispPicWidth, decodedInfo->dispPicHeight, decodedInfo->sequenceNo,
|
|
decodedInfo->frameCycle, decodedInfo->seekCycle, decodedInfo->parseCycle, decodedInfo->DecodedCycle,
|
|
queueStatus.reportQueueCount, queueStatus.instanceQueueCount,
|
|
0
|
|
);
|
|
}
|
|
if (logLevel == ERR) {
|
|
VLOG(ERR, "\t>>ERROR REASON: 0x%08x(0x%08x)\n", decodedInfo->errorReason, decodedInfo->errorReasonExt);
|
|
}
|
|
if (decodedInfo->numOfErrMBs) {
|
|
VLOG(WARN, "\t>> ErrorBlock: %d\n", decodedInfo->numOfErrMBs);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DisplayDecodedInformationForAVC(
|
|
DecHandle handle,
|
|
Uint32 frameNo,
|
|
BOOL performance,
|
|
DecOutputInfo* decodedInfo)
|
|
{
|
|
Int32 logLevel;
|
|
QueueStatusInfo queueStatus;
|
|
PhysicalAddress frameSize = 0, frameStAddr = 0, frameEdAddr = 0;
|
|
|
|
VPU_DecGiveCommand(handle, DEC_GET_QUEUE_STATUS, &queueStatus);
|
|
|
|
if (decodedInfo == NULL) {
|
|
// Print header
|
|
if ( performance == TRUE ) {
|
|
VLOG(INFO, " | FRAME | HOST | SEEK_S SEEK_E SEEK | PARSE_S PARSE_E PARSE | DEC_S DEC_E DEC |\n");
|
|
VLOG(INFO, "I NO T POC NAL DECO DISP DISPFLAG RD_PTR WR_PTR FRM_START FRM_END FRM_SIZE WxH SEQ TEMP | CYCLE | TICK | TICK TICK CYCLE | TICK TICK CYCLE | TICK TICK CYCLE | RQ IQ VCore\n");
|
|
}
|
|
else {
|
|
VLOG(INFO, "I NO T POC NAL DECO DISP DISPFLAG RD_PTR WR_PTR FRM_START FRM_END FRM_SIZE WxH SEQ TEMP CYCLE ( Seek, Parse, Dec) RQ IQ VCore\n");
|
|
}
|
|
VLOG(INFO, "-----------------------------------------------------------------------------------------------------------------------------------------------\n");
|
|
}
|
|
else {
|
|
logLevel = (decodedInfo->decodingSuccess&0x01) == 0 ? ERR : INFO;
|
|
frameStAddr = decodedInfo->bytePosFrameStart;
|
|
frameEdAddr = decodedInfo->bytePosFrameEnd;
|
|
frameSize = (frameEdAddr > frameStAddr) ? (frameEdAddr - frameStAddr) : (frameStAddr - frameEdAddr);
|
|
// Print informations
|
|
if (performance == TRUE) {
|
|
VLOG(logLevel, "%02d %5d %d %4d(%4d) %3d %2d(%2d) %2d(%2d) %08x %08x %08x %08x %08x %8d %4dx%-4d %4d %4d %8d %8d (%6d,%6d,%8d) (%6d,%6d,%8d) (%6d,%6d,%8d) %d %d %d\n",
|
|
handle->instIndex, frameNo, decodedInfo->picType, decodedInfo->decodedPOC, decodedInfo->displayPOC, decodedInfo->nalType,
|
|
decodedInfo->indexFrameDecoded, decodedInfo->indexFrameDecodedForTiled,
|
|
decodedInfo->indexFrameDisplay, decodedInfo->indexFrameDisplayForTiled,
|
|
decodedInfo->frameDisplayFlag,decodedInfo->rdPtr, decodedInfo->wrPtr,
|
|
decodedInfo->bytePosFrameStart, decodedInfo->bytePosFrameEnd, frameSize,
|
|
decodedInfo->dispPicWidth, decodedInfo->dispPicHeight, decodedInfo->sequenceNo, decodedInfo->temporalId,
|
|
decodedInfo->frameCycle, decodedInfo->decHostCmdTick,
|
|
decodedInfo->decSeekStartTick, decodedInfo->decSeekEndTick, decodedInfo->seekCycle,
|
|
decodedInfo->decParseStartTick, decodedInfo->decParseEndTick, decodedInfo->parseCycle,
|
|
decodedInfo->decDecodeStartTick, decodedInfo->decDecodeEndTick, decodedInfo->DecodedCycle,
|
|
queueStatus.reportQueueCount, queueStatus.instanceQueueCount,
|
|
0
|
|
);
|
|
}
|
|
else {
|
|
VLOG(logLevel, "%02d %5d %d %4d(%4d) %3d %2d(%2d) %2d(%2d) %08x %08x %08x %08x %08x %8d %4dx%-4d %4d %4d %8d(%8d,%8d,%8d) %d %d %d\n",
|
|
handle->instIndex, frameNo, decodedInfo->picType, decodedInfo->decodedPOC, decodedInfo->displayPOC, decodedInfo->nalType,
|
|
decodedInfo->indexFrameDecoded, decodedInfo->indexFrameDecodedForTiled,
|
|
decodedInfo->indexFrameDisplay, decodedInfo->indexFrameDisplayForTiled,
|
|
decodedInfo->frameDisplayFlag,decodedInfo->rdPtr, decodedInfo->wrPtr,
|
|
decodedInfo->bytePosFrameStart, decodedInfo->bytePosFrameEnd, frameSize,
|
|
decodedInfo->dispPicWidth, decodedInfo->dispPicHeight, decodedInfo->sequenceNo, decodedInfo->temporalId,
|
|
decodedInfo->frameCycle, decodedInfo->seekCycle, decodedInfo->parseCycle, decodedInfo->DecodedCycle,
|
|
queueStatus.reportQueueCount, queueStatus.instanceQueueCount,
|
|
0
|
|
);
|
|
}
|
|
|
|
if (logLevel == ERR) {
|
|
VLOG(ERR, "\t>>ERROR REASON: 0x%08x(0x%08x)\n", decodedInfo->errorReason, decodedInfo->errorReasonExt);
|
|
}
|
|
if (decodedInfo->numOfErrMBs) {
|
|
VLOG(WARN, "\t>> ErrorBlock: %d\n", decodedInfo->numOfErrMBs);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DisplayDecodedInformationForAV1(
|
|
DecHandle handle,
|
|
Uint32 frameNo,
|
|
BOOL performance,
|
|
DecOutputInfo* decodedInfo)
|
|
{
|
|
Int32 logLevel;
|
|
QueueStatusInfo queueStatus;
|
|
PhysicalAddress frameSize = 0, frameStAddr = 0, frameEdAddr = 0;
|
|
|
|
VPU_DecGiveCommand(handle, DEC_GET_QUEUE_STATUS, &queueStatus);
|
|
|
|
if (decodedInfo == NULL) {
|
|
// Print header
|
|
if ( performance == TRUE ) {
|
|
VLOG(INFO, " | FRAME | HOST | SEEK_S SEEK_E SEEK | PARSE_S PARSE_E PARSE | DEC_S DEC_E DEC |\n");
|
|
VLOG(INFO, "I NO T DECO DISP DISPFLAG RD_PTR WR_PTR FRM_START FRM_END FRM_SIZE WxH SEQ | CYCLE | TICK | TICK TICK CYCLE | TICK TICK CYCLE | TICK TICK CYCLE | RQ IQ\n");
|
|
}
|
|
else {
|
|
VLOG(INFO, "I NO T DECO DISP DISPFLAG RD_PTR WR_PTR FRM_START FRM_END FRM_SIZE WxH SEQ CYCLE (Seek, Parse, Dec) RQ IQ\n");
|
|
}
|
|
VLOG(INFO, "--------------------------------------------------------------------------------------------\n");
|
|
}
|
|
else {
|
|
logLevel = (decodedInfo->decodingSuccess&0x01) == 0 ? ERR : TRACE;
|
|
frameStAddr = decodedInfo->bytePosFrameStart;
|
|
frameEdAddr = decodedInfo->bytePosFrameEnd;
|
|
frameSize = (frameEdAddr > frameStAddr) ? (frameEdAddr - frameStAddr) : (frameStAddr - frameEdAddr);
|
|
// Print informations
|
|
if (performance == TRUE) {
|
|
VLOG(logLevel, "%02d %5d %d %2d(%2d) %2d(%2d) %08x %08x %08x %08x %08x %8d %4dx%-4d %4d %8d %8d (%6d,%6d,%8d) (%6d,%6d,%8d) (%6d,%6d,%8d) %d %d %d\n",
|
|
handle->instIndex, frameNo, decodedInfo->picType,
|
|
decodedInfo->indexFrameDecoded, decodedInfo->indexFrameDecodedForTiled,
|
|
decodedInfo->indexFrameDisplay, decodedInfo->indexFrameDisplayForTiled,
|
|
decodedInfo->frameDisplayFlag,decodedInfo->rdPtr, decodedInfo->wrPtr,
|
|
decodedInfo->bytePosFrameStart, decodedInfo->bytePosFrameEnd, frameSize,
|
|
decodedInfo->dispPicWidth, decodedInfo->dispPicHeight, decodedInfo->sequenceNo,
|
|
decodedInfo->frameCycle, decodedInfo->decHostCmdTick,
|
|
decodedInfo->decSeekStartTick, decodedInfo->decSeekEndTick, decodedInfo->seekCycle,
|
|
decodedInfo->decParseStartTick, decodedInfo->decParseEndTick, decodedInfo->parseCycle,
|
|
decodedInfo->decDecodeStartTick, decodedInfo->decDecodeEndTick, decodedInfo->DecodedCycle,
|
|
queueStatus.reportQueueCount, queueStatus.instanceQueueCount,
|
|
0
|
|
);
|
|
}
|
|
else {
|
|
VLOG(logLevel, "%02d %5d %d %2d(%2d) %2d(%2d) %08x %08x %08x %08x %08x %8d %4dx%-4d %4d %8d (%8d,%8d,%8d) %d %d %d\n",
|
|
handle->instIndex, frameNo, decodedInfo->picType,
|
|
decodedInfo->indexFrameDecoded, decodedInfo->indexFrameDecodedForTiled,
|
|
decodedInfo->indexFrameDisplay, decodedInfo->indexFrameDisplayForTiled,
|
|
decodedInfo->frameDisplayFlag,decodedInfo->rdPtr, decodedInfo->wrPtr,
|
|
decodedInfo->bytePosFrameStart, decodedInfo->bytePosFrameEnd, frameSize,
|
|
decodedInfo->dispPicWidth, decodedInfo->dispPicHeight, decodedInfo->sequenceNo,
|
|
decodedInfo->frameCycle, decodedInfo->seekCycle, decodedInfo->parseCycle, decodedInfo->DecodedCycle,
|
|
queueStatus.reportQueueCount, queueStatus.instanceQueueCount,
|
|
0
|
|
);
|
|
}
|
|
if (logLevel == ERR) {
|
|
VLOG(ERR, "\t>>ERROR REASON: 0x%08x(0x%08x)\n", decodedInfo->errorReason, decodedInfo->errorReasonExt);
|
|
}
|
|
if (decodedInfo->numOfErrMBs) {
|
|
VLOG(WARN, "\t>> ErrorBlock: %d\n", decodedInfo->numOfErrMBs);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DisplayDecodedInformationCommon(
|
|
DecHandle handle,
|
|
Uint32 frameNo,
|
|
DecOutputInfo* decodedInfo)
|
|
{
|
|
Int32 logLevel;
|
|
PhysicalAddress frameSize = 0, frameStAddr = 0, frameEdAddr = 0;
|
|
|
|
if (decodedInfo == NULL) {
|
|
// Print header
|
|
VLOG(TRACE, "I NO T DECO DISP DISPFLAG RD_PTR WR_PTR FRM_START FRM_END FRM_SIZE WxH \n");
|
|
VLOG(TRACE, "---------------------------------------------------------------------------\n");
|
|
}
|
|
else {
|
|
VpuRect rc = decodedInfo->rcDisplay;
|
|
Uint32 width = rc.right - rc.left;
|
|
Uint32 height = rc.bottom - rc.top;
|
|
logLevel = (decodedInfo->decodingSuccess&0x01) == 0 ? WARN : INFO;
|
|
frameStAddr = decodedInfo->bytePosFrameStart;
|
|
frameEdAddr = decodedInfo->bytePosFrameEnd;
|
|
frameSize = (frameEdAddr > frameStAddr) ? (frameEdAddr - frameStAddr) : (frameStAddr - frameEdAddr);
|
|
// Print informations
|
|
VLOG(logLevel, "%02d %5d %d %2d(%2d) %2d(%2d) %08x %08x %08x %08x %08x %8d %dx%d\n",
|
|
handle->instIndex, frameNo, decodedInfo->picType,
|
|
decodedInfo->indexFrameDecoded, decodedInfo->indexFrameDecodedForTiled,
|
|
decodedInfo->indexFrameDisplay, decodedInfo->indexFrameDisplayForTiled,
|
|
decodedInfo->frameDisplayFlag,decodedInfo->rdPtr, decodedInfo->wrPtr,
|
|
decodedInfo->bytePosFrameStart, decodedInfo->bytePosFrameEnd, frameSize,
|
|
width, height);
|
|
if (logLevel == ERR) {
|
|
VLOG(ERR, "\t>>ERROR REASON: 0x%08x(0x%08x)\n", decodedInfo->errorReason, decodedInfo->errorReasonExt);
|
|
}
|
|
if (decodedInfo->numOfErrMBs) {
|
|
VLOG(WARN, "\t>> ErrorBlock: %d\n", decodedInfo->numOfErrMBs);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \brief Print out decoded information such like RD_PTR, WR_PTR, PIC_TYPE, ..
|
|
* \param decodedInfo If this parameter is not NULL then print out decoded informations
|
|
* otherwise print out header.
|
|
*/
|
|
void
|
|
DisplayDecodedInformation(
|
|
DecHandle handle __attribute__((unused)),
|
|
CodStd codec,
|
|
Uint32 frameNo __attribute__((unused)),
|
|
DecOutputInfo* decodedInfo,
|
|
...
|
|
)
|
|
{
|
|
int performance = FALSE;
|
|
va_list ap;
|
|
|
|
va_start(ap, decodedInfo);
|
|
performance = va_arg(ap, Uint32);
|
|
va_end(ap);
|
|
switch (codec)
|
|
{
|
|
case STD_HEVC:
|
|
DisplayDecodedInformationForHevc(handle, frameNo, performance, decodedInfo);
|
|
break;
|
|
case STD_VP9:
|
|
DisplayDecodedInformationForVP9(handle, frameNo, performance, decodedInfo);
|
|
break;
|
|
case STD_AVS2:
|
|
DisplayDecodedInformationForAVS2(handle, frameNo, performance, decodedInfo);
|
|
break;
|
|
case STD_AVC:
|
|
DisplayDecodedInformationForAVC(handle, frameNo, performance, decodedInfo);
|
|
break;
|
|
case STD_AV1:
|
|
DisplayDecodedInformationForAV1(handle, frameNo, performance, decodedInfo);
|
|
break;
|
|
default:
|
|
DisplayDecodedInformationCommon(handle, frameNo, decodedInfo);
|
|
break;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void SetDefaultEncTestConfig(TestEncConfig* testConfig) {
|
|
osal_memset(testConfig, 0, sizeof(TestEncConfig));
|
|
|
|
testConfig->frame_endian = VPU_FRAME_ENDIAN;
|
|
testConfig->stream_endian = VPU_STREAM_ENDIAN;
|
|
testConfig->source_endian = VPU_SOURCE_ENDIAN;
|
|
testConfig->mapType = COMPRESSED_FRAME_MAP;
|
|
testConfig->lineBufIntEn = TRUE;
|
|
#ifdef SUPPORT_SOURCE_RELEASE_INTERRUPT
|
|
testConfig->srcReleaseIntEnable = FALSE;
|
|
#endif
|
|
testConfig->ringBufferEnable = FALSE;
|
|
testConfig->ringBufferWrapEnable = FALSE;
|
|
|
|
testConfig->coreIdx = 0;
|
|
testConfig->cbcrInterleave = TRUE;
|
|
testConfig->nv21 = FALSE;
|
|
}
|
|
|
|
void Coda9SetDefaultEncTestConfig(TestEncConfig* encConfig) {
|
|
osal_memset(encConfig, 0, sizeof(TestEncConfig));
|
|
|
|
encConfig->stdMode = STD_AVC;
|
|
encConfig->frame_endian = VPU_FRAME_ENDIAN;
|
|
encConfig->stream_endian = VPU_STREAM_ENDIAN;
|
|
encConfig->source_endian = VPU_SOURCE_ENDIAN;
|
|
encConfig->mapType = LINEAR_FRAME_MAP;
|
|
encConfig->ringBufferEnable = FALSE;
|
|
encConfig->yuv_mode = SOURCE_YUV;
|
|
}
|
|
|
|
|
|
static void Wave5DisplayEncodedInformation(
|
|
EncHandle handle,
|
|
CodStd codec __attribute__((unused)),
|
|
Uint32 frameNo __attribute__((unused)),
|
|
EncOutputInfo* encodedInfo,
|
|
Int32 srcEndFlag,
|
|
Int32 srcFrameIdx,
|
|
Int32 performance
|
|
)
|
|
{
|
|
QueueStatusInfo queueStatus;
|
|
|
|
VPU_EncGiveCommand(handle, ENC_GET_QUEUE_STATUS, &queueStatus);
|
|
|
|
if (encodedInfo == NULL) {
|
|
if (performance == TRUE ) {
|
|
printf("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n");
|
|
printf(" USEDSRC | FRAME | HOST | PREP_S PREP_E PREP | PROCE_S PROCE_E PROCE | ENC_S ENC_E ENC |\n");
|
|
printf("I NO T RECON RD_PTR WR_PTR BYTES SRCIDX IDX IDC Vcore | CYCLE | TICK | TICK TICK CYCLE | TICK TICK CYCLE | TICK TICK CYCLE | RQ IQ\n");
|
|
printf("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n");
|
|
}
|
|
else {
|
|
printf("---------------------------------------------------------------------------------------------------------------------------\n");
|
|
printf(" USEDSRC | CYCLE\n");
|
|
printf("I NO T RECON RD_PTR WR_PTR BYTES SRCIDX IDX IDC Vcore | FRAME PREPARING PROCESSING ENCODING | RQ IQ\n");
|
|
printf("---------------------------------------------------------------------------------------------------------------------------\n");
|
|
}
|
|
} else {
|
|
if (performance == TRUE) {
|
|
printf("%02d %5d %5d %5d %08x %08x %8x %2d %2d %08x %2d %8u %8u (%8u,%8u,%8u) (%8u,%8u,%8u) (%8u,%8u,%8u) %d %d\n",
|
|
handle->instIndex, encodedInfo->encPicCnt, encodedInfo->picType, encodedInfo->reconFrameIndex, encodedInfo->rdPtr, encodedInfo->wrPtr,
|
|
encodedInfo->bitstreamSize, (srcEndFlag == 1 ? -1 : srcFrameIdx), encodedInfo->encSrcIdx,
|
|
encodedInfo->releaseSrcFlag,
|
|
0,
|
|
encodedInfo->frameCycle, encodedInfo->encHostCmdTick,
|
|
encodedInfo->encPrepareStartTick, encodedInfo->encPrepareEndTick, encodedInfo->prepareCycle,
|
|
encodedInfo->encProcessingStartTick, encodedInfo->encProcessingEndTick, encodedInfo->processing,
|
|
encodedInfo->encEncodeStartTick, encodedInfo->encEncodeEndTick, encodedInfo->EncodedCycle,
|
|
queueStatus.reportQueueCount, queueStatus.instanceQueueCount);
|
|
}
|
|
else {
|
|
printf("%02d %5d %5d %5d %08x %08x %8x %2d %2d %04x %d %8d %8d %8d %8d %d %d\n",
|
|
handle->instIndex, encodedInfo->encPicCnt, encodedInfo->picType, encodedInfo->reconFrameIndex, encodedInfo->rdPtr, encodedInfo->wrPtr,
|
|
encodedInfo->bitstreamSize, (srcEndFlag == 1 ? -1 : srcFrameIdx), encodedInfo->encSrcIdx,
|
|
encodedInfo->releaseSrcFlag,
|
|
0,
|
|
encodedInfo->frameCycle, encodedInfo->prepareCycle, encodedInfo->processing, encodedInfo->EncodedCycle,
|
|
queueStatus.reportQueueCount, queueStatus.instanceQueueCount);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void Coda9DisplayEncodedInformation(
|
|
DecHandle handle,
|
|
CodStd codec,
|
|
Uint32 frameNo,
|
|
EncOutputInfo* encodedInfo
|
|
)
|
|
{
|
|
if (encodedInfo == NULL) {
|
|
// Print header
|
|
VLOG(INFO, "I NO T RECON RD_PTR WR_PTR \n");
|
|
VLOG(INFO, "-------------------------------------\n");
|
|
}
|
|
else {
|
|
char** picTypeArray = (char**)(codec==STD_AVC ? EncPicTypeStringH264 : EncPicTypeStringMPEG4);
|
|
const char* strPicType;
|
|
|
|
if (encodedInfo->picType > 2) strPicType = "?";
|
|
else strPicType = picTypeArray[encodedInfo->picType];
|
|
// Print informations
|
|
VLOG(INFO, "%02d %5d %5s %5d %08x %08x\n",
|
|
handle->instIndex, frameNo, strPicType,
|
|
encodedInfo->reconFrameIndex, encodedInfo->rdPtr, encodedInfo->wrPtr);
|
|
}
|
|
}
|
|
|
|
/*lint -esym(438, ap) */
|
|
void
|
|
DisplayEncodedInformation(
|
|
EncHandle handle,
|
|
CodStd codec,
|
|
Uint32 frameNo __attribute__((unused)),
|
|
EncOutputInfo* encodedInfo,
|
|
...
|
|
)
|
|
{
|
|
int srcEndFlag;
|
|
int srcFrameIdx;
|
|
int performance = FALSE;
|
|
va_list ap;
|
|
|
|
switch (codec) {
|
|
case STD_HEVC:
|
|
va_start(ap, encodedInfo);
|
|
srcEndFlag = va_arg(ap, Uint32);
|
|
srcFrameIdx = va_arg(ap, Uint32);
|
|
performance = va_arg(ap, Uint32);
|
|
va_end(ap);
|
|
Wave5DisplayEncodedInformation(handle, codec, frameNo, encodedInfo, srcEndFlag , srcFrameIdx, performance);
|
|
break;
|
|
case STD_AVC:
|
|
if(handle->productId == PRODUCT_ID_521) {
|
|
va_start(ap, encodedInfo);
|
|
srcEndFlag = va_arg(ap, Uint32);
|
|
srcFrameIdx = va_arg(ap, Uint32);
|
|
performance = va_arg(ap, Uint32);
|
|
va_end(ap);
|
|
Wave5DisplayEncodedInformation(handle, codec, frameNo, encodedInfo, srcEndFlag , srcFrameIdx, performance);
|
|
}
|
|
else
|
|
Coda9DisplayEncodedInformation(handle, codec, frameNo, encodedInfo);
|
|
break;
|
|
default:
|
|
Coda9DisplayEncodedInformation(handle, codec, frameNo, encodedInfo);
|
|
break;
|
|
}
|
|
|
|
return;
|
|
}
|
|
/*lint +esym(438, ap) */
|
|
|
|
|
|
void replace_character(char* str,
|
|
char c,
|
|
char r)
|
|
{
|
|
int i=0;
|
|
int len;
|
|
len = (Int32)strlen(str);
|
|
|
|
for(i=0; i<len; i++)
|
|
{
|
|
if (str[i] == c)
|
|
str[i] = r;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void ChangePathStyle(
|
|
char *str __attribute__((unused))
|
|
)
|
|
{
|
|
}
|
|
|
|
void ReleaseVideoMemory(
|
|
DecHandle handle,
|
|
vpu_buffer_t* memoryArr,
|
|
Uint32 count
|
|
)
|
|
{
|
|
Int32 coreIndex = handle->coreIdx;
|
|
Uint32 idx;
|
|
|
|
for (idx=0; idx<count; idx++) {
|
|
if (memoryArr[idx].size)
|
|
vdi_free_dma_memory(coreIndex, &memoryArr[idx], DEC_FBC, handle->instIndex);
|
|
}
|
|
}
|
|
|
|
|
|
BOOL AllocateDecFrameBuffer(
|
|
DecHandle decHandle,
|
|
TestDecConfig* config,
|
|
Uint32 nonLinearFbCnt,
|
|
Uint32 linearFbCount,
|
|
FrameBuffer* retFbArray,
|
|
vpu_buffer_t* retFbAddrs,
|
|
Uint32* retStride
|
|
)
|
|
{
|
|
Uint32 framebufSize;
|
|
Uint32 totalFbCount, linearFbStartIdx = 0;
|
|
Uint32 coreIndex;
|
|
Uint32 idx;
|
|
FrameBufferFormat format = config->wtlFormat;
|
|
DecInitialInfo seqInfo;
|
|
FrameBufferAllocInfo fbAllocInfo;
|
|
RetCode ret;
|
|
vpu_buffer_t* pvb;
|
|
size_t framebufStride;
|
|
size_t framebufHeight;
|
|
Uint32 productId;
|
|
DRAMConfig* pDramCfg = NULL;
|
|
DRAMConfig dramCfg;
|
|
const DecInfo* pDecInfo = VPU_HANDLE_TO_DECINFO(decHandle);
|
|
|
|
memset(&dramCfg, 0, sizeof(DRAMConfig));
|
|
|
|
coreIndex = VPU_HANDLE_CORE_INDEX(decHandle);
|
|
productId = VPU_HANDLE_PRODUCT_ID(decHandle);
|
|
VPU_DecGiveCommand(decHandle, DEC_GET_SEQ_INFO, (void*)&seqInfo);
|
|
|
|
if (pDecInfo->productCode == WAVE521C_DUAL_CODE) {
|
|
if ( seqInfo.lumaBitdepth == 8 && seqInfo.chromaBitdepth == 8) {
|
|
config->mapType = COMPRESSED_FRAME_MAP_DUAL_CORE_8BIT;
|
|
}
|
|
else {
|
|
config->mapType = COMPRESSED_FRAME_MAP_DUAL_CORE_10BIT;
|
|
}
|
|
}
|
|
|
|
totalFbCount = nonLinearFbCnt + linearFbCount;
|
|
if (PRODUCT_ID_W_SERIES(productId)) {
|
|
linearFbStartIdx = nonLinearFbCnt;
|
|
}
|
|
else { //CODA series
|
|
if (0 == nonLinearFbCnt) {
|
|
nonLinearFbCnt = linearFbCount;
|
|
linearFbCount = 0;
|
|
}
|
|
else {
|
|
linearFbStartIdx = nonLinearFbCnt;
|
|
}
|
|
}
|
|
|
|
if (PRODUCT_ID_W_SERIES(productId)) {
|
|
format = (seqInfo.lumaBitdepth > 8 || seqInfo.chromaBitdepth > 8) ? FORMAT_420_P10_16BIT_LSB : FORMAT_420;
|
|
}
|
|
else { //CODA series
|
|
pDramCfg = &dramCfg;
|
|
ret = VPU_DecGiveCommand(decHandle, GET_DRAM_CONFIG, pDramCfg);
|
|
if (RETCODE_SUCCESS != ret) {
|
|
VLOG(ERR, "%s:%d VPU_DecGiveCommand[GET_DRAM_CONFIG] failed Error code is 0x%x \n", __FUNCTION__, __LINE__, ret );
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (config->bitFormat == STD_VP9) {
|
|
framebufStride = CalcStride(VPU_ALIGN64((Uint32)seqInfo.picWidth), seqInfo.picHeight, format, config->cbcrInterleave, config->mapType, TRUE);
|
|
framebufHeight = VPU_ALIGN64((Uint32)seqInfo.picHeight);
|
|
framebufSize = VPU_GetFrameBufSize(decHandle, decHandle->coreIdx, (Int32)framebufStride, (Int32)framebufHeight,
|
|
config->mapType, format, config->cbcrInterleave, NULL);
|
|
*retStride = (Uint32)framebufStride;
|
|
}
|
|
else if (config->bitFormat == STD_AVS2) {
|
|
framebufStride = CalcStride(seqInfo.picWidth, seqInfo.picHeight, format, config->cbcrInterleave, config->mapType, FALSE);
|
|
framebufHeight = VPU_ALIGN8(seqInfo.picHeight);
|
|
framebufSize = VPU_GetFrameBufSize(decHandle, decHandle->coreIdx, (Int32)framebufStride, (Int32)framebufHeight,
|
|
config->mapType, format, config->cbcrInterleave, pDramCfg);
|
|
*retStride = (Uint32)framebufStride;
|
|
}
|
|
else if (config->bitFormat == STD_AV1){
|
|
framebufStride = CalcStride(VPU_ALIGN64((Uint32)seqInfo.picWidth), seqInfo.picHeight, format, config->cbcrInterleave, config->mapType, TRUE);
|
|
framebufHeight = VPU_ALIGN64((Uint32)seqInfo.picHeight);
|
|
framebufSize = VPU_GetFrameBufSize(decHandle, decHandle->coreIdx, (Int32)framebufStride, (Int32)framebufHeight,
|
|
config->mapType, format, config->cbcrInterleave, NULL);
|
|
*retStride = (Uint32)framebufStride;
|
|
}
|
|
else {
|
|
*retStride = VPU_ALIGN32(seqInfo.picWidth);
|
|
framebufStride = CalcStride(seqInfo.picWidth, seqInfo.picHeight, format, config->cbcrInterleave, config->mapType, FALSE);
|
|
framebufHeight = VPU_ALIGN32(seqInfo.picHeight);
|
|
framebufSize = VPU_GetFrameBufSize(decHandle, decHandle->coreIdx, (Int32)framebufStride, (Int32)framebufHeight,
|
|
config->mapType, format, config->cbcrInterleave, pDramCfg);
|
|
}
|
|
|
|
osal_memset((void*)&fbAllocInfo, 0x00, sizeof(fbAllocInfo));
|
|
osal_memset((void*)retFbArray, 0x00, (Int32)sizeof(FrameBuffer)*totalFbCount);
|
|
fbAllocInfo.format = format;
|
|
fbAllocInfo.cbcrInterleave = config->cbcrInterleave;
|
|
fbAllocInfo.mapType = config->mapType;
|
|
fbAllocInfo.stride = (Int32)framebufStride;
|
|
fbAllocInfo.height = (Int32)framebufHeight;
|
|
fbAllocInfo.size = framebufSize;
|
|
fbAllocInfo.lumaBitDepth = seqInfo.lumaBitdepth;
|
|
fbAllocInfo.chromaBitDepth = seqInfo.chromaBitdepth;
|
|
fbAllocInfo.num = nonLinearFbCnt;
|
|
fbAllocInfo.endian = PRODUCT_ID_NOT_W_SERIES(productId) ? config->frameEndian : VDI_128BIT_LITTLE_ENDIAN ; // FBC endian is not fixed.
|
|
fbAllocInfo.type = FB_TYPE_CODEC;
|
|
osal_memset((void*)retFbAddrs, 0x00, (Int32)sizeof(vpu_buffer_t)*totalFbCount);
|
|
// APIDPRINT("ALLOC MEM - FBC data\n");
|
|
|
|
for (idx=0; idx<nonLinearFbCnt; idx++) {
|
|
pvb = &retFbAddrs[idx];
|
|
pvb->size = framebufSize;
|
|
if (vdi_allocate_dma_memory(coreIndex, pvb, DEC_FBC, decHandle->instIndex) < 0) {
|
|
VLOG(ERR, "%s:%d fail to allocate frame buffer\n", __FUNCTION__, __LINE__);
|
|
ReleaseVideoMemory(decHandle, retFbAddrs, totalFbCount);
|
|
return FALSE;
|
|
}
|
|
retFbArray[idx].bufY = pvb->phys_addr;
|
|
retFbArray[idx].bufCb = (PhysicalAddress)-1;
|
|
retFbArray[idx].bufCr = (PhysicalAddress)-1;
|
|
retFbArray[idx].updateFbInfo = TRUE;
|
|
retFbArray[idx].size = framebufSize;
|
|
retFbArray[idx].width = seqInfo.picWidth;
|
|
}
|
|
|
|
if (nonLinearFbCnt != 0) {
|
|
if ((ret=VPU_DecAllocateFrameBuffer(decHandle, fbAllocInfo, retFbArray)) != RETCODE_SUCCESS) {
|
|
VLOG(ERR, "%s:%d failed to VPU_DecAllocateFrameBuffer(), ret(%d)\n",
|
|
__FUNCTION__, __LINE__, ret);
|
|
ReleaseVideoMemory(decHandle, retFbAddrs, totalFbCount);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (config->enableWTL == TRUE || linearFbCount != 0) {
|
|
size_t linearStride;
|
|
size_t picWidth;
|
|
size_t picHeight;
|
|
size_t fbHeight;
|
|
TiledMapType mapType = LINEAR_FRAME_MAP;
|
|
FrameBufferFormat outFormat = config->wtlFormat;
|
|
picWidth = seqInfo.picWidth;
|
|
picHeight = seqInfo.picHeight;
|
|
fbHeight = picHeight;
|
|
|
|
if (PRODUCT_ID_960 == productId || PRODUCT_ID_980 == productId) {
|
|
//wtl frame buffer
|
|
mapType = (FF_FRAME == config->wtlMode) ? LINEAR_FRAME_MAP : LINEAR_FIELD_MAP;
|
|
}
|
|
|
|
if (config->bitFormat == STD_VP9) {
|
|
fbHeight = VPU_ALIGN64(picHeight);
|
|
}
|
|
else if (config->bitFormat == STD_AVS2) {
|
|
fbHeight = VPU_ALIGN8(picHeight);
|
|
}
|
|
else if (productId == PRODUCT_ID_960 || productId == PRODUCT_ID_980)
|
|
{
|
|
fbHeight = VPU_ALIGN32(picHeight);
|
|
}
|
|
else if (config->bitFormat == STD_AV1)
|
|
{
|
|
fbHeight = VPU_ALIGN8(picHeight);
|
|
}
|
|
if (config->scaleDownWidth > 0 || config->scaleDownHeight > 0) {
|
|
ScalerInfo sclInfo;
|
|
VPU_DecGiveCommand(decHandle, DEC_GET_SCALER_INFO, (void*)&sclInfo);
|
|
if (sclInfo.enScaler == TRUE) {
|
|
picWidth = sclInfo.scaleWidth;
|
|
picHeight = sclInfo.scaleHeight;
|
|
if (config->bitFormat == STD_VP9) {
|
|
fbHeight = VPU_ALIGN64((Uint32)picHeight);
|
|
}
|
|
else {
|
|
fbHeight = VPU_CEIL(picHeight, 2);
|
|
}
|
|
}
|
|
}
|
|
if (config->bitFormat == STD_VP9) {
|
|
linearStride = CalcStride(VPU_ALIGN64((Uint32)picWidth), (Uint32)picHeight, outFormat, config->cbcrInterleave, (TiledMapType)mapType, TRUE);
|
|
}
|
|
else if (config->bitFormat == STD_AV1) {
|
|
linearStride = CalcStride(VPU_ALIGN16((Uint32)picWidth), (Uint32)picHeight, outFormat, config->cbcrInterleave, (TiledMapType)mapType, TRUE);
|
|
}
|
|
else {
|
|
linearStride = CalcStride((Uint32)picWidth, (Uint32)picHeight, outFormat, config->cbcrInterleave, (TiledMapType)mapType, FALSE);
|
|
}
|
|
framebufSize = VPU_GetFrameBufSize(decHandle, coreIndex, (Uint32)linearStride, (Uint32)fbHeight, (TiledMapType)mapType, outFormat, config->cbcrInterleave, pDramCfg);
|
|
|
|
for (idx=linearFbStartIdx; idx<totalFbCount; idx++) {
|
|
pvb = &retFbAddrs[idx];
|
|
pvb->size = framebufSize;
|
|
if (vdi_allocate_dma_memory(coreIndex, pvb, DEC_FB_LINEAR, decHandle->instIndex) < 0) {
|
|
VLOG(ERR, "%s:%d fail to allocate frame buffer\n", __FUNCTION__, __LINE__);
|
|
ReleaseVideoMemory(decHandle, retFbAddrs, totalFbCount);
|
|
return FALSE;
|
|
}
|
|
retFbArray[idx].bufY = pvb->phys_addr;
|
|
retFbArray[idx].bufCb = (PhysicalAddress)-1;
|
|
retFbArray[idx].bufCr = (PhysicalAddress)-1;
|
|
retFbArray[idx].updateFbInfo = TRUE;
|
|
retFbArray[idx].size = framebufSize;
|
|
retFbArray[idx].width = (Int32)picWidth;
|
|
|
|
}
|
|
|
|
fbAllocInfo.nv21 = config->nv21;
|
|
fbAllocInfo.format = outFormat;
|
|
fbAllocInfo.num = linearFbCount;
|
|
fbAllocInfo.mapType = (TiledMapType)mapType;
|
|
fbAllocInfo.stride = (Int32)linearStride;
|
|
fbAllocInfo.height = (Int32)fbHeight;
|
|
|
|
ret = VPU_DecAllocateFrameBuffer(decHandle, fbAllocInfo, &retFbArray[linearFbStartIdx]);
|
|
if (ret != RETCODE_SUCCESS) {
|
|
VLOG(ERR, "%s:%d failed to VPU_DecAllocateFrameBuffer() ret:%d\n",
|
|
__FUNCTION__, __LINE__, ret);
|
|
ReleaseVideoMemory(decHandle, retFbAddrs, totalFbCount);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AllocFBMemory(Uint32 coreIdx, vpu_buffer_t *pFbMem, FrameBuffer* pFb,Uint32 memSize, Uint32 memNum, Int32 memTypes, Int32 instIndex)
|
|
{
|
|
Uint32 i =0;
|
|
for (i = 0; i < memNum; i++) {
|
|
pFbMem[i].size = memSize;
|
|
if (vdi_allocate_dma_memory(coreIdx, &pFbMem[i], memTypes, instIndex) < 0) {
|
|
VLOG(ERR, "fail to allocate src buffer\n");
|
|
return FALSE;
|
|
}
|
|
pFb[i].bufY = pFbMem[i].phys_addr;
|
|
pFb[i].bufCb = (PhysicalAddress) - 1;
|
|
pFb[i].bufCr = (PhysicalAddress) - 1;
|
|
pFb[i].size = memSize;
|
|
pFb[i].updateFbInfo = TRUE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL Coda9AllocateDecPPUFrameBuffer(
|
|
BOOL* pEnablePPU,
|
|
DecHandle decHandle,
|
|
TestDecConfig* config,
|
|
FrameBuffer* retFbArray,
|
|
vpu_buffer_t* retFbAddrs,
|
|
Queue* ppuQ
|
|
)
|
|
{
|
|
Uint32 stridePpu = 0;
|
|
Uint32 sizePPUFb = 0;
|
|
Uint32 rotate = config->coda9.rotate;
|
|
Uint32 rotateWidth = 0;
|
|
Uint32 rotateHeight = 0;
|
|
Uint32 coreIndex = 0;
|
|
const Uint32 ppuFbCount = 2; // #define PPU_FB_COUNT 2
|
|
Uint32 idx = 0;
|
|
DecInitialInfo seqInfo;
|
|
BOOL enablePPU = FALSE;
|
|
vpu_buffer_t* pvb = NULL;
|
|
FrameBufferAllocInfo fbAllocInfo;
|
|
DRAMConfig* pDramCfg = NULL;
|
|
DRAMConfig dramCfg;
|
|
|
|
memset(&dramCfg, 0, sizeof(DRAMConfig));
|
|
|
|
osal_memset((void*)&fbAllocInfo, 0x00, sizeof(fbAllocInfo));
|
|
osal_memset((void*)retFbArray, 0x00, sizeof(FrameBuffer)*ppuFbCount);
|
|
|
|
enablePPU = (BOOL)(config->coda9.rotate > 0 || config->coda9.mirror > 0 ||
|
|
config->coda9.enableTiled2Linear == TRUE || config->coda9.enableDering == TRUE);
|
|
|
|
if(pEnablePPU) {
|
|
*pEnablePPU = enablePPU;
|
|
}
|
|
|
|
if(!enablePPU) {
|
|
VLOG(INFO, "<%s> No need PPU Buffers.\n", __FUNCTION__);
|
|
return TRUE;
|
|
}
|
|
else {
|
|
VLOG(INFO, "<%s> PPU Buffer : %d\n", __FUNCTION__, ppuFbCount);
|
|
}
|
|
|
|
pDramCfg = &dramCfg;
|
|
VPU_DecGiveCommand(decHandle, GET_DRAM_CONFIG, pDramCfg);
|
|
|
|
coreIndex = VPU_HANDLE_CORE_INDEX(decHandle);
|
|
VPU_DecGiveCommand(decHandle, DEC_GET_SEQ_INFO, (void*)&seqInfo);
|
|
|
|
rotateWidth = seqInfo.picWidth;
|
|
rotateHeight = seqInfo.picHeight;
|
|
|
|
if (rotate == 90 || rotate == 270) {
|
|
rotateWidth = seqInfo.picHeight;
|
|
rotateHeight = seqInfo.picWidth;
|
|
}
|
|
|
|
rotateWidth = VPU_ALIGN32(rotateWidth);
|
|
rotateHeight = VPU_ALIGN32(rotateHeight);
|
|
|
|
stridePpu = CalcStride(rotateWidth, rotateHeight, FORMAT_420, config->cbcrInterleave, LINEAR_FRAME_MAP, FALSE);
|
|
sizePPUFb = VPU_GetFrameBufSize(decHandle, coreIndex, stridePpu, rotateHeight, LINEAR_FRAME_MAP, FORMAT_420, config->cbcrInterleave, pDramCfg);
|
|
|
|
for (idx=0; idx<ppuFbCount; idx++) {
|
|
pvb = &(retFbAddrs[idx]);
|
|
pvb->size = sizePPUFb;
|
|
if (vdi_allocate_dma_memory(coreIndex, pvb, DEC_ETC, decHandle->instIndex) < 0) {
|
|
VLOG(ERR, "%s:%d fail to allocate frame buffer\n", __FUNCTION__, __LINE__);
|
|
return FALSE;
|
|
}
|
|
retFbArray[idx].bufY = pvb->phys_addr;
|
|
retFbArray[idx].bufCb = (PhysicalAddress)-1;
|
|
retFbArray[idx].bufCr = (PhysicalAddress)-1;
|
|
retFbArray[idx].updateFbInfo = TRUE;
|
|
retFbArray[idx].size = sizePPUFb;
|
|
}
|
|
|
|
fbAllocInfo.mapType = LINEAR_FRAME_MAP;
|
|
fbAllocInfo.cbcrInterleave = config->cbcrInterleave;
|
|
fbAllocInfo.format = FORMAT_420;
|
|
fbAllocInfo.stride = stridePpu;
|
|
fbAllocInfo.height = rotateHeight;
|
|
fbAllocInfo.endian = config->frameEndian;
|
|
fbAllocInfo.lumaBitDepth = 8;
|
|
fbAllocInfo.chromaBitDepth = 8;
|
|
fbAllocInfo.num = ppuFbCount;
|
|
fbAllocInfo.type = FB_TYPE_PPU;
|
|
fbAllocInfo.size = sizePPUFb;
|
|
if (RETCODE_SUCCESS != VPU_DecAllocateFrameBuffer(decHandle, fbAllocInfo, retFbArray)) {
|
|
VLOG(ERR, "%s:%d failed to VPU_DecAllocateFrameBuffer() ret:%d\n", __FUNCTION__, __LINE__);
|
|
return FALSE;
|
|
}
|
|
// Note: Please keep the below call sequence.
|
|
VPU_DecGiveCommand(decHandle, SET_ROTATION_ANGLE, (void*)&(config->coda9.rotate));
|
|
VPU_DecGiveCommand(decHandle, SET_MIRROR_DIRECTION, (void*)&(config->coda9.mirror));
|
|
VPU_DecGiveCommand(decHandle, SET_ROTATOR_STRIDE, (void*)&stridePpu);
|
|
|
|
for (idx=0; idx<ppuFbCount; idx++) {
|
|
Queue_Enqueue(ppuQ, (void*)&retFbArray[idx]);
|
|
}
|
|
|
|
PrepareDecoderTest(decHandle);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
RetCode SetUpDecoderOpenParam(
|
|
DecOpenParam* param,
|
|
TestDecConfig* config
|
|
)
|
|
{
|
|
RetCode ret = RETCODE_SUCCESS;
|
|
|
|
if (NULL == param || NULL == config) {
|
|
ret = RETCODE_INVALID_PARAM;
|
|
} else {
|
|
param->bitstreamFormat = config->bitFormat;
|
|
param->coreIdx = config->coreIdx;
|
|
param->bitstreamMode = config->bitstreamMode;
|
|
param->wtlEnable = config->enableWTL;
|
|
param->wtlMode = config->wtlMode;
|
|
param->cbcrInterleave = config->cbcrInterleave;
|
|
param->nv21 = config->nv21;
|
|
param->streamEndian = config->streamEndian;
|
|
param->frameEndian = config->frameEndian;
|
|
|
|
if (PRODUCT_ID_W_SERIES(config->productId)) {
|
|
//WAVE
|
|
param->errorConcealMode = config->errConcealMode;
|
|
param->errorConcealUnit = config->errConcealUnit;
|
|
param->av1Format = config->wave.av1Format;
|
|
} else {
|
|
//CODA
|
|
param->avcExtension = config->coda9.enableMvc;
|
|
param->bwbEnable = config->coda9.enableBWB;
|
|
param->mp4Class = config->coda9.mp4class;
|
|
param->tiled2LinearEnable = config->coda9.enableTiled2Linear;
|
|
param->tiled2LinearMode = config->coda9.tiled2LinearMode;
|
|
param->mp4DeblkEnable = config->coda9.enableDeblock;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
#if defined(_WIN32) || defined(__MSDOS__)
|
|
#define DOS_FILESYSTEM
|
|
#define IS_DIR_SEPARATOR(__c) ((__c == '/') || (__c == '\\'))
|
|
#else
|
|
/* UNIX style */
|
|
#define IS_DIR_SEPARATOR(__c) (__c == '/')
|
|
#endif
|
|
|
|
char* GetDirname(
|
|
const char* path
|
|
)
|
|
{
|
|
int length;
|
|
int i;
|
|
char* upper_dir;
|
|
|
|
if (path == NULL) return NULL;
|
|
|
|
length = (Int32)strlen(path);
|
|
for (i=length-1; i>=0; i--) {
|
|
if (IS_DIR_SEPARATOR(path[i])) break;
|
|
}
|
|
|
|
if (i<0) {
|
|
upper_dir = strdup(".");
|
|
} else {
|
|
upper_dir = strdup(path);
|
|
upper_dir[i] = 0;
|
|
}
|
|
|
|
return upper_dir;
|
|
}
|
|
|
|
char* GetBasename(
|
|
const char* pathname
|
|
)
|
|
{
|
|
const char* base = NULL;
|
|
const char* p = pathname;
|
|
|
|
if (p == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
#if defined(DOS_FILESYSTEM)
|
|
if (isalpha((int)p[0]) && p[1] == ':') {
|
|
p += 2;
|
|
}
|
|
#endif
|
|
|
|
for (base=p; *p; p++) {//lint !e443
|
|
if (IS_DIR_SEPARATOR(*p)) {
|
|
base = p+1;
|
|
}
|
|
}
|
|
|
|
return (char*)base;
|
|
}
|
|
|
|
char* GetFileExtension(
|
|
const char* filename
|
|
)
|
|
{
|
|
Int32 len;
|
|
Int32 i;
|
|
|
|
len = (Int32)strlen(filename);
|
|
for (i=len-1; i>=0; i--) {
|
|
if (filename[i] == '.') {
|
|
return (char*)&filename[i+1];
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void byte_swap(unsigned char* data, int len)
|
|
{
|
|
Uint8 temp;
|
|
Int32 i;
|
|
|
|
for (i=0; i<len; i+=2) {
|
|
temp = data[i];
|
|
data[i] = data[i+1];
|
|
data[i+1] = temp;
|
|
}
|
|
}
|
|
|
|
void word_swap(unsigned char* data, int len)
|
|
{
|
|
Uint16 temp;
|
|
Uint16* ptr = (Uint16*)data;
|
|
Int32 i, size = len/(int)sizeof(Uint16);
|
|
|
|
for (i=0; i<size; i+=2) {
|
|
temp = ptr[i];
|
|
ptr[i] = ptr[i+1];
|
|
ptr[i+1] = temp;
|
|
}
|
|
}
|
|
|
|
void dword_swap(unsigned char* data, int len)
|
|
{
|
|
Uint32 temp;
|
|
Uint32* ptr = (Uint32*)data;
|
|
Int32 i, size = len/(int)sizeof(Uint32);
|
|
|
|
for (i=0; i<size; i+=2) {
|
|
temp = ptr[i];
|
|
ptr[i] = ptr[i+1];
|
|
ptr[i+1] = temp;
|
|
}
|
|
}
|
|
|
|
void lword_swap(unsigned char* data, int len)
|
|
{
|
|
Uint64 temp;
|
|
Uint64* ptr = (Uint64*)data;
|
|
Int32 i, size = len/(int)sizeof(Uint64);
|
|
|
|
for (i=0; i<size; i+=2) {
|
|
temp = ptr[i];
|
|
ptr[i] = ptr[i+1];
|
|
ptr[i+1] = temp;
|
|
}
|
|
}
|
|
|
|
BOOL IsEndOfFile(FILE* fp)
|
|
{
|
|
BOOL result = FALSE;
|
|
Int32 idx = 0;
|
|
char cTemp;
|
|
|
|
// Check current fp pos
|
|
if (osal_feof(fp) != 0) {
|
|
result = TRUE;
|
|
}
|
|
|
|
// Check next fp pos
|
|
// Ignore newline character
|
|
do {
|
|
cTemp = (char)fgetc(fp);
|
|
idx++;
|
|
|
|
if (osal_feof(fp) != 0) {
|
|
result = TRUE;
|
|
break;
|
|
}
|
|
} while (cTemp == '\n' || cTemp == '\r');
|
|
|
|
// Revert fp pos
|
|
idx *= (-1);
|
|
osal_fseek(fp, idx, SEEK_CUR);
|
|
|
|
return result;
|
|
}
|
|
|
|
BOOL CalcYuvSize(
|
|
Int32 format,
|
|
Int32 picWidth,
|
|
Int32 picHeight,
|
|
Int32 cbcrInterleave,
|
|
size_t *lumaSize,
|
|
size_t *chromaSize,
|
|
size_t *frameSize,
|
|
Int32 *bitDepth,
|
|
Int32 *packedFormat,
|
|
Int32 *yuv3p4b)
|
|
{
|
|
Int32 temp_picWidth;
|
|
Int32 chromaWidth = 0, chromaHeight = 0;
|
|
|
|
if ( bitDepth != 0)
|
|
*bitDepth = 0;
|
|
if ( packedFormat != 0)
|
|
*packedFormat = 0;
|
|
if ( yuv3p4b != 0)
|
|
*yuv3p4b = 0;
|
|
|
|
if (!lumaSize || !chromaSize || !frameSize )
|
|
return FALSE;
|
|
|
|
switch (format)
|
|
{
|
|
case FORMAT_420:
|
|
chromaWidth = (picWidth+1)/2;
|
|
chromaHeight = (picHeight+1)/2;
|
|
*lumaSize = picWidth * picHeight;
|
|
*chromaSize = chromaWidth * chromaHeight / 2;
|
|
*frameSize = picWidth * picHeight * 3 /2;
|
|
break;
|
|
case FORMAT_YUYV:
|
|
case FORMAT_YVYU:
|
|
case FORMAT_UYVY:
|
|
case FORMAT_VYUY:
|
|
if ( packedFormat != 0)
|
|
*packedFormat = 1;
|
|
*lumaSize = picWidth * picHeight;
|
|
*chromaSize = picWidth * picHeight;
|
|
*frameSize = *lumaSize + *chromaSize;
|
|
break;
|
|
case FORMAT_224:
|
|
*lumaSize = picWidth * picHeight;
|
|
*chromaSize = picWidth * picHeight;
|
|
*frameSize = picWidth * picHeight * 4 / 2;
|
|
break;
|
|
case FORMAT_422:
|
|
*lumaSize = picWidth * picHeight;
|
|
*chromaSize = picWidth * picHeight;
|
|
*frameSize = picWidth * picHeight * 4 / 2;
|
|
break;
|
|
case FORMAT_444:
|
|
*lumaSize = picWidth * picHeight;
|
|
*chromaSize = picWidth * picHeight * 2;
|
|
*frameSize = picWidth * picHeight * 3;
|
|
break;
|
|
case FORMAT_400:
|
|
*lumaSize = picWidth * picHeight;
|
|
*chromaSize = 0;
|
|
*frameSize = picWidth * picHeight;
|
|
break;
|
|
case FORMAT_422_P10_16BIT_MSB:
|
|
case FORMAT_422_P10_16BIT_LSB:
|
|
if ( bitDepth != NULL) {
|
|
*bitDepth = 10;
|
|
}
|
|
*lumaSize = picWidth * picHeight * 2;
|
|
*chromaSize = *lumaSize;
|
|
*frameSize = *lumaSize + *chromaSize;
|
|
break;
|
|
case FORMAT_420_P10_16BIT_MSB:
|
|
case FORMAT_420_P10_16BIT_LSB:
|
|
if ( bitDepth != 0)
|
|
*bitDepth = 10;
|
|
*lumaSize = picWidth * picHeight * 2;
|
|
chromaWidth = picWidth;
|
|
chromaHeight = picHeight;
|
|
if (picWidth & 0x01) {
|
|
chromaWidth = chromaWidth+1;
|
|
}
|
|
if (picHeight & 0x01) {
|
|
chromaHeight = chromaHeight+1;
|
|
}
|
|
*chromaSize = chromaWidth * chromaHeight;
|
|
*frameSize = *lumaSize + *chromaSize;
|
|
break;
|
|
case FORMAT_YUYV_P10_16BIT_MSB: // 4:2:2 10bit packed
|
|
case FORMAT_YUYV_P10_16BIT_LSB:
|
|
case FORMAT_YVYU_P10_16BIT_MSB:
|
|
case FORMAT_YVYU_P10_16BIT_LSB:
|
|
case FORMAT_UYVY_P10_16BIT_MSB:
|
|
case FORMAT_UYVY_P10_16BIT_LSB:
|
|
case FORMAT_VYUY_P10_16BIT_MSB:
|
|
case FORMAT_VYUY_P10_16BIT_LSB:
|
|
if ( bitDepth != 0)
|
|
*bitDepth = 10;
|
|
if ( packedFormat != 0)
|
|
*packedFormat = 1;
|
|
*lumaSize = picWidth * picHeight * 2;
|
|
*chromaSize = picWidth * picHeight * 2;
|
|
*frameSize = *lumaSize + *chromaSize;
|
|
break;
|
|
case FORMAT_420_P10_32BIT_MSB:
|
|
case FORMAT_420_P10_32BIT_LSB:
|
|
if ( bitDepth != 0)
|
|
*bitDepth = 10;
|
|
if ( yuv3p4b != 0)
|
|
*yuv3p4b = 1;
|
|
temp_picWidth = VPU_ALIGN32(picWidth);
|
|
chromaWidth = ((VPU_ALIGN16(temp_picWidth/2*(1<<cbcrInterleave))+2)/3*4);
|
|
if ( cbcrInterleave == 1)
|
|
{
|
|
*lumaSize = (temp_picWidth+2)/3*4 * picHeight;
|
|
*chromaSize = chromaWidth * picHeight/2;
|
|
} else {
|
|
*lumaSize = (temp_picWidth+2)/3*4 * picHeight;
|
|
*chromaSize = chromaWidth * picHeight/2*2;
|
|
}
|
|
*frameSize = *lumaSize + *chromaSize;
|
|
break;
|
|
case FORMAT_422_P10_32BIT_MSB:
|
|
case FORMAT_422_P10_32BIT_LSB:
|
|
if ( bitDepth != 0)
|
|
*bitDepth = 10;
|
|
if ( yuv3p4b != 0)
|
|
*yuv3p4b = 1;
|
|
temp_picWidth = VPU_ALIGN32(picWidth);
|
|
*lumaSize = (VPU_ALIGN16(temp_picWidth)+2)/3*4 * picHeight;
|
|
*chromaSize = *lumaSize;
|
|
*frameSize = *lumaSize + *chromaSize;
|
|
break;
|
|
case FORMAT_YUYV_P10_32BIT_MSB:
|
|
case FORMAT_YUYV_P10_32BIT_LSB:
|
|
case FORMAT_YVYU_P10_32BIT_MSB:
|
|
case FORMAT_YVYU_P10_32BIT_LSB:
|
|
case FORMAT_UYVY_P10_32BIT_MSB:
|
|
case FORMAT_UYVY_P10_32BIT_LSB:
|
|
case FORMAT_VYUY_P10_32BIT_MSB:
|
|
case FORMAT_VYUY_P10_32BIT_LSB:
|
|
if ( bitDepth != 0)
|
|
*bitDepth = 10;
|
|
if ( packedFormat != 0)
|
|
*packedFormat = 1;
|
|
if ( yuv3p4b != 0)
|
|
*yuv3p4b = 1;
|
|
*frameSize = ((picWidth*2)+2)/3*4 * picHeight;
|
|
*lumaSize = *frameSize/2;
|
|
*chromaSize = *frameSize/2;
|
|
break;
|
|
default:
|
|
*frameSize = picWidth * picHeight * 3 / 2;
|
|
VLOG(ERR, "%s:%d Not supported format(%d)\n", __FILE__, __LINE__, format);
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
FrameBufferFormat GetPackedFormat (
|
|
int srcBitDepth,
|
|
int packedType,
|
|
int p10bits,
|
|
int msb)
|
|
{
|
|
FrameBufferFormat format = FORMAT_YUYV;
|
|
|
|
// default pixel format = P10_16BIT_LSB (p10bits = 16, msb = 0)
|
|
if (srcBitDepth == 8) {
|
|
|
|
switch(packedType) {
|
|
case PACKED_YUYV:
|
|
format = FORMAT_YUYV;
|
|
break;
|
|
case PACKED_YVYU:
|
|
format = FORMAT_YVYU;
|
|
break;
|
|
case PACKED_UYVY:
|
|
format = FORMAT_UYVY;
|
|
break;
|
|
case PACKED_VYUY:
|
|
format = FORMAT_VYUY;
|
|
break;
|
|
default:
|
|
format = FORMAT_ERR;
|
|
}
|
|
}
|
|
else if (srcBitDepth == 10) {
|
|
switch(packedType) {
|
|
case PACKED_YUYV:
|
|
if (p10bits == 16) {
|
|
format = (msb == 0) ? FORMAT_YUYV_P10_16BIT_LSB : FORMAT_YUYV_P10_16BIT_MSB;
|
|
}
|
|
else if (p10bits == 32) {
|
|
format = (msb == 0) ? FORMAT_YUYV_P10_32BIT_LSB : FORMAT_YUYV_P10_32BIT_MSB;
|
|
}
|
|
else {
|
|
format = FORMAT_ERR;
|
|
}
|
|
break;
|
|
case PACKED_YVYU:
|
|
if (p10bits == 16) {
|
|
format = (msb == 0) ? FORMAT_YVYU_P10_16BIT_LSB : FORMAT_YVYU_P10_16BIT_MSB;
|
|
}
|
|
else if (p10bits == 32) {
|
|
format = (msb == 0) ? FORMAT_YVYU_P10_32BIT_LSB : FORMAT_YVYU_P10_32BIT_MSB;
|
|
}
|
|
else {
|
|
format = FORMAT_ERR;
|
|
}
|
|
break;
|
|
case PACKED_UYVY:
|
|
if (p10bits == 16) {
|
|
format = (msb == 0) ? FORMAT_UYVY_P10_16BIT_LSB : FORMAT_UYVY_P10_16BIT_MSB;
|
|
}
|
|
else if (p10bits == 32) {
|
|
format = (msb == 0) ? FORMAT_UYVY_P10_32BIT_LSB : FORMAT_UYVY_P10_32BIT_MSB;
|
|
}
|
|
else {
|
|
format = FORMAT_ERR;
|
|
}
|
|
break;
|
|
case PACKED_VYUY:
|
|
if (p10bits == 16) {
|
|
format = (msb == 0) ? FORMAT_VYUY_P10_16BIT_LSB : FORMAT_VYUY_P10_16BIT_MSB;
|
|
}
|
|
else if (p10bits == 32) {
|
|
format = (msb == 0) ? FORMAT_VYUY_P10_32BIT_LSB : FORMAT_VYUY_P10_32BIT_MSB;
|
|
}
|
|
else {
|
|
format = FORMAT_ERR;
|
|
}
|
|
break;
|
|
default:
|
|
format = FORMAT_ERR;
|
|
}
|
|
}
|
|
else {
|
|
format = FORMAT_ERR;
|
|
}
|
|
|
|
return format;
|
|
}
|
|
|
|
|
|
BOOL SetupEncoderOpenParam(
|
|
EncOpenParam* param,
|
|
TestEncConfig* config,
|
|
ENC_CFG* encCfg,
|
|
ENCParameter* get_param
|
|
)
|
|
{
|
|
param->bitstreamFormat = config->stdMode;
|
|
|
|
if (GetEncOpenParam(param, config, encCfg, get_param) == FALSE) {
|
|
VLOG(ERR, "[ERROR] Failed to parse CFG file(GetEncOpenParam)\n");
|
|
return FALSE;
|
|
}
|
|
|
|
if (0 == param->streamBufCount) {
|
|
param->streamBufCount = ENC_STREAM_BUF_COUNT;
|
|
}
|
|
if (0 == param->streamBufSize) {
|
|
param->streamBufSize = ENC_STREAM_BUF_SIZE;
|
|
}
|
|
|
|
if (param->srcBitDepth == 8) {
|
|
if ( config->i422 == TRUE ) {
|
|
config->srcFormat = FORMAT_422;
|
|
} else {
|
|
config->srcFormat = FORMAT_420;
|
|
}
|
|
}
|
|
else if (param->srcBitDepth == 10) {
|
|
if (config->srcFormat == FORMAT_420) {
|
|
config->srcFormat = FORMAT_420_P10_16BIT_MSB; //set srcFormat in ParseArgumentAndSetTestConfig function
|
|
return FALSE;
|
|
} else if (config->srcFormat == FORMAT_422) {
|
|
config->srcFormat = FORMAT_422_P10_16BIT_MSB; //set srcFormat in ParseArgumentAndSetTestConfig function
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (config->optYuvPath[0] != 0)
|
|
strcpy(config->yuvFileName, config->optYuvPath);
|
|
|
|
|
|
if (config->packedFormat >= PACKED_YUYV) {
|
|
int p10bits = 0;
|
|
FrameBufferFormat packedFormat;
|
|
if (config->srcFormat == FORMAT_420_P10_16BIT_MSB || config->srcFormat == FORMAT_420_P10_16BIT_LSB )
|
|
p10bits = 16;
|
|
if (config->srcFormat == FORMAT_420_P10_32BIT_MSB || config->srcFormat == FORMAT_420_P10_32BIT_LSB )
|
|
p10bits = 32;
|
|
|
|
packedFormat = GetPackedFormat(param->srcBitDepth, config->packedFormat, p10bits, 1);
|
|
if (packedFormat == -1) {
|
|
VLOG(ERR, "[ERROR] Failed to GetPackedFormat\n");
|
|
return FALSE;
|
|
}
|
|
param->srcFormat = packedFormat;
|
|
param->nv21 = 0;
|
|
param->cbcrInterleave = 0;
|
|
}
|
|
else {
|
|
param->srcFormat = config->srcFormat;
|
|
param->nv21 = config->nv21;
|
|
}
|
|
param->packedFormat = config->packedFormat;
|
|
param->cbcrInterleave = config->cbcrInterleave;
|
|
param->frameEndian = config->frame_endian;
|
|
param->streamEndian = config->stream_endian;
|
|
param->sourceEndian = config->source_endian;
|
|
param->lineBufIntEn = config->lineBufIntEn;
|
|
param->coreIdx = config->coreIdx;
|
|
param->cbcrOrder = CBCR_ORDER_NORMAL;
|
|
param->EncStdParam.waveParam.useLongTerm = (config->useAsLongtermPeriod > 0 && config->refLongtermPeriod > 0) ? 1 : 0;
|
|
if (PRODUCT_ID_W_SERIES(config->productId)) {
|
|
#ifdef SUPPORT_SOURCE_RELEASE_INTERRUPT
|
|
param->srcReleaseIntEnable = config->srcReleaseIntEnable;
|
|
#endif
|
|
param->ringBufferEnable = config->ringBufferEnable;
|
|
param->ringBufferWrapEnable = config->ringBufferWrapEnable;
|
|
if (config->ringBufferEnable == TRUE) {
|
|
param->streamBufCount = 1;
|
|
param->lineBufIntEn = FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
param->subFrameSyncEnable = config->subFrameSyncEn;
|
|
param->subFrameSyncMode = config->subFrameSyncMode;// default mode = register based for Ref.SW
|
|
if(PRODUCT_ID_NOT_W_SERIES(config->productId)) {
|
|
param->bwbEnable = TRUE;
|
|
param->linear2TiledEnable = config->coda9.enableLinear2Tiled;
|
|
param->linear2TiledMode = config->coda9.linear2TiledMode;
|
|
param->ringBufferEnable = config->ringBufferEnable;
|
|
if (TRUE == config->ringBufferEnable) {
|
|
param->streamBufCount = 1;
|
|
}
|
|
#ifdef SUPPORT_NEW_SCHEDULER
|
|
param->ringBufferWrapEnable = config->ringBufferWrapEnable;
|
|
#endif
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
void GenRegionToMap(
|
|
VpuRect *region, /**< The size of the ROI region for H.265 (start X/Y in CTU, end X/Y int CTU) */
|
|
int *roiQp,
|
|
int num,
|
|
Uint32 mapWidth,
|
|
Uint32 mapHeight,
|
|
Uint8 *roiCtuMap)
|
|
{
|
|
Int32 roi_id, blk_addr;
|
|
Uint32 roi_map_size = mapWidth * mapHeight;
|
|
|
|
//init roi map
|
|
for (blk_addr=0; blk_addr<(Int32)roi_map_size; blk_addr++)
|
|
roiCtuMap[blk_addr] = 0;
|
|
|
|
//set roi map. roi_entry[i] has higher priority than roi_entry[i+1]
|
|
for (roi_id=(Int32)num-1; roi_id>=0; roi_id--)
|
|
{
|
|
Uint32 x, y;
|
|
VpuRect *roi = region + roi_id;
|
|
|
|
for (y=roi->top; y<=roi->bottom; y++)
|
|
{
|
|
for (x=roi->left; x<=roi->right; x++)
|
|
{
|
|
roiCtuMap[y*mapWidth + x] = (Uint8)(*(roiQp + roi_id));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void GenRegionToQpMap(
|
|
VpuRect *region, /**< The size of the ROI region for H.265 (start X/Y in CTU, end X/Y int CTU) */
|
|
int *roiQp,
|
|
int num,
|
|
int initQp,
|
|
Uint32 mapWidth,
|
|
Uint32 mapHeight,
|
|
Uint8 *roiCtuMap)
|
|
{
|
|
Int32 roi_id, blk_addr;
|
|
Uint32 roi_map_size = mapWidth * mapHeight;
|
|
|
|
//init roi map
|
|
for (blk_addr=0; blk_addr<(Int32)roi_map_size; blk_addr++)
|
|
roiCtuMap[blk_addr] = (Uint8)initQp;
|
|
|
|
//set roi map. roi_entry[i] has higher priority than roi_entry[i+1]
|
|
for (roi_id=(Int32)num-1; roi_id>=0; roi_id--)
|
|
{
|
|
Uint32 x, y;
|
|
VpuRect *roi = region + roi_id;
|
|
|
|
for (y=roi->top; y<=roi->bottom; y++)
|
|
{
|
|
for (x=roi->left; x<=roi->right; x++)
|
|
{
|
|
roiCtuMap[y*mapWidth + x] = (Uint8)(*(roiQp + roi_id));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
Int32 writeVuiRbsp(int coreIdx, TestEncConfig *encConfig, EncOpenParam *encOP, vpu_buffer_t *vbVuiRbsp)
|
|
{
|
|
if (encOP->encodeVuiRbsp == TRUE) {
|
|
vbVuiRbsp->size = VUI_HRD_RBSP_BUF_SIZE;
|
|
|
|
if (vdi_allocate_dma_memory(coreIdx, vbVuiRbsp, ENC_ETC, 0) < 0) {//I don't know instIndex before Calling VpuEncOpen
|
|
VLOG(ERR, "fail to allocate VUI rbsp buffer\n" );
|
|
return FALSE;
|
|
}
|
|
encOP->vuiRbspDataAddr = vbVuiRbsp->phys_addr;
|
|
|
|
if (encConfig->vui_rbsp_file_name) {
|
|
Uint8 *pVuiRbspBuf;
|
|
Int32 rbspSizeInByte = (encOP->vuiRbspDataSize+7)>>3;
|
|
ChangePathStyle(encConfig->vui_rbsp_file_name);
|
|
if ((encConfig->vui_rbsp_fp = (FILE*)osal_fopen(encConfig->vui_rbsp_file_name, "r")) == NULL) {
|
|
VLOG(ERR, "fail to open VUI rbsp Data file, %s\n", encConfig->vui_rbsp_file_name);
|
|
return FALSE;
|
|
}
|
|
|
|
if (rbspSizeInByte > (Int32)VUI_HRD_RBSP_BUF_SIZE)
|
|
VLOG(ERR, "VUI Rbsp size is bigger than buffer size\n");
|
|
|
|
pVuiRbspBuf = (Uint8*)osal_malloc(VUI_HRD_RBSP_BUF_SIZE);
|
|
osal_memset(pVuiRbspBuf, 0, VUI_HRD_RBSP_BUF_SIZE);
|
|
osal_fread(pVuiRbspBuf, 1, rbspSizeInByte, encConfig->vui_rbsp_fp);
|
|
vdi_write_memory(coreIdx, encOP->vuiRbspDataAddr, pVuiRbspBuf, rbspSizeInByte, encOP->streamEndian);
|
|
osal_free(pVuiRbspBuf);
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
Int32 writeHrdRbsp(int coreIdx, TestEncConfig *encConfig, EncOpenParam *encOP, vpu_buffer_t *vbHrdRbsp)
|
|
{
|
|
if (encOP->encodeHrdRbspInVPS)
|
|
{
|
|
vbHrdRbsp->size = VUI_HRD_RBSP_BUF_SIZE;
|
|
if (vdi_allocate_dma_memory(coreIdx, vbHrdRbsp, ENC_ETC, 0) < 0) {//I don't know instIndex before Calling VpuEncOpen
|
|
VLOG(ERR, "fail to allocate HRD rbsp buffer\n" );
|
|
return FALSE;
|
|
}
|
|
|
|
encOP->hrdRbspDataAddr = vbHrdRbsp->phys_addr;
|
|
|
|
if (encConfig->hrd_rbsp_file_name) {
|
|
Uint8 *pHrdRbspBuf;
|
|
Int32 rbspSizeInByte = (encOP->hrdRbspDataSize+7)>>3;
|
|
ChangePathStyle(encConfig->hrd_rbsp_file_name);
|
|
if ((encConfig->hrd_rbsp_fp = (FILE*)osal_fopen(encConfig->hrd_rbsp_file_name, "r")) == NULL) {
|
|
VLOG(ERR, "fail to open HRD rbsp Data file, %s\n", encConfig->hrd_rbsp_file_name);
|
|
return FALSE;
|
|
}
|
|
|
|
if (rbspSizeInByte > (Int32)VUI_HRD_RBSP_BUF_SIZE)
|
|
VLOG(ERR, "HRD Rbsp size is bigger than buffer size\n");
|
|
|
|
pHrdRbspBuf = (Uint8*)osal_malloc(VUI_HRD_RBSP_BUF_SIZE);
|
|
osal_memset(pHrdRbspBuf, 0, VUI_HRD_RBSP_BUF_SIZE);
|
|
osal_fread(pHrdRbspBuf, 1, rbspSizeInByte, encConfig->hrd_rbsp_fp);
|
|
vdi_write_memory(coreIdx, encOP->hrdRbspDataAddr, pHrdRbspBuf, rbspSizeInByte, encOP->streamEndian);
|
|
osal_free(pHrdRbspBuf);
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
int openRoiMapFile(TestEncConfig *encConfig)
|
|
{
|
|
if (encConfig->roi_enable) {
|
|
if (encConfig->roi_file_name) {
|
|
ChangePathStyle(encConfig->roi_file_name);
|
|
if ((encConfig->roi_file = (FILE*)osal_fopen(encConfig->roi_file_name, "r")) == NULL) {
|
|
VLOG(ERR, "fail to open ROI file, %s\n", encConfig->roi_file_name);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
int allocateRoiMapBuf(EncHandle handle, TestEncConfig encConfig, vpu_buffer_t *vbRoi, int srcFbNum, int ctuNum)
|
|
{
|
|
int i;
|
|
Int32 coreIdx = handle->coreIdx;
|
|
if (encConfig.roi_enable) {
|
|
//number of roi buffer should be the same as source buffer num.
|
|
for (i = 0; i < srcFbNum ; i++) {
|
|
vbRoi[i].size = ctuNum;
|
|
if (vdi_allocate_dma_memory(coreIdx, &vbRoi[i], ENC_ETC, handle->instIndex) < 0) {
|
|
VLOG(ERR, "fail to allocate ROI buffer\n" );
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
// Define tokens for parsing scaling list file
|
|
const char* MatrixType[SCALING_LIST_SIZE_NUM][SL_NUM_MATRIX] =
|
|
{
|
|
{"INTRA4X4_LUMA", "INTRA4X4_CHROMAU", "INTRA4X4_CHROMAV", "INTER4X4_LUMA", "INTER4X4_CHROMAU", "INTER4X4_CHROMAV"},
|
|
{"INTRA8X8_LUMA", "INTRA8X8_CHROMAU", "INTRA8X8_CHROMAV", "INTER8X8_LUMA", "INTER8X8_CHROMAU", "INTER8X8_CHROMAV"},
|
|
{"INTRA16X16_LUMA", "INTRA16X16_CHROMAU", "INTRA16X16_CHROMAV", "INTER16X16_LUMA", "INTER16X16_CHROMAU", "INTER16X16_CHROMAV"},
|
|
{"INTRA32X32_LUMA", "INTRA32X32_CHROMAU_FROM16x16_CHROMAU", "INTRA32X32_CHROMAV_FROM16x16_CHROMAV","INTER32X32_LUMA", "INTER32X32_CHROMAU_FROM16x16_CHROMAU", "INTER32X32_CHROMAV_FROM16x16_CHROMAV"}
|
|
};
|
|
|
|
const char* MatrixType_DC[SCALING_LIST_SIZE_NUM - 2][SL_NUM_MATRIX] =
|
|
{
|
|
{"INTRA16X16_LUMA_DC", "INTRA16X16_CHROMAU_DC", "INTRA16X16_CHROMAV_DC", "INTER16X16_LUMA_DC", "INTER16X16_CHROMAU_DC", "INTER16X16_CHROMAV_DC"},
|
|
{"INTRA32X32_LUMA_DC", "INTRA32X32_CHROMAU_DC_FROM16x16_CHROMAU", "INTRA32X32_CHROMAV_DC_FROM16x16_CHROMAV", "INTER32X32_LUMA_DC","INTER32X32_CHROMAU_DC_FROM16x16_CHROMAU","INTER32X32_CHROMAV_DC_FROM16x16_CHROMAV"},
|
|
};
|
|
|
|
static Uint8* get_sl_addr(UserScalingList* sl, Uint32 size_id, Uint32 mat_id)
|
|
{
|
|
Uint8* addr = NULL;
|
|
|
|
switch(size_id)
|
|
{
|
|
case SCALING_LIST_4x4:
|
|
addr = sl->s4[mat_id];
|
|
break;
|
|
case SCALING_LIST_8x8:
|
|
addr = sl->s8[mat_id];
|
|
break;
|
|
case SCALING_LIST_16x16:
|
|
addr = sl->s16[mat_id];
|
|
break;
|
|
case SCALING_LIST_32x32:
|
|
addr = sl->s32[mat_id];
|
|
break;
|
|
}
|
|
return addr;
|
|
}
|
|
|
|
int parse_user_scaling_list(UserScalingList* sl, FILE* fp_sl, CodStd stdMode)
|
|
{
|
|
#define LINE_SIZE (1024)
|
|
const Uint32 scaling_list_size[SCALING_LIST_SIZE_NUM] = {16, 64, 64, 64};
|
|
char line[LINE_SIZE];
|
|
Uint32 i;
|
|
Uint32 size_id, mat_id, data, num_coef = 0;
|
|
Uint8* src = NULL;
|
|
Uint8* ref = NULL;
|
|
char* ret;
|
|
const char* type_str;
|
|
Uint32 maxScalingListSizeNum;
|
|
|
|
if (fp_sl == NULL)
|
|
return 0;
|
|
|
|
// for HEVC : 4x4, 8x8, 16x16, 32x32
|
|
// for AVC : 4x4, 8x8
|
|
maxScalingListSizeNum = (stdMode == STD_HEVC) ? SCALING_LIST_SIZE_NUM : SCALING_LIST_SIZE_NUM-2;
|
|
|
|
for(size_id = 0; size_id < maxScalingListSizeNum; size_id++) {
|
|
num_coef = scaling_list_size[size_id];//lint !e644
|
|
|
|
// for intra_y, intra_cb, intra_cr, inter_y, inter_cb, inter_cr
|
|
for(mat_id = 0; mat_id < SL_NUM_MATRIX; mat_id++) {
|
|
src = get_sl_addr(sl, size_id, mat_id);
|
|
|
|
// for AVC : ignore scaling list of chroma8x8
|
|
if((stdMode == STD_AVC) && (size_id == SCALING_LIST_8x8 && (mat_id % 3)))
|
|
continue;
|
|
|
|
// for HEVC : derive scaling list of chroma32x32 from chroma16x16
|
|
if((stdMode == STD_HEVC) && (size_id == SCALING_LIST_32x32 && (mat_id % 3))) {
|
|
ref = get_sl_addr(sl, size_id - 1, mat_id);
|
|
|
|
for(i = 0; i < num_coef; i++)
|
|
src[i] = ref[i];
|
|
|
|
continue;
|
|
}
|
|
|
|
fseek(fp_sl,0,0);
|
|
type_str = MatrixType[size_id][mat_id];
|
|
|
|
do {
|
|
ret = fgets(line, LINE_SIZE, fp_sl);
|
|
if((ret == NULL) || (strstr(line, type_str) == NULL && feof(fp_sl))) {
|
|
VLOG(ERR,"Error: can't read a scaling list matrix(%s)\n", type_str);
|
|
return 0;
|
|
}
|
|
} while (strstr(line, type_str) == NULL);
|
|
|
|
// get all coeff
|
|
for(i = 0; i < num_coef; i++) {
|
|
if(fscanf(fp_sl, "%u,", &data) != 1) {
|
|
VLOG(ERR,"Error: can't read a scaling list matrix(%s)\n", type_str);
|
|
return 0;
|
|
}
|
|
if (stdMode == STD_AVC && data < 4) {
|
|
VLOG(ERR,"Error: invald value in scaling list matrix(%s %d)\n", type_str, data);
|
|
return 0;
|
|
}
|
|
src[i] = (Uint8)data;
|
|
}
|
|
|
|
// get DC coeff for 16, 32
|
|
if(size_id > SCALING_LIST_8x8) {
|
|
fseek(fp_sl,0,0);
|
|
type_str = MatrixType_DC[size_id - 2][mat_id];
|
|
|
|
do {
|
|
ret = fgets(line, LINE_SIZE, fp_sl);
|
|
if((ret == NULL) || (strstr(line, type_str) == NULL && feof(fp_sl))) {
|
|
VLOG(ERR,"Error: can't read a scaling list matrix(%s)\n", type_str);
|
|
return 0;
|
|
}
|
|
} while (strstr(line, type_str) == NULL);
|
|
|
|
if(fscanf(fp_sl, "%u,", &data) != 1) {
|
|
VLOG(ERR,"Error: can't read a scaling list matrix(%s)\n", type_str);
|
|
return 0;
|
|
}
|
|
if (stdMode == STD_AVC && data < 4) {
|
|
VLOG(ERR,"Error: invald value in scaling list matrix(%s %d)\n", type_str, data);
|
|
return 0;
|
|
}
|
|
if(size_id == SCALING_LIST_16x16)
|
|
sl->s16dc[mat_id] = (Uint8)data;
|
|
else // SCALING_LIST_32x32
|
|
sl->s32dc[mat_id/3] = (Uint8)data;
|
|
}
|
|
} // for matrix id
|
|
} // for size id
|
|
return 1;
|
|
}
|
|
|
|
int parse_custom_lambda(Uint32 buf[NUM_CUSTOM_LAMBDA], FILE* fp)
|
|
{
|
|
int i, j = 0;
|
|
char lineStr[256] = {0, };
|
|
for(i = 0; i < 52; i++)
|
|
{
|
|
if( NULL == fgets(lineStr, 256, fp) )
|
|
{
|
|
VLOG(ERR,"Error: can't read custom_lambda\n");
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
sscanf(lineStr, "%u\n", &buf[j++]);
|
|
}
|
|
}
|
|
for(i = 0; i < 52; i++)
|
|
{
|
|
if( NULL == fgets(lineStr, 256, fp) )
|
|
{
|
|
VLOG(ERR,"Error: can't read custom_lambda\n");
|
|
return 0;
|
|
}
|
|
else
|
|
sscanf(lineStr, "%u\n", &buf[j++]);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
#if defined(PLATFORM_NON_OS) || defined (PLATFORM_LINUX)
|
|
struct option* ConvertOptions(
|
|
struct OptionExt* cnmOpt,
|
|
Uint32 nItems
|
|
)
|
|
{
|
|
struct option* opt;
|
|
Uint32 i;
|
|
|
|
opt = (struct option*)osal_malloc((Int32)(sizeof(struct option) * nItems));
|
|
if (opt == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
for (i=0; i<nItems; i++) {
|
|
osal_memcpy((void*)&opt[i], (void*)&cnmOpt[i], sizeof(struct option));
|
|
}
|
|
|
|
return opt;
|
|
}
|
|
#endif
|
|
|
|
// #if defined(PLATFORM_LINUX) || defined(PLATFORM_QNX) || defined(SUPPORT_READ_BITSTREAM_IN_ENCODER)
|
|
int mkdir_recursive(
|
|
char *path,
|
|
mode_t omode
|
|
)
|
|
{
|
|
struct stat sb;
|
|
mode_t numask, oumask;
|
|
int first, last, retval;
|
|
char *p;
|
|
|
|
p = path;
|
|
oumask = 0;
|
|
retval = 0;
|
|
if (p[0] == '/') /* Skip leading '/'. */
|
|
++p;
|
|
for (first = 1, last = 0; !last ; ++p) {//lint !e441 !e443
|
|
if (p[0] == '\0')
|
|
last = 1;
|
|
else if (p[0] != '/')
|
|
continue;
|
|
*p = '\0';
|
|
if (p[1] == '\0')
|
|
last = 1;
|
|
if (first) {
|
|
/*
|
|
* POSIX 1003.2:
|
|
* For each dir operand that does not name an existing
|
|
* directory, effects equivalent to those cased by the
|
|
* following command shall occcur:
|
|
*
|
|
* mkdir -p -m $(umask -S),u+wx $(dirname dir) &&
|
|
* mkdir [-m mode] dir
|
|
*
|
|
* We change the user's umask and then restore it,
|
|
* instead of doing chmod's.
|
|
*/
|
|
oumask = umask(0);
|
|
numask = oumask & ~(S_IWUSR | S_IXUSR);
|
|
(void)umask(numask);
|
|
first = 0;
|
|
}
|
|
if (last)
|
|
(void)umask(oumask);
|
|
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
|
|
if (errno == EEXIST || errno == EISDIR) {
|
|
if (stat(path, &sb) < 0) {
|
|
VLOG(INFO, "%s", path);
|
|
retval = 1;
|
|
break;
|
|
} else if (!S_ISDIR(sb.st_mode)) {
|
|
if (last)
|
|
errno = EEXIST;
|
|
else
|
|
errno = ENOTDIR;
|
|
VLOG(INFO, "%s", path);
|
|
retval = 1;
|
|
break;
|
|
}
|
|
} else {
|
|
VLOG(INFO, "%s", path);
|
|
retval = 1;
|
|
break;
|
|
}
|
|
} else {
|
|
VLOG(INFO, "%s", path);
|
|
chmod(path, omode);
|
|
}
|
|
if (!last)
|
|
*p = '/';
|
|
}
|
|
if (!first && !last)
|
|
(void)umask(oumask);
|
|
return (retval);
|
|
}
|
|
// #endif
|
|
|
|
int file_exist(
|
|
char* path
|
|
)
|
|
{
|
|
#ifdef _MSC_VER
|
|
DWORD attributes;
|
|
char temp[4096];
|
|
LPCTSTR lp_path = (LPCTSTR)temp;
|
|
|
|
if (path == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
strcpy(temp, path);
|
|
replace_character(temp, '/', '\\');
|
|
attributes = GetFileAttributes(lp_path);
|
|
return (attributes != (DWORD)-1);
|
|
#else
|
|
return !access(path, F_OK);
|
|
#endif
|
|
}
|
|
|
|
BOOL MkDir(
|
|
const char* path
|
|
)
|
|
{
|
|
#if defined(PLATFORM_NON_OS) || defined(PLATFORM_QNX)
|
|
/* need to implement */
|
|
return FALSE;
|
|
#else
|
|
#ifdef _MSC_VER
|
|
char cmd[4096];
|
|
#endif
|
|
if (file_exist((char*)path))
|
|
return TRUE;
|
|
|
|
#ifdef _MSC_VER
|
|
sprintf(cmd, "mkdir %s", path);
|
|
replace_character(cmd, '/', '\\');
|
|
if (system(cmd)) {
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
#else
|
|
return mkdir_recursive((char*)path, S_IRWXU | S_IRWXG | S_IRWXO);
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
void GetUserData(Int32 coreIdx, Uint8* pBase, vpu_buffer_t vbUserData, DecOutputInfo outputInfo)
|
|
{
|
|
int idx;
|
|
user_data_entry_t* pEntry = (user_data_entry_t*)pBase;
|
|
|
|
VpuReadMem(coreIdx, vbUserData.phys_addr, pBase, vbUserData.size, VPU_USER_DATA_ENDIAN);
|
|
VLOG(INFO, "===== USER DATA(SEI OR VUI) : NUM(%d) =====\n", outputInfo.decOutputExtData.userDataNum);
|
|
|
|
for (idx=0; idx<32; idx++) {
|
|
if (outputInfo.decOutputExtData.userDataHeader&(1<<idx)) {
|
|
VLOG(INFO, "\nUSERDATA INDEX: %02d offset: %8d size: %d\n", idx, pEntry[idx].offset, pEntry[idx].size);
|
|
|
|
if (idx == H265_USERDATA_FLAG_MASTERING_COLOR_VOL) {
|
|
h265_mastering_display_colour_volume_t* mastering;
|
|
int i;
|
|
|
|
mastering = (h265_mastering_display_colour_volume_t*)(pBase + pEntry[H265_USERDATA_FLAG_MASTERING_COLOR_VOL].offset);
|
|
VLOG(INFO, " MASTERING DISPLAY COLOR VOLUME\n");
|
|
for (i=0; i<3; i++) {
|
|
VLOG(INFO, " PRIMARIES_X%d : %10d PRIMARIES_Y%d : %10d\n", i, mastering->display_primaries_x[i], i, mastering->display_primaries_y[i]);
|
|
}
|
|
VLOG(INFO, " WHITE_POINT_X: %10d WHITE_POINT_Y: %10d\n", mastering->white_point_x, mastering->white_point_y);
|
|
VLOG(INFO, " MIN_LUMINANCE: %10d MAX_LUMINANCE: %10d\n", mastering->min_display_mastering_luminance, mastering->max_display_mastering_luminance);
|
|
}
|
|
|
|
if(idx == H265_USERDATA_FLAG_VUI)
|
|
{
|
|
h265_vui_param_t* vui;
|
|
|
|
vui = (h265_vui_param_t*)(pBase + pEntry[H265_USERDATA_FLAG_VUI].offset);
|
|
VLOG(INFO, " VUI SAR(%d, %d)\n", vui->sar_width, vui->sar_height);
|
|
VLOG(INFO, " VIDEO FORMAT(%d)\n", vui->video_format);
|
|
VLOG(INFO, " COLOUR PRIMARIES(%d)\n", vui->colour_primaries);
|
|
VLOG(INFO, "log2_max_mv_length_horizontal: %d\n", vui->log2_max_mv_length_horizontal);
|
|
VLOG(INFO, "log2_max_mv_length_vertical : %d\n", vui->log2_max_mv_length_vertical);
|
|
VLOG(INFO, "video_full_range_flag : %d\n", vui->video_full_range_flag);
|
|
VLOG(INFO, "transfer_characteristics : %d\n", vui->transfer_characteristics);
|
|
VLOG(INFO, "matrix_coeffs : %d\n", vui->matrix_coefficients);
|
|
}
|
|
if (idx == H265_USERDATA_FLAG_CHROMA_RESAMPLING_FILTER_HINT) {
|
|
h265_chroma_resampling_filter_hint_t* c_resampleing_filter_hint;
|
|
Uint32 i,j;
|
|
|
|
c_resampleing_filter_hint = (h265_chroma_resampling_filter_hint_t*)(pBase + pEntry[H265_USERDATA_FLAG_CHROMA_RESAMPLING_FILTER_HINT].offset);
|
|
VLOG(INFO, " CHROMA_RESAMPLING_FILTER_HINT\n");
|
|
VLOG(INFO, " VER_CHROMA_FILTER_IDC: %10d HOR_CHROMA_FILTER_IDC: %10d\n", c_resampleing_filter_hint->ver_chroma_filter_idc, c_resampleing_filter_hint->hor_chroma_filter_idc);
|
|
VLOG(INFO, " VER_FILTERING_FIELD_PROCESSING_FLAG: %d \n", c_resampleing_filter_hint->ver_filtering_field_processing_flag);
|
|
if (c_resampleing_filter_hint->ver_chroma_filter_idc == 1 || c_resampleing_filter_hint->hor_chroma_filter_idc == 1) {
|
|
VLOG(INFO, " TARGET_FORMAT_IDC: %d \n", c_resampleing_filter_hint->target_format_idc);
|
|
if (c_resampleing_filter_hint->ver_chroma_filter_idc == 1) {
|
|
VLOG(INFO, " NUM_VERTICAL_FILTERS: %d \n", c_resampleing_filter_hint->num_vertical_filters);
|
|
for (i=0; i<c_resampleing_filter_hint->num_vertical_filters; i++) {
|
|
VLOG(INFO, " VER_TAP_LENGTH_M1[%d]: %d \n", i, c_resampleing_filter_hint->ver_tap_length_minus1[i]);
|
|
for (j=0; j<c_resampleing_filter_hint->ver_tap_length_minus1[i]; j++) {
|
|
VLOG(INFO, " VER_FILTER_COEFF[%d][%d]: %d \n", i, j, c_resampleing_filter_hint->ver_filter_coeff[i][j]);
|
|
}
|
|
}
|
|
}
|
|
if (c_resampleing_filter_hint->hor_chroma_filter_idc == 1) {
|
|
VLOG(INFO, " NUM_HORIZONTAL_FILTERS: %d \n", c_resampleing_filter_hint->num_horizontal_filters);
|
|
for (i=0; i<c_resampleing_filter_hint->num_horizontal_filters; i++) {
|
|
VLOG(INFO, " HOR_TAP_LENGTH_M1[%d]: %d \n", i, c_resampleing_filter_hint->hor_tap_length_minus1[i]);
|
|
for (j=0; j<c_resampleing_filter_hint->hor_tap_length_minus1[i]; j++) {
|
|
VLOG(INFO, " HOR_FILTER_COEFF[%d][%d]: %d \n", i, j, c_resampleing_filter_hint->hor_filter_coeff[i][j]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (idx == H265_USERDATA_FLAG_KNEE_FUNCTION_INFO) {
|
|
h265_knee_function_info_t* knee_function;
|
|
|
|
knee_function = (h265_knee_function_info_t*)(pBase + pEntry[H265_USERDATA_FLAG_KNEE_FUNCTION_INFO].offset);
|
|
VLOG(INFO, " FLAG_KNEE_FUNCTION_INFO\n");
|
|
VLOG(INFO, " KNEE_FUNCTION_ID: %10d\n", knee_function->knee_function_id);
|
|
VLOG(INFO, " KNEE_FUNCTION_CANCEL_FLAG: %d\n", knee_function->knee_function_cancel_flag);
|
|
if (!knee_function->knee_function_cancel_flag) {
|
|
int i;
|
|
|
|
VLOG(INFO, " KNEE_FUNCTION_PERSISTENCE_FLAG: %10d\n", knee_function->knee_function_persistence_flag);
|
|
VLOG(INFO, " INPUT_D_RANGE: %d\n", knee_function->input_d_range);
|
|
VLOG(INFO, " INPUT_DISP_LUMINANCE: %d\n", knee_function->input_disp_luminance);
|
|
VLOG(INFO, " OUTPUT_D_RANGE: %d\n", knee_function->output_d_range);
|
|
VLOG(INFO, " OUTPUT_DISP_LUMINANCE: %d\n", knee_function->output_disp_luminance);
|
|
VLOG(INFO, " NUM_KNEE_POINTS_M1: %d\n", knee_function->num_knee_points_minus1);
|
|
for (i=0; (Uint32)i<knee_function->num_knee_points_minus1; i++) {
|
|
VLOG(INFO, " INPUT_KNEE_POINT: %10d OUTPUT_KNEE_POINT: %10d\n", knee_function->input_knee_point[i], knee_function->output_knee_point[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (idx == H265_USERDATA_FLAG_ITU_T_T35_PRE)
|
|
{
|
|
char* itu_t_t35 = (char*)(pBase + pEntry[H265_USERDATA_FLAG_ITU_T_T35_PRE].offset);
|
|
Uint32 i;
|
|
|
|
VLOG(INFO, "ITU_T_T35_PRE = %d bytes, offset = %d\n",pEntry[H265_USERDATA_FLAG_ITU_T_T35_PRE].size, pEntry[H265_USERDATA_FLAG_ITU_T_T35_PRE].offset);
|
|
for(i=0; i<pEntry[H265_USERDATA_FLAG_ITU_T_T35_PRE].size; i++)
|
|
{
|
|
VLOG(INFO, "%02X ", (unsigned char)(itu_t_t35[i]));
|
|
}
|
|
VLOG(INFO, "\n");
|
|
|
|
}
|
|
|
|
if (idx == H265_USERDATA_FLAG_ITU_T_T35_PRE_1)
|
|
{
|
|
char* itu_t_t35 = (char*)(pBase + pEntry[H265_USERDATA_FLAG_ITU_T_T35_PRE_1].offset);
|
|
Uint32 i;
|
|
|
|
VLOG(INFO, "ITU_T_T35_PRE = %d bytes, offset = %d\n",pEntry[H265_USERDATA_FLAG_ITU_T_T35_PRE_1].size, pEntry[H265_USERDATA_FLAG_ITU_T_T35_PRE_1].offset);
|
|
for(i=0; i<pEntry[H265_USERDATA_FLAG_ITU_T_T35_PRE_1].size; i++)
|
|
{
|
|
VLOG(INFO, "%02X ", (unsigned char)(itu_t_t35[i]));
|
|
}
|
|
VLOG(INFO, "\n");
|
|
}
|
|
|
|
if (idx == H265_USERDATA_FLAG_ITU_T_T35_PRE_2)
|
|
{
|
|
char* itu_t_t35 = (char*)(pBase + pEntry[H265_USERDATA_FLAG_ITU_T_T35_PRE_2].offset);
|
|
Uint32 i;
|
|
//user_data_entry_t* pEntry_prev;
|
|
|
|
VLOG(INFO, "ITU_T_T35_PRE = %d bytes, offset = %d\n",pEntry[H265_USERDATA_FLAG_ITU_T_T35_PRE_2].size, pEntry[H265_USERDATA_FLAG_ITU_T_T35_PRE_2].offset);
|
|
for(i=0; i<pEntry[H265_USERDATA_FLAG_ITU_T_T35_PRE_2].size; i++)
|
|
{
|
|
VLOG(INFO, "%02X ", (unsigned char)(itu_t_t35[i]));
|
|
}
|
|
VLOG(INFO, "\n");
|
|
|
|
//pEntry_prev = (user_data_entry_t*)(itu_t_t35 + pEntry[H265_USERDATA_FLAG_ITU_T_T35_PRE_2].size - sizeof(user_data_entry_t));
|
|
//pEntry[H265_USERDATA_FLAG_ITU_T_T35_PRE_2].size = pEntry_prev->size;
|
|
//pEntry[H265_USERDATA_FLAG_ITU_T_T35_PRE_2].offset = pEntry_prev->offset;
|
|
}
|
|
|
|
if (idx == H265_USERDATA_FLAG_COLOUR_REMAPPING_INFO) {
|
|
int c, i;
|
|
h265_colour_remapping_info_t* colour_remapping;
|
|
colour_remapping = (h265_colour_remapping_info_t*)(pBase + pEntry[H265_USERDATA_FLAG_COLOUR_REMAPPING_INFO].offset);
|
|
|
|
VLOG(INFO, " COLOUR_REMAPPING_INFO\n");
|
|
VLOG(INFO, " COLOUR_REMAP_ID: %10d\n", colour_remapping->colour_remap_id);
|
|
|
|
|
|
VLOG(INFO, " COLOUR_REMAP_CANCEL_FLAG: %d\n", colour_remapping->colour_remap_cancel_flag);
|
|
if (!colour_remapping->colour_remap_cancel_flag) {
|
|
VLOG(INFO, " COLOUR_REMAP_PERSISTENCE_FLAG: %d\n", colour_remapping->colour_remap_persistence_flag);
|
|
VLOG(INFO, " COLOUR_REMAP_VIDEO_SIGNAL_INFO_PRESENT_FLAG: %d\n", colour_remapping->colour_remap_video_signal_info_present_flag);
|
|
if (colour_remapping->colour_remap_video_signal_info_present_flag) {
|
|
VLOG(INFO, " COLOUR_REMAP_FULL_RANGE_FLAG: %d\n", colour_remapping->colour_remap_full_range_flag);
|
|
VLOG(INFO, " COLOUR_REMAP_PRIMARIES: %d\n", colour_remapping->colour_remap_primaries);
|
|
VLOG(INFO, " COLOUR_REMAP_TRANSFER_FUNCTION: %d\n", colour_remapping->colour_remap_transfer_function);
|
|
VLOG(INFO, " COLOUR_REMAP_MATRIX_COEFFICIENTS: %d\n", colour_remapping->colour_remap_matrix_coefficients);
|
|
}
|
|
|
|
VLOG(INFO, " COLOUR_REMAP_INPUT_BIT_DEPTH: %d\n", colour_remapping->colour_remap_input_bit_depth);
|
|
VLOG(INFO, " COLOUR_REMAP_OUTPUT_BIT_DEPTH: %d\n", colour_remapping->colour_remap_output_bit_depth);
|
|
|
|
for( c = 0; c < H265_MAX_LUT_NUM_VAL; c++ )
|
|
{
|
|
VLOG(INFO, " PRE_LUT_NUM_VAL_MINUS1[%d]: %d\n", c, colour_remapping->pre_lut_num_val_minus1[c]);
|
|
if(colour_remapping->pre_lut_num_val_minus1[c] > 0)
|
|
{
|
|
for( i = 0; i <= colour_remapping->pre_lut_num_val_minus1[c]; i++ )
|
|
{
|
|
VLOG(INFO, " PRE_LUT_CODED_VALUE[%d][%d]: %d\n", c, i, colour_remapping->pre_lut_coded_value[c][i]);
|
|
VLOG(INFO, " PRE_LUT_TARGET_VALUE[%d][%d]: %d\n", c, i, colour_remapping->pre_lut_target_value[c][i]);
|
|
}
|
|
}
|
|
}
|
|
VLOG(INFO, " COLOUR_REMAP_MATRIX_PRESENT_FLAG: %d\n", colour_remapping->colour_remap_matrix_present_flag);
|
|
if(colour_remapping->colour_remap_matrix_present_flag) {
|
|
VLOG(INFO, " LOG2_MATRIX_DENOM: %d\n", colour_remapping->log2_matrix_denom);
|
|
for( c = 0; c < H265_MAX_COLOUR_REMAP_COEFFS; c++ )
|
|
for( i = 0; i < H265_MAX_COLOUR_REMAP_COEFFS; i++ )
|
|
VLOG(INFO, " LOG2_MATRIX_DENOM[%d][%d]: %d\n", c, i, colour_remapping->colour_remap_coeffs[c][i]);
|
|
}
|
|
|
|
for( c = 0; c < H265_MAX_LUT_NUM_VAL; c++ )
|
|
{
|
|
VLOG(INFO, " POST_LUT_NUM_VAL_MINUS1[%d]: %d\n", c, colour_remapping->post_lut_num_val_minus1[c]);
|
|
if(colour_remapping->post_lut_num_val_minus1[c] > 0)
|
|
{
|
|
for( i = 0; i <= colour_remapping->post_lut_num_val_minus1[c]; i++)
|
|
{
|
|
VLOG(INFO, " POST_LUT_CODED_VALUE[%d][%d]: %d\n", c, i, colour_remapping->post_lut_coded_value[c][i]);
|
|
VLOG(INFO, " POST_LUT_TARGET_VALUE[%d][%d]: %d\n", c, i, colour_remapping->post_lut_target_value[c][i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (idx == H265_USERDATA_FLAG_TONE_MAPPING_INFO) {
|
|
h265_tone_mapping_info_t* tone_mapping;
|
|
|
|
tone_mapping = (h265_tone_mapping_info_t*)(pBase + pEntry[H265_USERDATA_FLAG_TONE_MAPPING_INFO].offset);
|
|
VLOG(INFO, " FLAG_TONE_MAPPING_INFO\n");
|
|
VLOG(INFO, " TONE_MAP_ID: %10d\n", tone_mapping->tone_map_id);
|
|
VLOG(INFO, " TONE_MAP_CANCEL_FLAG: %d\n", tone_mapping->tone_map_cancel_flag);
|
|
if (!tone_mapping->tone_map_cancel_flag) {
|
|
Uint32 i;
|
|
|
|
VLOG(INFO, " TONE_MAP_PERSISTENCE_FLAG: %10d\n", tone_mapping->tone_map_persistence_flag);
|
|
VLOG(INFO, " CODED_DATA_BIT_DEPTH : %d\n", tone_mapping->coded_data_bit_depth);
|
|
VLOG(INFO, " TARGET_BIT_DEPTH : %d\n", tone_mapping->target_bit_depth);
|
|
VLOG(INFO, " TONE_MAP_MODEL_ID : %d\n", tone_mapping->tone_map_model_id);
|
|
VLOG(INFO, " MIN_VALUE : %d\n", tone_mapping->min_value);
|
|
VLOG(INFO, " MAX_VALUE : %d\n", tone_mapping->max_value);
|
|
VLOG(INFO, " SIGMOID_MIDPOINT : %d\n", tone_mapping->sigmoid_midpoint);
|
|
VLOG(INFO, " SIGMOID_MIDPOINT : %d\n", tone_mapping->sigmoid_width);
|
|
for (i=0; i<(Uint32)(1<<tone_mapping->target_bit_depth); i++) {
|
|
VLOG(INFO, " START_OF_CODED_INTERVAL[%d] : %d\n", i, tone_mapping->start_of_coded_interval[i]); // [1 << target_bit_depth] // 10bits
|
|
}
|
|
|
|
VLOG(INFO, " NUM_PIVOTS : %d\n", tone_mapping->num_pivots); // [(1 << coded_data_bit_depth)?1][(1 << target_bit_depth)-1] // 10bits
|
|
for (i=0; i<tone_mapping->num_pivots; i++) {
|
|
VLOG(INFO, " CODED_PIVOT_VALUE[%d] : %d, TARGET_PIVOT_VALUE[%d] : %d\n", i, tone_mapping->coded_pivot_value[i]
|
|
, i, tone_mapping->target_pivot_value[i]);
|
|
}
|
|
|
|
VLOG(INFO, " CAMERA_ISO_SPEED_IDC : %d\n", tone_mapping->camera_iso_speed_idc);
|
|
VLOG(INFO, " CAMERA_ISO_SPEED_VALUE : %d\n", tone_mapping->camera_iso_speed_value);
|
|
|
|
VLOG(INFO, " EXPOSURE_INDEX_IDC : %d\n", tone_mapping->exposure_index_idc);
|
|
VLOG(INFO, " EXPOSURE_INDEX_VALUE : %d\n", tone_mapping->exposure_index_value);
|
|
VLOG(INFO, " EXPOSURE_INDEX_COMPESATION_VALUE_SIGN_FLAG : %d\n", tone_mapping->exposure_compensation_value_sign_flag);
|
|
VLOG(INFO, " EXPOSURE_INDEX_COMPESATION_VALUE_NUMERATOR : %d\n", tone_mapping->exposure_compensation_value_numerator);
|
|
VLOG(INFO, " EXPOSURE_INDEX_COMPESATION_VALUE_DENOM_IDC : %d\n", tone_mapping->exposure_compensation_value_denom_idc);
|
|
|
|
VLOG(INFO, " REF_SCREEN_LUMINANCE_WHITE : %d\n", tone_mapping->ref_screen_luminance_white);
|
|
|
|
VLOG(INFO, " EXTENDED_RANGE_WHITE_LEVEL : %d\n", tone_mapping->extended_range_white_level);
|
|
VLOG(INFO, " NOMINAL_BLACK_LEVEL_CODE_VALUE : %d\n", tone_mapping->nominal_black_level_code_value);
|
|
VLOG(INFO, " NOMINAL_WHITE_LEVEL_CODE_VALUE : %d\n", tone_mapping->nominal_white_level_code_value);
|
|
VLOG(INFO, " EXTENDED_WHITE_LEVEL_CODE_VALUE : %d\n", tone_mapping->extended_white_level_code_value);
|
|
}
|
|
VLOG(INFO, "\n");
|
|
}
|
|
|
|
if (idx == H265_USERDATA_FLAG_CONTENT_LIGHT_LEVEL_INFO) {
|
|
h265_content_light_level_info_t* content_light_level;
|
|
|
|
content_light_level = (h265_content_light_level_info_t*)(pBase + pEntry[H265_USERDATA_FLAG_CONTENT_LIGHT_LEVEL_INFO].offset);
|
|
VLOG(INFO, " CONTNET_LIGHT_INFO\n");
|
|
VLOG(INFO, " MAX_CONTENT_LIGHT_LEVEL : %d\n", content_light_level->max_content_light_level);
|
|
VLOG(INFO, " MAX_PIC_AVERAGE_LIGHT_LEVEL : %d\n", content_light_level->max_pic_average_light_level);
|
|
VLOG(INFO, "\n");
|
|
}
|
|
|
|
if (idx == H265_USERDATA_FLAG_FILM_GRAIN_CHARACTERISTICS_INFO) {
|
|
h265_film_grain_characteristics_t* film_grain_characteristics;
|
|
int i,j,c;
|
|
|
|
film_grain_characteristics = (h265_film_grain_characteristics_t*)(pBase + pEntry[H265_USERDATA_FLAG_FILM_GRAIN_CHARACTERISTICS_INFO].offset);
|
|
VLOG(INFO, " FILM_GRAIN_CHARACTERISTICS_INFO\n");
|
|
VLOG(INFO, " FILM_GRAIN_CHARACTERISTICS_CANCEL_FLAG: %d\n", film_grain_characteristics->film_grain_characteristics_cancel_flag);
|
|
if (!film_grain_characteristics->film_grain_characteristics_cancel_flag) {
|
|
VLOG(INFO, " FILM_GRAIN_MODEL_ID: %10d\n", film_grain_characteristics->film_grain_model_id);
|
|
|
|
VLOG(INFO, " SEPARATE_COLOUR_DESCRIPTION_PRESENT_FLAG: %d\n", film_grain_characteristics->separate_colour_description_present_flag);
|
|
if (film_grain_characteristics->separate_colour_description_present_flag)
|
|
{
|
|
VLOG(INFO, " FILM_GRAIN_BIT_DEPTH_LUMA_MINUS8: %d\n", film_grain_characteristics->film_grain_bit_depth_luma_minus8);
|
|
VLOG(INFO, " FILM_GRAIN_BIT_DEPTH_CHROMA_MINUS8: %d\n", film_grain_characteristics->film_grain_bit_depth_chroma_minus8);
|
|
VLOG(INFO, " FILM_GRAIN_FULL_RANGE_FLAG: %d\n", film_grain_characteristics->film_grain_full_range_flag);
|
|
VLOG(INFO, " FILM_GRAIN_COLOUR_PRIMARIES: %d\n", film_grain_characteristics->film_grain_colour_primaries);
|
|
VLOG(INFO, " FILM_GRAIN_TRANSFER_CHARACTERISTICS: %d\n", film_grain_characteristics->film_grain_transfer_characteristics);
|
|
VLOG(INFO, " FILM_GRAIN_MATRIX_COEFF: %d\n", film_grain_characteristics->film_grain_matrix_coeffs);
|
|
}
|
|
}
|
|
|
|
VLOG(INFO, " BLENDING_MODE_ID: %d\n", film_grain_characteristics->blending_mode_id);
|
|
VLOG(INFO, " LOG2_SCALE_FACTOR: %d\n", film_grain_characteristics->log2_scale_factor);
|
|
for(c=0; c < H265_MAX_NUM_FILM_GRAIN_COMPONENT; c++ )
|
|
{
|
|
VLOG(INFO, " COMP_MODEL_PRESENT_FLAG[%d]: %d\n", c, film_grain_characteristics->comp_model_present_flag[c]);
|
|
}
|
|
|
|
for(c=0; c < H265_MAX_NUM_FILM_GRAIN_COMPONENT; c++ )
|
|
{
|
|
if(film_grain_characteristics->comp_model_present_flag[c])
|
|
{
|
|
|
|
VLOG(INFO, " NUM_INTENSITY_INTERVALS_MINUS1[%d]: %d\n", c, film_grain_characteristics->num_intensity_intervals_minus1[c]);
|
|
VLOG(INFO, " NUM_MODEL_VALUES_MINUS1[%d]: %d\n", c, film_grain_characteristics->num_model_values_minus1[c]);
|
|
for(i=0; (Uint32)i <= film_grain_characteristics->num_intensity_intervals_minus1[c]; i++)
|
|
{
|
|
VLOG(INFO, " INTENSITY_INTERVAL_LOWER_BOUND[%d][%d]: %d\n", c, i, film_grain_characteristics->intensity_interval_lower_bound[c][i]);
|
|
VLOG(INFO, " INTENSITY_INTERVAL_UPPER_BOUND[%d][%d]: %d\n", c, i, film_grain_characteristics->intensity_interval_upper_bound[c][i]);
|
|
for(j=0; (Uint32)j <= film_grain_characteristics->num_model_values_minus1[c]; j++)
|
|
{
|
|
VLOG(INFO, " COMP_MODEL_VALUE[%d][%d][%d]: %d\n", c, i, j, film_grain_characteristics->comp_model_value[c][i][j]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
VLOG(INFO, " FILM_GRAIN_CHARACTERISTICS_PERSISTENCE_FLAG: %d\n", film_grain_characteristics->film_grain_characteristics_persistence_flag);
|
|
VLOG(INFO, "\n");
|
|
}
|
|
}
|
|
}
|
|
VLOG(INFO, "===========================================\n");
|
|
}
|
|
|
|
void SetMapData(int coreIdx, TestEncConfig encConfig, EncOpenParam encOP, EncParam *encParam, int srcFrameWidth, int srcFrameHeight, unsigned long addrCustomMap)
|
|
{
|
|
int productId = VPU_GetProductId(coreIdx);
|
|
|
|
if (productId == PRODUCT_ID_521 && encOP.bitstreamFormat == STD_AVC) {
|
|
Uint8 roiMapBuf[MAX_MB_NUM] = {0,};
|
|
Uint8 modeMapBuf[MAX_MB_NUM] = {0,};
|
|
AvcEncCustomMap customMapBuf[MAX_MB_NUM]; // custom map 1 MB data = 8bits
|
|
int MbWidth = VPU_ALIGN16(encOP.picWidth) >> 4;
|
|
int MbHeight = VPU_ALIGN16(encOP.picHeight) >> 4;
|
|
int h, w, mbAddr;
|
|
osal_memset(&customMapBuf[0], 0x00, MAX_MB_NUM);
|
|
if (encParam->customMapOpt.customRoiMapEnable == 1) {
|
|
int sumQp = 0;
|
|
int bufSize = MbWidth*MbHeight;
|
|
|
|
if ( (int)(osal_fread(&roiMapBuf[0], 1, bufSize, encConfig.roi_file)) != bufSize) {
|
|
osal_fseek(encConfig.roi_file, 0, SEEK_SET);
|
|
osal_fread(&roiMapBuf[0], 1, bufSize, encConfig.roi_file);
|
|
}
|
|
|
|
for (h = 0; h < MbHeight; h++) {
|
|
for (w = 0; w < MbWidth; w++) {
|
|
mbAddr = w + h*MbWidth;
|
|
customMapBuf[mbAddr].field.mb_qp = MAX(MIN(roiMapBuf[mbAddr], 51), 0) & 0x3F;
|
|
sumQp += customMapBuf[mbAddr].field.mb_qp;
|
|
}
|
|
}
|
|
encParam->customMapOpt.roiAvgQp = (sumQp + (bufSize>>1)) / bufSize; // round off.
|
|
}
|
|
|
|
if (encParam->customMapOpt.customModeMapEnable == 1) {
|
|
int bufSize = MbWidth*MbHeight;
|
|
|
|
if ((int)(osal_fread(&modeMapBuf[0], 1, bufSize, encConfig.mode_map_file)) != bufSize) {
|
|
osal_fseek(encConfig.mode_map_file, 0, SEEK_SET);
|
|
osal_fread(&modeMapBuf[0], 1, bufSize, encConfig.mode_map_file);
|
|
}
|
|
|
|
for (h = 0; h < MbHeight; h++) {
|
|
for (w = 0; w < MbWidth; w++) {
|
|
mbAddr = w + h*MbWidth;
|
|
customMapBuf[mbAddr].field.mb_force_mode = modeMapBuf[mbAddr] & 0x3;
|
|
}
|
|
}
|
|
}
|
|
|
|
encParam->customMapOpt.addrCustomMap = (PhysicalAddress)addrCustomMap;
|
|
vdi_write_memory(coreIdx, encParam->customMapOpt.addrCustomMap, (unsigned char*)customMapBuf, MAX_MB_NUM, VDI_LITTLE_ENDIAN);
|
|
}
|
|
else {
|
|
// for HEVC custom map.
|
|
Uint8 roiMapBuf[MAX_SUB_CTU_NUM] = {0,};
|
|
Uint8 lambdaMapBuf[MAX_SUB_CTU_NUM] = {0,};
|
|
Uint8 modeMapBuf[MAX_CTU_NUM] = {0,};
|
|
EncCustomMap customMapBuf[MAX_CTU_NUM]; // custom map 1 CTU data = 64bits
|
|
int ctuMapWidthCnt = VPU_ALIGN64(encOP.picWidth) >> 6;
|
|
int ctuMapHeightCnt = VPU_ALIGN64(encOP.picHeight) >> 6;
|
|
int ctuMapStride = VPU_ALIGN64(encOP.picWidth) >> 6;
|
|
int subCtuMapStride = VPU_ALIGN64(encOP.picWidth) >> 5;
|
|
int i, sumQp = 0;;
|
|
int h, w, ctuPos, initQp;
|
|
Uint8* src;
|
|
VpuRect region[MAX_ROI_NUMBER]; /**< The size of the ROI region for H.265 (start X/Y in CTU, end X/Y int CTU) */
|
|
int roiQp[MAX_ROI_NUMBER]; /**< An importance level for the given ROI region for H.265. The higher an ROI level is, the more important the region is with a lower QP. */
|
|
|
|
osal_memset(&customMapBuf[0], 0x00, MAX_CTU_NUM * 8);
|
|
if (encParam->customMapOpt.customRoiMapEnable == 1) {
|
|
int bufSize = (VPU_ALIGN64(encOP.picWidth) >> 5) * (VPU_ALIGN64(encOP.picHeight) >> 5);
|
|
|
|
if (productId == PRODUCT_ID_521) {
|
|
if ((int)osal_fread(&roiMapBuf[0], 1, bufSize, encConfig.roi_file) != bufSize) {
|
|
osal_fseek(encConfig.roi_file, 0, SEEK_SET);
|
|
osal_fread(&roiMapBuf[0], 1, bufSize, encConfig.roi_file);
|
|
}
|
|
}
|
|
else {
|
|
int roiNum = 0;
|
|
// sample code to convert ROI coordinate to ROI map.
|
|
osal_memset(®ion[0], 0, sizeof(VpuRect)*MAX_ROI_NUMBER);
|
|
osal_memset(&roiQp[0], 0, sizeof(int)*MAX_ROI_NUMBER);
|
|
if (encConfig.roi_file_name[0]) {
|
|
char lineStr[256] = {0,};
|
|
int val;
|
|
fgets(lineStr, 256, encConfig.roi_file);
|
|
sscanf(lineStr, "%d\n", &val);
|
|
if (val != 0xFFFF)
|
|
VLOG(ERR, "can't find the picture delimiter \n");
|
|
|
|
fgets(lineStr, 256, encConfig.roi_file);
|
|
sscanf(lineStr, "%d\n", &val); // picture index
|
|
|
|
fgets(lineStr, 256, encConfig.roi_file);
|
|
sscanf(lineStr, "%d\n", &roiNum); // number of roi regions
|
|
|
|
for (i = 0; i < roiNum; i++) {
|
|
fgets(lineStr, 256, encConfig.roi_file);
|
|
if (parseRoiCtuModeParam(lineStr, ®ion[i], &roiQp[i], srcFrameWidth, srcFrameHeight) == 0) {
|
|
VLOG(ERR, "CFG file error : %s value is not available. \n", encConfig.roi_file_name);
|
|
}
|
|
}
|
|
}
|
|
encParam->customMapOpt.customRoiMapEnable = (roiNum != 0) ? encParam->customMapOpt.customRoiMapEnable : 0;
|
|
|
|
if (encParam->customMapOpt.customRoiMapEnable) {
|
|
initQp = encConfig.roi_avg_qp;
|
|
GenRegionToQpMap(®ion[0], &roiQp[0], roiNum, initQp, subCtuMapStride, VPU_ALIGN64(encOP.picHeight) >> 5, &roiMapBuf[0]);
|
|
}
|
|
}
|
|
|
|
for (h = 0; h < ctuMapHeightCnt; h++) {
|
|
src = &roiMapBuf[subCtuMapStride * h * 2];
|
|
for (w = 0; w < ctuMapWidthCnt; w++, src += 2) {
|
|
ctuPos = (h * ctuMapStride + w);
|
|
|
|
// store in the order of sub-ctu.
|
|
customMapBuf[ctuPos].field.sub_ctu_qp_0 = MAX(MIN(*src, 51), 0) & 0x3F;
|
|
customMapBuf[ctuPos].field.sub_ctu_qp_1 = MAX(MIN(*(src + 1), 51), 0) & 0x3F;
|
|
customMapBuf[ctuPos].field.sub_ctu_qp_2 = MAX(MIN(*(src + subCtuMapStride), 51), 0) & 0x3F;
|
|
customMapBuf[ctuPos].field.sub_ctu_qp_3 = MAX(MIN(*(src + subCtuMapStride + 1), 51), 0) & 0x3F;
|
|
sumQp += (customMapBuf[ctuPos].field.sub_ctu_qp_0 + customMapBuf[ctuPos].field.sub_ctu_qp_1 + customMapBuf[ctuPos].field.sub_ctu_qp_2 + customMapBuf[ctuPos].field.sub_ctu_qp_3);
|
|
}
|
|
}
|
|
if (productId == PRODUCT_ID_521)
|
|
encParam->customMapOpt.roiAvgQp = (sumQp + (bufSize>>1)) / bufSize; // round off.
|
|
}
|
|
|
|
if (encParam->customMapOpt.customLambdaMapEnable == 1) {
|
|
int bufSize = (VPU_ALIGN64(encOP.picWidth) >> 5) * (VPU_ALIGN64(encOP.picHeight) >> 5);
|
|
|
|
if ((int)osal_fread(&lambdaMapBuf[0], 1, bufSize, encConfig.lambda_map_file) != bufSize) {
|
|
osal_fseek(encConfig.lambda_map_file, 0, SEEK_SET);
|
|
osal_fread(&lambdaMapBuf[0], 1, bufSize, encConfig.lambda_map_file);
|
|
}
|
|
|
|
for (h = 0; h < ctuMapHeightCnt; h++) {
|
|
src = &lambdaMapBuf[subCtuMapStride * 2 * h];
|
|
for (w = 0; w < ctuMapWidthCnt; w++, src += 2) {
|
|
ctuPos = (h * ctuMapStride + w);
|
|
|
|
// store in the order of sub-ctu.
|
|
customMapBuf[ctuPos].field.lambda_sad_0 = *src;
|
|
customMapBuf[ctuPos].field.lambda_sad_1 = *(src + 1);
|
|
customMapBuf[ctuPos].field.lambda_sad_2 = *(src + subCtuMapStride);
|
|
customMapBuf[ctuPos].field.lambda_sad_3 = *(src + subCtuMapStride + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((encParam->customMapOpt.customModeMapEnable == 1)
|
|
|| (encParam->customMapOpt.customCoefDropEnable == 1)) {
|
|
int bufSize = (VPU_ALIGN64(encOP.picWidth) >> 6) * (VPU_ALIGN64(encOP.picHeight) >> 6);
|
|
|
|
if ((int)osal_fread(&modeMapBuf[0], 1, bufSize, encConfig.mode_map_file) != bufSize) {
|
|
osal_fseek(encConfig.mode_map_file, 0, SEEK_SET);
|
|
osal_fread(&modeMapBuf[0], 1, bufSize, encConfig.mode_map_file);
|
|
}
|
|
|
|
for (h = 0; h < ctuMapHeightCnt; h++) {
|
|
src = &modeMapBuf[ctuMapStride * h];
|
|
for (w = 0; w < ctuMapWidthCnt; w++, src++) {
|
|
ctuPos = (h * ctuMapStride + w);
|
|
customMapBuf[ctuPos].field.ctu_force_mode = (*src) & 0x3;
|
|
customMapBuf[ctuPos].field.ctu_coeff_drop = ((*src) >> 2) & 0x1;
|
|
}
|
|
}
|
|
}
|
|
|
|
encParam->customMapOpt.addrCustomMap = (PhysicalAddress)addrCustomMap;
|
|
|
|
vdi_write_memory(coreIdx, encParam->customMapOpt.addrCustomMap, (unsigned char*)customMapBuf, MAX_CTU_NUM * 8, VDI_LITTLE_ENDIAN);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
RetCode SetChangeParam(EncHandle handle, TestEncConfig encConfig, EncOpenParam encOP __attribute__((unused)), Int32 changedCount)
|
|
{
|
|
int i;
|
|
RetCode ret;
|
|
ENC_CFG ParaChagCfg;
|
|
EncChangeParam changeParam;
|
|
|
|
osal_memset(&ParaChagCfg, 0x00, sizeof(ENC_CFG));
|
|
osal_memset(&changeParam, 0x00, sizeof(EncChangeParam));
|
|
|
|
parseWaveChangeParamCfgFile(&ParaChagCfg, encConfig.changeParam[changedCount].cfgName);
|
|
|
|
changeParam.enable_option = encConfig.changeParam[changedCount].enableOption;
|
|
|
|
if (changeParam.enable_option & ENC_SET_CHANGE_PARAM_PPS) {
|
|
changeParam.constIntraPredFlag = ParaChagCfg.waveCfg.constIntraPredFlag;
|
|
changeParam.lfCrossSliceBoundaryEnable = ParaChagCfg.waveCfg.lfCrossSliceBoundaryEnable;
|
|
changeParam.weightPredEnable = ParaChagCfg.waveCfg.weightPredEnable;
|
|
changeParam.disableDeblk = ParaChagCfg.waveCfg.disableDeblk;
|
|
changeParam.betaOffsetDiv2 = ParaChagCfg.waveCfg.betaOffsetDiv2;
|
|
changeParam.tcOffsetDiv2 = ParaChagCfg.waveCfg.tcOffsetDiv2;
|
|
changeParam.chromaCbQpOffset = ParaChagCfg.waveCfg.chromaCbQpOffset;
|
|
changeParam.chromaCrQpOffset = ParaChagCfg.waveCfg.chromaCrQpOffset;
|
|
if (encConfig.stdMode == STD_AVC) {
|
|
changeParam.transform8x8Enable = ParaChagCfg.waveCfg.transform8x8;
|
|
changeParam.entropyCodingMode = ParaChagCfg.waveCfg.entropyCodingMode;
|
|
}
|
|
}
|
|
|
|
if (changeParam.enable_option & ENC_SET_CHANGE_PARAM_INDEPEND_SLICE) {
|
|
changeParam.independSliceMode = ParaChagCfg.waveCfg.independSliceMode;
|
|
changeParam.independSliceModeArg = ParaChagCfg.waveCfg.independSliceModeArg;
|
|
if (encConfig.stdMode == STD_AVC) {
|
|
changeParam.avcSliceMode = ParaChagCfg.waveCfg.avcSliceMode;
|
|
changeParam.avcSliceArg = ParaChagCfg.waveCfg.avcSliceArg;
|
|
}
|
|
}
|
|
|
|
if (changeParam.enable_option & ENC_SET_CHANGE_PARAM_DEPEND_SLICE) {
|
|
changeParam.dependSliceMode = ParaChagCfg.waveCfg.dependSliceMode;
|
|
changeParam.dependSliceModeArg = ParaChagCfg.waveCfg.dependSliceModeArg;
|
|
}
|
|
|
|
if (changeParam.enable_option & ENC_SET_CHANGE_PARAM_RDO) {
|
|
changeParam.coefClearDisable = ParaChagCfg.waveCfg.coefClearDisable;
|
|
changeParam.intraNxNEnable = ParaChagCfg.waveCfg.intraNxNEnable;
|
|
changeParam.maxNumMerge = ParaChagCfg.waveCfg.maxNumMerge;
|
|
changeParam.customLambdaEnable = ParaChagCfg.waveCfg.customLambdaEnable;
|
|
changeParam.customMDEnable = ParaChagCfg.waveCfg.customMDEnable;
|
|
if (encConfig.stdMode == STD_AVC) {
|
|
changeParam.rdoSkip = ParaChagCfg.waveCfg.rdoSkip;
|
|
changeParam.lambdaScalingEnable = ParaChagCfg.waveCfg.lambdaScalingEnable;
|
|
}
|
|
}
|
|
|
|
if (changeParam.enable_option & ENC_SET_CHANGE_PARAM_RC_FRAME_RATE) {
|
|
changeParam.frameRate = ParaChagCfg.waveCfg.frameRate;
|
|
}
|
|
|
|
if (changeParam.enable_option & ENC_SET_CHANGE_PARAM_RC_TARGET_RATE) {
|
|
changeParam.bitRate = ParaChagCfg.RcBitRate;
|
|
}
|
|
|
|
if (changeParam.enable_option & ENC_SET_CHANGE_PARAM_RC) {
|
|
changeParam.hvsQPEnable = ParaChagCfg.waveCfg.hvsQPEnable;
|
|
changeParam.hvsQpScale = ParaChagCfg.waveCfg.hvsQpScale;
|
|
changeParam.vbvBufferSize = ParaChagCfg.VbvBufferSize;
|
|
}
|
|
|
|
if (changeParam.enable_option & ENC_SET_CHANGE_PARAM_RC_MIN_MAX_QP) {
|
|
changeParam.minQpI = ParaChagCfg.waveCfg.minQp;
|
|
changeParam.maxQpI = ParaChagCfg.waveCfg.maxQp;
|
|
changeParam.hvsMaxDeltaQp = ParaChagCfg.waveCfg.maxDeltaQp;
|
|
}
|
|
|
|
if (changeParam.enable_option & ENC_SET_CHANGE_PARAM_RC_INTER_MIN_MAX_QP) {
|
|
changeParam.minQpP = ParaChagCfg.waveCfg.minQp;
|
|
changeParam.minQpB = ParaChagCfg.waveCfg.minQp;
|
|
changeParam.maxQpP = ParaChagCfg.waveCfg.maxQp;
|
|
changeParam.maxQpB = ParaChagCfg.waveCfg.maxQp;
|
|
}
|
|
|
|
if (changeParam.enable_option & ENC_SET_CHANGE_PARAM_RC_BIT_RATIO_LAYER) {
|
|
for (i=0 ; i<MAX_GOP_NUM; i++)
|
|
changeParam.fixedBitRatio[i] = ParaChagCfg.waveCfg.fixedBitRatio[i];
|
|
}
|
|
|
|
if (changeParam.enable_option & ENC_SET_CHANGE_PARAM_BG) {
|
|
changeParam.s2fmeDisable = ParaChagCfg.waveCfg.s2fmeDisable;
|
|
changeParam.bgThrDiff = ParaChagCfg.waveCfg.bgThrDiff;
|
|
changeParam.bgThrMeanDiff = ParaChagCfg.waveCfg.bgThrMeanDiff;
|
|
changeParam.bgLambdaQp = ParaChagCfg.waveCfg.bgLambdaQp;
|
|
changeParam.bgDeltaQp = ParaChagCfg.waveCfg.bgDeltaQp;
|
|
changeParam.s2fmeDisable = ParaChagCfg.waveCfg.s2fmeDisable;
|
|
}
|
|
|
|
if (changeParam.enable_option & ENC_SET_CHANGE_PARAM_NR) {
|
|
changeParam.nrYEnable = ParaChagCfg.waveCfg.nrYEnable;
|
|
changeParam.nrCbEnable = ParaChagCfg.waveCfg.nrCbEnable;
|
|
changeParam.nrCrEnable = ParaChagCfg.waveCfg.nrCrEnable;
|
|
changeParam.nrNoiseEstEnable = ParaChagCfg.waveCfg.nrNoiseEstEnable;
|
|
changeParam.nrNoiseSigmaY = ParaChagCfg.waveCfg.nrNoiseSigmaY;
|
|
changeParam.nrNoiseSigmaCb = ParaChagCfg.waveCfg.nrNoiseSigmaCb;
|
|
changeParam.nrNoiseSigmaCr = ParaChagCfg.waveCfg.nrNoiseSigmaCr;
|
|
|
|
changeParam.nrIntraWeightY = ParaChagCfg.waveCfg.nrIntraWeightY;
|
|
changeParam.nrIntraWeightCb = ParaChagCfg.waveCfg.nrIntraWeightCb;
|
|
changeParam.nrIntraWeightCr = ParaChagCfg.waveCfg.nrIntraWeightCr;
|
|
changeParam.nrInterWeightY = ParaChagCfg.waveCfg.nrInterWeightY;
|
|
changeParam.nrInterWeightCb = ParaChagCfg.waveCfg.nrInterWeightCb;
|
|
changeParam.nrInterWeightCr = ParaChagCfg.waveCfg.nrInterWeightCr;
|
|
}
|
|
|
|
if (changeParam.enable_option & ENC_SET_CHANGE_PARAM_CUSTOM_MD) {
|
|
changeParam.pu04DeltaRate = ParaChagCfg.waveCfg.pu04DeltaRate;
|
|
changeParam.pu08DeltaRate = ParaChagCfg.waveCfg.pu08DeltaRate;
|
|
changeParam.pu16DeltaRate = ParaChagCfg.waveCfg.pu16DeltaRate;
|
|
changeParam.pu32DeltaRate = ParaChagCfg.waveCfg.pu32DeltaRate;
|
|
changeParam.pu04IntraPlanarDeltaRate = ParaChagCfg.waveCfg.pu04IntraPlanarDeltaRate;
|
|
changeParam.pu04IntraDcDeltaRate = ParaChagCfg.waveCfg.pu04IntraDcDeltaRate;
|
|
changeParam.pu04IntraAngleDeltaRate = ParaChagCfg.waveCfg.pu04IntraAngleDeltaRate;
|
|
changeParam.pu08IntraPlanarDeltaRate = ParaChagCfg.waveCfg.pu08IntraPlanarDeltaRate;
|
|
changeParam.pu08IntraDcDeltaRate = ParaChagCfg.waveCfg.pu08IntraDcDeltaRate;
|
|
changeParam.pu08IntraAngleDeltaRate = ParaChagCfg.waveCfg.pu08IntraAngleDeltaRate;
|
|
changeParam.pu16IntraPlanarDeltaRate = ParaChagCfg.waveCfg.pu16IntraPlanarDeltaRate;
|
|
changeParam.pu16IntraDcDeltaRate = ParaChagCfg.waveCfg.pu16IntraDcDeltaRate;
|
|
changeParam.pu16IntraAngleDeltaRate = ParaChagCfg.waveCfg.pu16IntraAngleDeltaRate;
|
|
changeParam.pu32IntraPlanarDeltaRate = ParaChagCfg.waveCfg.pu32IntraPlanarDeltaRate;
|
|
changeParam.pu32IntraDcDeltaRate = ParaChagCfg.waveCfg.pu32IntraDcDeltaRate;
|
|
changeParam.pu32IntraAngleDeltaRate = ParaChagCfg.waveCfg.pu32IntraAngleDeltaRate;
|
|
changeParam.cu08IntraDeltaRate = ParaChagCfg.waveCfg.cu08IntraDeltaRate;
|
|
changeParam.cu08InterDeltaRate = ParaChagCfg.waveCfg.cu08InterDeltaRate;
|
|
changeParam.cu08MergeDeltaRate = ParaChagCfg.waveCfg.cu08MergeDeltaRate;
|
|
changeParam.cu16IntraDeltaRate = ParaChagCfg.waveCfg.cu16IntraDeltaRate;
|
|
changeParam.cu16InterDeltaRate = ParaChagCfg.waveCfg.cu16InterDeltaRate;
|
|
changeParam.cu16MergeDeltaRate = ParaChagCfg.waveCfg.cu16MergeDeltaRate;
|
|
changeParam.cu32IntraDeltaRate = ParaChagCfg.waveCfg.cu32IntraDeltaRate;
|
|
changeParam.cu32InterDeltaRate = ParaChagCfg.waveCfg.cu32InterDeltaRate;
|
|
changeParam.cu32MergeDeltaRate = ParaChagCfg.waveCfg.cu32MergeDeltaRate;
|
|
}
|
|
|
|
if (changeParam.enable_option & ENC_SET_CHANGE_PARAM_INTRA_PARAM) {
|
|
changeParam.intraQP = ParaChagCfg.waveCfg.intraQP;
|
|
changeParam.intraPeriod = ParaChagCfg.waveCfg.intraPeriod;
|
|
changeParam.avcIdrPeriod = ParaChagCfg.waveCfg.idrPeriod;
|
|
changeParam.forcedIdrHeaderEnable = ParaChagCfg.waveCfg.forcedIdrHeaderEnable;
|
|
}
|
|
ret = VPU_EncGiveCommand(handle, ENC_SET_PARA_CHANGE, &changeParam);
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL GetBitstreamToBuffer(
|
|
EncHandle handle,
|
|
Uint8* pBuffer,
|
|
PhysicalAddress rdAddr,
|
|
PhysicalAddress wrAddr,
|
|
PhysicalAddress streamBufStartAddr,
|
|
PhysicalAddress streamBufEndAddr,
|
|
Uint32 streamSize,
|
|
EndianMode endian,
|
|
BOOL ringbufferEnabled
|
|
)
|
|
{
|
|
Int32 coreIdx = -1;
|
|
Uint32 room = 0;
|
|
|
|
if (NULL == handle) {
|
|
VLOG(ERR, "<%s:%d> NULL point exception\n", __FUNCTION__, __LINE__);
|
|
return FALSE;
|
|
}
|
|
|
|
coreIdx = VPU_HANDLE_CORE_INDEX(handle);
|
|
|
|
if (0 == streamBufStartAddr || 0 == streamBufEndAddr) {
|
|
VLOG(ERR, "<%s:%d> Wrong Address, start or end Addr\n", __FUNCTION__, __LINE__);
|
|
return FALSE;
|
|
} else if (0 == rdAddr || 0 == wrAddr) {
|
|
VLOG(ERR, "<%s:%d> Wrong Address, read or write Addr\n", __FUNCTION__, __LINE__);
|
|
return FALSE;
|
|
}
|
|
|
|
if (TRUE == ringbufferEnabled) {
|
|
if ((rdAddr + streamSize) > streamBufEndAddr) {
|
|
//wrap around on ringbuffer
|
|
room = streamBufEndAddr - rdAddr;
|
|
vdi_read_memory(coreIdx, rdAddr, pBuffer, room, endian);
|
|
vdi_read_memory(coreIdx, streamBufStartAddr, pBuffer + room, (streamSize-room), endian);
|
|
}
|
|
else {
|
|
vdi_read_memory(coreIdx, rdAddr, pBuffer, streamSize, endian);
|
|
}
|
|
} else { //Line buffer
|
|
vdi_read_memory(coreIdx, rdAddr, pBuffer, streamSize, endian);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
typedef struct CommandLineArgument{
|
|
int argc;
|
|
char **argv;
|
|
}CommandLineArgument;
|
|
|
|
CODEC_ERR_STATE nc_init_encoder(ENCParameter *get_param)
|
|
{
|
|
const char* fwPath = NULL;
|
|
TestEncConfig testConfig;
|
|
Uint32 sizeInWord;
|
|
Uint16* pusBitCode;
|
|
|
|
mq_unlink(MQ_NAME_DATA_TO_ENCODE);
|
|
|
|
osal_memset(&enc_config, 0x00, sizeof(CNMComponentConfig));
|
|
|
|
SetDefaultEncTestConfig(&testConfig);
|
|
|
|
testConfig.stdMode = (CodStd)get_param->enc_codec_type;
|
|
testConfig.productId = (ProductId)VPU_GetProductId(testConfig.coreIdx);
|
|
|
|
if(testConfig.productId == PRODUCT_ID_521) {
|
|
fwPath = getenv("VIDEO_CODEC_FIRMWARE_FILE");
|
|
nc_trim((char*)fwPath);
|
|
if(fwPath == NULL || fwPath[0] == '\0') {
|
|
fwPath = CORE_6_BIT_CODE_FILE_PATH;
|
|
}
|
|
} else {
|
|
VLOG(ERR, "Unknown product id: %d\n", testConfig.productId);
|
|
return ERR_ENC_INVALID_PRODUCT_ID;
|
|
}
|
|
|
|
if (LoadFirmware(testConfig.productId, (Uint8**)&pusBitCode, &sizeInWord, fwPath) < 0) {
|
|
VLOG(ERR, "Failed to load firmware: %s\n", fwPath);
|
|
return ERR_ENC_LOAD_FIRMWARE;
|
|
}
|
|
|
|
enc_config.testEncConfig = testConfig;
|
|
enc_config.bitcode = (Uint8*)pusBitCode;
|
|
enc_config.sizeOfBitcode = sizeInWord;
|
|
enc_config.testEncConfig.subFrameSyncMode = REGISTER_BASE_SUB_FRAME_SYNC;
|
|
|
|
if (SetupEncoderOpenParam(&enc_config.encOpenParam, &enc_config.testEncConfig, NULL, get_param) == FALSE) {
|
|
VLOG(ERR, "SetupEncoderOpenParam error\n");
|
|
return ERR_ENC_INVALID_PARAM;
|
|
}
|
|
|
|
return CODEC_SUCCESS;
|
|
}
|
|
|
|
CODEC_ERR_STATE nc_start_encoder(void)
|
|
{
|
|
int ret;
|
|
CNMTask task;
|
|
Component yuvFeeder;
|
|
Component encoder;
|
|
Component reader;
|
|
EncListenerContext lsnCtx;
|
|
|
|
CNMAppInit();
|
|
|
|
task = CNMTaskCreate();
|
|
yuvFeeder = ComponentCreate("yuvfeeder", &enc_config);
|
|
encoder = ComponentCreate("wave_encoder", &enc_config);
|
|
reader = ComponentCreate("reader", &enc_config);
|
|
|
|
CNMTaskAdd(task, yuvFeeder);
|
|
CNMTaskAdd(task, encoder);
|
|
CNMTaskAdd(task, reader);
|
|
CNMAppAdd(task);
|
|
|
|
if ((ret=SetupEncListenerContext(&lsnCtx, &enc_config)) == TRUE) {
|
|
ComponentRegisterListener(encoder, COMPONENT_EVENT_ENC_ALL, EncoderListener, (void*)&lsnCtx);
|
|
if(!CNMAppRun()) {
|
|
VLOG(ERR, "Fail to create encoder pipeline\n");
|
|
return ERR_ENC_CREATE_PIPELINE;
|
|
}
|
|
}
|
|
else {
|
|
CNMAppStop();
|
|
VLOG(ERR, "Fail to create event listner\n");
|
|
return ERR_ENC_CREATE_EVENT_LISTNER;
|
|
}
|
|
|
|
osal_free(enc_config.bitcode);
|
|
ClearEncListenerContext(&lsnCtx);
|
|
|
|
return CODEC_SUCCESS;
|
|
}
|
|
|
|
CODEC_ERR_STATE nc_send_buf_to_encode(Uint8 *ptr_video_buf, int32 auto_free)
|
|
{
|
|
CODEC_ERR_STATE ret = CODEC_SUCCESS;
|
|
struct mq_attr attr;
|
|
attr.mq_maxmsg = MAX_MQ_SIZE_ENC;
|
|
attr.mq_msgsize = sizeof(Uint8*);
|
|
int oflag = O_WRONLY | O_CREAT;
|
|
|
|
auto_free_data_for_encode = auto_free;
|
|
|
|
mqd_t mfd = mq_open(MQ_NAME_DATA_TO_ENCODE, oflag, 0666, &attr);
|
|
if (mfd == -1) {
|
|
perror("mq open error");
|
|
return ERR_ENC_FAIL_TO_OPEN;
|
|
}
|
|
|
|
if ((mq_send(mfd, (const char *)&ptr_video_buf, attr.mq_msgsize, 1)) == -1) {
|
|
ret = ERR_ENC_SEND_BUF;
|
|
printf("errno of mq_send = %d\n", errno);
|
|
}
|
|
mq_close(mfd);
|
|
|
|
return ret;
|
|
}
|
|
|
|
CODEC_ERR_STATE nc_receive_buf_to_encode(Uint8 **out_video_buf, int32 *auto_free)
|
|
{
|
|
CODEC_ERR_STATE ret = CODEC_SUCCESS;
|
|
struct mq_attr attr;
|
|
attr.mq_maxmsg = MAX_MQ_SIZE_ENC;
|
|
attr.mq_msgsize = sizeof(Uint8 *);
|
|
int oflag = O_RDONLY | O_CREAT;
|
|
|
|
mqd_t mfd = mq_open(MQ_NAME_DATA_TO_ENCODE, oflag, 0666, &attr);
|
|
if (mfd == -1) {
|
|
perror("mq open error");
|
|
return ERR_ENC_FAIL_TO_OPEN;
|
|
}
|
|
|
|
*auto_free = auto_free_data_for_encode;
|
|
|
|
if (((int)mq_receive(mfd, (char*)out_video_buf, attr.mq_msgsize, NULL)) == -1) {
|
|
ret = ERR_ENC_RECEIVE_BUF;
|
|
printf("errno of mq_receive = %d\n", errno);
|
|
}
|
|
mq_close(mfd);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void nc_stop_encoder(void)
|
|
{
|
|
CNMAppStop();
|
|
}
|
|
|
|
static BOOL CheckDecConfig(TestDecConfig testConfig)
|
|
{
|
|
BOOL isValidParameters = TRUE;
|
|
|
|
/* Check parameters */
|
|
if (testConfig.skipMode < 0 || testConfig.skipMode == 3 || testConfig.skipMode > 4) {
|
|
VLOG(ERR, "Invalid skip mode: %d\n", testConfig.skipMode);
|
|
isValidParameters = FALSE;
|
|
}
|
|
if ((FORMAT_422 < testConfig.wtlFormat && testConfig.wtlFormat <= FORMAT_400) ||
|
|
testConfig.wtlFormat < FORMAT_420 || testConfig.wtlFormat >= FORMAT_MAX) {
|
|
VLOG(ERR, "Invalid WTL format(%d)\n", testConfig.wtlFormat);
|
|
isValidParameters = FALSE;
|
|
}
|
|
if (isValidParameters == TRUE && (testConfig.scaleDownWidth > 0 || testConfig.scaleDownHeight > 0)) {
|
|
}
|
|
if (testConfig.renderType < RENDER_DEVICE_NULL || testConfig.renderType >= RENDER_DEVICE_MAX) {
|
|
VLOG(ERR, "unknown render device type(%d)\n", testConfig.renderType);
|
|
isValidParameters = FALSE;
|
|
}
|
|
if (testConfig.thumbnailMode == TRUE && testConfig.skipMode != 0) {
|
|
VLOG(ERR, "Turn off thumbnail mode or skip mode\n");
|
|
isValidParameters = FALSE;
|
|
}
|
|
|
|
if (STD_AVC == testConfig.bitFormat || STD_AV1 == testConfig.bitFormat) {
|
|
isValidParameters = (testConfig.secondaryAXI&0x04) ? FALSE : TRUE;
|
|
if (!isValidParameters) {
|
|
VLOG(ERR, "AVC/AV1 do not support tBPU secondary AXI. \n");
|
|
}
|
|
}
|
|
|
|
return isValidParameters;
|
|
}
|
|
|
|
CODEC_ERR_STATE nc_init_decoder(DECParameter *get_param)
|
|
{
|
|
const char* fwPath = NULL;
|
|
TestDecConfig testConfig;
|
|
Uint32 sizeInWord;
|
|
Uint16* pusBitCode;
|
|
BOOL ret;
|
|
|
|
mq_unlink(MQ_NAME_DATA_TO_DECODE);
|
|
|
|
osal_memset(&dec_config, 0x00, sizeof(CNMComponentConfig));
|
|
|
|
SetDefaultDecTestConfig(&testConfig);
|
|
|
|
testConfig.bitFormat = (CodStd)get_param->dec_codec_type;
|
|
testConfig.fps = get_param->dec_framerate;
|
|
|
|
if (CheckDecConfig(testConfig) == FALSE) {
|
|
VLOG(ERR, "fail to CheckDecConfig()\n");
|
|
return ERR_DEC_INVALID_PARAM;
|
|
}
|
|
|
|
testConfig.productId = (ProductId)VPU_GetProductId(testConfig.coreIdx);
|
|
|
|
if(testConfig.productId == PRODUCT_ID_521) {
|
|
fwPath = getenv("VIDEO_CODEC_FIRMWARE_FILE");
|
|
nc_trim((char*)fwPath);
|
|
if(fwPath == NULL || fwPath[0] == '\0') {
|
|
fwPath = CORE_6_BIT_CODE_FILE_PATH;
|
|
}
|
|
} else {
|
|
VLOG(ERR, "Unknown product id: %d\n", testConfig.productId);
|
|
return ERR_DEC_INVALID_PRODUCT_ID;
|
|
}
|
|
|
|
if (LoadFirmware(testConfig.productId, (Uint8**)&pusBitCode, &sizeInWord, fwPath) < 0) {
|
|
VLOG(ERR, "Failed to load firmware: %s\n", fwPath);
|
|
return ERR_DEC_LOAD_FIRMWARE;
|
|
}
|
|
|
|
dec_config.testDecConfig = testConfig;
|
|
dec_config.bitcode = (Uint8*)pusBitCode;
|
|
dec_config.sizeOfBitcode = sizeInWord;
|
|
|
|
printf("\n==================================================\n");
|
|
printf(" DEC CONFIGURATION\n");
|
|
printf("\n dec_framerate : %d\n",
|
|
testConfig.fps
|
|
);
|
|
printf("==================================================\n");
|
|
|
|
if (RETCODE_SUCCESS != (ret=SetUpDecoderOpenParam(&(dec_config.decOpenParam), &(dec_config.testDecConfig)))) {
|
|
VLOG(ERR, "SetUpDecoderOpenParam failed Error code is 0x%x \n", ret);
|
|
return ERR_DEC_INVALID_PARAM;
|
|
}
|
|
|
|
return CODEC_SUCCESS;
|
|
}
|
|
|
|
CODEC_ERR_STATE nc_start_decoder(void)
|
|
{
|
|
CNMTask task;
|
|
Component feeder;
|
|
Component decoder;
|
|
Component renderer;
|
|
BOOL ret;
|
|
DecListenerContext lsnCtx;
|
|
|
|
CNMAppInit();
|
|
|
|
task = CNMTaskCreate();
|
|
feeder = ComponentCreate("feeder", &dec_config);
|
|
decoder = ComponentCreate("wave_decoder", &dec_config);
|
|
renderer = ComponentCreate("renderer", &dec_config);
|
|
|
|
CNMTaskAdd(task, feeder);
|
|
CNMTaskAdd(task, decoder);
|
|
CNMTaskAdd(task, renderer);
|
|
CNMAppAdd(task);
|
|
|
|
if ((ret=SetupDecListenerContext(&lsnCtx, &dec_config, renderer)) == TRUE) {
|
|
ComponentRegisterListener(decoder, COMPONENT_EVENT_DEC_ALL, DecoderListener, (void*)&lsnCtx);
|
|
if(!CNMAppRun()) {
|
|
VLOG(ERR, "Fail to create decoder pipeline\n");
|
|
return ERR_DEC_CREATE_PIPELINE;
|
|
}
|
|
}
|
|
else {
|
|
CNMAppStop();
|
|
VLOG(ERR, "Fail to create event listner\n");
|
|
return ERR_DEC_CREATE_EVENT_LISTNER;
|
|
}
|
|
|
|
osal_free(dec_config.bitcode);
|
|
ClearDecListenerContext(&lsnCtx);
|
|
|
|
return CODEC_SUCCESS;
|
|
}
|
|
|
|
void nc_stop_decoder(void)
|
|
{
|
|
CNMAppStop();
|
|
}
|
|
|
|
void nc_display_libncvcodec_info(void)
|
|
{
|
|
printf("\n================================================== \n");
|
|
printf(" Nextchip Video CODEC library info \n\n");
|
|
printf(" Build Date : %s %s \n", APP_BUILD_DATE, APP_BUILD_TIME);
|
|
printf(" Library Version : ver.%02d.%02d.%02d \n", APP_VER_MAJOR, APP_VER_MINOR1, APP_VER_MINOR2);
|
|
printf(" Git Hash : %s \n", GIT_HEAD_HASH);
|
|
printf("================================================== \n");
|
|
}
|
|
|
|
CODEC_ERR_STATE nc_send_buf_to_decode(Uint8 *ptr_video_buf, Uint32 size, Int32 end_of_file, Int32 auto_free)
|
|
{
|
|
DECODED_DATA *get_decode_data;
|
|
|
|
CODEC_ERR_STATE ret = CODEC_SUCCESS;
|
|
struct mq_attr attr;
|
|
attr.mq_maxmsg = MAX_MQ_SIZE_DEC;
|
|
attr.mq_msgsize = sizeof(DECODED_DATA*);
|
|
int oflag = O_WRONLY | O_CREAT;
|
|
|
|
auto_free_data_for_decode = auto_free;
|
|
|
|
get_decode_data = (DECODED_DATA*)malloc(sizeof(DECODED_DATA));
|
|
|
|
get_decode_data->ptr_decoded_buf = ptr_video_buf;
|
|
get_decode_data->size = size;
|
|
get_decode_data->end_of_file = end_of_file;
|
|
|
|
mqd_t mfd = mq_open(MQ_NAME_DATA_TO_DECODE, oflag, 0666, &attr);
|
|
if (mfd == -1) {
|
|
perror("mq open error");
|
|
return ERR_DEC_FAIL_TO_OPEN;
|
|
}
|
|
|
|
if ((mq_send(mfd, (const char *)&get_decode_data, attr.mq_msgsize, 1)) == -1) {
|
|
ret = ERR_DEC_SEND_BUF;
|
|
printf("############# errno of mq_send = %d\n", errno);
|
|
}
|
|
mq_close(mfd);
|
|
|
|
return ret;
|
|
}
|
|
|
|
CODEC_ERR_STATE nc_receive_buf_to_decode(DECODED_DATA **out_video_buf, int32 *auto_free)
|
|
{
|
|
CODEC_ERR_STATE ret = CODEC_SUCCESS;
|
|
struct mq_attr attr;
|
|
attr.mq_maxmsg = MAX_MQ_SIZE_DEC;
|
|
attr.mq_msgsize = sizeof(DECODED_DATA *);
|
|
int oflag = O_RDONLY | O_CREAT;
|
|
|
|
mqd_t mfd = mq_open(MQ_NAME_DATA_TO_DECODE, oflag, 0666, &attr);
|
|
if (mfd == -1) {
|
|
perror("mq open error");
|
|
return ERR_DEC_FAIL_TO_OPEN;
|
|
}
|
|
|
|
*auto_free = auto_free_data_for_decode;
|
|
|
|
if (((int)mq_receive(mfd, (char*)out_video_buf, attr.mq_msgsize, NULL)) == -1) {
|
|
ret = ERR_DEC_RECEIVE_BUF;
|
|
printf("errno of mq_receive = %d\n", errno);
|
|
}
|
|
|
|
mq_close(mfd);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void nc_lock_encoding_done(void)
|
|
{
|
|
pthread_mutex_lock(&encoded_lock);
|
|
}
|
|
|
|
void nc_unlock_encoding_done(void)
|
|
{
|
|
pthread_mutex_unlock(&encoded_lock);
|
|
} |