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