DvevmStRetCode
dvtb_vc1Dec2Control(DvevmStVC1Dec2Info *vd)
{
int status = -1, i = 0;
DvevmStRetCode retCode = DVEVM_ST_SUCCESS;
ASSERT(vd != NULL);
ASSERT((VIDDEC2_Handle) vd->vdec2Hdl != NULL);
vd->vdec2Status.viddecStatus.data.buf = NULL;
status = VIDDEC2_control((VIDDEC2_Handle) vd->vdec2Hdl, vd->vdec2Cmd, (VIDDEC2_DynamicParams *) &vd->vdec2DynParams, (VIDDEC2_Status *) &vd->vdec2Status);
if (VIDDEC2_EOK != status)
{
SYS_ERROR("Video Decode Control failed (%d)\n", status);
SYS_ERROR("Video Decode Extended Error(in Hex) (%x)\n", (int)vd->vdec2Status.viddecStatus.extendedError);
retCode = DVEVM_ST_FAIL;
}
else
{
SYS_DEBUG("Video Decode Control => Command : %d\n", vd->vdec2Cmd);
if (XDM_GETBUFINFO == vd->vdec2Cmd)
{
vd->inBuf.numBufs = vd->vdec2Status.viddecStatus.bufInfo.minNumInBufs;
vd->outBuf.numBufs = vd->vdec2Status.viddecStatus.bufInfo.minNumOutBufs;
for (i = 0; i < vd->inBuf.numBufs; i++)
{
vd->inBuf.bufSizes[i] = vd->vdec2Status.viddecStatus.bufInfo.minInBufSize[i];
}
for (i = 0; i < vd->outBuf.numBufs; i++)
{
vd->outBuf.bufSizes[i] = vd->vdec2Status.viddecStatus.bufInfo.minOutBufSize[i];
}
}
}
return retCode;
}
/*
* ======== encode_decode ========
*/
static Void encode_decode(VIDENC1_Handle enc, VIDDEC2_Handle dec, FILE *in,
FILE *out)
{
Int n;
Int32 status;
VIDDEC2_InArgs decInArgs;
VIDDEC2_OutArgs decOutArgs;
VIDDEC2_DynamicParams decDynParams;
VIDDEC2_Status decStatus;
VIDENC1_InArgs encInArgs;
VIDENC1_OutArgs encOutArgs;
VIDENC1_DynamicParams encDynParams;
VIDENC1_Status encStatus;
IVIDEO1_BufDescIn encInBufDesc;
XDM_BufDesc encOutBufDesc;
XDAS_Int8 *encoded[XDM_MAX_IO_BUFFERS];
XDAS_Int32 encBufSizes[XDM_MAX_IO_BUFFERS];
XDM1_BufDesc decInBufDesc;
XDM_BufDesc decOutBufDesc;
XDAS_Int8 *dst[XDM_MAX_IO_BUFFERS];
XDAS_Int32 outBufSizes[XDM_MAX_IO_BUFFERS];
/* clear and initialize the buffer descriptors */
memset(encoded, 0, sizeof(encoded[0]) * XDM_MAX_IO_BUFFERS);
memset(dst, 0, sizeof(dst[0]) * XDM_MAX_IO_BUFFERS);
encoded[0] = encodedBuf;
dst[0] = outBuf;
encInBufDesc.numBufs = encOutBufDesc.numBufs = decInBufDesc.numBufs =
decOutBufDesc.numBufs = 1;
encOutBufDesc.bufSizes = encBufSizes;
decOutBufDesc.bufSizes = outBufSizes;
encInBufDesc.bufDesc[0].bufSize = encBufSizes[0] =
decInBufDesc.descs[0].bufSize = outBufSizes[0] = NSAMPLES;
encInBufDesc.bufDesc[0].buf = inBuf;
encOutBufDesc.bufs = encoded;
decInBufDesc.descs[0].buf = encoded[0];
decOutBufDesc.bufs = dst;
encInBufDesc.frameWidth = 0; /* TODO */
encInBufDesc.frameHeight = 0; /* TODO */
encInBufDesc.framePitch = 0; /* TODO */
/* initialize all "sized" fields */
encInArgs.size = sizeof(encInArgs);
decInArgs.size = sizeof(decInArgs);
encOutArgs.size = sizeof(encOutArgs);
decOutArgs.size = sizeof(decOutArgs);
encDynParams.size = sizeof(encDynParams);
decDynParams.size = sizeof(decDynParams);
encStatus.size = sizeof(encStatus);
decStatus.size = sizeof(decStatus);
/*
* Note that we use versionBuf in both the encoder and decoder. In this
* application, this is okay, as there is always only one user of
* the buffer. Not all applications can make this assumption.
*/
encStatus.data.buf = decStatus.data.buf = versionBuf;
encStatus.data.bufSize = decStatus.data.bufSize = MAXVERSIONSIZE;
/* if the codecs support it, dump their versions */
status = VIDDEC2_control(dec, XDM_GETVERSION, &decDynParams, &decStatus);
Log_print1(Diags_USER1, "[+1] Decoder version: %s",
(IArg)((status == VIDDEC2_EOK ? ((char *)decStatus.data.buf) :
"[unknown]")));
status = VIDENC1_control(enc, XDM_GETVERSION, &encDynParams, &encStatus);
Log_print1(Diags_USER1, "[+1] Encoder version: %s",
(IArg)((status == VIDENC1_EOK ? ((char *)encStatus.data.buf) :
"[unknown]")));
/*
* This app expects the encoder to provide 1 buf in and get 1 buf out,
* and the buf sizes of the in and out buffer must be able to handle
* NSAMPLES bytes of data.
*/
status = VIDENC1_control(enc, XDM_GETSTATUS, &encDynParams, &encStatus);
if (status != VIDENC1_EOK) {
/* failure, report error and exit */
Log_print1(Diags_USER7, "[+7] encode control status = %ld",
(IArg)status);
return;
}
/* Validate this encoder codec will meet our buffer requirements */
if ((encInBufDesc.numBufs < encStatus.bufInfo.minNumInBufs) ||
(IFRAMESIZE < encStatus.bufInfo.minInBufSize[0]) ||
(encOutBufDesc.numBufs < encStatus.bufInfo.minNumOutBufs) ||
(EFRAMESIZE < encStatus.bufInfo.minOutBufSize[0])) {
/* failure, report error and exit */
Log_print0(Diags_USER7, "[+7] Error: encoder codec feature conflict");
return;
}
status = VIDDEC2_control(dec, XDM_GETSTATUS, &decDynParams, &decStatus);
if (status != VIDDEC2_EOK) {
/* failure, report error and exit */
Log_print1(Diags_USER7, "[+7] decode control status = %ld",
(IArg)status);
return;
}
/* Validate this decoder codec will meet our buffer requirements */
if ((decInBufDesc.numBufs < decStatus.bufInfo.minNumInBufs) ||
(EFRAMESIZE < decStatus.bufInfo.minInBufSize[0]) ||
(decOutBufDesc.numBufs < decStatus.bufInfo.minNumOutBufs) ||
(OFRAMESIZE < decStatus.bufInfo.minOutBufSize[0])) {
/* failure, report error and exit */
Log_print0(Diags_USER7,
"[+7] App-> ERROR: decoder does not meet buffer requirements.");
return;
}
/*
* Read complete frames from in, encode, decode, and write to out.
*/
for (n = 0; fread(inBuf, IFRAMESIZE, 1, in) == 1; n++) {
#ifdef CACHE_ENABLED
#if defined(xdc_target__isaCompatible_64P) || \
defined(xdc_target__isaCompatible_64T)
/*
* fread() on this processor is implemented using CCS's stdio, which
* is known to write into the cache, not physical memory. To meet
* XDAIS DMA Rule 7, we must writeback the cache into physical
* memory. Also, per DMA Rule 7, we must invalidate the buffer's
* cache before providing it to any xDAIS algorithm.
*/
Memory_cacheWbInv(inBuf, IFRAMESIZE);
#else
#error Unvalidated config - add appropriate fread-related cache maintenance
#endif
/* Per DMA Rule 7, our output buffer cache lines must be cleaned */
Memory_cacheInv(encodedBuf, EFRAMESIZE);
#endif
Log_print1(Diags_USER1, "[+1] App-> Processing frame %d...", (IArg)n);
/*
* Encode the frame.
*
* Note, inputID == 0 is an error. This example doesn't account
* for the case where 'n + 1' wraps to zero.
*/
encInArgs.inputID = n + 1;
status = VIDENC1_process(enc, &encInBufDesc, &encOutBufDesc, &encInArgs,
&encOutArgs);
Log_print2(Diags_USER2,
"[+2] App-> Encoder frame %d process returned - 0x%x)",
(IArg)n, (IArg)status);
if (status != VIDENC1_EOK) {
Log_print3(Diags_USER7,
"[+7] App-> Encoder frame %d processing FAILED, status = 0x%x, "
"extendedError = 0x%x",
(IArg)n, (IArg)status, (IArg)(encOutArgs.extendedError));
break;
}
/*
* So far, so good. Validate our assumption that the encoder
* provided encodedBuf as it's encOutArgs->encodedBuf.buf. If
* that's not the case, we may be dealing with a codec that's
* giving us out of order frames... and this simple app
* doesn't support that.
*/
if (encOutArgs.encodedBuf.buf != encodedBuf) {
Log_print0(Diags_USER7,
"[+7] App-> Internal error. Unsupported encoder");
break;
}
#ifdef CACHE_ENABLED
/*
* Conditionally writeback the encoded buf from the previous
* call. Also, as encodedBuf is an inBuf to the next process
* call, conditionally invalidate it as well.
*/
if (XDM_ISACCESSMODE_WRITE(encOutArgs.encodedBuf.accessMask)) {
Memory_cacheWbInv(encodedBuf, EFRAMESIZE);
}
/*
* Per DMA Rule 7, our output buffer cache lines (for the
* upcoming decoder) must be cleaned.
*/
Memory_cacheInv(outBuf, OFRAMESIZE);
#endif
/* decode the frame */
decInArgs.numBytes = EFRAMESIZE;
decInArgs.inputID = 1; /* typically this varies by each frame */
status = VIDDEC2_process(dec, &decInBufDesc, &decOutBufDesc,
&decInArgs, &decOutArgs);
Log_print2(Diags_USER2,
"[+2] App-> Decoder frame %d process returned - 0x%x)",
(IArg)n, (IArg)status);
if (status != VIDDEC2_EOK) {
Log_print2(Diags_USER7,
"[+7] App-> Decoder frame %d processing FAILED, status ="
" 0x%x", (IArg)n, (IArg)status);
break;
}
/* again, validate our assumption that we don't get out-of-order bufs */
if (decOutArgs.decodedBufs.bufDesc[0].buf != outBuf) {
Log_print0(Diags_USER7,
"[+7] App-> Internal error. Unsupported decoder");
break;
}
#ifdef CACHE_ENABLED
/* Conditionally writeback the decoded buf */
if (XDM_ISACCESSMODE_WRITE(
decOutArgs.decodedBufs.bufDesc[0].accessMask)) {
Memory_cacheWb(outBuf, OFRAMESIZE);
}
#endif
/* write to file */
fwrite(dst[0], OFRAMESIZE, 1, out);
}
Log_print1(Diags_USER1, "[+1] %d frames encoded/decoded", (IArg)n);
}
DvevmStRetCode
dvtb_h264Dec2Control(DvevmStH264Dec2Info *vd)
{
int status = -1, i = 0;
DvevmStRetCode retCode = DVEVM_ST_SUCCESS;
ASSERT(vd != NULL);
ASSERT(vd->vdec2Hdl != NULL);
vd->vdec2Status.viddecStatus.data.buf = NULL;
status = VIDDEC2_control(vd->vdec2Hdl, vd->vdec2Cmd,(VIDDEC2_DynamicParams *)&vd->vdec2DynParams,(VIDDEC2_Status *)&vd->vdec2Status);
if (VIDDEC2_EOK != status)
{
SYS_ERROR("Video Decode Control failed (%d)\n", status);
retCode = DVEVM_ST_FAIL;
}
else
{
SYS_DEBUG("Video Decode Control => Command : %d\n", vd->vdec2Cmd);
if (XDM_GETBUFINFO == vd->vdec2Cmd)
{
do
{
vd->inBuf.numBufs = vd->vdec2Status.viddecStatus.bufInfo.minNumInBufs;
for (i = 0; i < vd->inBuf.numBufs; i++)
vd->inBuf.bufSizes[i] = vd->vdec2Status.viddecStatus.bufInfo.minInBufSize[i];
#if 1
if(vd->vdec2DynParams.Sei_Vui_parse_flag)
{
vd->vdec2Status.viddecStatus.bufInfo.minNumOutBufs -= 1;
// vd->vdec2Status.viddecStatus.bufInfo.minOutBufSize[vd->vdec2Status.viddecStatus.bufInfo.minNumOutBufs] = 0;
if(DVEVM_ST_FAIL == dvtb_allocSingleBufCmem((char **)&vd->sei_vui_buffer,sizeof(sSeiVuiParams_t)) )
{
SYS_ERROR("Unable to allocate memory for sei_vui_buffer of size %d \n",sizeof(sSeiVuiParams_t));
retCode = DVEVM_ST_FAIL;
break;
}
memset(vd->sei_vui_buffer, 0x00, sizeof(sSeiVuiParams_t));
}
#else
if(vd->vdec2DynParams.Sei_Vui_parse_flag)
{
vd->vdec2Status.viddecStatus.bufInfo.minOutBufSize[vd->vdec2Status.viddecStatus.bufInfo.minNumOutBufs-1] = sizeof(sSeiVuiParams_t);
}
#endif
vd->outBuf.numBufs = vd->vdec2Status.viddecStatus.bufInfo.minNumOutBufs;
for (i = 0; i < vd->outBuf.numBufs; i++)
{
vd->outBuf.bufSizes[i] = vd->vdec2Status.viddecStatus.bufInfo.minOutBufSize[i];
}
dvtb_h264Dec2ControlDebug(&vd->vdec2Status);
}while(0);
}
}
return retCode;
}
