/*****************************************************************************
Prototype : jpg_enc_process
Description : Run alg for jpeg encode
Input : Ptr algHandle
AlgBuf *inBuf
Ptr inArgsPtr
AlgBuf *outBuf
Ptr outArgsPtr
Output : None
Return Value : static
Calls :
Called By :
History :
1.Date : 2012/2/1
Author : Sun
Modification : Created function
*****************************************************************************/
static Int32 jpg_encode_process(Ptr algHandle, AlgBuf *inBuf, Ptr inArgsPtr, AlgBuf *outBuf, Ptr outArgsPtr)
{
JpgEncodeHandle hJpgEnc = (JpgEncodeHandle)algHandle;
if(!algHandle || !hJpgEnc->algHandle || !inBuf || !outBuf || !inArgsPtr || !outArgsPtr)
return E_INVAL;
JpgEncInArgs *inArgs = (JpgEncInArgs *)inArgsPtr;
JpgEncOutArgs *outArgs =(JpgEncOutArgs *)outArgsPtr;
if(inArgs->size != sizeof(JpgEncInArgs) || outArgs->size != sizeof(JpgEncOutArgs)) {
ERR("Invaild in/out args size.");
return E_INVAL;
}
/* Setup input and output args */
IIMGENC1_InArgs inEncArgs;
IIMGENC1_OutArgs outEncArgs;
inEncArgs.size = sizeof(IIMGENC1_InArgs);
outEncArgs.size = sizeof(IIMGENC1_OutArgs);
outEncArgs.bytesGenerated = 0;
outEncArgs.currentAU = 0;
outEncArgs.extendedError = 0;
/* Setup buffer descriptors */
Int32 i, offset = 0;
for(i = 0; i < hJpgEnc->inBufDesc.numBufs; i++) {
hJpgEnc->inBufDesc.descs[i].buf = (XDAS_Int8 *)(inBuf->buf + offset);
offset += hJpgEnc->status.bufInfo.minInBufSize[i];
}
hJpgEnc->outBufDesc.descs[0].buf = (XDAS_Int8 *)(outBuf->buf);
Int32 status;
status = IMGENC1_process(hJpgEnc->algHandle,
&hJpgEnc->inBufDesc,
&hJpgEnc->outBufDesc,
&inEncArgs, &outEncArgs);
if(status != IIMGENC1_EOK) {
ERR("process error: %d", (int)status);
return E_IO;
}
/* Fill out args */
if(inArgs->appendData) {
/* Append data to the end of jpeg image */
outArgs->bytesGenerated = jpg_append_data(outBuf, outEncArgs.bytesGenerated, inArgs);
} else {
outArgs->bytesGenerated = outEncArgs.bytesGenerated;
}
return E_NO;
}
/*
* ======== encode_decode ========
*/
static Void encode_decode(IMGENC1_Handle enc, IMGDEC1_Handle dec, FILE *in,
FILE *out)
{
Int n;
Int32 status;
IMGDEC1_InArgs decInArgs;
IMGDEC1_OutArgs decOutArgs;
IMGDEC1_DynamicParams decDynParams;
IMGDEC1_Status decStatus;
IMGENC1_InArgs encInArgs;
IMGENC1_OutArgs encOutArgs;
IMGENC1_DynamicParams encDynParams;
IMGENC1_Status encStatus;
XDM1_BufDesc inBufDesc;
XDM1_BufDesc encodedBufDesc;
XDM1_BufDesc outBufDesc;
/* initialize the buffer descriptors */
inBufDesc.numBufs = encodedBufDesc.numBufs = outBufDesc.numBufs = 1;
inBufDesc.descs[0].bufSize = encodedBufDesc.descs[0].bufSize =
outBufDesc.descs[0].bufSize = NSAMPLES;
inBufDesc.descs[0].buf = inBuf;
encodedBufDesc.descs[0].buf = encodedBuf;
outBufDesc.descs[0].buf = outBuf;
/* 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);
/*
* Note that we use versionBuf in both the encoder and decoder. In this
* application, this is okay, as there is always only one user of
* the buffer. Not all applications can make this assumption.
*/
encStatus.data.buf = decStatus.data.buf = versionBuf;
encStatus.data.bufSize = decStatus.data.bufSize = MAXVERSIONSIZE;
/* if the codecs support it, dump their versions */
status = IMGDEC1_control(dec, XDM_GETVERSION, &decDynParams, &decStatus);
GT_1trace(curMask, GT_1CLASS, "Decoder version: %s\n",
(status == IMGDEC1_EOK ? ((char *)decStatus.data.buf) : "[unknown]"));
status = IMGENC1_control(enc, XDM_GETVERSION, &encDynParams, &encStatus);
GT_1trace(curMask, GT_1CLASS, "Encoder version: %s\n",
(status == IMGENC1_EOK ? ((char *)encStatus.data.buf) : "[unknown]"));
/*
* This app expects the encoder to accept 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 = IMGENC1_control(enc, XDM_GETBUFINFO, &encDynParams, &encStatus);
if (status != IMGENC1_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 = IMGDEC1_control(dec, XDM_GETBUFINFO, &decDynParams, &decStatus);
if (status != IMGDEC1_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++) {
if (appPause) {
printf("About to start frame %d. Press Enter to continue...\n", n);
appPause = ('c' == getchar() ? 0 : 1);
}
/* Deal with cache issues, if necessary */
#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 = IMGENC1_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 != IMGENC1_EOK) {
GT_3trace(curMask, GT_7CLASS,
"App-> Encoder frame %d processing FAILED, status = 0x%x, "
"extendedError = 0x%x\n", n, status, encOutArgs.extendedError);
break;
}
/* decode the frame */
decInArgs.numBytes = encOutArgs.bytesGenerated;
status = IMGDEC1_process(dec, &encodedBufDesc, &outBufDesc, &decInArgs,
&decOutArgs);
GT_2trace(curMask, GT_2CLASS,
"App-> Decoder frame %d process returned - 0x%x)\n",
n, status);
if (status != IMGDEC1_EOK) {
GT_3trace(curMask, GT_7CLASS,
"App-> Decoder frame %d processing FAILED, status = 0x%x, "
"extendedError = 0x%x\n", n, status, decOutArgs.extendedError);
break;
}
#ifdef CACHE_ENABLED
/* Writeback the outBuf. */
Memory_cacheWb(outBuf, OFRAMESIZE);
#endif
/* write to file */
fwrite(outBuf, OFRAMESIZE, 1, out);
#ifdef USE_POWER_MANAGEMENT
if (Global_usePowerManagement) {
if (appPause) {
printf("About to hibernate. Press Enter to continue...\n");
appPause = ('c' == getchar() ? 0 : 1);
}
LPM_Status lpmStat = LPM_SOK;
GT_0trace(curMask, GT_2CLASS, "Turning DSP off\n");
lpmStat = LPM_setPowerState(lpmHandle, LPM_HIBERNATE);
if (lpmStat != LPM_SOK) {
fprintf(stderr, "Error: LPM_setPowerState() failed\n");
return;
}
if (appPause) {
printf("DSP is off: Press Enter to continue...\n");
appPause = ('c' == getchar() ? 0 : 1);
}
else {
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 200000; /* 200 msec */
if (select(0, NULL, NULL, NULL, &tv) == -1) {
fprintf(stderr, "Error: select() failed\n");
return;
}
}
GT_0trace(curMask, GT_1CLASS, "Turning DSP on\n");
lpmStat = LPM_resume(lpmHandle);
if (lpmStat != LPM_SOK) {
fprintf(stderr, "Error: LPM_resume() failed\n");
return;
}
if (appPause) {
printf("DSP is on: Press Enter to continue...\n");
appPause = ('c' == getchar() ? 0 : 1);
}
}
#endif
}
GT_1trace(curMask, GT_1CLASS, "%d frames encoded/decoded\n", n);
}
//changed by zeng
int ALG_jpgEncRun(void *hndl, ALG_JpgEncRunPrm *prm, ALG_JpgEncRunStatus *runStatus, CallBackSetOSDPixel func)
{
ALG_JpgEncObj *pObj = (ALG_JpgEncObj*)hndl;
XDM1_BufDesc inBufDesc;
XDM1_BufDesc outBufDesc;
XDAS_Int32 status;
IMGENC1_InArgs inArgs;
IMGENC1_OutArgs outArgs;
Uint32 bytesPerPixel, offset;
runStatus->bytesGenerated = 0;
if(pObj==NULL)
return OSA_EFAIL;
offset = pObj->createPrm.offsetH * pObj->createPrm.offsetV;
if(prm->outDataMaxSize==0)
prm->outDataMaxSize = pObj->createPrm.width*pObj->createPrm.height*2;
prm->inStartY = OSA_floor(prm->inStartY, 2);
prm->inStartX = OSA_floor(prm->inStartX, 2);
inBufDesc.numBufs = 1;
bytesPerPixel = 1;
if(pObj->createPrm.dataFormat==ALG_VID_DATA_FORMAT_YUV422) {
bytesPerPixel = 2;
}
inBufDesc.descs[0].bufSize = pObj->createPrm.offsetH*pObj->createPrm.offsetV*bytesPerPixel;
inBufDesc.descs[0].buf = (XDAS_Int8*)(prm->inAddr + prm->inStartY*pObj->createPrm.offsetH*bytesPerPixel + prm->inStartX*bytesPerPixel);
inBufDesc.descs[0].accessMask = 0;
if(pObj->createPrm.dataFormat==ALG_VID_DATA_FORMAT_YUV420) {
inBufDesc.numBufs = 2;
inBufDesc.descs[1].bufSize = pObj->createPrm.offsetH*pObj->createPrm.offsetV/2;
inBufDesc.descs[1].buf = (XDAS_Int8*)(prm->inAddr + offset + prm->inStartY*pObj->createPrm.offsetH/2 + prm->inStartX);
inBufDesc.descs[1].accessMask = 0;
}
if(prm->snapEnable) {
OSA_fileWriteVideoData(prm->snapFilename, (Uint8 *)inBufDesc.descs[0].buf, (Uint8 *)inBufDesc.descs[1].buf,
pObj->createPrm.width, pObj->createPrm.height, pObj->createPrm.offsetH);
}
outBufDesc.numBufs = 1;
outBufDesc.descs[0].buf = (XDAS_Int8*)prm->outAddr;
outBufDesc.descs[0].bufSize = prm->outDataMaxSize;
outBufDesc.descs[0].accessMask = 0;
inArgs.size = sizeof(IMGENC1_InArgs);
outArgs.size = sizeof(IMGENC1_OutArgs);
if( func != NULL ){
func(pObj->params.maxWidth, pObj->params.maxHeight, inBufDesc.descs[0].buf, inBufDesc.descs[1].buf);
}
status = IMGENC1_process(pObj->hEncode, &inBufDesc, &outBufDesc, &inArgs, &outArgs);
if (status != IMGENC1_EOK)
return OSA_EFAIL;
runStatus->bytesGenerated = outArgs.bytesGenerated;
return OSA_SOK;
}
