/******************************************************************************
* Sdec_process
******************************************************************************/
Int Sdec_process(Sdec_Handle hSd, Buffer_Handle hInBuf, Buffer_Handle hOutBuf)
{
SPHDEC_DynamicParams dynamicParams;
SPHDEC_Status decStatus;
XDM_BufDesc inBufDesc;
XDM_BufDesc outBufDesc;
XDAS_Int32 inBufSizeArray[1];
XDAS_Int32 outBufSizeArray[1];
XDAS_Int32 status;
SPHDEC_InArgs inArgs;
SPHDEC_OutArgs outArgs;
XDAS_Int8 *inPtr;
XDAS_Int8 *outPtr;
assert(hSd);
assert(hInBuf);
assert(hOutBuf);
assert(Buffer_getUserPtr(hInBuf));
assert(Buffer_getUserPtr(hOutBuf));
assert(Buffer_getNumBytesUsed(hInBuf));
assert(Buffer_getSize(hOutBuf));
inPtr = Buffer_getUserPtr(hInBuf);
outPtr = Buffer_getUserPtr(hOutBuf);
inBufSizeArray[0] = Buffer_getNumBytesUsed(hInBuf);
outBufSizeArray[0] = Buffer_getSize(hOutBuf);
inBufDesc.bufSizes = inBufSizeArray;
inBufDesc.bufs = &inPtr;
inBufDesc.numBufs = 1;
outBufDesc.bufSizes = outBufSizeArray;
outBufDesc.bufs = &outPtr;
outBufDesc.numBufs = 1;
inArgs.size = sizeof(SPHDEC_InArgs);
inArgs.inBufferSize = Buffer_getNumBytesUsed(hInBuf);
outArgs.size = sizeof(SPHDEC_OutArgs);
/* Decode the speech buffer */
status = SPHDEC_process(hSd->hDecode, &inBufDesc, &outBufDesc, &inArgs,
&outArgs);
if (status != SPHDEC_EOK) {
decStatus.size = sizeof(SPHDEC_Status);
dynamicParams.size = sizeof(SPHDEC_DynamicParams);
status = SPHDEC_control(hSd->hDecode, XDM_GETSTATUS, &dynamicParams,
&decStatus);
if (status != SPHDEC_EOK) {
Dmai_err1("XDM_GETSTATUS failed, status=%d\n", status);
return Dmai_EFAIL;
}
if (status == SPHDEC_ERUNTIME ||
XDM_ISFATALERROR(decStatus.extendedError)) {
Dmai_err2("SPHDEC_process() failed with error (%d ext: 0x%x)\n",
(Int)status, (Uns) decStatus.extendedError);
return Dmai_EFAIL;
}
else {
Dmai_dbg1("SPHDEC_process() non-fatal error 0x%x\n",
(Uns) decStatus.extendedError);
return Dmai_EBITERROR;
}
}
/* A fixed x2 decompression ratio, only works for g711 */
Buffer_setNumBytesUsed(hOutBuf, Buffer_getNumBytesUsed(hInBuf) * 2);
return Dmai_EOK;
}
/*
* ======== 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);
}
/******************************************************************************
* Sdec_create
******************************************************************************/
Sdec_Handle Sdec_create(Engine_Handle hEngine, Char *codecName,
SPHDEC_Params *params, SPHDEC_DynamicParams *dynParams)
{
Sdec_Handle hSd;
SPHDEC_Handle hDecode;
SPHDEC_Status decStatus;
XDAS_Int32 status;
if (hEngine == NULL || codecName == NULL ||
params == NULL || dynParams == NULL) {
Dmai_err0("Cannot pass null for engine, codec name, params or "
"dynamic params\n");
return NULL;
}
/* Allocate space for the object */
hSd = (Sdec_Handle)calloc(1, sizeof(Sdec_Object));
if (hSd == NULL) {
Dmai_err0("Failed to allocate space for Sdec Object\n");
return NULL;
}
/* Create speech decoder */
hDecode = SPHDEC_create(hEngine, codecName, params);
if (hDecode == NULL) {
Dmai_err0("Failed to create speech decoder\n");
cleanup(hSd);
return NULL;
}
Dmai_dbg1("Speech decoder instance of %s created\n", codecName);
/* Set dynamic parameters */
decStatus.size = sizeof(SPHDEC_Status);
status = SPHDEC_control(hDecode, XDM_SETPARAMS, dynParams, &decStatus);
if (status != SPHDEC_EOK) {
Dmai_err1("XDM_SETPARAMS failed, status=%d\n", status);
SPHDEC_delete(hDecode);
cleanup(hSd);
return NULL;
}
/* Get buffer information from video decoder */
status = SPHDEC_control(hDecode, XDM_GETBUFINFO, dynParams,
&decStatus);
if (status != SPHDEC_EOK) {
Dmai_err0("XDM_GETBUFINFO control failed\n");
SPHDEC_delete(hDecode);
cleanup(hSd);
return NULL;
}
Dmai_dbg2("Speech decoder requires buffer sizes in %u and out %u\n",
(Uns) decStatus.bufInfo.minInBufSize[0],
(Uns) decStatus.bufInfo.minInBufSize[1]);
memcpy(hSd->minInBufSize,
decStatus.bufInfo.minInBufSize, sizeof(hSd->minInBufSize));
hSd->minNumInBufs = decStatus.bufInfo.minNumInBufs;
memcpy(hSd->minOutBufSize,
decStatus.bufInfo.minOutBufSize, sizeof(hSd->minOutBufSize));
hSd->minNumOutBufs = decStatus.bufInfo.minNumOutBufs;
hSd->hDecode = hDecode;
return hSd;
}
