之前网上有个opencv dsp加速之类，是基于c6acces的，比较麻烦，我干脆全部移植到codec当中去。在videnc_copy中成功编译，在dm3730上跑，也成功，速度还好。达芬奇davince平台都可以这样干了。后期在8148上面试试速度。如果达芬奇平台启动时间够快，做车载运用，将是比较好的选择。以下是个测试程序 /* * Copyright (c) 2010, Texas Instruments Incorporated * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * * Neither the name of Texas Instruments Incorporated nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ /* * ======== videnc_copy.c ======== * Video Encoder "copy" algorithm. * * This file contains an implementation of the deprecated IVIDENC interface * as defined by xDM 0.9. */ #include #include #include #include #include #include #include #include #include #include #include "videnc_copy_ti.h" #include "videnc_copy_ti_priv.h" #include "cv.h" #include "cxcore.h" /* buffer definitions */ #define MININBUFS 1 #define MINOUTBUFS 1 #define MININBUFSIZE 1 #define MINOUTBUFSIZE 1 IplImage* pImg = NULL; IplImage* pCannyImg = NULL; static Int8 *xxx = NULL; #define SIZEOFIMG ((320)*(240)*(3)*(sizeof(char))) static Memory_AllocParams MemParams = { Memory_CONTIGHEAP, Memory_CACHED, 8, 0 }; extern IALG_Fxns VIDENCCOPY_TI_IALG; #define IALGFXNS &VIDENCCOPY_TI_IALG, /* module ID */ VIDENCCOPY_TI_activate, /* activate */ VIDENCCOPY_TI_alloc, /* alloc */ NULL, /* control (NULL => no control ops) */ VIDENCCOPY_TI_deactivate, /* deactivate */ VIDENCCOPY_TI_free, /* free */ VIDENCCOPY_TI_initObj, /* init */ NULL, /* moved */ NULL /* numAlloc (NULL => IALG_MAXMEMRECS) */ /* * ======== VIDENCCOPY_TI_IVIDENC ======== * This structure defines TI's implementation of the IVIDENC interface * for the VIDENCCOPY_TI module. */ IVIDENC_Fxns VIDENCCOPY_TI_VIDENCCOPY = { /* module_vendor_interface */ {IALGFXNS}, VIDENCCOPY_TI_process, VIDENCCOPY_TI_control, }; XDAS_Int16 width; XDAS_Int16 height; XDAS_UInt8* pResult_rgb_dsp; XDAS_UInt8 rectCount =0; /* * ======== VIDENCCOPY_TI_IALG ======== * This structure defines TI's implementation of the IALG interface * for the VIDENCCOPY_TI module. */ #ifdef _TI_ /* satisfy xDAIS symbol requirement without any overhead */ asm("_VIDENCCOPY_TI_IALG .set _VIDENCCOPY_TI_VIDENCCOPY"); #else /* * We duplicate the structure here to allow this code to be compiled and * run non-DSP platforms at the expense of unnecessary data space * consumed by the definition below. */ IALG_Fxns VIDENCCOPY_TI_IALG = { /* module_vendor_interface */ IALGFXNS }; #endif /* tracing information */ #define GTNAME "ti.sdo.ce.examples.codecs.videnc_copy" static GT_Mask curTrace = {NULL,NULL}; #ifdef USE_ACPY3 /* Implementation of IDMA3 interface functions & IDMA3_Fxns vtable */ #include #include #include #define NUM_LOGICAL_CH 1 /* * ======== VIDENCCOPY_TI_dmaChangeChannels ======== * Update instance object with new logical channel. */ Void VIDENCCOPY_TI_dmaChangeChannels(IALG_Handle handle, IDMA3_ChannelRec dmaTab[]) { VIDENCCOPY_TI_Obj *videncObj = (Void *)handle; GT_2trace(curTrace, GT_ENTER, "VIDENCCOPY_TI_dmaChangeChannels(0x%x, 0x%x) ", handle, dmaTab); videncObj->dmaHandle1D1D8B = dmaTab[0].handle; } /* * ======== VIDENCCOPY_TI_dmaGetChannelCnt ======== * Return max number of logical channels requested. */ Uns VIDENCCOPY_TI_dmaGetChannelCnt(Void) { GT_0trace(curTrace, GT_ENTER, "VIDENCCOPY_TI_dmaGetChannelCnt() "); return (NUM_LOGICAL_CH); } /* * ======== VIDENCCOPY_TI_dmaGetChannels ======== * Declare DMA resource requirement/holdings. */ Uns VIDENCCOPY_TI_dmaGetChannels(IALG_Handle handle, IDMA3_ChannelRec dmaTab[]) { VIDENCCOPY_TI_Obj *videncObj = (Void *)handle; int i; GT_2trace(curTrace, GT_ENTER, "VIDENCCOPY_TI_dmaGetChannels(0x%x, 0x%x) ", handle, dmaTab); /* Initial values on logical channels */ dmaTab[0].handle = videncObj->dmaHandle1D1D8B; dmaTab[0].numTransfers = 1; dmaTab[0].numWaits = 1; /* * Request logical DMA channels for use with ACPY3 * AND with environment size obtained from ACPY3 implementation * AND with low priority. */ for (i = 0; i < NUM_LOGICAL_CH; i++) { dmaTab[i].priority = IDMA3_PRIORITY_LOW; dmaTab[i].persistent = FALSE; dmaTab[i].protocol = &ACPY3_PROTOCOL; } return (NUM_LOGICAL_CH); } /* * ======== VIDENCCOPY_TI_dmaInit ======== * Initialize instance object with granted logical channel. */ Int VIDENCCOPY_TI_dmaInit(IALG_Handle handle, IDMA3_ChannelRec dmaTab[]) { VIDENCCOPY_TI_Obj *videncObj = (Void *)handle; GT_2trace(curTrace, GT_ENTER, "VIDENCCOPY_TI_dmaInit(0x%x, 0x%x) ", handle, dmaTab); videncObj->dmaHandle1D1D8B = dmaTab[0].handle; return (IALG_EOK); } /* * ======== VIDENCCOPY_TI_IDMA3 ======== * This structure defines TI's implementation of the IDMA3 interface * for the VIDENCCOPY_TI module. */ IDMA3_Fxns VIDENCCOPY_TI_IDMA3 = { /* module_vendor_interface */ &VIDENCCOPY_TI_IALG, /* IALG functions */ VIDENCCOPY_TI_dmaChangeChannels, /* ChangeChannels */ VIDENCCOPY_TI_dmaGetChannelCnt, /* GetChannelCnt */ VIDENCCOPY_TI_dmaGetChannels, /* GetChannels */ VIDENCCOPY_TI_dmaInit /* initialize logical channels */ }; #endif /* * ======== VIDENCCOPY_TI_activate ======== */ Void VIDENCCOPY_TI_activate(IALG_Handle handle) { GT_1trace(curTrace, GT_ENTER, "VIDENCCOPY_TI_activate(0x%x) ", handle); } /* * ======== VIDENCCOPY_TI_deactivate ======== */ Void VIDENCCOPY_TI_deactivate(IALG_Handle handle) { GT_1trace(curTrace, GT_ENTER, "VIDENCCOPY_TI_deactivate(0x%x) ", handle); } /* * ======== VIDENCCOPY_TI_alloc ======== */ Int VIDENCCOPY_TI_alloc(const IALG_Params *algParams, IALG_Fxns **pf, IALG_MemRec memTab[]) { if (curTrace.modName == NULL) { /* initialize GT (tracing) */ GT_create(&curTrace, GTNAME); } GT_3trace(curTrace, GT_ENTER, "VIDENCCOPY_TI_alloc(0x%x, 0x%x, 0x%x) ", algParams, pf, memTab); /* Request memory for my object */ memTab[0].size = sizeof(VIDENCCOPY_TI_Obj); memTab[0].alignment = 0; memTab[0].space = IALG_EXTERNAL; memTab[0].attrs = IALG_PERSIST; memTab[1].size = SIZEOFIMG; memTab[1].alignment = 0; memTab[1].space = IALG_EXTERNAL; memTab[1].attrs = IALG_PERSIST; //img_opencv =cvCreateImage(cvSize(320,240),8,3); return (2); } /* * ======== VIDENCCOPY_TI_free ======== */ Int VIDENCCOPY_TI_free(IALG_Handle handle, IALG_MemRec memTab[]) { GT_2trace(curTrace, GT_ENTER, "VIDENCCOPY_TI_free(0x%lx, 0x%lx) ", handle, memTab); VIDENCCOPY_TI_alloc(NULL, NULL, memTab); memTab[1].size = SIZEOFIMG; memTab[1].alignment = 0; memTab[1].space = IALG_EXTERNAL; memTab[1].attrs = IALG_PERSIST; memTab[1].base = pResult_rgb_dsp; //free(pResult_rgb_dsp); //cvReleaseImage(&img_opencv); return (2); } /* * ======== VIDENCCOPY_TI_initObj ======== */ Int VIDENCCOPY_TI_initObj(IALG_Handle handle, const IALG_MemRec memTab[], IALG_Handle p, const IALG_Params *algParams) { GT_4trace(curTrace, GT_ENTER, "VIDENCCOPY_TI_initObj(0x%x, 0x%x, 0x%x, 0x%x) ", handle, memTab, p, algParams); pResult_rgb_dsp =(unsigned char *) memTab[1].base; return (IALG_EOK); } #if 0 CV_IMPL void* cvAlloc( size_t size ) { CV_FUNCNAME( "cvAlloc" ); //IALG_MemRec *memTab = malloc( sizeof(IALG_MemRec)); void * ptr; __BEGIN__; ptr= (void *)malloc(size); __END__; return ptr; } CV_IMPL void cvFree_( void* ptr ) { CV_FUNCNAME( "cvFree_" ); __BEGIN__; free( ptr ); __END__; } #endif static unsigned char buf_dsp_x[320*240*2]; static unsigned char image_Y_dsp_x[320*240*2]; inline void yuv_to_rgb16_dsp(unsigned char y, unsigned char u, unsigned char v, unsigned char *rgb) { register int r,g,b; int rgb16; r = (1192 * (y - 16) + 1634 * (v - 128) ) >> 10; g = (1192 * (y - 16) - 833 * (v - 128) - 400 * (u -128) ) >> 10; b = (1192 * (y - 16) + 2066 * (u - 128) ) >> 10; r = r > 255 ? 255 : r < 0 ? 0 : r; g = g > 255 ? 255 : g < 0 ? 0 : g; b = b > 255 ? 255 : b < 0 ? 0 : b; rgb16 = (int)(((r >> 3)<<11) | ((g >> 2) << 5)| ((b >> 3) << 0)); *rgb = (unsigned char)(rgb16 & 0xFF); rgb++; *rgb = (unsigned char)((rgb16 & 0xFF00) >> 8); } void convert(unsigned char *buf, unsigned char *rgb, int width, int height) { int x, y, z = 0; int blocks; blocks = (width * height) * 2; for (y = 0; y < blocks; y += 4) { unsigned char Y1, Y2, U, V; Y1 = buf[y + 0]; U = buf[y + 1]; Y2 = buf[y + 2]; V = buf[y + 3]; yuv_to_rgb16_dsp(Y1, U, V, &rgb[y]); yuv_to_rgb16_dsp(Y2, U, V, &rgb[y + 2]); } } void YtoRGB(unsigned char *Outrgb, unsigned char *pSrcbuf, int width, int height) { int x,y,z=0; int blocks; blocks = (width * height) * 2; for (y = 0; y < blocks; y+=4) { unsigned char Y1, Y2, U, V; /////////////////////////////////////// Y1 =*pSrcbuf; pSrcbuf++; Y2 =*pSrcbuf; pSrcbuf++; yuv_to_rgb16_dsp(Y1, 0x80, 0x80, &Outrgb[y]); yuv_to_rgb16_dsp(Y2, 0x80, 0x80, &Outrgb[y + 2]); } } #define Memory_DEFAULTALIGNMENT ((xdc_UInt)(-1)) void convert_dsp(unsigned char *buf, unsigned char *rgb, int width, int height) { int x,y,z=0; int blocks; blocks = (width * height) * 2; for (y = 0; y < blocks; y+=4) { unsigned char Y1, Y2, U, V; /////////////////////////////////////// Y1 = buf[y + 0]; U = buf[y + 1]; Y2 = buf[y + 2]; V = buf[y + 3]; ////////////////////////////////////// yuv_to_rgb16_dsp(Y1, U, V, &rgb[y]); yuv_to_rgb16_dsp(Y2, U, V, &rgb[y + 2]); //yuv_to_rgb16(Y1, 0x80, 0x80, &rgb[y]); //yuv_to_rgb16(Y2, 0x80, 0x80, &rgb[y + 2]); } } #if 1 void YuyvToY_dsp(unsigned char *Srbuf, unsigned char *pDstbuf, int width, int height) { int x,y,z=0; int blocks; blocks = (width * height) * 2; for (y = 0; y < blocks; y+=4) { /////////////////////////////////////// *pDstbuf = Srbuf[y + 0]; pDstbuf++; *pDstbuf = Srbuf[y+2]; pDstbuf++; } } #endif inline void yuv_to_rgb24(unsigned char y, unsigned char u, unsigned char v, unsigned char *rgb) { register int r, g, b; r = (1192 * (y - 16) + 1634 * (v - 128)) >> 10; g = (1192 * (y - 16) - 833 * (v - 128) - 400 * (u - 128)) >> 10; b = (1192 * (y - 16) + 2066 * (u - 128)) >> 10; r = r > 255 ? 255 : r < 0 ? 0 : r; g = g > 255 ? 255 : g < 0 ? 0 : g; b = b > 255 ? 255 : b < 0 ? 0 : b; *rgb = r; rgb++; *rgb = g; rgb++; *rgb = b; #if 0 rgb16 = (int) (((r >> 3) << 11) | ((g >> 2) << 5) | ((b >> 3) << 0)); *rgb = (unsigned char) (rgb16 & 0xFF); rgb++; *rgb = (unsigned char) ((rgb16 & 0xFF00) >> 8); #endif } void YUVToRGB24(unsigned char *buf, unsigned char *rgb, int width, int height) { int y = 0; int j = 0; int blocks; blocks = (width * height) * 2; for (y = 0; y < blocks; y += 4) { unsigned char Y1, Y2, U1, V1; Y1 = buf[y + 0]; U1 = buf[y + 1]; Y2 = buf[y + 2]; V1 = buf[y + 3]; yuv_to_rgb24(Y1, U1, V1, &rgb[j]); yuv_to_rgb24(Y2, U1, V1, &rgb[j + 3]); j +=6; } } void YUVToRGB24_8(unsigned char *buf, unsigned char *rgb, int width, int height) { int y = 0; int j = 0; int blocks; blocks = (width * height) * 2; for (y = 0; y < blocks; y += 8) { unsigned char Y1, Y2, U1, V1; unsigned char Y1_1, Y2_1, U1_1, V1_1; Y1 = buf[y + 0]; U1 = buf[y + 1]; Y2 = buf[y + 2]; V1 = buf[y + 3]; // V1 = buf[y + 1]; //U1 = buf[y + 3]; Y1_1 = buf[y + 4]; U1_1 = buf[y + 5]; Y2_1 = buf[y + 6]; V1_1 = buf[y + 7]; // V1_1 = buf[y + 7]; // U1_1 = buf[y + 5]; yuv_to_rgb24(Y1, U1, V1, &rgb[j]); yuv_to_rgb24(Y2, U1, V1, &rgb[j + 3]); yuv_to_rgb24(Y1_1, U1_1, V1_1, &rgb[j + 6]); yuv_to_rgb24(Y2_1, U1_1, V1_1, &rgb[j + 9]); j +=12; } } static Ptr myMemalign(UInt32 size, UInt32 align) { UInt32 alignSize; UInt32 alignBytes; UInt32 remainBytes; Ptr buf; Ptr alignBuf; UInt32 tmpAlign; UInt32 *addrPtr; /* * Must at least align on 32-bit boundary since we're storing the * 32-bit address of the malloc'd buffer. */ alignBytes = (align < sizeof(UInt32)) ? sizeof(UInt32) : align; /* * We will allocate a buffer larger than "size", to allow for alignment * and to store the address and original size of the buffer returned by * malloc() at the end of the buffer. * Make size a multiple of 32-bits so it will be easier to find the * address of the buffer returned by malloc(). */ alignSize = size; if ((remainBytes = alignSize & (sizeof(UInt32) - 1)) != 0) { /* size is not a multiple of 32-bits */ alignSize += sizeof(UInt32) - remainBytes; remainBytes = sizeof(UInt32) - remainBytes; } /* Add 2 32-bit words to store address and original size of buffer */ alignSize += sizeof(UInt32) * 2; alignSize += alignBytes; /* malloc the buffer! */ if ((buf = malloc(alignSize)) == NULL) { return (NULL); } /* Get the aligned address */ tmpAlign = (UInt32)buf & (alignBytes - 1); if (tmpAlign) { alignBuf = (Void *)((UInt32)buf + alignBytes - tmpAlign); } else { /* The buffer was already aligned */ alignBuf = buf; } /* Store the malloc'd address and original size for freeing later. */ addrPtr = (UInt32 *)((UInt32)alignBuf + size + remainBytes); *addrPtr = (UInt32)buf; *(addrPtr + 1) = alignSize; return (alignBuf); } /* * ======== VIDENCCOPY_TI_process ======== */ XDAS_Int32 VIDENCCOPY_TI_process(IVIDENC_Handle h, XDM_BufDesc *inBufs, XDM_BufDesc *outBufs, IVIDENC_InArgs *inArgs, IVIDENC_OutArgs *outArgs) { XDAS_Int32 curBuf; XDAS_UInt32 minSamples; int i,j; int width,height; unsigned char * ptr; unsigned char *temp; #ifdef USE_ACPY3 const Uint32 maxTransferChunkSize = 0xffff; Uint32 thisTransferChunkSize = 0x0; Uint32 remainingTransferChunkSize; Uint32 thisTransferSrcAddr, thisTransferDstAddr; ACPY3_Params params; VIDENCCOPY_TI_Obj *videncObj = (VIDENCCOPY_TI_Obj *)h; #endif GT_5trace(curTrace, GT_ENTER, "VIDENCCOPY_TI_process(0x%x, 0x%x, 0x%x, " "0x%x, 0x%x) ", h, inBufs, outBufs, inArgs, outArgs); /* validate arguments - this codec only supports "base" xDM. */ if ((inArgs->size != sizeof(*inArgs)) || (outArgs->size != sizeof(*outArgs))) { GT_2trace(curTrace, GT_ENTER, "VIDENCCOPY_TI_process, unsupported size " "(0x%x, 0x%x) ", inArgs->size, outArgs->size); return (IVIDENC_EFAIL); } #ifdef USE_ACPY3 /* * Activate Channel scratch DMA channels. */ ACPY3_activate(videncObj->dmaHandle1D1D8B); #endif /* outArgs->bytesGenerated reports the total number of bytes generated */ outArgs->bytesGenerated = 0; /* * A couple constraints for this simple "copy" codec: * - Video encoding presumes a single input buffer, so only one input * buffer will be encoded, regardless of inBufs->numBufs. * - Given a different size of an input and output buffers, only * encode (i.e., copy) the lesser of the sizes. */ for (curBuf = 0; (curBuf < inBufs->numBufs) && (curBuf < outBufs->numBufs); curBuf++) { /* there's an available in and out buffer, how many samples? */ minSamples = inBufs->bufSizes[curBuf] < outBufs->bufSizes[curBuf] ? inBufs->bufSizes[curBuf] : outBufs->bufSizes[curBuf]; ////////////////////////////////////////////////////////////////////// #if 0 YuyvToY_dsp((unsigned char *)inBufs->bufs[curBuf], (unsigned char *)buf_dsp_x, 320,240); for(i =0; i < 240; i++) for(j =0; j < 160; j++) { //*((unsigned char *)buf_dsp_x+ i*320+ j) = 0x80; //*((unsigned char *)buf_dsp+ i*640+ j) = 0x80; } YtoRGB((unsigned char *)outBufs->bufs[curBuf], (unsigned char *)buf_dsp_x, 320,240); #endif // convert_dsp(inBufs->bufs[curBuf],outBufs->bufs[curBuf],320, 240); //convert(inBufs->bufs[curBuf], outBufs->bufs[curBuf], 320, 240); // memcpy(outBufs->bufs[curBuf], inBufs->bufs[curBuf], minSamples); //YUVToRGB24((unsigned char *)inBufs->bufs[curBuf],(unsigned char *)outBufs->bufs[curBuf], 320, 240); ////////////////////////////////////////////////////////////////////////// //#ifdef USE_ACPY3 #if 0 thisTransferSrcAddr = (Uint32)inBufs->bufs[curBuf]; thisTransferDstAddr = (Uint32)outBufs->bufs[curBuf]; remainingTransferChunkSize = minSamples; 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); } GT_1trace(curTrace, GT_2CLASS, "VIDENCCOPY_TI_process> " "ACPY3 Processed %d bytes. ", minSamples); #else GT_3trace(curTrace, GT_2CLASS, "VIDENCCOPY_TI_process> " "memcpy (0x%x, 0x%x, %d) ", outBufs->bufs[curBuf], inBufs->bufs[curBuf], minSamples); /* process the data: read input, produce output */ //YUVToRGB24((unsigned char *)inBufs->bufs[curBuf],(unsigned char *)outBufs->bufs[curBuf], 320, 240); // ptr = (unsigned char *)pImg->imageData #if 0 for(i = 0; i <120; i++){ ptr =(unsigned char *)(pImg->imageData + i*3*320); for(j = 0; j <320; j++){ *( ptr+3*j + 0) = 80; *( ptr+3*j + 1) = 80; *( ptr+3*j + 2) = 80; } } //cvCanny(pImg, pCannyImg, 50, 150, 3); memcpy( (unsigned char *)outBufs->bufs[curBuf],(unsigned char *)pImg->imageData, 320*240*3); #else //cvCanny(pImg, pCannyImg, 50, 150, 3); //memcpy( (unsigned char *)outBufs->bufs[curBuf],(unsigned char *)pImg->imageData, 320*240*3); //temp = (unsigned char *)malloc(320 * 240 *3); //temp = (unsigned char *)pResult_rgb_dsp; //temp = (unsigned char *)Memory_contigAlloc(320*240*3,8); // temp = (unsigned char *)myMemalign(320*240*3,8); pImg = cvCreateImage(cvSize(320,240),8,3); pCannyImg = cvCreateImage(cvSize(320,240),8,3); memcpy((unsigned char *)pImg->imageData, (unsigned char *)inBufs->bufs[curBuf], 320*240*3); for(i = 0; i <120; i++){ ptr =((unsigned char *)pImg->imageData+i*3*320); for(j = 0; j < 320; j++){ ptr[3*j + 0] = 255; ptr[3*j + 1] = 255; ptr[3*j + 2] = 255; } } // cvCanny(pImg, pCannyImg, 50, 150, 3); cvLine( pImg, cvPoint(15,15), cvPoint(75,15), CV_RGB(255, 0, 0), 3 ,1,0 ); cvLine( pImg, cvPoint(75,15), cvPoint(75,75), CV_RGB(255, 0, 0), 3 ,1,0 ); cvRectangle(pImg, cvPoint(75,75), cvPoint(120,120), CV_RGB(0, 255, 0), 3, 1, 0); memcpy((unsigned char *)outBufs->bufs[curBuf], (unsigned char *)pImg->imageData, minSamples); //memcpy(outBufs->bufs[curBuf], temp, minSamples); #endif //memcpy(outBufs->bufs[curBuf], inBufs->bufs[curBuf], minSamples); #endif //Memory_contigFree(temp,320*240*3); cvReleaseImage(&pImg); cvReleaseImage(&pCannyImg); outArgs->bytesGenerated += minSamples; } /* Fill out the rest of the outArgs struct */ outArgs->extendedError = 0; outArgs->encodedFrameType = 0; /* TODO */ outArgs->inputFrameSkip = IVIDEO_FRAME_ENCODED; outArgs->reconBufs.numBufs = 0; /* important: indicate no reconBufs */ return (IVIDENC_EOK); } /* * ======== VIDENCCOPY_TI_control ======== */ XDAS_Int32 VIDENCCOPY_TI_control(IVIDENC_Handle handle, IVIDENC_Cmd id, IVIDENC_DynamicParams *params, IVIDENC_Status *status) { XDAS_Int32 retVal; GT_4trace(curTrace, GT_ENTER, "VIDENCCOPY_TI_control(0x%x, 0x%x, 0x%x, " "0x%x) ", handle, id, params, status); /* validate arguments - this codec only supports "base" xDM. */ if ((params->size != sizeof(*params)) || (status->size != sizeof(*status))) { GT_2trace(curTrace, GT_ENTER, "VIDENCCOPY_TI_control, unsupported size " "(0x%x, 0x%x) ", params->size, status->size); return (IVIDENC_EFAIL); } switch (id) { case XDM_GETSTATUS: case XDM_GETBUFINFO: status->extendedError = 0; status->bufInfo.minNumInBufs = MININBUFS; status->bufInfo.minNumOutBufs = MINOUTBUFS; status->bufInfo.minInBufSize[0] = MININBUFSIZE; status->bufInfo.minOutBufSize[0] = MINOUTBUFSIZE; retVal = IVIDENC_EOK; break; case XDM_SETPARAMS: case XDM_SETDEFAULT: case XDM_RESET: case XDM_FLUSH: /* TODO - for now just return success. */ retVal = IVIDENC_EOK; break; default: /* unsupported cmd */ retVal = IVIDENC_EFAIL; break; } return (retVal); } /* * @(#) ti.sdo.ce.examples.codecs.videnc_copy; 1, 0, 0,262; 12-2-2010 21:23:15; /db/atree/library/trees/ce/ce-r11x/src/ xlibrary */