/****************************************************************************** * 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; }