/* ARGSUSED - this line tells the TI compiler not to warn about unused args. */
XDAS_Int32 AUDDECCOPY_TI_process(IAUDDEC_Handle h, XDM_BufDesc *inBufs,
XDM_BufDesc *outBufs, IAUDDEC_InArgs *inArgs, IAUDDEC_OutArgs *outArgs)
{
/* validate arguments - this codec only supports "base" XDM. */
if ((inArgs->size != sizeof(*inArgs)) ||
(outArgs->size != sizeof(*outArgs))) {
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
return (IAUDDEC_EFAIL);
}
/* validate that there's at least a single inBuf and outBuf */
if ((inBufs->numBufs < 1) || (outBufs->numBufs < 1)) {
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
return (IAUDDEC_EFAIL);
}
/*
* The number of bytes we can consume is the lesser of the specified
* number of bytes to decode (inArgs->numBytes) and the size of the
* buffer that will contain the output (outBufs->bufSizes[0]).
*/
outArgs->bytesConsumed = (inArgs->numBytes <= outBufs->bufSizes[0]) ?
inArgs->numBytes : outBufs->bufSizes[0];
/* process the data: read input, produce output */
memcpy(outBufs->bufs[0], inBufs->bufs[0], outArgs->bytesConsumed);
/* Fill out the rest of the outArgs struct */
outArgs->extendedError = 0;
return (IAUDDEC_EOK);
}
/* ARGSUSED - this line tells the TI compiler not to warn about unused args. */
XDAS_Int32 UNIVERSALCOPY_TI_process(IUNIVERSAL_Handle h,
XDM1_BufDesc *inBufs, XDM1_BufDesc *outBufs, XDM1_BufDesc *inOutBufs,
IUNIVERSAL_InArgs *inArgs, IUNIVERSAL_OutArgs *outArgs)
{
XDAS_Int32 numInBytes;
#if (XDAIS_TRACE_OUT == 1) /* 'handle' only used in TRACE_ statements */
IALG_Handle handle = (IALG_Handle)h;
#endif
TRACE_6print(handle, TRACE_ENTER,
"UNIVERSALCOPY_TI_process> Enter (h=0x%x, inBufs=0x%x, "
"outBufs=0x%x, inOutBufs=0x%x, inArgs=0x%x, outArgs=0x%x)\n", h,
inBufs, outBufs, inOutBufs, inArgs, outArgs);
/* validate arguments - this codec only supports "base" XDM. */
if ((inArgs->size != sizeof(*inArgs)) ||
(outArgs->size != sizeof(*outArgs))) {
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
TRACE_0print(handle, TRACE_ENTER,
"UNIVERSALCOPY_TI_process> Exit "
"(status=IUNIVERSAL_EUNSUPPORTED)\n");
return (IUNIVERSAL_EUNSUPPORTED);
}
/* validate that there's at least a single inBuf and outBuf */
if ((inBufs->numBufs < 1) || (outBufs->numBufs < 1)) {
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
TRACE_0print(handle, TRACE_ENTER,
"UNIVERSALCOPY_TI_process> Exit "
"(status=IUNIVERSAL_EFAIL)\n");
return (IUNIVERSAL_EFAIL);
}
numInBytes = inBufs->descs[0].bufSize < outBufs->descs[0].bufSize ?
inBufs->descs[0].bufSize : outBufs->descs[0].bufSize;
/* everything looks good, do the 'transcode', set outArgs and return */
TRACE_0print(handle, TRACE_4CLASS,
"UNIVERSALCOPY_TI_process> Performing the transcode\n");
memcpy(outBufs->descs[0].buf, inBufs->descs[0].buf, numInBytes);
/* report how we accessed the input buffer */
inBufs->descs[0].accessMask = 0;
XDM_SETACCESSMODE_READ(inBufs->descs[0].accessMask);
/* report how we accessed the output buffer */
outBufs->descs[0].accessMask = 0;
XDM_SETACCESSMODE_WRITE(outBufs->descs[0].accessMask);
TRACE_0print(handle, TRACE_ENTER,
"UNIVERSALCOPY_TI_process> Exit (status=IUNIVERSAL_EOK)\n");
return (IUNIVERSAL_EOK);
}
/*
* ======== AUDENC1COPY_TI_process ========
*/
XDAS_Int32 AUDENC1COPY_TI_process(IAUDENC1_Handle handle, XDM1_BufDesc *inBufs,
XDM1_BufDesc *outBufs, IAUDENC1_InArgs *inArgs, IAUDENC1_OutArgs *outArgs)
{
XDAS_Int32 numInBytes;
AUDENC1COPY_TI_Obj *obj = (AUDENC1COPY_TI_Obj *)handle;
/* validate arguments - this codec only supports "base" xDM. */
if ((inArgs->size != sizeof(*inArgs)) ||
(outArgs->size != sizeof(*outArgs))) {
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
return (IAUDENC1_EUNSUPPORTED);
}
/* validate that there's at least a single inBuf and outBuf */
if ((inBufs->numBufs < 1) || (outBufs->numBufs < 1)) {
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
return (IAUDENC1_EFAIL);
}
/* convert samples to bytes */
numInBytes = inArgs->numInSamples * (obj->inputBitsPerSample / BITSPERBYTE);
/*
* Sanity check that inBufs->descs[0].bufSize is really capable of holding
* numInBytes bytes of data, and that outBufs->descs[0].bufSize
* can hold the 'encoded' data.
*/
if ((numInBytes > inBufs->descs[0].bufSize) ||
(numInBytes > outBufs->descs[0].bufSize)) {
/* inBuf is smaller than provided data(!) or "too small" outBuf */
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
return (IAUDENC1_EFAIL);
}
/* everything looks good, do the 'encode', set outArgs and return */
memcpy(outBufs->descs[0].buf, inBufs->descs[0].buf, numInBytes);
/* report _how_ we accessed the 2 data buffers */
XDM_CLEARACCESSMODE_WRITE(inBufs->descs[0].accessMask);
XDM_SETACCESSMODE_READ(inBufs->descs[0].accessMask);
XDM_CLEARACCESSMODE_READ(outBufs->descs[0].accessMask);
XDM_SETACCESSMODE_WRITE(outBufs->descs[0].accessMask);
/* outArgs->bytesGenerated reports the total number of bytes encoded */
outArgs->bytesGenerated = numInBytes;
/* Fill out the rest of the outArgs struct */
outArgs->extendedError = 0;
outArgs->numInSamples = inArgs->numInSamples;
outArgs->numZeroesPadded = 0; /* TODO */
return (IAUDENC1_EOK);
}
/* ARGSUSED - this line tells the TI compiler not to warn about unused args. */
XDAS_Int32 IMGDEC1COPY_TI_process(IIMGDEC1_Handle h, XDM1_BufDesc *inBufs,
XDM1_BufDesc *outBufs, IIMGDEC1_InArgs *inArgs, IIMGDEC1_OutArgs *outArgs)
{
XDAS_Int32 numInBytes;
/* validate arguments - this codec only supports "base" XDM. */
if ((inArgs->size != sizeof(*inArgs)) ||
(outArgs->size != sizeof(*outArgs))) {
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
return (IIMGDEC1_EUNSUPPORTED);
}
/* validate that there's at least a single inBuf and outBuf */
if ((inBufs->numBufs < 1) || (outBufs->numBufs < 1)) {
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
return (IIMGDEC1_EFAIL);
}
numInBytes = inArgs->numBytes;
/*
* Sanity check that inBufs->descs[0].bufSize is really capable of holding
* numInBytes bytes of data, and that outBufs->descs[0].bufSize
* can hold the 'encoded' data.
*/
if ((numInBytes > inBufs->descs[0].bufSize) ||
(numInBytes > outBufs->descs[0].bufSize)) {
/* inBuf is smaller than provided data(!) or "too small" outBuf */
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
return (IIMGDEC1_EFAIL);
}
/* everything looks good, do the decode, set outArgs and return */
memcpy(outBufs->descs[0].buf, inBufs->descs[0].buf, numInBytes);
/* report how we accessed the data buffers */
XDM_CLEARACCESSMODE_WRITE(inBufs->descs[0].accessMask);
XDM_SETACCESSMODE_READ(inBufs->descs[0].accessMask);
XDM_CLEARACCESSMODE_READ(outBufs->descs[0].accessMask);
XDM_SETACCESSMODE_WRITE(outBufs->descs[0].accessMask);
/* outArgs->bytesConsumed reports the total number of bytes decoded */
outArgs->bytesConsumed = numInBytes;
/* Fill out the rest of the outArgs struct */
outArgs->extendedError = 0;
outArgs->currentAU = 0; /* TODO */
outArgs->currentScan = 0; /* TODO */
return (IIMGDEC1_EOK);
}
/* ARGSUSED - this line tells the TI compiler not to warn about unused args. */
XDAS_Int32 IMGENC1COPY_TI_process(IIMGENC1_Handle h, XDM1_BufDesc *inBufs,
XDM1_BufDesc *outBufs, IIMGENC1_InArgs *inArgs, IIMGENC1_OutArgs *outArgs)
{
XDAS_Int32 numInBytes;
/* validate arguments - this codec only supports "base" XDM. */
if ((inArgs->size != sizeof(*inArgs)) ||
(outArgs->size != sizeof(*outArgs))) {
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
return (IIMGENC1_EUNSUPPORTED);
}
/* validate that there's at least a single inBuf and outBuf */
if ((inBufs->numBufs < 1) || (outBufs->numBufs < 1)) {
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
return (IIMGENC1_EFAIL);
}
numInBytes = inBufs->descs[0].bufSize < outBufs->descs[0].bufSize ?
inBufs->descs[0].bufSize : outBufs->descs[0].bufSize;
/* everything looks good, do the 'encode', set outArgs and return */
memcpy(outBufs->descs[0].buf, inBufs->descs[0].buf, numInBytes);
/* report _how_ we accessed the 2 data buffers */
XDM_CLEARACCESSMODE_WRITE(inBufs->descs[0].accessMask);
XDM_SETACCESSMODE_READ(inBufs->descs[0].accessMask);
XDM_CLEARACCESSMODE_READ(outBufs->descs[0].accessMask);
XDM_SETACCESSMODE_WRITE(outBufs->descs[0].accessMask);
/* outArgs->bytesGenerated reports the total number of bytes encoded */
outArgs->bytesGenerated = numInBytes;
/* Fill out the rest of the outArgs struct */
outArgs->extendedError = 0;
outArgs->currentAU = 0; /* TODO */
return (IIMGENC1_EOK);
}
/*
* ======== TRIK_VIDTRANSCODE_RESAMPLE_process ========
*/
XDAS_Int32 TRIK_VIDTRANSCODE_RESAMPLE_process(
IVIDTRANSCODE_Handle algHandle,
XDM1_BufDesc* xdmInBufs,
XDM_BufDesc* xdmOutBufs,
IVIDTRANSCODE_InArgs* vidInArgs,
IVIDTRANSCODE_OutArgs* vidOutArgs)
{
TrikVideoResampleHandle* handle = (TrikVideoResampleHandle*)algHandle;
if ( (vidInArgs->size != sizeof(IVIDTRANSCODE_InArgs))
|| (vidOutArgs->size != sizeof(IVIDTRANSCODE_OutArgs)))
{
XDM_SETUNSUPPORTEDPARAM(vidOutArgs->extendedError);
return IVIDTRANSCODE_EUNSUPPORTED;
}
if ( xdmInBufs->numBufs != 1
|| handle->m_params.base.numOutputStreams < 0
|| xdmOutBufs->numBufs < handle->m_params.base.numOutputStreams)
{
XDM_SETUNSUPPORTEDPARAM(vidOutArgs->extendedError);
return IVIDTRANSCODE_EFAIL;
}
XDM1_SingleBufDesc* xdmInBuf = &xdmInBufs->descs[0];
if ( xdmInBuf->buf == NULL
|| vidInArgs->numBytes < 0
|| vidInArgs->numBytes > xdmInBuf->bufSize)
{
XDM_SETUNSUPPORTEDPARAM(vidOutArgs->extendedError);
return IVIDTRANSCODE_EFAIL;
}
XDAS_Int32 inBufFormat;
XDAS_Int32 inBufHeight;
XDAS_Int32 inBufWidth;
XDAS_Int32 inBufLineLength;
if (!handlePickInputParams(handle, &inBufFormat, &inBufHeight, &inBufWidth, &inBufLineLength))
{
XDM_SETUNSUPPORTEDPARAM(vidOutArgs->extendedError);
return IVIDTRANSCODE_EFAIL;
}
XDM_CLEARACCESSMODE_WRITE(xdmInBuf->accessMask);
XDM_SETACCESSMODE_READ(xdmInBuf->accessMask);
vidOutArgs->bitsConsumed = vidInArgs->numBytes * CHAR_BIT;
vidOutArgs->decodedPictureType = IVIDEO_NA_PICTURE;
vidOutArgs->decodedPictureStructure = IVIDEO_CONTENTTYPE_NA;
vidOutArgs->decodedHeight = handle->m_dynamicParams.inputHeight;
vidOutArgs->decodedWidth = handle->m_dynamicParams.inputWidth;
XDAS_Int32 outBufIndex;
for (outBufIndex = 0; outBufIndex < handle->m_params.base.numOutputStreams; ++outBufIndex)
{
XDM1_SingleBufDesc* xdmOutBuf = &vidOutArgs->encodedBuf[outBufIndex];
xdmOutBuf->buf = xdmOutBufs->bufs[outBufIndex];
xdmOutBuf->bufSize = xdmOutBufs->bufSizes[outBufIndex];
xdmOutBuf->accessMask = 0;
if ( xdmOutBuf->buf == NULL
|| xdmOutBuf->bufSize < 0)
{
XDM_SETCORRUPTEDDATA(vidOutArgs->extendedError);
return IVIDTRANSCODE_EFAIL;
}
XDAS_Int32 outBufFormat;
XDAS_Int32 outBufHeight;
XDAS_Int32 outBufWidth;
XDAS_Int32 outBufLineLength;
if (!handlePickOutputParams(handle, outBufIndex, &outBufFormat, &outBufHeight, &outBufWidth, &outBufLineLength))
{
XDM_SETUNSUPPORTEDPARAM(vidOutArgs->extendedError);
return IVIDTRANSCODE_EFAIL;
}
XDAS_Int32 outBufUsed = 0;
TrikVideoResampleStatus result = resampleBuffer(xdmInBuf->buf, vidInArgs->numBytes,
inBufFormat, inBufHeight, inBufWidth, inBufLineLength,
xdmOutBuf->buf, xdmOutBuf->bufSize, &outBufUsed,
outBufFormat, outBufHeight, outBufWidth, outBufLineLength);
switch (result)
{
case TRIK_VIDTRANSCODE_RESAMPLE_STATUS_OK:
break;
// TODO other statuses
default:
XDM_SETCORRUPTEDDATA(vidOutArgs->extendedError);
return IVIDTRANSCODE_EFAIL;
}
XDM_SETACCESSMODE_WRITE(xdmOutBuf->accessMask);
xdmOutBuf->bufSize = outBufUsed;
vidOutArgs->bitsGenerated[outBufIndex] = outBufUsed * CHAR_BIT;
vidOutArgs->encodedPictureType[outBufIndex] = vidOutArgs->decodedPictureType;
vidOutArgs->encodedPictureStructure[outBufIndex] = vidOutArgs->decodedPictureStructure;
vidOutArgs->outputID[outBufIndex] = vidInArgs->inputID;
vidOutArgs->inputFrameSkipTranscodeFlag[outBufIndex] = XDAS_FALSE;
}
vidOutArgs->outBufsInUseFlag = XDAS_FALSE;
return IVIDTRANSCODE_EOK;
}
/* ARGSUSED - this line tells the TI compiler not to warn about unused args. */
XDAS_Int32 VIDDEC1COPY_TI_process(IVIDDEC1_Handle h, XDM1_BufDesc *inBufs,
XDM_BufDesc *outBufs, IVIDDEC1_InArgs *inArgs, IVIDDEC1_OutArgs *outArgs)
{
XDAS_Int32 numInBytes;
/* validate arguments - this codec only supports "base" XDM. */
if ((inArgs->size != sizeof(*inArgs)) ||
(outArgs->size != sizeof(*outArgs))) {
XDM_SETUNSUPPORTEDPARAM(outArgs->decodedBufs.extendedError);
return (IVIDDEC1_EUNSUPPORTED);
}
/* validate that there's at least a single inBuf and outBuf */
if ((inBufs->numBufs < 1) || (outBufs->numBufs < 1)) {
XDM_SETUNSUPPORTEDPARAM(outArgs->decodedBufs.extendedError);
return (IVIDDEC1_EFAIL);
}
numInBytes = inArgs->numBytes;
/*
* Sanity check that inBufs->descs[0].bufSize is really capable of holding
* numInBytes bytes of data, and that outBufs->bufSizes[0]
* can hold the 'encoded' data.
*/
if ((inBufs->descs[0].bufSize < inArgs->numBytes) ||
(outBufs->bufSizes[0] < MINOUTBUFSIZE)){
/* inBuf is smaller than provided data(!) or "too small" outBuf */
XDM_SETUNSUPPORTEDPARAM(outArgs->decodedBufs.extendedError);
return (IVIDDEC1_EFAIL);
}
/* everything looks good, do the 'encode', set outArgs and return */
memcpy(outBufs->bufs[0], inBufs->descs[0].buf, numInBytes);
/* report _how_ we accessed the input buffer */
XDM_CLEARACCESSMODE_WRITE(inBufs->descs[0].accessMask);
XDM_SETACCESSMODE_READ(inBufs->descs[0].accessMask);
/* outArgs->bytesConsumed reports the total number of bytes decoded */
outArgs->bytesConsumed = numInBytes;
/* Fill out the rest of the outArgs struct */
outArgs->outputID[0] = inArgs->inputID;
outArgs->outputID[1] = 0; /* end of array - invalid ID */
outArgs->decodedBufs.numBufs = 1;
outArgs->decodedBufs.frameWidth = numInBytes; /* minBytes wide */
outArgs->decodedBufs.frameHeight = 1; /* one pixel high */
outArgs->decodedBufs.framePitch = 0; /* TODO */
outArgs->decodedBufs.bufDesc[0].buf = outBufs->bufs[0];
outArgs->decodedBufs.bufDesc[0].bufSize = outBufs->bufSizes[0];
/* initialize the accessMask, then indicate how we accessed it */
outArgs->decodedBufs.bufDesc[0].accessMask = 0;
XDM_SETACCESSMODE_WRITE(outArgs->decodedBufs.bufDesc[0].accessMask);
outArgs->decodedBufs.extendedError = 0;
outArgs->decodedBufs.frameType = 0; /* TODO */
outArgs->decodedBufs.topFieldFirstFlag = XDAS_FALSE; /* TODO */
outArgs->decodedBufs.repeatFirstFieldFlag = XDAS_FALSE; /* TODO */
outArgs->decodedBufs.frameStatus = IVIDEO_FRAME_NOERROR;
outArgs->decodedBufs.repeatFrame = 0; /* TODO */
outArgs->decodedBufs.contentType = IVIDEO_PROGRESSIVE;
outArgs->decodedBufs.chromaFormat = XDM_CHROMAFORMAT_DEFAULT;
/* Single display buf equivalent to the decoded buf above */
outArgs->displayBufs[0] = outArgs->decodedBufs;
outArgs->displayBufs[1].numBufs = 0; /* end of array */
/* MB data support is TBD */
outArgs->outputMbDataID = 0; /* invalid ID */
outArgs->mbDataBuf.buf = NULL; /* important, set to NULL if no MB Data! */
outArgs->freeBufID[0] = inArgs->inputID; /* release the only outBuf */
outArgs->freeBufID[1] = 0; /* end of array - invalid ID */
outArgs->outBufsInUseFlag = XDAS_FALSE;
return (IVIDDEC1_EOK);
}
/* ARGSUSED - this line tells the TI compiler not to warn about unused args. */
XDAS_Int32 VIDENC1COPY_TI_process(IVIDENC1_Handle h, IVIDEO1_BufDescIn *inBufs,
XDM_BufDesc *outBufs, IVIDENC1_InArgs *inArgs, IVIDENC1_OutArgs *outArgs)
{
XDAS_Int32 numInBytes;
#ifdef USE_ACPY3
const Uint32 maxTransferChunkSize = 0xffff;
Uint32 thisTransferChunkSize = 0x0;
Uint32 remainingTransferChunkSize;
Uint32 thisTransferSrcAddr, thisTransferDstAddr;
ACPY3_Params params;
VIDENC1COPY_TI_Obj *videncObj = (VIDENC1COPY_TI_Obj *)h;
#endif
/*
* Validate arguments - this codec supports "base" XDM and an extended
* inArgs.
*/
if (((inArgs->size != sizeof(*inArgs)) &&
(inArgs->size != sizeof(IVIDENC1CPY_InArgs))) ||
(outArgs->size != sizeof(*outArgs))) {
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
return (IVIDENC1_EUNSUPPORTED);
}
/* validate that there's at least a single inBuf and outBuf */
if ((inBufs->numBufs < 1) || (outBufs->numBufs < 1)) {
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
return (IVIDENC1_EFAIL);
}
/* validate inputID */
if (inArgs->inputID == 0) {
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
return (IVIDENC1_EFAIL);
}
/* there's an available in and out buffer, how many samples? */
numInBytes = inBufs->bufDesc[0].bufSize < outBufs->bufSizes[0] ?
inBufs->bufDesc[0].bufSize : outBufs->bufSizes[0];
/* and honor the extended maxBytes if it was provided */
if (inArgs->size == sizeof(IVIDENC1CPY_InArgs)) {
if (numInBytes > ((IVIDENC1CPY_InArgs *)inArgs)->maxBytes) {
numInBytes = ((IVIDENC1CPY_InArgs *)inArgs)->maxBytes;
}
}
#ifdef USE_ACPY3
/*
* Activate Channel scratch DMA channels.
*/
ACPY3_activate(videncObj->dmaHandle1D1D8B);
thisTransferSrcAddr = (Uint32)inBufs->bufDesc[0].buf;
thisTransferDstAddr = (Uint32)outBufs->bufs[0];
remainingTransferChunkSize = numInBytes;
while (remainingTransferChunkSize > 0) {
if (remainingTransferChunkSize > maxTransferChunkSize) {
thisTransferChunkSize = maxTransferChunkSize;
}
else {
thisTransferChunkSize = remainingTransferChunkSize;
}
/* Configure the logical channel */
params.transferType = ACPY3_1D1D;
params.srcAddr = (void *)thisTransferSrcAddr;
params.dstAddr = (void *)thisTransferDstAddr;
params.elementSize = thisTransferChunkSize;
params.numElements = 1;
params.waitId = 0;
params.numFrames = 1;
remainingTransferChunkSize -= thisTransferChunkSize;
thisTransferSrcAddr += thisTransferChunkSize;
thisTransferDstAddr += thisTransferChunkSize;
/* Configure logical dma channel */
ACPY3_configure(videncObj->dmaHandle1D1D8B, ¶ms, 0);
/* Use DMA to copy data */
ACPY3_start(videncObj->dmaHandle1D1D8B);
/* wait for transfer to finish */
ACPY3_wait(videncObj->dmaHandle1D1D8B);
}
/*
* Deactivate Channel scratch DMA channels.
*/
ACPY3_deactivate(videncObj->dmaHandle1D1D8B);
/*
* Because we used DMA, the algo processor didn't accessed either of the
* 2 data buffers.
*/
XDM_CLEARACCESSMODE_READ(inBufs->bufDesc[0].accessMask);
XDM_CLEARACCESSMODE_WRITE(inBufs->bufDesc[0].accessMask);
XDM_CLEARACCESSMODE_READ(outArgs->encodedBuf.accessMask);
XDM_CLEARACCESSMODE_WRITE(outArgs->encodedBuf.accessMask);
#else
/* everything looks good, do the 'encode', set outArgs and return */
memcpy(outBufs->bufs[0], inBufs->bufDesc[0].buf, numInBytes);
/* memcpy read from inBuf and wrote to encodedBuf (in our case, outBuf) */
XDM_CLEARACCESSMODE_WRITE(inBufs->bufDesc[0].accessMask);
XDM_SETACCESSMODE_READ(inBufs->bufDesc[0].accessMask);
XDM_CLEARACCESSMODE_READ(outArgs->encodedBuf.accessMask);
XDM_SETACCESSMODE_WRITE(outArgs->encodedBuf.accessMask);
#endif
/* outArgs->bytesGenerated reports the total number of bytes encoded */
outArgs->bytesGenerated = numInBytes;
/* report that the encoded data is in outArgs->encodedBuf */
outArgs->encodedBuf.buf = outBufs->bufs[0];
outArgs->encodedBuf.bufSize = outBufs->bufSizes[0];
/* Fill out the rest of the outArgs struct */
outArgs->extendedError = 0;
outArgs->encodedFrameType = 0; /* TODO */
outArgs->inputFrameSkip = IVIDEO_FRAME_ENCODED;
outArgs->outputID = inArgs->inputID;
/* TODO - add support for reconBufs */
outArgs->reconBufs.numBufs = 0;
return (IVIDENC1_EOK);
}
/*
* ======== VIDANALYTICSCOPY_TI_process ========
*/
XDAS_Int32 VIDANALYTICSCOPY_TI_process(IVIDANALYTICS_Handle handle,
XDM1_BufDesc *inBufs, XDM1_BufDesc *outBufs, IVIDANALYTICS_InArgs *inArgs,
IVIDANALYTICS_OutArgs *outArgs)
{
VIDANALYTICSCOPY_TI_Obj *obj = (VIDANALYTICSCOPY_TI_Obj *)handle;
/* begin this process call with 'good' view */
obj->viewState = IVIDANALYTICS_VIEWSTATE_GOOD;
/* validate arguments - this codec only supports "base" XDM. */
if ((inArgs->size != sizeof(*inArgs)) ||
(outArgs->size != sizeof(*outArgs))) {
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
XDM_SETUNSUPPORTEDPARAM(obj->extendedError);
return (IVIDANALYTICS_EUNSUPPORTED);
}
/* validate that there's at least a single inBuf and outBuf */
if ((inBufs->numBufs < 1) || (outBufs->numBufs < 1)) {
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
XDM_SETUNSUPPORTEDPARAM(obj->extendedError);
return (IVIDANALYTICS_EFAIL);
}
/*
* Sanity check that outBufs->descs[0].bufSize can hold the
* 'analyzed' data.
*/
if (outBufs->descs[0].bufSize < inBufs->descs[0].bufSize){
/* "too small" outBuf */
XDM_SETUNSUPPORTEDPARAM(outArgs->extendedError);
XDM_SETUNSUPPORTEDPARAM(obj->extendedError);
return (IVIDANALYTICS_EFAIL);
}
/* everything looks good, do the 'analysis', set outArgs and return */
memcpy(outBufs->descs[0].buf, inBufs->descs[0].buf,
inBufs->descs[0].bufSize);
/* report _how_ we accessed the input buffer */
XDM_CLEARACCESSMODE_WRITE(inBufs->descs[0].accessMask);
XDM_SETACCESSMODE_READ(inBufs->descs[0].accessMask);
/* indicate how we accessed outBufs it */
XDM_CLEARACCESSMODE_READ(outBufs->descs[0].accessMask);
XDM_SETACCESSMODE_WRITE(outBufs->descs[0].accessMask);
/* didn't detect anything. */
outArgs->numTargets = 0;
outArgs->numEvents = 0;
/* note that this example doesn't set outArgs->date. */
outArgs->extendedError = 0;
return (IVIDANALYTICS_EOK);
}
