DvevmStRetCode
dvtb_deInterEncode(DvevmStDeInterInfo *deinter, int* encDuration)
{
XDAS_Int32 status = -1;
int i = 0;
DvevmStTime timeStmpBfrEnc, timeStmpAftrEnc;
DvevmStRetCode retCode = DVEVM_ST_SUCCESS;
XDM1_BufDesc inBufDesc;
XDM1_BufDesc outBufDesc;
ASSERT(deinter != NULL);
ASSERT(deinter->ceHdl != NULL);
ASSERT(deinter->deinterHdl != NULL);
ASSERT(deinter->inBuf.numBufs > 0);
ASSERT(deinter->inBuf.numBufs > 0);
outBufDesc.numBufs = deinter->outBuf.numBufs;
for(i = 0 ; i < outBufDesc.numBufs; i++)
{
outBufDesc.descs[i].bufSize = deinter->outBuf.bufSizes[i];
outBufDesc.descs[i].buf = (XDAS_Int8 *)deinter->outBuf.bufs[i];
}
inBufDesc.numBufs = deinter->inBuf.numBufs;
for(i = 0 ; i < inBufDesc.numBufs; i++)
{
inBufDesc.descs[i].bufSize = deinter->inBuf.bufSizes[i];
inBufDesc.descs[i].buf = (XDAS_Int8 *) deinter->inBuf.bufs[i];
}
timeStmpBfrEnc = dvtb_getTime();
status = UNIVERSAL_process(deinter->deinterHdl, &inBufDesc, &outBufDesc, NULL, (UNIVERSAL_InArgs *)&deinter->deinterInArgs, (UNIVERSAL_OutArgs *)&deinter->deinterOutArgs);
timeStmpAftrEnc = dvtb_getTime();
*encDuration = ((timeStmpAftrEnc.tv_sec * NUM_MICROSECS_IN_SEC) + timeStmpAftrEnc.tv_usec) - ((timeStmpBfrEnc.tv_sec * NUM_MICROSECS_IN_SEC) + timeStmpBfrEnc.tv_usec);
if (status != UNIVERSAL_EOK )
{
SYS_ERROR("DeInterlacer Process failed (%d)\n", (int) status);
retCode = DVEVM_ST_FAIL;
}
return retCode;
}
/*
* ======== processLoop ========
*/
static Void processLoop(UNIVERSAL_Handle hUniversal, FILE *in, FILE *out,
XDAS_Int8 *inBuf, XDAS_Int8 *outBuf, XDAS_Int8 *versionBuf)
{
Int n;
Int32 status;
UNIVERSAL_InArgs universalInArgs;
UNIVERSAL_OutArgs universalOutArgs;
UNIVERSAL_DynamicParams universalDynParams;
UNIVERSAL_Status universalStatus;
XDM1_BufDesc universalInBufDesc;
XDM1_BufDesc universalOutBufDesc;
/* initialize bufDescs */
universalInBufDesc.numBufs = universalOutBufDesc.numBufs = 1;
universalInBufDesc.descs[0].bufSize = universalOutBufDesc.descs[0].bufSize =
NSAMPLES;
universalInBufDesc.descs[0].buf = inBuf;
universalOutBufDesc.descs[0].buf = outBuf;
/* initialize all "sized" fields */
universalInArgs.size = sizeof(universalInArgs);
universalOutArgs.size = sizeof(universalOutArgs);
universalDynParams.size = sizeof(universalDynParams);
universalStatus.size = sizeof(universalStatus);
/* if the codecs support it, dump their versions */
universalStatus.data.numBufs = 1;
universalStatus.data.descs[0].buf = versionBuf;
universalStatus.data.descs[0].bufSize = MAXVERSIONSIZE;
universalStatus.data.descs[1].buf = NULL;
#ifdef CACHE_ENABLED
/* invalidate versionBuf it before the alg fills it */
Memory_cacheInv(versionBuf, MAXVERSIONSIZE);
#endif
status = UNIVERSAL_control(hUniversal, XDM_GETVERSION, &universalDynParams,
&universalStatus);
Log_print1(Diags_USER1, "[+1] Alg version: %s",
(IArg)((status == UNIVERSAL_EOK ?
((char *)universalStatus.data.descs[0].buf) : "[unknown]")));
/*
* Read complete frames from in, process them, 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(outBuf, OFRAMESIZE);
#endif
Log_print1(Diags_USER1, "[+1] App-> Processing frame %d...", (IArg)n);
/*
* Transcode the frame.
*
* Note, inputID == 0 is an error. This example doesn't account
* for the case where 'n + 1' wraps to zero.
*/
status = UNIVERSAL_process(hUniversal, &universalInBufDesc,
&universalOutBufDesc, NULL, &universalInArgs, &universalOutArgs);
Log_print2(Diags_USER2,
"[+2] App-> Alg frame %d process returned - 0x%x",
(IArg)n, (IArg)status);
if (status != UNIVERSAL_EOK) {
Log_print3(Diags_USER7,
"[+7] App-> Alg frame %d processing FAILED, status = 0x%x, "
"extendedError = 0x%x",
(IArg)n, (IArg)status,
(IArg)(universalOutArgs.extendedError));
break;
}
#ifdef CACHE_ENABLED
/*
* Conditionally writeback the processed buf from the previous
* call. This [pessimistic] writeback illustrates the general
* situation where the subsequent access of outBuf (fwrite(), in
* this case), is not known to be via CPU/cache or DMA/physical mem.
*
* An optimized system, where the access mode of outBufs known,
* may be able to eliminate this writeback.
*/
if (XDM_ISACCESSMODE_WRITE(universalOutBufDesc.descs[0].accessMask)) {
Memory_cacheWb(outBuf, OFRAMESIZE);
}
#endif
/* write to file */
fwrite(outBuf, OFRAMESIZE, 1, out);
}
Log_print1(Diags_USER1, "[+1] %d frames processed", (IArg)n);
}
/*
* ======== call ========
*/
static VISA_Status call(VISA_Handle visaHandle, VISA_Msg visaMsg)
{
_UNIVERSAL_Msg *msg = (_UNIVERSAL_Msg *)visaMsg;
UNIVERSAL_Handle handle = (UNIVERSAL_Handle)visaHandle;
Int i;
XDM1_BufDesc inBufs, *pInBufs = &inBufs;
XDM1_BufDesc outBufs, *pOutBufs = &outBufs;
XDM1_BufDesc inOutBufs, *pInOutBufs = &inOutBufs;
IUNIVERSAL_OutArgs *pOutArgs;
IUNIVERSAL_Status *pStatus;
Int numBufs;
/* perform the requested UNIVERSAL operation by parsing message. */
switch (msg->visa.cmd) {
case _UNIVERSAL_CPROCESS: {
/* unmarshal buffers */
if (msg->cmd.process.inBufs.numBufs == 0) {
pInBufs = NULL;
}
else {
inBufs = msg->cmd.process.inBufs;
if (SKEL_cachingPolicy == SKEL_LOCALBUFFERINVWB) {
/* invalidate cache for all input buffers */
for (i = 0, numBufs = 0; i < XDM_MAX_IO_BUFFERS; i++) {
if (inBufs.descs[i].buf != NULL) {
/* valid member of sparse array, manage it */
Memory_cacheInv(inBufs.descs[i].buf,
inBufs.descs[i].bufSize);
if (++numBufs == inBufs.numBufs) {
break;
}
}
}
}
}
if (msg->cmd.process.outBufs.numBufs == 0) {
pOutBufs = NULL;
}
else {
outBufs = msg->cmd.process.outBufs;
if (SKEL_cachingPolicy == SKEL_LOCALBUFFERINVWB) {
/* invalidate cache for all output buffers */
for (i = 0, numBufs = 0; i < XDM_MAX_IO_BUFFERS; i++) {
if (outBufs.descs[i].buf != NULL) {
/* valid member of sparse array, manage it */
Memory_cacheInv(outBufs.descs[i].buf,
outBufs.descs[i].bufSize);
if (++numBufs == outBufs.numBufs) {
break;
}
}
}
}
}
if (msg->cmd.process.inOutBufs.numBufs == 0) {
pInOutBufs = NULL;
}
else {
inOutBufs = msg->cmd.process.inOutBufs;
if (SKEL_cachingPolicy == SKEL_LOCALBUFFERINVWB) {
/* invalidate cache for all in/out buffers */
for (i = 0, numBufs = 0; i < XDM_MAX_IO_BUFFERS; i++) {
if (inOutBufs.descs[i].buf != NULL) {
/* valid member of sparse array, manage it */
Memory_cacheInv(inOutBufs.descs[i].buf,
inOutBufs.descs[i].bufSize);
if (++numBufs == inOutBufs.numBufs) {
break;
}
}
}
}
}
/* unmarshall outArgs based on the "size" of inArgs */
pOutArgs =
(IUNIVERSAL_OutArgs *)((UInt)(&(msg->cmd.process.inArgs)) +
msg->cmd.process.inArgs.size);
/* make the process call */
msg->visa.status = UNIVERSAL_process(handle,
pInBufs, pOutBufs, pInOutBufs, &(msg->cmd.process.inArgs),
pOutArgs);
if (SKEL_cachingPolicy == SKEL_WBINVALL) {
Memory_cacheWbInvAll();
}
else if (SKEL_cachingPolicy == SKEL_LOCALBUFFERINVWB) {
/* writeback cache for output buffers */
if (pOutBufs != NULL) {
for (i = 0, numBufs = 0; i < XDM_MAX_IO_BUFFERS; i++) {
if (outBufs.descs[i].buf != NULL) {
if (XDM_ISACCESSMODE_WRITE(outBufs.descs[i]
.accessMask)) {
/* valid member of sparse array, written via CPU */
Memory_cacheWb(outBufs.descs[i].buf,
outBufs.descs[i].bufSize);
/*
* Since we've cacheWb this buffer, we arguably
* should reflect this cache state and clear the
* WRITE bit in the .accessMask field. However,
* we know the stub doesn't propogate this field
* to the calling app, so this extra buffer
* management detail isn't necessary:
*
* XDM_CLEARACCESSMODE_WRITE(outBufs.descs[i]
* .accessMask);
*/
}
if (++numBufs == outBufs.numBufs) {
break;
}
}
}
}
if (pInOutBufs != NULL) {
/* writeback cache for in/out buffers */
for (i = 0, numBufs = 0; i < XDM_MAX_IO_BUFFERS; i++) {
if (inOutBufs.descs[i].buf != NULL) {
if (XDM_ISACCESSMODE_WRITE(inOutBufs.descs[i]
.accessMask)) {
/* valid member of sparse array, written via CPU */
Memory_cacheWb(inOutBufs.descs[i].buf,
inOutBufs.descs[i].bufSize);
/*
* Since we've cacheWb this buffer, we arguably
* should reflect this cache state and clear the
* WRITE bit in the .accessMask field. However,
* we know the stub doesn't propogate this field
* to the calling app, so this extra buffer
* management detail isn't necessary:
*
* XDM_CLEARACCESSMODE_WRITE(inOutBufs.descs[i]
* .accessMask);
*/
}
if (++numBufs == inOutBufs.numBufs) {
break;
}
}
}
}
}
break;
}
case _UNIVERSAL_CCONTROL: {
/* unmarshall status based on the "size" of dynParams */
pStatus =
(IUNIVERSAL_Status *)((UInt)(&(msg->cmd.control.dynParams)) +
msg->cmd.control.dynParams.size);
/* invalidate data buffers */
for (i = 0, numBufs = 0; i < XDM_MAX_IO_BUFFERS; i++) {
if (pStatus->data.descs[i].buf != NULL) {
/* valid member of sparse array, manage it */
Memory_cacheInv(pStatus->data.descs[i].buf,
pStatus->data.descs[i].bufSize);
if (++numBufs == pStatus->data.numBufs) {
break;
}
}
}
msg->visa.status = UNIVERSAL_control(handle, msg->cmd.control.id,
&(msg->cmd.control.dynParams), pStatus);
/* writeback data buffers */
for (i = 0, numBufs = 0; i < XDM_MAX_IO_BUFFERS; i++) {
if (pStatus->data.descs[i].buf != NULL) {
if (XDM_ISACCESSMODE_WRITE(pStatus->data.descs[i]
.accessMask)) {
/* valid member of sparse array, manage it */
Memory_cacheWb(pStatus->data.descs[i].buf,
pStatus->data.descs[i].bufSize);
/*
* Since we've cacheWb this buffer, we arguably should
* reflect this cache state and clear the WRITE bit in
* the .accessMask field. However, we know the stub
* doesn't propogate this field to the calling app, so
* this extra buffer management detail isn't necessary:
*
* XDM_CLEARACCESSMODE_WRITE(pStatus->data.descs[i]
* .accessMask);
*/
}
if (++numBufs == pStatus->data.numBufs) {
break;
}
}
}
break;
}
default: {
msg->visa.status = VISA_EFAIL;
break;
}
}
return (VISA_EOK);
}
/*
* ======== processLoop ========
*/
static Void processLoop(UNIVERSAL_Handle hUniversal, FILE *in, FILE *out)
{
Int n;
Int32 status;
UNIVERSAL_InArgs universalInArgs;
UNIVERSAL_OutArgs universalOutArgs;
UNIVERSAL_DynamicParams universalDynParams;
UNIVERSAL_Status universalStatus;
XDM1_BufDesc universalInBufDesc;
XDM1_BufDesc universalOutBufDesc;
/* initialize bufDescs */
universalInBufDesc.numBufs = universalOutBufDesc.numBufs = 1;
universalInBufDesc.descs[0].bufSize = universalOutBufDesc.descs[0].bufSize =
NSAMPLES;
universalInBufDesc.descs[0].buf = inBuf;
universalOutBufDesc.descs[0].buf = outBuf;
/* initialize all "sized" fields */
universalInArgs.size = sizeof(universalInArgs);
universalOutArgs.size = sizeof(universalOutArgs);
universalDynParams.size = sizeof(universalDynParams);
universalStatus.size = sizeof(universalStatus);
/* if the codecs support it, dump their versions */
universalStatus.data.numBufs = 1;
universalStatus.data.descs[0].buf = versionBuf;
universalStatus.data.descs[0].bufSize = MAXVERSIONSIZE;
universalStatus.data.descs[1].buf = NULL;
status = UNIVERSAL_control(hUniversal, XDM_GETVERSION, &universalDynParams,
&universalStatus);
GT_1trace(curMask, GT_1CLASS, "Alg version: %s\n",
(status == UNIVERSAL_EOK ?
((char *)universalStatus.data.descs[0].buf) : "[unknown]"));
/*
* Read complete frames from in, process them, and write to out.
*/
for (n = 0; fread(inBuf, IFRAMESIZE, 1, in) == 1; n++) {
#ifdef CACHE_ENABLED
#ifdef xdc_target__isaCompatible_64P
/*
* 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(outBuf, OFRAMESIZE);
#endif
GT_1trace(curMask, GT_1CLASS, "App-> Processing frame %d...\n", n);
/*
* Transcode the frame.
*
* Note, inputID == 0 is an error. This example doesn't account
* for the case where 'n + 1' wraps to zero.
*/
status = UNIVERSAL_process(hUniversal, &universalInBufDesc,
&universalOutBufDesc, NULL, &universalInArgs, &universalOutArgs);
GT_2trace(curMask, GT_2CLASS,
"App-> Alg frame %d process returned - 0x%x)\n", n, status);
if (status != UNIVERSAL_EOK) {
GT_3trace(curMask, GT_7CLASS,
"App-> Alg frame %d processing FAILED, status = 0x%x, "
"extendedError = 0x%x\n", n, status,
universalOutArgs.extendedError);
break;
}
#ifdef CACHE_ENABLED
/*
* Conditionally writeback the processed buf from the previous
* call.
*/
if (XDM_ISACCESSMODE_WRITE(universalOutBufDesc.descs[0].accessMask)) {
Memory_cacheWb(outBuf, OFRAMESIZE);
}
#endif
/* write to file */
fwrite(outBuf, OFRAMESIZE, 1, out);
}
GT_1trace(curMask, GT_1CLASS, "%d frames processed\n", n);
}
