DvevmStRetCode
dvtb_h264Dec2Decode(DvevmStH264Dec2Info *vd, int *decDuration)
{
int status = -1;
DvevmStTime timeStmpBfrDec, timeStmpAftrDec;
DvevmStRetCode retCode = DVEVM_ST_SUCCESS;
ASSERT(vd != NULL);
ASSERT(vd->vdec2Hdl != NULL);
vd->skipFrame = DVEVM_ST_FALSE;
dvtb_h264UpdateSEIVUIBuffers(vd);
timeStmpBfrDec = dvtb_getTime( );
status = VIDDEC2_process(vd->vdec2Hdl, &vd->inBufDesc, &vd->outBufDesc,(VIDDEC2_InArgs *)&vd->vdec2InArgs,(VIDDEC2_OutArgs *)&vd->vdec2OutArgs);
timeStmpAftrDec = dvtb_getTime( );
*decDuration = ((timeStmpAftrDec.tv_sec * NUM_MICROSECS_IN_SEC) + timeStmpAftrDec.tv_usec) - ((timeStmpBfrDec.tv_sec * NUM_MICROSECS_IN_SEC) + timeStmpBfrDec.tv_usec);
if (status != VIDDEC2_EOK)
{
SYS_ERROR("Video Decode Process Failed (%d)\n", (int) status);
vd->vdec2Cmd = XDM_GETSTATUS;
if (DVEVM_ST_FAIL == dvtb_h264Dec2Control(vd))
{
SYS_ERROR("Unable to get the status \n");
retCode = DVEVM_ST_FAIL;
}
else
{
SYS_ERROR("Codec Error = %d\n", (int) vd->vdec2Status.viddecStatus.extendedError);
if (XDM_ISFATALERROR(vd->vdec2Status.viddecStatus.extendedError))
{
SYS_ERROR("Video Decode Process failed (%d) with a Codec fatal error %x. Exiting.\n", (int) status, (int) vd->vdec2Status.viddecStatus.extendedError);
retCode = DVEVM_ST_FAIL;
}
SYS_ERROR("Video Decode Process failed (%d) with a Codec non fatal error %x. Continuing.\n", (int) status, (int) vd->vdec2Status.viddecStatus.extendedError);
}
}
if(vd->vdec2DynParams.Sei_Vui_parse_flag)
{
if(XDM_YUV_420P == vd->vdec2Params.viddecParams.forceChromaFormat)
{
vd->outBufDesc.bufs[4] = NULL;
vd->outBufDesc.bufSizes[4] = 0;
}
else if(XDM_YUV_422ILE == vd->vdec2Params.viddecParams.forceChromaFormat)
{
vd->outBufDesc.bufs[2] = NULL;
vd->outBufDesc.bufSizes[2] = 0;
}
}
return retCode;
}
DvevmStRetCode
dvtb_audDecDecode(DvevmStAudDecInfo *ad, int *decDuration)
{
XDAS_Int32 status = -1;
XDM_BufDesc inBufDesc, outBufDesc;
XDAS_Int8 *src = NULL, *dst = NULL;
IAUDDEC_InArgs decInArgs;
IAUDDEC_OutArgs decOutArgs;
DvevmStTime timeStmpBfrDec, timeStmpAftrDec;
DvevmStRetCode retCode = DVEVM_ST_SUCCESS;
ASSERT(ad != NULL);
ASSERT(ad->ceHdl != NULL);
ASSERT(ad->adecHdl != NULL);
ASSERT(ad->inBuf.start != NULL);
ASSERT(ad->outBuf.start != NULL);
src = (XDAS_Int8 *) ad->inBuf.start;
dst = (XDAS_Int8 *) ad->outBuf.start;
inBufDesc.numBufs = outBufDesc.numBufs = 1;
inBufDesc.bufSizes = (XDAS_Int32 *) &ad->inFrameSize;
outBufDesc.bufSizes = (XDAS_Int32 *) &ad->outBuf.size;
inBufDesc.bufs = &src;
outBufDesc.bufs = &dst;
decInArgs.size = sizeof(decInArgs);
decInArgs.numBytes = ad->inFrameSize;
decOutArgs.size = sizeof(decOutArgs);
timeStmpBfrDec = dvtb_getTime( );
status = AUDDEC_process(ad->adecHdl, &inBufDesc, &outBufDesc, &decInArgs, &decOutArgs);
timeStmpAftrDec = dvtb_getTime( );
*decDuration = ((timeStmpAftrDec.tv_sec * NUM_MICROSECS_IN_SEC) + timeStmpAftrDec.tv_usec) - ((timeStmpBfrDec.tv_sec * NUM_MICROSECS_IN_SEC) + timeStmpBfrDec.tv_usec);
if (status != AUDDEC_EOK)
{
if (XDM_ISFATALERROR(decOutArgs.extendedError))
{
SYS_ERROR("Audio Decode Process failed (%d)\n", (int) status);
SYS_ERROR("Codec Fatal Error => %d\n", (int) decOutArgs.extendedError);
retCode = DVEVM_ST_FAIL;
}
SYS_ERROR("Audio Decode Process failed (%d)\n", (int) status);
SYS_ERROR("Codec Non Fatal Extended Error => %d\n", (int) decOutArgs.extendedError);
}
if(DVEVM_ST_FAIL != retCode)
{
dvtb_audDecProcessDebug(&decOutArgs);
ad->decFrameSize = decOutArgs.bytesConsumed;
}
return retCode;
}
DvevmStRetCode
dvtb_vc1Dec2Decode(DvevmStVC1Dec2Info *vd, int nFrames, int *decDuration)
{
XDAS_Int32 status = -1;
int i = 0;
DvevmStTime timeStmpBfrDec, timeStmpAftrDec;
DvevmStRetCode retCode = DVEVM_ST_SUCCESS;
ASSERT(vd != NULL);
ASSERT((VIDDEC2_Handle) vd->vdec2Hdl != NULL);
vd->skipFrame = DVEVM_ST_FALSE;
vd->inBufDesc.numBufs = vd->inBuf.numBufs;
for (i = 0; i < vd->inBuf.numBufs; i++)
{
vd->inBufDesc.descs[i].buf = (XDAS_Int8 *) vd->inBuf.bufs[i];
vd->inBufDesc.descs[i].bufSize = (XDAS_Int32) vd->inBuf.bufSizes[i];
}
timeStmpBfrDec = dvtb_getTime();
status = VIDDEC2_process((VIDDEC2_Handle) vd->vdec2Hdl, &vd->inBufDesc, &vd->outBufDesc, (VIDDEC2_InArgs *) &vd->vdec2InArgs, (VIDDEC2_OutArgs*) &vd->vdec2OutArgs);
timeStmpAftrDec = dvtb_getTime();
*decDuration = ((timeStmpAftrDec.tv_sec * NUM_MICROSECS_IN_SEC) + timeStmpAftrDec.tv_usec) - ((timeStmpBfrDec.tv_sec * NUM_MICROSECS_IN_SEC) + timeStmpBfrDec.tv_usec);
if (status != VIDDEC2_EOK)
{
SYS_ERROR("Video Decode Process Failed (%d)\n", (int) status);
vd->vdec2Cmd = XDM_GETSTATUS;
if (DVEVM_ST_FAIL == dvtb_vc1Dec2Control(vd))
{
SYS_ERROR("Unable to get the status for frame # %d\n", nFrames);
retCode = DVEVM_ST_FAIL;
}
else
{
if (XDM_ISFATALERROR(vd->vdec2Status.viddecStatus.extendedError))
{
SYS_ERROR("Video Decode Process failed (%d) with a Codec fatal error %x. Exiting.\n", (int) status, (int) vd->vdec2Status.viddecStatus.extendedError);
return DVEVM_ST_FAIL;
}
SYS_ERROR("Video Decode Process failed (%d) with a Codec non fatal error %d. Continuing.\n", (int) status, (int) vd->vdec2Status.viddecStatus.extendedError);
}
}
return retCode;
}
DvevmStRetCode
dvtb_vidDecDecode(DvevmStVidDecInfo *vd, int nFrames, int *decDuration)
{
XDM_BufDesc inBufDesc;
XDM_BufDesc outBufDesc;
XDAS_Int32 status;
DvevmStTime timeStmpBfrEnc, timeStmpAftrEnc;
ASSERT(vd != NULL);
ASSERT(vd->vdecHdl != NULL);
ASSERT(vd->inBuf.bufs[0] != NULL);
ASSERT(vd->outBuf.bufs[0] != NULL);
inBufDesc.numBufs = vd->inBuf.numBufs;
inBufDesc.bufSizes = (XDAS_Int32 *) vd->inBuf.bufSizes;
inBufDesc.bufs = (XDAS_Int8 **) vd->inBuf.bufs;
outBufDesc.numBufs = vd->outBuf.numBufs;
outBufDesc.bufSizes = (XDAS_Int32 *) vd->outBuf.bufSizes;
outBufDesc.bufs = (XDAS_Int8 **) vd->outBuf.bufs;
vd->skipFrame = DVEVM_ST_FALSE;
timeStmpBfrEnc = dvtb_getTime();
status = VIDDEC_process(vd->vdecHdl, &inBufDesc, &outBufDesc, &vd->vdecInArgs, &vd->vdecOutArgs);
timeStmpAftrEnc = dvtb_getTime();
*decDuration = ((timeStmpAftrEnc.tv_sec*NUM_MICROSECS_IN_SEC)+timeStmpAftrEnc.tv_usec)-((timeStmpBfrEnc.tv_sec*NUM_MICROSECS_IN_SEC)+timeStmpBfrEnc.tv_usec);
if (status != VIDDEC_EOK)
{
if (VIDDEC_ERUNTIME == status ||
XDM_ISFATALERROR(vd->vdecOutArgs.extendedError))
{
SYS_ERROR("Video Decode Process failed (%d) with a codec fatal error (0x%x)\n", (int) status, (int) vd->vdecOutArgs.extendedError);
return DVEVM_ST_FAIL;
}
SYS_DEBUG("Video Decode Process Failed (%d)\n", (int) status);
SYS_DEBUG("Codec Error : %d\n", (int) vd->vdecOutArgs.extendedError);
// vd->skipFrame = DVEVM_ST_TRUE;
}
dvtb_vidDecProcessDebug(&vd->vdecOutArgs);
return DVEVM_ST_SUCCESS;
}
DvevmStRetCode
dvtb_MPEG4Enc1Control(DvevmStMPEG4Enc1Info *ve)
{
int status = -1, i = 0;
DvevmStRetCode retCode = DVEVM_ST_SUCCESS;
ASSERT(ve != NULL);
ASSERT(ve->ceHdl != NULL);
status = VIDENC1_control(ve->venc1Hdl, ve->venc1Cmd, (IVIDENC1_DynamicParams *) (&ve->venc1DynParams), (IVIDENC1_Status *) (&ve->venc1Status));
if (VIDENC1_EOK != status)
{
SYS_ERROR("Error (%d), Codec Error (%d) in Video Encoder Control\n", status, (int) ve->venc1Status.videncStatus.extendedError);
retCode = DVEVM_ST_FAIL;
}
else
{
if (XDM_GETBUFINFO == ve->venc1Cmd)
{
ve->inBuf.numBufs = ve->venc1Status.videncStatus.bufInfo.minNumInBufs;
for (i = 0; i < ve->inBuf.numBufs; i++)
ve->inBuf.bufSizes[i] = ve->venc1Status.videncStatus.bufInfo.minInBufSize[i];
ve->outBuf.numBufs = ve->venc1Status.videncStatus.bufInfo.minNumOutBufs;
for (i = 0; i < ve->outBuf.numBufs; i++)
ve->outBuf.bufSizes[i] = ve->venc1Status.videncStatus.bufInfo.minOutBufSize[i];
}
else if(XDM_GETSTATUS == ve->venc1Cmd)
{
if(ve->venc1Status.videncStatus.extendedError)
{
if(XDM_ISFATALERROR(ve->venc1Status.videncStatus.extendedError))
{
SYS_ERROR("Exiting: Encode Failed with a Codec fatal error %x.\n", (int) ve->venc1Status.videncStatus.extendedError);
retCode = DVEVM_ST_FAIL;
}
else
SYS_DEBUG("Continue: Codec generated an non fatal error %x.\n", (int) ve->venc1Status.videncStatus.extendedError);
}
}
}
return retCode;
}
/******************************************************************************
* Idec1_process
******************************************************************************/
Int Idec1_process(Idec1_Handle hId, Buffer_Handle hInBuf,
Buffer_Handle hOutBuf)
{
BufferGfx_Dimensions dim;
IMGDEC1_DynamicParams dynParams;
IMGDEC1_InArgs inArgs;
IMGDEC1_OutArgs outArgs;
IMGDEC1_Status decStatus;
XDM1_BufDesc inBufDesc;
XDM1_BufDesc outBufDesc;
XDAS_Int32 status;
XDAS_Int8 * inPtr;
XDAS_Int8 * outPtr;
UInt32 offset = 0;
UInt32 i;
assert(hId);
assert(hInBuf);
assert(hOutBuf);
assert(Buffer_getSize(hInBuf));
assert(Buffer_getUserPtr(hInBuf));
assert(Buffer_getUserPtr(hOutBuf));
assert(Buffer_getNumBytesUsed(hInBuf));
assert(Buffer_getSize(hOutBuf));
assert(Buffer_getType(hOutBuf) == Buffer_Type_GRAPHICS);
BufferGfx_getDimensions(hOutBuf, &dim);
inPtr = Buffer_getUserPtr(hInBuf);
outPtr = Buffer_getUserPtr(hOutBuf);
inArgs.size = sizeof(IMGDEC1_InArgs);
inArgs.numBytes = Buffer_getNumBytesUsed(hInBuf);
outArgs.size = sizeof(IMGDEC1_OutArgs);
inBufDesc.numBufs = 1;
outBufDesc.numBufs = hId->minNumOutBufs;
inBufDesc.descs[0].buf = inPtr;
inBufDesc.descs[0].bufSize = Buffer_getSize(hInBuf);
for(i = 0; i < hId->minNumOutBufs; i++)
{
outBufDesc.descs[i].buf = (XDAS_Int8 *)((unsigned int)outPtr + offset);
offset += hId->minOutBufSize[i];
outBufDesc.descs[i].bufSize = hId->minOutBufSize[i];
}
/* Decode image buffer */
status = IMGDEC1_process(hId->hDecode, &inBufDesc, &outBufDesc, &inArgs,
&outArgs);
Buffer_setNumBytesUsed(hInBuf, outArgs.bytesConsumed);
if (status != IMGDEC1_EOK) {
if (XDM_ISFATALERROR(outArgs.extendedError)) {
Dmai_err2("IMGDEC1_process() failed with error (%d ext: 0x%x)\n",
(Int)status, (Uns) outArgs.extendedError);
return Dmai_EFAIL;
}
else {
Dmai_dbg1("IMGDEC1_process() non-fatal error 0x%x\n",
(Uns) outArgs.extendedError);
return Dmai_EBITERROR;
}
}
/* Get the dynamic codec status */
decStatus.data.buf = NULL;
decStatus.size = sizeof(IMGDEC1_Status);
dynParams.size = sizeof(IMGDEC1_DynamicParams);
status = IMGDEC1_control(hId->hDecode, XDM_GETSTATUS, &dynParams,
&decStatus);
if (status != IMGDEC1_EOK) {
Dmai_err1("XDM_GETSTATUS failed, status=%d\n", status);
return Dmai_EFAIL;
}
/* Set output Color Format */
switch (decStatus.outputChromaFormat) {
case XDM_YUV_422ILE:
BufferGfx_setColorSpace (hOutBuf, ColorSpace_UYVY);
break;
case XDM_YUV_420P:
BufferGfx_setColorSpace (hOutBuf, ColorSpace_YUV420P);
break;
case XDM_YUV_422P:
BufferGfx_setColorSpace (hOutBuf, ColorSpace_YUV422P);
break;
case XDM_YUV_444P:
BufferGfx_setColorSpace (hOutBuf, ColorSpace_YUV444P);
break;
case XDM_GRAY:
BufferGfx_setColorSpace (hOutBuf, ColorSpace_GRAY);
break;
default:
printf("Unsupported output color space.\n");
return Dmai_EFAIL;
}
dim.x = dim.y = 0;
dim.width = decStatus.outputWidth;
dim.height = decStatus.outputHeight;
dim.lineLength = decStatus.outputWidth *
ColorSpace_getBpp(BufferGfx_getColorSpace(hOutBuf)) / 8;
if (BufferGfx_setDimensions(hOutBuf, &dim) < 0) {
Dmai_err0("Frame does not fit in allocated buffer\n");
return Dmai_EFAIL;
}
return Dmai_EOK;
}
/*
* ======== VIDDEC1_process ========
* This method must be the same for both local and remote invocation;
* each call site in the client might be calling different implementations
* (one that marshalls & sends and one that simply calls). This API
* abstracts *all* video decoders (both high and low complexity
* decoders are invoked using this method).
*/
XDAS_Int32 VIDDEC1_process(VIDDEC1_Handle handle, XDM1_BufDesc *inBufs,
XDM_BufDesc *outBufs, VIDDEC1_InArgs *inArgs, VIDDEC1_OutArgs *outArgs)
{
XDAS_Int32 retVal = VIDDEC1_EFAIL;
VIDDEC1_InArgs refInArgs;
Int32 i;
/*
* Note, we assign "VISA_isChecked()" results to a local variable
* rather than repeatedly query it throughout this fxn because
* someday we may allow dynamically changing the global
* 'VISA_isChecked()' value on the fly. If we allow that, we need
* to ensure the value stays consistent in the context of this
* call.
*/
Bool checked = VISA_isChecked();
if (checked) {
/* Ensure inArgs and outArgs are non-NULL, per the XDM spec */
if ((!(XdmUtils_validateExtendedStruct(inArgs, sizeof(*inArgs),
"inArgs"))) || (!(XdmUtils_validateExtendedStruct(outArgs,
sizeof(*outArgs), "outArgs")))) {
/* for safety, return here before dereferencing and crashing */
return (retVal);
}
}
Log_print5(Diags_ENTRY, "[+E] VIDDEC1_process> "
"Enter (handle=0x%x, inBufs=0x%x, outBufs=0x%x, inArgs=0x%x, "
"outArgs=0x%x)",
(IArg)handle, (IArg)inBufs, (IArg)outBufs, (IArg)inArgs,
(IArg)outArgs);
if (handle) {
IVIDDEC1_Fxns *fxns =
(IVIDDEC1_Fxns *)VISA_getAlgFxns((VISA_Handle)handle);
IVIDDEC1_Handle alg = VISA_getAlgHandle((VISA_Handle)handle);
if ((fxns != NULL) && (alg != NULL)) {
if (checked) {
/* validate inArgs with ranges. */
if (inArgs->inputID == 0) {
Log_print2(Diags_USER7,
"[+7] ERROR> app provided codec (0x%x) with out of range "
"inArgs->inputID field (0x%x)",
(IArg)alg, (IArg)(inArgs->inputID));
}
/*
* Validate inBufs and outBufs.
*/
XdmUtils_validateSparseBufDesc1(inBufs, "inBufs");
XdmUtils_validateSparseBufDesc(outBufs, "outBufs");
/*
* Make a reference copy of inArgs so we can check that
* the codec didn't modify them during process().
*/
refInArgs = *inArgs;
}
//Log_printf(ti_sdo_ce_dvtLog, "%s", (Arg)"VIDDEC1:process",
// (Arg)handle, (Arg)0);
VISA_enter((VISA_Handle)handle);
retVal = fxns->process(alg, inBufs, outBufs, inArgs, outArgs);
VISA_exit((VISA_Handle)handle);
if (checked) {
/* ensure the codec didn't modify the read-only inArgs */
if (memcmp(&refInArgs, inArgs, sizeof(*inArgs)) != 0) {
Log_print1(Diags_USER7,
"[+7] ERROR> codec (0x%x) modified read-only inArgs "
"struct!", (IArg)handle);
}
/* only check these on successful return */
if ((retVal == IVIDDEC1_EOK) || (!(XDM_ISFATALERROR(
outArgs->decodedBufs.extendedError)))) {
/* Validate outArgs->decodedBufs */
XdmUtils_validateVideo1BufDesc(&(outArgs->decodedBufs),
"decodedBufs");
}
/* Validate outArgs->displayBufs */
for (i = 0; ((outArgs->outputID[i] != 0) &&
(i < XDM_MAX_IO_BUFFERS)); i++) {
if ((retVal == IVIDDEC1_EOK) ||
(!(XDM_ISFATALERROR(outArgs->
displayBufs[i].extendedError)))) {
XdmUtils_validateVideo1BufDesc(&(outArgs->displayBufs[i]),
"displayBufs");
}
}
}
}
}
Log_print2(Diags_EXIT, "[+X] VIDDEC1_process> "
"Exit (handle=0x%x, retVal=0x%x)", (IArg)handle, (IArg)retVal);
return (retVal);
}
/*
* ======== unmarshallMsg ========
*/
static XDAS_Int32 unmarshallMsg(IVIDDEC2_Handle h, XDM1_BufDesc *inBufs,
XDM_BufDesc *outBufs, IVIDDEC2_InArgs *inArgs, IVIDDEC2_OutArgs *outArgs,
_VIDDEC2_Msg *msg, XDAS_Int32 retVal)
{
VISA_Handle visa = (VISA_Handle)h;
IVIDDEC2_OutArgs *pMsgOutArgs;
Int i, j;
Int numBufs;
/*
* Do a wholesale replace of skeleton returned structure.
* Pointer conversion of fields in outArgs is done below (only
* in the case of a successful return value).
*/
pMsgOutArgs = (IVIDDEC2_OutArgs *)((UInt)(&(msg->cmd.process.inArgs)) +
inArgs->size);
if (VISA_isChecked()) {
/* ensure the codec didn't change outArgs->size */
Assert_isTrue(pMsgOutArgs->size == outArgs->size, (Assert_Id)NULL);
}
memcpy(outArgs, pMsgOutArgs, outArgs->size);
/* if VISA_call was successful, unmarshall the necessary buffers. */
if (retVal == IVIDDEC2_EOK) {
/* unmarshall the output data: outBufs and mbDataBuf. */
if (VISA_isChecked()) {
/* ensure the codec didn't send back "too many" buffers */
Assert_isTrue(msg->cmd.process.numOutBufs < XDM_MAX_IO_BUFFERS,
(Assert_Id)NULL);
}
/* The outBufs may have changed, so don't rely on what was passed in */
outBufs->numBufs = msg->cmd.process.numOutBufs;
for (i = 0, numBufs = 0;
((numBufs < outBufs->numBufs) && (i < XDM_MAX_IO_BUFFERS)); i++) {
if (msg->cmd.process.outBufs[i] != NULL) {
/* valid member of sparse array, convert it */
outBufs->bufSizes[i] = msg->cmd.process.outBufSizes[i];
outBufs->bufs[i] = (XDAS_Int8 *)
Memory_getBufferVirtualAddress(
(UInt32)msg->cmd.process.outBufs[i],
outBufs->bufSizes[i]);
if (outBufs->bufs[i] == NULL) {
/* TODO:M - should add at least a trace statement when trace
* is supported. Another good idea is to return something
* more clear than EFAIL.
*/
retVal = IVIDDEC2_EFAIL;
goto exit;
}
/* found, and handled, another buffer. */
numBufs++;
}
else {
/* empty member of sparse array, no conversion needed */
outBufs->bufSizes[i] = 0;
outBufs->bufs[i] = NULL;
}
}
/* convert mbDataBuf */
if (outArgs->mbDataBuf.buf != NULL) {
Memory_getBufferVirtualAddress((UInt32)outArgs->mbDataBuf.buf,
outArgs->mbDataBuf.bufSize);
/* Clear .accessMask; the local processor didn't access this buf */
outArgs->mbDataBuf.accessMask = 0;
}
}
/*
* Note that buffers can also be returned if IVIDDEC_EFAIL is returned
* with a non-fatal .extendedError in displayBufs[] and decodedBufs.
*/
/* address translate the decoded buffers if non-fatal error */
if ((retVal == IVIDDEC2_EOK) ||
(!(XDM_ISFATALERROR(outArgs->decodedBufs.extendedError)))) {
for (i = 0; i < IVIDEO_MAX_YUV_BUFFERS; i++) {
if (outArgs->decodedBufs.bufDesc[i].buf != NULL) {
outArgs->decodedBufs.bufDesc[i].buf =
Memory_getBufferVirtualAddress(
(UInt32)outArgs->decodedBufs.bufDesc[i].buf,
outArgs->decodedBufs.bufDesc[i].bufSize);
/* Clear .accessMask; the local proc didn't access this buf */
outArgs->decodedBufs.bufDesc[i].accessMask = 0;
}
}
}
/* Buffers in outArgs.displayBufs are physical, so convert them if needed */
for (i = 0; i < IVIDDEC2_MAX_IO_BUFFERS; i++) {
if (outArgs->outputID[i] != 0) {
if ((retVal == IVIDDEC2_EOK) ||
(!(XDM_ISFATALERROR(outArgs->
displayBufs[i].extendedError)))) {
for (j = 0; j < IVIDEO_MAX_YUV_BUFFERS; j++) {
if (outArgs->displayBufs[i].bufDesc[j].buf != NULL) {
outArgs->displayBufs[i].bufDesc[j].buf =
Memory_getBufferVirtualAddress(
(UInt32)outArgs->displayBufs[i].bufDesc[j].buf,
outArgs->displayBufs[i].bufDesc[j].bufSize);
/*
* Clear .accessMask; the local processor didn't
* access this buf.
*/
outArgs->displayBufs[i].bufDesc[j].accessMask = 0;
}
}
}
}
}
/* Note that we did *nothing* with inBufs nor inArgs. This should be ok. */
exit:
VISA_freeMsg(visa, (VISA_Msg)msg);
return (retVal);
}
static gint
codec_process (GstDucatiVidDec * self, gboolean send, gboolean flush)
{
gint err;
GstClockTime t;
GstBuffer *outbuf = NULL;
gint i;
self->outArgs->outputID[0] = 0;
self->outArgs->freeBufID[0] = 0;
t = gst_util_get_timestamp ();
err = VIDDEC3_process (self->codec,
self->inBufs, self->outBufs, self->inArgs, self->outArgs);
GST_INFO_OBJECT (self, "%10dns", (gint) (gst_util_get_timestamp () - t));
if (err) {
GST_WARNING_OBJECT (self, "err=%d, extendedError=%08x",
err, self->outArgs->extendedError);
err = VIDDEC3_control (self->codec, XDM_GETSTATUS,
self->dynParams, self->status);
GST_WARNING_OBJECT (self, "XDM_GETSTATUS: err=%d, extendedError=%08x",
err, self->status->extendedError);
if (XDM_ISFATALERROR (self->outArgs->extendedError) || flush) {
/* we are processing for display and it is a non-fatal error, so lets
* try to recover.. otherwise return the error
*/
err = XDM_EFAIL;
}
}
for (i = 0; self->outArgs->outputID[i]; i++) {
if (G_UNLIKELY (self->first_out_buffer) && send) {
/* send region of interest to sink on first buffer: */
XDM_Rect *r = &(self->outArgs->displayBufs.bufDesc[0].activeFrameRegion);
GST_DEBUG_OBJECT (self, "setting crop to %d, %d, %d, %d",
r->topLeft.x, r->topLeft.y, r->bottomRight.x, r->bottomRight.y);
gst_pad_push_event (self->srcpad,
gst_event_new_crop (r->topLeft.y, r->topLeft.x,
r->bottomRight.x - r->topLeft.x,
r->bottomRight.y - r->topLeft.y));
self->first_out_buffer = FALSE;
}
outbuf = codec_get_outbuf (self, self->outArgs->outputID[i]);
if (send) {
if (GST_IS_DUCATIBUFFER (outbuf)) {
outbuf = gst_ducati_buffer_get (GST_DUCATIBUFFER (outbuf));
}
GST_DEBUG_OBJECT (self, "got buffer: %d %p (%" GST_TIME_FORMAT ")",
i, outbuf, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)));
gst_pad_push (self->srcpad, outbuf);
} else {
GST_DEBUG_OBJECT (self, "free buffer: %d %p", i, outbuf);
gst_buffer_unref (outbuf);
}
}
for (i = 0; self->outArgs->freeBufID[i]; i++) {
codec_unlock_outbuf (self, self->outArgs->freeBufID[i]);
}
return err;
}
DvevmStRetCode
dvtb_audDec1Decode(DvevmStAudDec1Info *ad, int *decDuration)
{
XDAS_Int32 status = -1;
XDM1_BufDesc inBufDesc, outBufDesc;
IAUDDEC1_InArgs decInArgs;
IAUDDEC1_OutArgs decOutArgs;
DvevmStTime timeStmpBfrDec, timeStmpAftrDec;
DvevmStRetCode retCode = DVEVM_ST_SUCCESS;
ASSERT(ad != NULL);
ASSERT(ad->ceHdl != NULL);
ASSERT(ad->adecHdl != NULL);
ad->inBuf.numBufs = 1;
ad->outBuf.numBufs = 1;
inBufDesc.numBufs = 1;
inBufDesc.descs[0].bufSize = ad->inBuf.bufSizes[0];
inBufDesc.descs[0].buf = (XDAS_Int8 *)ad->inBuf.bufs[0];
outBufDesc.numBufs = 1;
outBufDesc.descs[0].bufSize = ad->outBuf.bufSizes[0];
outBufDesc.descs[0].buf = (XDAS_Int8 *) ad->outBuf.bufs[0];
decInArgs.size = sizeof(decInArgs);
decInArgs.numBytes = ad->inFrameSize;
decInArgs.desiredChannelMode = ad->desiredChannelMode;
decInArgs.lfeFlag = ad->lfeFlag;
decOutArgs.size = sizeof(decOutArgs);
timeStmpBfrDec = dvtb_getTime( );
status = AUDDEC1_process(ad->adecHdl, &inBufDesc, &outBufDesc, &decInArgs, &decOutArgs);
timeStmpAftrDec = dvtb_getTime( );
*decDuration = ((timeStmpAftrDec.tv_sec * NUM_MICROSECS_IN_SEC) + timeStmpAftrDec.tv_usec) - ((timeStmpBfrDec.tv_sec * NUM_MICROSECS_IN_SEC) + timeStmpBfrDec.tv_usec);
if (status != AUDDEC1_EOK)
{
if (XDM_ISFATALERROR(decOutArgs.extendedError))
{
SYS_ERROR("Audio Decode Process failed with a fatal error (%d)\n", (int) status);
SYS_ERROR("Codec Error => %d\n", (int) decOutArgs.extendedError);
retCode = DVEVM_ST_FAIL;
}
else if ((1 << XDM_INSUFFICIENTDATA) & decOutArgs.extendedError)
{
SYS_ERROR("Audio Decode Process failed with ERROR: INSUFFICIENTDATA \n");
SYS_DEBUG("Number of bytes remained: %d \n", (int) ad->inFrameSize - (int) decOutArgs.bytesConsumed);
retCode = DVEVM_ST_FAIL;
}
else
{
SYS_ERROR("Audio Decode Process failed (%d) \n", (int) status);
SYS_ERROR(" Non Fatal Codec Error => %d. continue decoding \n", (int) decOutArgs.extendedError);
}
}
if(DVEVM_ST_FAIL != retCode)
{
dvtb_audDec1ProcessDebug(&decOutArgs);
ad->decFrameSize = decOutArgs.bytesConsumed;
}
return retCode;
}
/******************************************************************************
* 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;
}
