/*
* ======== ceapp_encodeBuf ========
*/
int ceapp_encodeBuf(char *inBuf, int inBufSize,
char *encodedBuf, int encodedBufSize)
{
/* declare codec I/O buffer descriptors for the codec's process() func. */
XDM_BufDesc inBufDesc;
XDM_BufDesc encodedBufDesc;
/* declare in and out argument descriptors for process() */
VIDENC_InArgs encoderInArgs;
VIDENC_OutArgs encoderOutArgs;
/* declare arrays describing I/O buffers and their sizes */
XDAS_Int8* inBufs [ XDM_MAX_IO_BUFFERS ];
XDAS_Int32 inBufSizes [ XDM_MAX_IO_BUFFERS ];
XDAS_Int8* encodedBufs [ XDM_MAX_IO_BUFFERS ];
XDAS_Int32 encodedBufSizes[ XDM_MAX_IO_BUFFERS ];
Int32 status;
int retval = -1; /* nonzero means failure */
/* define the arrays describing I/O buffers and their sizes */
inBufs[0] = inBuf;
inBufSizes[0] = inBufSize;
encodedBufs[0] = encodedBuf;
encodedBufSizes[0] = encodedBufSize;
/* define I/O buffer descriptors using lengths and addrs of arrays above */
inBufDesc.numBufs = 1;
inBufDesc.bufs = inBufs;
inBufDesc.bufSizes = inBufSizes;
encodedBufDesc.numBufs = 1;
encodedBufDesc.bufs = encodedBufs;
encodedBufDesc.bufSizes = encodedBufSizes;
/* fill in the input arguments structure; we have nothing for this case */
encoderInArgs.size = sizeof(encoderInArgs);
encoderOutArgs.size = sizeof(encoderOutArgs);
/* encode the frame, pass addrs of the structures we populated above */
status = VIDENC_process(encHandle, &inBufDesc, &encodedBufDesc,
&encoderInArgs, &encoderOutArgs);
if (status == VIDENC_EOK) {
retval = 0;
}
else {
printf("CEapp-> VIDENC_process() failed, status = 0x%lx, "
"extendedError = 0x%lx\n", status, encoderOutArgs.extendedError);
}
return retval;
}
/*
* ======== encode_decode ========
*/
static Void encode_decode(VIDENC_Handle enc, VIDDEC_Handle dec, FILE *in,
FILE *out)
{
Int n;
Int32 status;
VIDDEC_InArgs decInArgs;
VIDDEC_OutArgs decOutArgs;
VIDDEC_DynamicParams decDynParams;
VIDDEC_Status decStatus;
VIDENC_InArgs encInArgs;
VIDENC_OutArgs encOutArgs;
VIDENC_DynamicParams encDynParams;
VIDENC_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;
//Note , this declaration is tell the memtab how much need to allocate the buf sizes
inBufSizes[0] = IFRAMESIZE;
encBufSizes[0] = EFRAMESIZE;
outBufSizes[0] = OFRAMESIZE;
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 = VIDENC_control(enc, XDM_GETSTATUS, &encDynParams, &encStatus);
if (status != VIDENC_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;
}
//#if 0
status = VIDDEC_control(dec, XDM_GETSTATUS, &decDynParams, &decStatus);
if (status != VIDDEC_EOK) {
/* failure, report error and exit */
GT_1trace(curMask, GT_7CLASS, "decode control status = 0x%x\n", status);
return;
}
//#endif
/* 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.
*/
/* opencv create init image */
#ifdef USE_OPENCV_DISPLAY
cvNamedWindow("sobel",CV_WINDOW_AUTOSIZE);
cvResizeWindow("sobel",320,240);//怕畫面太大讓人看不完,所以顯示視窗設小一點
#endif
CvSize size=cvSize(320,240);
frame=cvCreateImage(size,IPL_DEPTH_8U,3);
frame_gray=cvCreateImage(size,IPL_DEPTH_8U,1);
frame_Smooth=cvCreateImage(size,IPL_DEPTH_8U,1);
frame_sobel=cvCreateImage(size,IPL_DEPTH_16S,1);
frame_sobel_8U=cvCreateImage(size,IPL_DEPTH_8U,1);
/* v4l2 init */
int count=0;
deviceOpen();
deviceInit();
/*start capturing*/
captureStart();
/*===============v4l2 grab frame by Camera======================*/
while(1){
mainLoop(); /*this is the v4l2grab frame*/
memcpy(inBuf,buffers[0].start,IFRAMESIZE);
#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", count);
/* encode the frame */
status = VIDENC_process(enc, &inBufDesc, &encodedBufDesc, &encInArgs,
&encOutArgs);
GT_2trace(curMask, GT_2CLASS,
"App-> Encoder frame %d process returned - 0x%x)\n",
count, 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 != VIDENC_EOK) {
GT_3trace(curMask, GT_7CLASS,
"App-> Encoder frame %d processing FAILED, status = 0x%x, "
"extendedError = 0x%x\n", count, status, encOutArgs.extendedError);
break;
}
/***************************decode part (Unuse)***********************************/
/************************** decode the frame**************************************/
status = VIDDEC_process(dec, &encodedBufDesc, &outBufDesc, &decInArgs,
&decOutArgs);
GT_2trace(curMask, GT_2CLASS,
"App-> Decoder frame %d process returned - 0x%x)\n",
n, status);
if (status != VIDDEC_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(encodedBuf, EFRAMESIZE, 1, out);
frame->imageData = encoded[0];
frame_gray->imageData = dst[0];
//cvCvtColor(frame,frame_gray,CV_BGR2GRAY);
#ifdef USE_OPENCV_DISPLAY
cvShowImage("sobel",frame_gray);
int key=cvWaitKey(33);
#endif
//cvSaveImage("22.bmp",frame_gray,0);
printf("the %d frame are completed \n",count);
count++;
}/*end while*/
#ifdef USE_OPENCV_DISPLAY
cvDestroyWindow("sobel");
#endif
cvReleaseImage(&frame);
cvReleaseImage(&frame_gray);
cvReleaseImage(&frame_Smooth);
cvReleaseImage(&frame_sobel);
cvReleaseImage(&frame_sobel_8U);
GT_1trace(curMask, GT_1CLASS, "%d frames encoded/decoded\n", n);
}
/*
* ======== encode_decode ========
*/
static Void encode_decode(VIDENC_Handle enc, VIDDEC_Handle dec, FILE *in,
FILE *out)
{
Int n;
Int32 status;
VIDDEC_InArgs decInArgs;
VIDDEC_OutArgs decOutArgs;
VIDDEC_DynamicParams decDynParams;
VIDDEC_Status decStatus;
VIDENC_InArgs encInArgs;
VIDENC_OutArgs encOutArgs;
VIDENC_DynamicParams encDynParams;
VIDENC_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 = VIDENC_control(enc, XDM_GETSTATUS, &encDynParams, &encStatus);
if (status != VIDENC_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 = VIDDEC_control(dec, XDM_GETSTATUS, &decDynParams, &decStatus);
if (status != VIDDEC_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 = VIDENC_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 != VIDENC_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 */
status = VIDDEC_process(dec, &encodedBufDesc, &outBufDesc, &decInArgs,
&decOutArgs);
GT_2trace(curMask, GT_2CLASS,
"App-> Decoder frame %d process returned - 0x%x)\n",
n, status);
if (status != VIDDEC_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(dst[0], OFRAMESIZE, 1, out);
}
GT_1trace(curMask, GT_1CLASS, "%d frames encoded/decoded\n", n);
}
/*
* ======== call ========
*/
static VISA_Status call(VISA_Handle visaHandle, VISA_Msg visaMsg)
{
_VIDENC_Msg *msg = (_VIDENC_Msg *)visaMsg;
VIDENC_Handle handle = (VIDENC_Handle)visaHandle;
Int i;
XDM_BufDesc inBufs, outBufs;
IVIDENC_OutArgs *pOutArgs;
IVIDENC_Status *pStatus;
IVIDENC_CodecClassConfig *codecClassConfig;
/* get stub/skeleton config data; can be NULL (for old codecs) */
codecClassConfig = (IVIDENC_CodecClassConfig *)
VISA_getCodecClassConfig( visaHandle );
/* perform the requested VIDENC operation by parsing message. */
switch (msg->visa.cmd) {
case _VIDENC_CPROCESS: {
/* unmarshall inBufs and outBufs since they differ in shape
* from what their flattened versions passed in the message
*/
inBufs.bufs = msg->cmd.process.inBufs;
inBufs.numBufs = msg->cmd.process.numInBufs;
inBufs.bufSizes = msg->cmd.process.inBufSizes;
outBufs.bufs = msg->cmd.process.outBufs;
outBufs.numBufs = msg->cmd.process.numOutBufs;
outBufs.bufSizes = msg->cmd.process.outBufSizes;
if (SKEL_cachingPolicy == SKEL_LOCALBUFFERINVWB) {
/* invalidate cache for all input buffers */
for (i = 0; i < inBufs.numBufs; i++) {
if (codecClassConfig != NULL &&
codecClassConfig->manageInBufsCache[i] == FALSE) {
continue;
}
Memory_cacheInv(inBufs.bufs[i], inBufs.bufSizes[i]);
}
/* invalidate cache for all output buffers (unless told not to) */
for (i = 0; i < outBufs.numBufs; i++) {
if (codecClassConfig != NULL &&
codecClassConfig->manageOutBufsCache[i] == FALSE) {
continue;
}
Memory_cacheInv(outBufs.bufs[i], outBufs.bufSizes[i]);
}
} /* SKEL_cachingPolicy == SKEL_LOCALBUFFERINVWB */
/* unmarshall outArgs based on the "size" of inArgs */
pOutArgs = (IVIDENC_OutArgs *)((UInt)(&(msg->cmd.process.inArgs)) +
msg->cmd.process.inArgs.size);
/* make the process call */
msg->visa.status = VIDENC_process(handle,
&inBufs, &outBufs, &(msg->cmd.process.inArgs), pOutArgs);
if (SKEL_cachingPolicy == SKEL_WBINVALL) {
Memory_cacheWbInvAll();
}
else if (SKEL_cachingPolicy == SKEL_LOCALBUFFERINVWB) {
/* flush cache for all output buffers and outArgs buffers
* (unless...)
*/
for (i = 0; i < outBufs.numBufs; i++) {
if (codecClassConfig != NULL &&
codecClassConfig->manageOutBufsCache[i] == FALSE) {
continue;
}
Memory_cacheWb(outBufs.bufs[i], outBufs.bufSizes[i]);
}
for (i = 0; i < pOutArgs->reconBufs.numBufs; i++) {
if (codecClassConfig != NULL &&
codecClassConfig->manageReconBufsCache[i] == FALSE) {
continue;
}
Memory_cacheWbInv(pOutArgs->reconBufs.bufs[i],
pOutArgs->reconBufs.bufSizes[i]);
}
}
/*
* Note that any changes to individual outBufs[i] values made by
* the codec will automatically update msg->cmd.process.outBufs
* as we pass the outBufs array by reference.
*/
break;
}
case _VIDENC_CCONTROL: {
/* unmarshall status based on the "size" of params */
pStatus = (IVIDENC_Status *)((UInt)(&(msg->cmd.control.params)) +
msg->cmd.control.params.size);
msg->visa.status = VIDENC_control(handle, msg->cmd.control.id,
&(msg->cmd.control.params), pStatus);
break;
}
default: {
msg->visa.status = VISA_EFAIL;
break;
}
}
return (VISA_EOK);
}