📄 mobile_demo.c
字号:
void Fim20DemoMem(void)
{
U32 i;
U32 freeBufStartAddr = 0x11000000;
U32 tempFreebuf;
// calculate camera 4 pingpong image size
//tempFreebuf = (((CIF_XSIZE*CIF_YSIZE)+ // (y size+
// ((CIF_XSIZE/2) * (CIF_YSIZE/2))) *2); //cb,cr size)
// current image start address setting
printf(" w = %d, h=%d\n", FimvImageWidth, FimvImageHeight);
freeBufStartAddr = AllocImage420(&currImage2[0], freeBufStartAddr, FimvImageWidth,FimvImageHeight,
IMAGE420_NO_PADDED);
freeBufStartAddr = AllocImage420(&currImage2[1], freeBufStartAddr, FimvImageWidth,FimvImageHeight,
IMAGE420_NO_PADDED);
freeBufStartAddr = AllocImage420(&currImage2[2], freeBufStartAddr, FimvImageWidth,FimvImageHeight,
IMAGE420_NO_PADDED);
freeBufStartAddr = AllocImage420(&currImage2[3], freeBufStartAddr, FimvImageWidth,FimvImageHeight,
IMAGE420_NO_PADDED);
// reference image start address setting
for(i=0;i<4;i++)
{
//printf("reference image #%d addr: %x\n",i,freeBufStartAddr);
printf(" ref addr [%d]= %08x\n",i,freeBufStartAddr);
freeBufStartAddr=
AllocImage420(&refImage[i],freeBufStartAddr,FimvImageWidth,FimvImageHeight,
IMAGE420_PADDED|IMAGE420_CLEAR);
}
// dctq coeff image address setting
for(i=0;i<4;i++)
{
//printf("dctqCoeff image #%d addr: %x\n",i,freeBufStartAddr);
freeBufStartAddr=
AllocImage420(&dctqCoeff[i],freeBufStartAddr,FimvImageWidth,FimvImageHeight,
IMAGE420_DCTQ_COEFF|IMAGE420_CLEAR);
}
printf("MV addr: [%x,",freeBufStartAddr);
meVector2[0] = freeBufStartAddr;
meVector2[1] = freeBufStartAddr + ((FimvImageWidth/16)*(FimvImageHeight/16) *20)*1;
meVector2[2] = freeBufStartAddr + ((FimvImageWidth/16)*(FimvImageHeight/16) *20)*2;
meVector2[3] = freeBufStartAddr + ((FimvImageWidth/16)*(FimvImageHeight/16) *20)*3;
freeBufStartAddr = freeBufStartAddr + ((FimvImageWidth/16)*(FimvImageHeight/16) *20)*4;
// Q-info initialize
//qinfo_freebuf = freeBufStartAddr;
InitQInfo(&pQInfo,&freeBufStartAddr,FimvImageWidth,FimvImageHeight,QINFO_INTER_MODE);
//LcdBGInit(MODE_PAR_16BIT565_240320|MODE_POST_DISPLAY_16B);
// confirm sec
CamInit(FimvImageWidth, FimvImageHeight, 352, 288, (CAM_SRC_HSIZE -FimvImageWidth)/2+40,
(CAM_SRC_VSIZE-FimvImageHeight)/2+8, 0x11000000, LCDFRAMEBUFFERFG2);
rCLKDIVN=(rCLKDIVN&~(0xf<<8))|(2<<8);//24Mhz, updated at 2004.02.13 by ows
//CamInit(FIMV_IMAGE_WIDTH, FIMV_IMAGE_HEIGHT, 352, 288, 0,0, 0x11000000, LCDFRAMEBUFFERBG1);
mpegframebuffer = 0x13600000;
PostSetFimv16B(FimvImageWidth,FimvImageHeight,240,320, refImage[0].frameStartAddr,mpegframebuffer);
LcdBGInit(MODE_PAR_16BIT565_240320|MODE_MPEG_DISPLAY_16B);
VlcConfig4Dctq(FimvImageWidth,0x12900000,(FimvImageWidth/16)*(FimvImageHeight/16),0);
freeBufStartAddr = freeBufStartAddr + (1152/16)*(864/16)*4;
if(freeBufStartAddr >= 0x12900000) printf("Memory allocaton Over : %08x\n",freeBufStartAddr);
else printf("Ok,memory allocation : %08x\n",freeBufStartAddr);
}
void Fim20DemoIsrUnmask(void)
{
ClearPending(BIT_ALLMSK);
//rSUBSRCPND |= (BIT_SUB_VLX | BIT_SUB_POST);
rSUBSRCPND |= BIT_SUB_POST;
pISR_DCTQ=(U32)Cam_Demo_DctqIsr;
rINTMSK&=~BIT_DCTQ;
pISR_ME=(U32)Cam_Demo_MeIsr;
rINTMSK&=~BIT_ME;
pISR_MC=(U32)Cam_Demo_McIsr;
rINTMSK&=~BIT_MC;
pISR_VLX_SPI1=(U32)Cam_Demo_VlxIsr;
rINTSUBMSK &= ~ BIT_SUB_VLX;
rINTMSK&=~BIT_VLX_SPI1;
pISR_CAMIF_CODEC =(U32)Cam_Demo_Cam_CodecIsr;
rINTMSK &=~BIT_CAMIF_CODEC;
pISR_LCD_POST =(U32)Cam_Demo_PostIsr;
rINTSUBMSK &= ~(BIT_SUB_POST); // SUB-INT POST Enable
rINTMSK &= ~(BIT_LCD_POST); // INT_POST_LCD Enable
rMODE |= (1<<7);//Post Interrupt Enable
}
void Fim20DemoIsrMask(void)
{
ClearPending(BIT_ALLMSK);
//rSUBSRCPND |= (BIT_SUB_VLX | BIT_SUB_POST);
rINTMSK|=BIT_DCTQ;
rINTMSK|=BIT_ME;
rINTMSK|=BIT_MC;
rINTSUBMSK |= BIT_SUB_VLX;
rINTMSK|=BIT_VLX_SPI1;
rINTMSK |=BIT_CAMIF_CODEC;
rINTSUBMSK |= (BIT_SUB_POST); // SUB-INT POST Enable
rINTMSK |= (BIT_LCD_POST); // INT_POST_LCD Enable
rMODE &= (0<<7);//Post Interrupt Enable
rINTSUBMSK |= (BIT_SUB_WDT | BIT_SUB_BATFLT);
rINTMSK |= (BIT_WDT_BATFLT); //Watch dog Interrupt service is available
ClearPending(BIT_WDT_BATFLT);
frameNum = 0;
//Lcd_Port_Init(); // LCD gpio setting
}
/*/////////////////////////////////////////////////////////////////////////////
1. download the mobile image "mob20_3.CIF" using the usb download
2. allocate the address 4-pingpong memory which consist of curr/prev/q_info/mv/dctqcoeff
3. start the DCTQ based on the download pointer mob20_3.cif.
4. after DCTQ Isr , POST start & ME operate
5. after ME Isr, MC operate
6. after MC Isr, DCTQ operate & adopt the VLX optionally
7. repeat the 4~6
/////////////////////////////////////////////////////////////////////////////*/
volatile U32 iter;
void Mobile_Image_Demo(void)
{
char is_char;
U32 currImageSize = (FIMV_IMAGE_WIDTH*FIMV_IMAGE_HEIGHT)*1.5;
U32 baseCurrImage= 0x12000000;
U32 qinfoBaseAddr;
U32 qinfoMode;
U32 imageWidth=FIMV_IMAGE_WIDTH;
U32 imageHeight=FIMV_IMAGE_HEIGHT;
U32 freeBufStartAddr =_NONCACHE_STARTADDRESS;
U32 *pVlcData;
U32 mode;
U32 mcedimage;
U32 fps;
U32 *pt;
rPRIORITY0 |= (1<<1); // fixed priority I-BUS
rPRIORITY1 |= (1<<1); // fixed priority I-BUS
prevImageNum = 0; frameNum = 0;
printf("/*** Mobile raw data image test Program ***/\n");
printf("/*** Download the mobile image ../bmp/mobile_20_3.CIF ***/\n");
printf("/*** Download address : 0x12000000(Noncahe_address ***/\n");
printf("\n");
//
printf(" Download OK? [Y]es, [N]o -->");
printf("\n\n");
is_char = getchar();
if((is_char == 'n')||(is_char == 'N')){
USB_Download();
printf(" Start Mpeg4 engine ? press any key!\n");
printf("\n");
}
else printf(" Start Mpeg4 engine ? press any key!\n");
getchar();
freeBufStartAddr = Alloc_FIMV_Addr_Init(freeBufStartAddr);
qinfoBaseAddr = freeBufStartAddr; // inter / intra mode change
InitQInfo(&pQInfo, &qinfoBaseAddr, FIMV_IMAGE_WIDTH, FIMV_IMAGE_HEIGHT, QINFO_INTRA_MODE);
/*
mode=POST_IN_YCBYCR420|POST_OUT_RGB16B;
mpegframebuffer = 0x13600000;
PostInit(384, 320, 352, 288, 16, 16,
240, 320, 240, 320, 0, 0,
refImage[0].frameStartAddr, mpegframebuffer, mode);
LcdBGInit(MODE_PAR_16BIT565_240320|MODE_POST_DISPLAY_16B);
*/
mpegframebuffer = 0x13600000;
PostSetFimv16B(FIMV_IMAGE_WIDTH,FIMV_IMAGE_HEIGHT,240,320, refImage[0].frameStartAddr,mpegframebuffer);
LcdBGInit(MODE_PAR_16BIT565_240320|MODE_MPEG_DISPLAY_16B);
FimvImageWidth = 352;
FimvImageHeight = 288;
//PostSetFimv16B(352,288,240,320, refImage[0].frameStartAddr,LCDFRAMEBUFFERBG1);
//PostSetFimv16B(352,288,240,320, 0x12000000,LCDFRAMEBUFFERBG1);
LcdEnvidOnOff(1);
pVlcData=(U32 *)0x12300000;
//freeBufStartAddr+=FIMV_MBLK_NUM*0x200;
for(pt=pVlcData;pt<(pVlcData+FIMV_MBLK_NUM*0x200/4);pt++)
*pt=0xffffffff;
printf("pVlcData=[%x,%x)\n",pVlcData,(pVlcData+FIMV_MBLK_NUM*0x200/4));
Init_FIMV20_Isr();
Timer_Start(2);
VlcConfig4Dctq(imageWidth,0x12400000,(imageWidth/16)*(imageHeight/16),0);
//DctqEngine(&currImage,&prevImage,&dctqCoeff,pQInfo,DCTQ_WITH_VLC_COEFF_WRITE);
//DctqEngine(&currImage, &refImage[prevImageNum], &dctqCoeff[frameNum], pQInfo, DCTQ_FRAME_START_MODE);
DctqEngine(&currImage, &refImage[prevImageNum], &dctqCoeff[frameNum], pQInfo, DCTQ_WITH_VLC_COEFF_NOTWRITE);
//VlcEngine(&dctqCoeff,pQInfo,(U32)pVlcData,0);
// start scheduler
while(!Uart_GetKey()){
//while(1){
//printf("prev = %d, frame = %d\n", prevImageNum,frameNum);
if(d_dctqDone == TRUE){
d_dctqDone = 0;
//PostStartFIMV20( refImage[0].frameStartAddr);
//PostStartProcessing(0,0);
PostStartFIMV20(refImage[prevImageNum].frameStartAddr);
//printf("framestart addr = %08x\n",refImage[prevImageNum].frameStartAddr);
frameNum++;
if(frameNum ==16) {
fps = Timer_Stop();
printf("iter = %d\n",iter++);
printf("fps = %d\n",1000000*16/(fps*64));
frameNum=0 ;baseCurrImage = 0x12000000;}
((frameNum %4 )== 0)? (qinfoMode=QINFO_INTRA_MODE):(qinfoMode=QINFO_INTER_MODE);
InitQInfo(&pQInfo, &qinfoBaseAddr, FIMV_IMAGE_WIDTH, FIMV_IMAGE_HEIGHT, qinfoMode);
// check point - ows
AllocImage420(&currImage, baseCurrImage+=currImageSize,
FIMV_IMAGE_WIDTH, FIMV_IMAGE_HEIGHT, IMAGE420_NO_PADDED);
if (qinfoMode == QINFO_INTRA_MODE) {
//DctqEngine(&currImage, &refImage[mcedimage], &dctqCoeff[frameNum%4], pQInfo,
// DCTQ_FRAME_START_MODE);
DctqEngine(&currImage, &refImage[mcedimage], &dctqCoeff[frameNum%4], pQInfo,
DCTQ_WITH_VLC_COEFF_WRITE);
}
else if(qinfoMode == QINFO_INTER_MODE){
MeEngine(&currImage, &refImage[prevImageNum], meVector2[frameNum%4], 0);
}
//InitQInfo(&pQInfo, &qinfoBaseAddr, FIMV_IMAGE_WIDTH, FIMV_IMAGE_HEIGHT, QINFO_INTER_MODE);
}
if(d_meDone == TRUE){
d_meDone = 0;
mcedimage = prevImageNum+1;
if(mcedimage== 4) mcedimage = 0;
McEngine(&refImage[prevImageNum], &refImage[mcedimage ], meVector2[frameNum%4], 0);
}
if(d_mcDone == TRUE){
d_mcDone = 0;
//DctqEngine(&currImage, &refImage[mcedimage], &dctqCoeff[frameNum%4], pQInfo,
// DCTQ_FRAME_START_MODE);
DctqEngine(&currImage, &refImage[mcedimage], &dctqCoeff[frameNum%4], pQInfo,
DCTQ_WITH_VLC_COEFF_NOTWRITE);
printf("1 %08x\n",rVLX_OUT1);
prevImageNum++;
if(prevImageNum == 4) prevImageNum=0;
}
}
printf(" ME : currimag = %08x, prev= %08x, mv=%08x\n", rME_CFSA, rME_PFSA, rME_MVSA);
printf(" MC : previmag = %08x, mced= %08x,mv= %08x\n", rMC_PFYSA_ENC, rMC_CFYSA_ENC, rMC_MVSA_ENC);
printf(" ME : currimag = %08x, mced= %08x, coeff=%08x, Q=%08x\n", rSAYCF, rSAYRF, rSAYDQF, rSACRDQF);
Fim20DemoIsrMask();
}
void PostStartFIMV20(U32 InFrameBuffer)
{
U32 OffsetY, OffsetC,src420,inmultiplier, OrgSrcWidth,OrgSrcHeight,SrcWidth,SrcHeight;
U32 SrcStartX,SrcStartY;
OrgSrcWidth = FimvImageWidth+32;
OrgSrcHeight = FimvImageHeight+32;
SrcWidth = FimvImageWidth;
SrcHeight = FimvImageHeight;
inmultiplier = 1;
src420 = 1;
SrcStartX=SrcStartY = 16;
OffsetY=(OrgSrcWidth-SrcWidth)*inmultiplier;
rADDRStart_Y=InFrameBuffer+(OrgSrcWidth*SrcStartY+SrcStartX)*inmultiplier;
rADDREnd_Y=rADDRStart_Y+SrcWidth*SrcHeight*inmultiplier+OffsetY*(SrcHeight-1);
//rOffset_Y=OffsetY;
if(src420) { //if .srcFormat420==1, .srcFormatInterleave should be 0.
OffsetC=((OrgSrcWidth-SrcWidth)/2)*1;
rADDRStart_Cb=InFrameBuffer+OrgSrcWidth*OrgSrcHeight*1+(OrgSrcWidth/2*SrcStartY/2+SrcStartX/2)*1;
rADDREnd_Cb=rADDRStart_Cb+(SrcWidth/2*SrcHeight/2)*1+OffsetC*(SrcHeight/2-1);
rADDRStart_Cr=InFrameBuffer+OrgSrcWidth*OrgSrcHeight*1+(OrgSrcWidth/2*OrgSrcHeight/2)*1+(OrgSrcWidth/2*SrcStartY/2+SrcStartX/2)*1;
rADDREnd_Cr=rADDRStart_Cr+(SrcWidth/2*SrcHeight/2)*1+OffsetC*(SrcHeight/2-1);
//rOffset_Cb=OffsetC;
//rOffset_Cr=OffsetC;
}
rMODE|=(1<<5);
}
/////////////// Function Description //////////////////////////
// initialzie the allocation of FIMV addr which curr / ref / dctq
///////////////////////////////////////////////////////////
U32 Alloc_FIMV_Addr_Init ( U32 freeBufStartAddr)
{
int i;
// completed interrupt flag initialzation
d_dctqDone=d_mcDone=d_meDone=d_vlxDone = FALSE;
prevImageNum = frameNum = FALSE;
// currImage [0] update only because image already loaded the memory
//. When we wann use the camera you must be mapping the camera codec 4pingpong memory
printf(" curr image start Addr = 0x12000000x\n");
//freeBufStartAddr = AllocImage420(&currImage, freeBufStartAddr, FIMV_IMAGE_WIDTH, FIMV_IMAGE_HEIGHT,
// IMAGE420_NO_PADDED);
AllocImage420(&currImage, 0x12000000, FIMV_IMAGE_WIDTH, FIMV_IMAGE_HEIGHT, IMAGE420_NO_PADDED);
// intialize the reference image address
for(i=0;i<4;i++){
printf(" ref. image start addr = 0x%08x\n",freeBufStartAddr);
freeBufStartAddr = AllocImage420(&refImage[i], freeBufStartAddr, FIMV_IMAGE_WIDTH, FIMV_IMAGE_HEIGHT,
IMAGE420_PADDED|IMAGE420_CLEAR);
}
for(i=0;i<4;i++){
printf(" DCTQ coeff. image start addr = 0x%08x\n",freeBufStartAddr);
freeBufStartAddr = AllocImage420(&dctqCoeff[i], freeBufStartAddr, FIMV_IMAGE_WIDTH, FIMV_IMAGE_HEIGHT,
IMAGE420_DCTQ_COEFF|IMAGE420_CLEAR);
}
printf("MV addr: [%x,",freeBufStartAddr);
meVector2[0] = freeBufStartAddr;
meVector2[1] = freeBufStartAddr + ((FIMV_IMAGE_WIDTH/16)*(FIMV_IMAGE_HEIGHT/16) *20)*1;
meVector2[2] = freeBufStartAddr + ((FIMV_IMAGE_WIDTH/16)*(FIMV_IMAGE_HEIGHT/16) *20)*2;
meVector2[3] = freeBufStartAddr + ((FIMV_IMAGE_WIDTH/16)*(FIMV_IMAGE_HEIGHT/16) *20)*3;
freeBufStartAddr = freeBufStartAddr + ((FIMV_IMAGE_WIDTH/16)*(FIMV_IMAGE_HEIGHT/16) *20)*4;
if(freeBufStartAddr >= 0x12000000) printf("Memory allocaton Over : %08x\n",freeBufStartAddr);
else printf("Ok,memory allocation : %08x\n",freeBufStartAddr);
return (freeBufStartAddr);
}
void Init_FIMV20_Isr(void)
{
pISR_DCTQ=(U32)demo_DctqIsr;
rINTMSK&=~BIT_DCTQ;
pISR_ME=(U32)demo_MeIsr;
rINTMSK&=~BIT_ME;
pISR_MC=(U32)demo_McIsr;
rINTMSK&=~BIT_MC;
pISR_VLX_SPI1=(U32)demo_VlxIsr;
rINTSUBMSK &= ~ BIT_SUB_VLX;
rINTMSK&=~BIT_VLX_SPI1;
pISR_LCD_POST =(U32)demo_PostIsr;
rINTSUBMSK &= ~(BIT_SUB_POST); // SUB-INT POST Enable
rINTMSK &= ~(BIT_LCD_POST); // INT_POST_LCD Enable
rMODE |= (1<<7);//Post Interrupt Enable
}
////////////////////////////////////////////////////////////////////
/// Mobile image FIMV10 Demo ISR
void __irq demo_DctqIsr(void)
{
ClearPending(BIT_DCTQ);
d_dctqDone=TRUE;
//printf("{d}");
}
void __irq demo_MeIsr(void)
{
ClearPending(BIT_ME);
d_meDone=TRUE;
//printf("{e}");
}
void __irq demo_McIsr(void)
{
ClearPending(BIT_MC);
d_mcDone=TRUE;
//printf("{c}");
}
void __irq demo_VlxIsr(void)
{
printf("2 %08x\n",rVLX_OUT1);
rSUBSRCPND |= BIT_SUB_VLX;
ClearPending(BIT_VLX_SPI1);
printf("3 %08x\n",rVLX_OUT1);
d_vlxDone=TRUE;
//printf("{v}");
}
void __irq demo_PostIsr(void)
{
rINTSUBMSK=BIT_SUB_DISP_FIFO|BIT_SUB_DISP_FRAME|BIT_SUB_POST;
rMODE &= ~(1<<6);//Clear Source in POST Processor
rSUBSRCPND=BIT_SUB_POST; //Clear SUB Interrupt Source Pending.
ClearPending(BIT_LCD_POST);//Clear Source Pending, Interrupt Pending
//postProcessingDone=1;
rINTSUBMSK&= ~(BIT_SUB_POST);
//Uart_Printf("{P}\n");
}
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
/// Camera FIMV20 Demo ISR
void __irq Cam_Demo_DctqIsr(void)
{
U32 dctq_flag;
ClearPending(BIT_DCTQ);
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -