DvevmStRetCode
dvtb_sphEncEncode(DvevmStSphEncInfo *se, int *encDuration)
{
XDAS_Int32 status = -1;
XDM_BufDesc inBufDesc, outBufDesc;
DvevmStTime timeStmpBfrEnc, timeStmpAftrEnc;
DvevmStRetCode retCode = DVEVM_ST_SUCCESS;
XDAS_Int8 *src = NULL, *dst = NULL;
ASSERT(se != NULL);
ASSERT(se->ceHdl != NULL);
ASSERT(se->sencHdl != NULL);
ASSERT(se->inBuf.start != NULL);
ASSERT(se->outBuf.start != NULL);
src = (XDAS_Int8 *) se->inBuf.start;
dst = (XDAS_Int8 *) se->outBuf.start;
inBufDesc.numBufs = outBufDesc.numBufs = 1;
inBufDesc.bufSizes = (XDAS_Int32 *) &se->inBuf.size;
outBufDesc.bufSizes = (XDAS_Int32 *) &se->inBuf.size;
inBufDesc.bufs = &src;
outBufDesc.bufs = &dst;
timeStmpBfrEnc = dvtb_getTime( );
status = SPHENC_process(se->sencHdl, &inBufDesc, &outBufDesc, &se->sencInArgs, &se->sencOutArgs);
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 != SPHENC_EOK)
{
SYS_ERROR("Error (%d) in Speech Encoder Process\n", (int) status);
retCode = DVEVM_ST_FAIL;
}
return retCode;
}
/*
* ======== encode_decode ========
*/
static Void encode_decode(SPHENC_Handle enc, SPHDEC_Handle dec, FILE *in,
FILE *out)
{
Int n;
Int32 status;
SPHDEC_InArgs decInArgs;
SPHDEC_OutArgs decOutArgs;
SPHDEC_DynamicParams decDynParams;
SPHDEC_Status decStatus;
SPHENC_InArgs encInArgs;
SPHENC_OutArgs encOutArgs;
SPHENC_DynamicParams encDynParams;
SPHENC_Status encStatus;
XDM_BufDesc inBufDesc;
XDAS_Int8 *src[XDM_MAX_IO_BUFFERS];
XDAS_Int32 inBufSizes[XDM_MAX_IO_BUFFERS];
XDM_BufDesc encodedBufDesc;
XDAS_Int8 *encoded[XDM_MAX_IO_BUFFERS];
XDAS_Int32 encBufSizes[XDM_MAX_IO_BUFFERS];
XDM_BufDesc outBufDesc;
XDAS_Int8 *dst[XDM_MAX_IO_BUFFERS];
XDAS_Int32 outBufSizes[XDM_MAX_IO_BUFFERS];
/* clear and initialize the buffer descriptors */
memset(src, 0, sizeof(src[0]) * XDM_MAX_IO_BUFFERS);
memset(encoded, 0, sizeof(encoded[0]) * XDM_MAX_IO_BUFFERS);
memset(dst, 0, sizeof(dst[0]) * XDM_MAX_IO_BUFFERS);
src[0] = inBuf;
encoded[0] = encodedBuf;
dst[0] = outBuf;
inBufDesc.numBufs = encodedBufDesc.numBufs = outBufDesc.numBufs = 1;
inBufDesc.bufSizes = inBufSizes;
encodedBufDesc.bufSizes = encBufSizes;
outBufDesc.bufSizes = outBufSizes;
inBufSizes[0] = encBufSizes[0] = outBufSizes[0] = NSAMPLES;
inBufDesc.bufs = src;
encodedBufDesc.bufs = encoded;
outBufDesc.bufs = dst;
/* 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);
/*
* Query the encoder and decoder.
* 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 = SPHENC_control(enc, XDM_GETBUFINFO, &encDynParams, &encStatus);
if (status != SPHENC_EOK) {
/* failure, report error and exit */
GT_1trace(curMask, GT_7CLASS, "encode control status = 0x%x\n", status);
return;
}
/* Validate this encoder codec will meet our buffer requirements */
if ((inBufDesc.numBufs < encStatus.bufInfo.minNumInBufs) ||
(IFRAMESIZE < encStatus.bufInfo.minInBufSize[0]) ||
(encodedBufDesc.numBufs < encStatus.bufInfo.minNumOutBufs) ||
(EFRAMESIZE < encStatus.bufInfo.minOutBufSize[0])) {
/* failure, report error and exit */
GT_0trace(curMask, GT_7CLASS,
"Error: encoder codec feature conflict\n");
return;
}
status = SPHDEC_control(dec, XDM_GETBUFINFO, &decDynParams, &decStatus);
if (status != SPHDEC_EOK) {
/* failure, report error and exit */
GT_1trace(curMask, GT_7CLASS, "decode control status = 0x%x\n", status);
return;
}
/* Validate this decoder codec will meet our buffer requirements */
if ((encodedBufDesc.numBufs < decStatus.bufInfo.minNumInBufs) ||
(EFRAMESIZE < decStatus.bufInfo.minInBufSize[0]) ||
(outBufDesc.numBufs < decStatus.bufInfo.minNumOutBufs) ||
(OFRAMESIZE < decStatus.bufInfo.minOutBufSize[0])) {
/* failure, report error and exit */
GT_0trace(curMask, GT_7CLASS,
"App-> ERROR: decoder does not meet buffer requirements.\n");
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
#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(encodedBuf, EFRAMESIZE);
#endif
GT_1trace(curMask, GT_1CLASS, "App-> Processing frame %d...\n", n);
/* encode the frame */
status = SPHENC_process(enc, &inBufDesc, &encodedBufDesc, &encInArgs,
&encOutArgs);
GT_2trace(curMask, GT_2CLASS,
"App-> Encoder frame %d process returned - 0x%x\n",
n, status);
#ifdef CACHE_ENABLED
/* Writeback this outBuf from the previous call. Also, as encodedBuf
* is an inBuf to the next process call, we must invalidate it also, to
* clean buffer lines.
*/
Memory_cacheWbInv(encodedBuf, EFRAMESIZE);
/* Per DMA Rule 7, our output buffer cache lines must be cleaned */
Memory_cacheInv(outBuf, OFRAMESIZE);
#endif
if (status != SPHENC_EOK) {
GT_2trace(curMask, GT_7CLASS,
"App-> Encoder frame %d processing FAILED, status = 0x%x\n",
n, status);
break;
}
/* decode the frame */
decInArgs.inBufferSize = encOutArgs.outbufferSize;
status = SPHDEC_process(dec, &encodedBufDesc, &outBufDesc, &decInArgs,
&decOutArgs);
GT_2trace(curMask, GT_2CLASS,
"App-> Decoder frame %d process returned - 0x%x\n",
n, status);
if (status != SPHDEC_EOK) {
GT_2trace(curMask, GT_7CLASS,
"App-> Decoder frame %d processing FAILED, status = 0x%x\n",
n, status);
break;
}
#ifdef CACHE_ENABLED
/* Writeback the outBuf. */
Memory_cacheWb(outBuf, OFRAMESIZE);
#endif
/* write to file */
fwrite(dst[0], OFRAMESIZE, 1, out);
}
GT_1trace(curMask, GT_1CLASS, "%d frames encoded/decoded\n", n);
}
/*
* ======== call ========
*/
static VISA_Status call(VISA_Handle visaHandle, VISA_Msg visaMsg)
{
_SPHENC_Msg *msg = (_SPHENC_Msg *)visaMsg;
SPHENC_Handle handle = (SPHENC_Handle)visaHandle;
Int i;
XDM_BufDesc inBufs, outBufs;
ISPHENC_OutArgs *pOutArgs;
ISPHENC_Status *pStatus;
/* perform the requested SPHENC operation by parsing message. */
switch (msg->visa.cmd) {
case _SPHENC_CPROCESS: {
/* unmarshall inBufs and outBufs since they differ in shape
* from what their flattened versions passed in the message
*/
inBufs.bufs = msg->cmd.process.inBufs;
inBufs.numBufs = msg->cmd.process.numInBufs;
inBufs.bufSizes = msg->cmd.process.inBufSizes;
outBufs.bufs = msg->cmd.process.outBufs;
outBufs.numBufs = msg->cmd.process.numOutBufs;
outBufs.bufSizes = msg->cmd.process.outBufSizes;
if (SKEL_cachingPolicy == SKEL_LOCALBUFFERINVWB) {
/* invalidate cache for all input buffers */
for (i = 0; i < inBufs.numBufs; i++) {
Memory_cacheInv(inBufs.bufs[i], inBufs.bufSizes[i]);
}
/* invalidate cache for all output buffers */
for (i = 0; i < outBufs.numBufs; i++) {
Memory_cacheInv(outBufs.bufs[i], outBufs.bufSizes[i]);
}
}
/* unmarshall outArgs based on the "size" of inArgs */
pOutArgs = (ISPHENC_OutArgs *)((UInt)(&(msg->cmd.process.inArgs)) +
msg->cmd.process.inArgs.size);
/* make the process call */
msg->visa.status = SPHENC_process(handle,
&inBufs, &outBufs, &(msg->cmd.process.inArgs), pOutArgs);
if (SKEL_cachingPolicy == SKEL_WBINVALL) {
Memory_cacheWbInvAll();
}
else if (SKEL_cachingPolicy == SKEL_LOCALBUFFERINVWB) {
/* writeback cache for all output buffers */
for (i = 0; i < outBufs.numBufs; i++) {
Memory_cacheWb(outBufs.bufs[i], outBufs.bufSizes[i]);
}
}
/*
* Note that any changes to individual outBufs[i] values made by
* the codec will automatically update msg->cmd.process.outBufs
* as we pass the outBufs array by reference.
*/
break;
}
case _SPHENC_CCONTROL: {
/* unmarshall status based on the "size" of params */
pStatus = (ISPHENC_Status *)((UInt)(&(msg->cmd.control.params)) +
msg->cmd.control.params.size);
msg->visa.status = SPHENC_control(handle, msg->cmd.control.id,
&(msg->cmd.control.params), pStatus);
break;
}
default: {
msg->visa.status = VISA_EFAIL;
break;
}
}
return (VISA_EOK);
}
