开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
camif.c
资源名称：src.rar　[点击查看]
上传用户：jankzhpno
上传日期：2022-08-03
资源大小：4763k
文件大小：28k
源码类别：

Windows CE

开发平台：

Visual C++

camif.c：源码内容
  1. /************************************************************
  2. File Name : camif.c
  3. Descriptions
  4.  -S3C2440 camera test routines & basic libraries
  5. History
  6.  - July 23, 2003. Draft Version 0.0 by purnnamu
  7.  - Janualy 15, 2004. Modifed by Boaz
  9. Copyright 2004 SAMSUNG Electronics.
  10. However, Anybody can use this code without our permission.  
  11. *************************************************************/
  13. #include "def.h"
  14. #include "option.h"
  15. #include "2440addr.h"
  16. #include "2440lib.h"
  18. #include "camif.h"
  19. #include "camproset.h" // for camera setting
  21. extern unsigned char camera_pic_240x320[];
  23. #define LCD_XSIZE_TFT  LCD_WIDTH
  24. #define LCD_YSIZE_TFT  LCD_HEIGHT
  26. #define SCR_XSIZE_TFT  LCD_WIDTH
  27. #define SCR_YSIZE_TFT  LCD_HEIGHT
  29. // GPB1/TOUT1 for Backlight control(PWM)
  30. #define GPB1_TO_OUT()   (rGPBUP &= 0xfffd, rGPBCON &= 0xfffffff3, rGPBCON |= 0x00000004)
  31. #define GPB1_TO_1()     (rGPBDAT |= 0x0002)
  32. #define GPB1_TO_0()     (rGPBDAT &= 0xfffd)
  34. volatile static unsigned short LCD_BUFFER_CAM[SCR_YSIZE_TFT][SCR_XSIZE_TFT];
  35. //*****************************************************************************
  37. volatile U32 camTestMode;
  38. volatile U32 camCodecCaptureCount;
  39. volatile U32 camPviewCaptureCount;
  40. volatile U32 camCodecStatus;
  41. volatile U32 camPviewStatus;
  42. volatile U32 amount;
  44. U32 save_GPJCON, save_GPJDAT, save_GPJUP;
  46. U8 flagCaptured_P = 0;
  47. U8 flagCaptured_C = 0;
  49. int Test_OV9650(void); //capbily
  51. /**************************************************************
  52. LCD视频和控制信号输出或者停止，1开启视频输出
  53. **************************************************************/
  54. static void Lcd_EnvidOnOff(int onoff)
  55. {
  56.     if(onoff==1)
  57. rLCDCON1|=1; // ENVID=ON
  58.     else
  59. rLCDCON1 =rLCDCON1 & 0x3fffe; // ENVID Off
  60. }
  62. /**************************************************************
  63. TFT LCD 电源控制引脚使能
  64. **************************************************************/
  65. static void Lcd_PowerEnable(int invpwren,int pwren)
  66. {
  67.     //GPG4 is setted as LCD_PWREN
  68.     rGPGUP=rGPGUP&(~(1<<4))|(1<<4); // Pull-up disable
  69.     rGPGCON=rGPGCON&(~(3<<8))|(3<<8); //GPG4=LCD_PWREN
  70.     rGPGDAT = rGPGDAT | (1<<4) ;
  71. // invpwren=pwren;
  72.     //Enable LCD POWER ENABLE Function
  73.     rLCDCON5=rLCDCON5&(~(1<<3))|(pwren<<3);   // PWREN
  74.     rLCDCON5=rLCDCON5&(~(1<<5))|(invpwren<<5);   // INVPWREN
  75. }
  76. //*****************************************************************************
  77. static void LCD_Init(void)
  78. {
  79. #define M5D(n) ((n)&0x1fffff)
  80. #define LCD_ADDR ((U32)LCD_BUFFER_CAM)
  81. rLCDCON1 = (LCD_PIXCLOCK << 8) | (3 <<  5) | (12 << 1);
  82.     rLCDCON2 = (LCD_UPPER_MARGIN << 24) | ((LCD_HEIGHT - 1) << 14) | (LCD_LOWER_MARGIN << 6) | (LCD_VSYNC_LEN << 0);
  83.     rLCDCON3 = (LCD_RIGHT_MARGIN << 19) | ((LCD_WIDTH  - 1) <<  8) | (LCD_LEFT_MARGIN << 0);
  84.     rLCDCON4 = (13 <<  8) | (LCD_HSYNC_LEN << 0);
  86. #if !defined(LCD_CON5)
  87. #    define LCD_CON5 ((1<<11) | (1 << 9) | (1 << 8) | (1 << 3) | (1 << 0))
  88. #endif
  89.     rLCDCON5   =  LCD_CON5;
  91.     rLCDSADDR1 = ((LCD_ADDR >> 22) << 21) | ((M5D(LCD_ADDR >> 1)) <<  0);
  92.     rLCDSADDR2 = M5D((LCD_ADDR + LCD_WIDTH * LCD_HEIGHT * 2) >> 1);
  93.     rLCDSADDR3 = LCD_WIDTH;        
  95.     rLCDINTMSK |= 3;
  96.    rTCONSEL   &= (~7);
  97.  
  99. rGPCCON = 0xaaaaaaaaU;
  100. rGPCUP  = 0xffffU; 
  101.     rTPAL     = 0x0;
  102.     rTCONSEL &= ~((1<<4) | 1);
  103.     rLCDCON1  |= 1;
  105.     rGPGCON = 1<<8;
  106.     rGPGDAT = 1<<4;
  107.     
  108.     rGPCUP  = 0x00000000;
  109.     rGPCCON = 0xaaaa02a9; 
  110.  
  111.     rGPDUP  = 0x00000000;
  112.     rGPDCON=0xaaaaaaaa; //Initialize VD[15:8]
  114. LcdBkLtSet( 70 ) ;
  115. Lcd_PowerEnable(0, 1);
  116.     Lcd_EnvidOnOff(1); //turn on vedio
  117. }
  119. static void Lcd_ClearScr( U32 c)
  120. {
  121. unsigned int x,y ;
  123.     for( y = 0 ; y < SCR_YSIZE_TFT ; y++ )
  124.     {
  125.      for( x = 0 ; x < SCR_XSIZE_TFT ; x++ )
  126.      {
  127. LCD_BUFFER_CAM[y][x] = c ;
  128.      }
  129.     }
  130. }
  131. //*****************************************************************************
  132. static void Paint_Bmp(int x0,int y0,int h,int l,unsigned char bmp[])
  133. {
  134. int x,y;
  135. U32 c;
  136. int p = 0;
  138.     for( y = y0 ; y < l ; y++ )
  139.     {
  140.      for( x = x0 ; x < h ; x++ )
  141.      {
  142.      c = bmp[p+1] | (bmp[p]<<8) ;
  144. if ( ( (x0+x) < SCR_XSIZE_TFT) && ( (y0+y) < SCR_YSIZE_TFT) )
  145.  LCD_BUFFER_CAM[y0+y][x0+x] = c ;
  147.      p = p + 2 ;
  148.      }
  149.     }
  150. }
  152. void Camera_Test(void)
  153. {
  154. int i;
  156. Uart_Printf("nCamera Preview Testn");
  158. #if defined(LCD_VGA1024768)
  159. TFT_LCD_Init();
  160. return ;
  161. #endif
  163. CamReset();
  165. // Initializing camif
  166. rCLKCON |= (1<<19); // enable camclk
  167. CamPortSet();
  168. //ChangeUPllValue(60, 4, 1); // UPLL clock = 96MHz, PLL input 16.9344MHz
  169. //--- capbily
  170. ChangeUPllValue(56, 2, 1); // UPLL clock = 96MHz, PLL input 12MHz
  171. //---
  172. rCLKDIVN|=(1<<3); // UCLK 48MHz setting for UPLL 96MHz
  173. // 0:48MHz, 1:24MHz, 2:16MHz, 3:12MHz...
  174. // Camera clock = UPLL/[(CAMCLK_DIV+1)X2]
  176. switch(USED_CAM_TYPE)
  177. {
  178. case CAM_AU70H :
  179. if (AU70H_VIDEO_SIZE==1152)
  180. SetCAMClockDivider(CAMCLK24000000); //Set Camera Clock for SXGA
  181. if (AU70H_VIDEO_SIZE==640)
  182. SetCAMClockDivider(CAMCLK16000000); //Set Camera Clock for VGA
  183. break;
  184. case CAM_S5X3A1 :
  185. SetCAMClockDivider(CAMCLK24000000); //Set Camera Clock for SXGA
  186. break;
  187. default :  // 24MHz
  188. SetCAMClockDivider(CAMCLK24000000); //Set Camera Clock 24MHz s5x532, ov7620
  189. break;
  190. }
  193. #if (USED_CAM_TYPE==CAM_OV7620) //capbily
  194. i = Test_OV9650();
  195. if( i )
  196. {
  197. Uart_Printf("nTest is failed!!!n");
  198. return ;
  199. }
  200. #else
  201. // Initializing camera module
  202. CamModuleReset(); // s5x532 must do this..
  203. Delay(100); // ready time of s5x433, s5x532 IIC interface. needed...
  204. CameraModuleSetting();
  205. #endif
  207. Uart_Printf("Initializing end...n");
  209. Test_CamPreview() ;
  211. Uart_Printf("nCamera Preview Test Endn");
  213. // CamModuleReset(); // s5x532 must do this..
  215. rCLKCON &= ~(1<<19); // disable camclk
  216. TFT_LCD_Init() ; //
  218. }
  221. void CamPortSet(void)
  222. {
  223. save_GPJCON = rGPJCON;
  224. save_GPJDAT = rGPJDAT;
  225. save_GPJUP = rGPJUP;
  227. rGPJCON = 0x2aaaaaa;
  228. rGPJDAT = 0;
  229. rGPJUP = 0;
  231. //--- capbily
  232. rGPGCON &= ~(3<<24);
  233. rGPGCON |= 1<<24;
  234. rGPGUP  |= 1<<12;
  235. #if (USED_CAM_TYPE==CAM_OV7620)
  236. rGPGDAT &= ~(1<<12);
  237. #else
  238. rGPGDAT |= 1<<12;
  239. #endif
  240. //---
  241. }
  243. void CamPortReturn(void)
  244. {
  245. rGPJCON = save_GPJCON;
  246. rGPJDAT = save_GPJDAT;
  247. rGPJUP = save_GPJUP;
  248. }
  250. void CamPreviewIntUnmask(void)
  251. {
  252.     rINTSUBMSK &= ~(BIT_SUB_CAM_P);//INT CAMERA Port A ENABLE 
  253.     rINTMSK &= ~(BIT_CAM);
  254. }
  256. void CamCodecIntUnmask(void)
  257. {
  258.     rINTSUBMSK &= ~(BIT_SUB_CAM_C);//INT CAMERA Port B ENABLE 
  259.     rINTMSK &= ~(BIT_CAM);
  260. }
  262. void CamPreviewIntMask(void)
  263. {
  264.     rINTSUBMSK |= BIT_SUB_CAM_P;//INT CAMERA Port A ENABLE 
  265.     rINTMSK |= (BIT_CAM);
  266. }
  268. void CamCodecIntMask(void)
  269. {
  270.     rINTSUBMSK |= BIT_SUB_CAM_C;//INT CAMERA Port B ENABLE 
  271.     rINTMSK |= (BIT_CAM);
  272. }
  275. /******************************************************
  276.  *                                                                       *    
  277.  *                       camera interface initialization                     *
  278.  *                                                                             *     
  279.  *******************************************************/
  281. void CamReset(void)
  282. {
  283. rCIGCTRL |= (1<<31); //camera I/F soft reset
  284. Delay(10);
  285. rCIGCTRL &= ~(1<<31);
  286. }
  288. void CamModuleReset(void)
  289. {
  290. switch(USED_CAM_TYPE)
  291. {
  292. case CAM_OV7620 : // reset - active high
  293. //case CAM_S5X532 : // reset - active low, but H/W inverted.. so, in this case active high, masked by capbily
  294. case CAM_S5X433 : // reset - active low, but H/W inverted.. so, in this case active high
  295. case CAM_S5X3A1 : // reset - active low, but H/W inverted.. so, in this case active high
  296. rCIGCTRL |= (1<<30);   //external camera reset high
  297. Delay(30);
  298. rCIGCTRL &= ~(1<<30); //external camera reset low
  299. break;
  300. case CAM_S5X532 : // reset - active low, move here by capbily
  301. case CAM_AU70H : // reset - active low
  302. default :
  303. rCIGCTRL &= ~(1<<30); //external camera reset low
  304. Delay(10);
  305. rCIGCTRL |= (1<<30); //external camera reset high
  306. break;
  307. }
  308. }
  310. // 0:48MHz, 1:24MHz, 2:16MHz, 3:12MHz...
  311. // Camera clock = UPLL/[(CAMCLK_DIV+1)X2]
  312. void SetCAMClockDivider(int divn) 
  313. {
  314. rCAMDIVN = (rCAMDIVN & ~(0xf))|(1<<4)|(divn); // CAMCLK is divided..
  315. }
  317. /* Description of Parameters
  318. CoDstWidth: Destination Width of Codec Path
  319. CoDstHeight: Destination Height of Codec Path
  320. PrDstWidth: Destination Width of Preview Path
  321. PrDstHeight: Destination Height of Preview Path
  322. WinHorOffset: Size of Window Offset for Horizontal Direction
  323. WinVerOffset: Size of Window Offset for Vertical Direction
  324. CoFrameBuffer: Start Address for Codec DMA
  325. PrFrameBuffer: Start Address for Previe DMA
  326. */
  327. void CamInit(U32 CoDstWidth, U32 CoDstHeight, U32 PrDstWidth, U32 PrDstHeight, 
  328. U32 WinHorOffset, U32 WinVerOffset,  U32 CoFrameBuffer, U32 PrFrameBuffer)
  329. {
  330. U32 WinOfsEn;
  331. U32 divisor, multiplier;
  332. U32 MainBurstSizeY, RemainedBurstSizeY, MainBurstSizeC, RemainedBurstSizeC, MainBurstSizeRGB, RemainedBurstSizeRGB;
  333. U32 H_Shift, V_Shift, PreHorRatio, PreVerRatio, MainHorRatio, MainVerRatio;
  334. U32 SrcWidth, SrcHeight;
  335. U32 ScaleUp_H_Co, ScaleUp_V_Co, ScaleUp_H_Pr, ScaleUp_V_Pr;
  337. //constant for calculating codec dma address
  338. if(CAM_CODEC_OUTPUT)
  339. divisor=2; //CCIR-422
  340. else
  341. divisor=4; //CCIR-420
  343. //constant for calculating preview dma address
  344. if(CAM_PVIEW_OUTPUT)
  345. multiplier=4;
  346. else
  347. multiplier=2;
  349. if(WinHorOffset==0 && WinVerOffset==0)
  350. WinOfsEn=0;
  351. else
  352. WinOfsEn=1;
  354. SrcWidth=CAM_SRC_HSIZE-WinHorOffset*2;
  355. SrcHeight=CAM_SRC_VSIZE-WinVerOffset*2;
  357. if(SrcWidth>=CoDstWidth) ScaleUp_H_Co=0; //down
  358. else ScaleUp_H_Co=1; //up
  360. if(SrcHeight>=CoDstHeight) ScaleUp_V_Co=0;
  361. else ScaleUp_V_Co=1;
  363. if(SrcWidth>=PrDstWidth) ScaleUp_H_Pr=0; //down
  364. else ScaleUp_H_Pr=1; //up
  366. if(SrcHeight>=PrDstHeight) ScaleUp_V_Pr=0;   // edited 040225
  367. else ScaleUp_V_Pr=1;
  369. ////////////////// common control setting
  370. rCIGCTRL |= (1<<26)|(0<<27); // inverse PCLK, test pattern
  371. //--- capbily
  372. //rCIGCTRL |= (0<<26)|(0<<27); // don't inverse PCLK, test pattern
  373. //---
  374. rCIWDOFST = (1<<30)|(0xf<<12); // clear overflow 
  375. rCIWDOFST = 0;
  376. rCIWDOFST=(WinOfsEn<<31)|(WinHorOffset<<16)|(WinVerOffset);
  377. rCISRCFMT=(CAM_ITU601<<31)|(0<<30)|(0<<29)|(CAM_SRC_HSIZE<<16)|(CAM_ORDER_YCBYCR<<14)|(CAM_SRC_VSIZE);
  378. //--- capbily
  379. //rCISRCFMT=(CAM_ITU601<<31)|(1<<30)|(0<<29)|(CAM_SRC_HSIZE<<16)|(CAM_ORDER_YCBYCR<<14)|(CAM_SRC_VSIZE);
  380. //---
  382. ////////////////// codec port setting
  383. if (CAM_CODEC_4PP)
  384. {
  385. rCICOYSA1=CoFrameBuffer;
  386. rCICOYSA2=rCICOYSA1+CoDstWidth*CoDstHeight+2*CoDstWidth*CoDstHeight/divisor;
  387. rCICOYSA3=rCICOYSA2+CoDstWidth*CoDstHeight+2*CoDstWidth*CoDstHeight/divisor;
  388. rCICOYSA4=rCICOYSA3+CoDstWidth*CoDstHeight+2*CoDstWidth*CoDstHeight/divisor;
  390. rCICOCBSA1=rCICOYSA1+CoDstWidth*CoDstHeight;
  391. rCICOCBSA2=rCICOYSA2+CoDstWidth*CoDstHeight;
  392. rCICOCBSA3=rCICOYSA3+CoDstWidth*CoDstHeight;
  393. rCICOCBSA4=rCICOYSA4+CoDstWidth*CoDstHeight;
  395. rCICOCRSA1=rCICOCBSA1+CoDstWidth*CoDstHeight/divisor;
  396. rCICOCRSA2=rCICOCBSA2+CoDstWidth*CoDstHeight/divisor;
  397. rCICOCRSA3=rCICOCBSA3+CoDstWidth*CoDstHeight/divisor;
  398. rCICOCRSA4=rCICOCBSA4+CoDstWidth*CoDstHeight/divisor;
  399. }
  400. else
  401. {
  402. rCICOYSA1=CoFrameBuffer;
  403. rCICOYSA2=rCICOYSA1;
  404. rCICOYSA3=rCICOYSA1;
  405. rCICOYSA4=rCICOYSA1;
  407. rCICOCBSA1=rCICOYSA1+CoDstWidth*CoDstHeight;
  408. rCICOCBSA2=rCICOCBSA1;
  409. rCICOCBSA3=rCICOCBSA1;
  410. rCICOCBSA4=rCICOCBSA1;
  412. rCICOCRSA1=rCICOCBSA1+CoDstWidth*CoDstHeight/divisor;
  413. rCICOCRSA2=rCICOCRSA1;
  414. rCICOCRSA3=rCICOCRSA1;
  415. rCICOCRSA4=rCICOCRSA1;
  416. }
  417. rCICOTRGFMT=(CAM_CODEC_IN_422<<31)|(CAM_CODEC_OUTPUT<<30)|(CoDstWidth<<16)|(CAM_FLIP_180<<14)|(CoDstHeight);
  419. CalculateBurstSize(CoDstWidth, &MainBurstSizeY, &RemainedBurstSizeY);
  420. CalculateBurstSize(CoDstWidth/2, &MainBurstSizeC, &RemainedBurstSizeC);
  421. rCICOCTRL=(MainBurstSizeY<<19)|(RemainedBurstSizeY<<14)|(MainBurstSizeC<<9)|(RemainedBurstSizeC<<4);
  423. CalculatePrescalerRatioShift(SrcWidth, CoDstWidth, &PreHorRatio, &H_Shift);
  424. CalculatePrescalerRatioShift(SrcHeight, CoDstHeight, &PreVerRatio, &V_Shift);
  425. MainHorRatio=(SrcWidth<<8)/(CoDstWidth<<H_Shift);
  426. MainVerRatio=(SrcHeight<<8)/(CoDstHeight<<V_Shift);
  427.     
  428. rCICOSCPRERATIO=((10-H_Shift-V_Shift)<<28)|(PreHorRatio<<16)|(PreVerRatio);
  429. rCICOSCPREDST=((SrcWidth/PreHorRatio)<<16)|(SrcHeight/PreVerRatio); 
  430. rCICOSCCTRL=(CAM_SCALER_BYPASS_OFF<<31)|(ScaleUp_H_Co<<30)|(ScaleUp_V_Co<<29)|(MainHorRatio<<16)|(MainVerRatio);
  432. rCICOTAREA=CoDstWidth*CoDstHeight;
  434. ///////////////// preview port setting
  435. if (CAM_PVIEW_4PP) // codec view mode
  436. {
  437. rCIPRCLRSA1=PrFrameBuffer;
  438. rCIPRCLRSA2=rCIPRCLRSA1+PrDstWidth*PrDstHeight*multiplier;
  439. rCIPRCLRSA3=rCIPRCLRSA2+PrDstWidth*PrDstHeight*multiplier;
  440. rCIPRCLRSA4=rCIPRCLRSA3+PrDstWidth*PrDstHeight*multiplier;
  441. }
  442. else // direct preview mode
  443. {
  444. rCIPRCLRSA1 = (U32)LCD_BUFFER_CAM;
  445. rCIPRCLRSA2 = (U32)LCD_BUFFER_CAM;
  446. rCIPRCLRSA3 = (U32)LCD_BUFFER_CAM;
  447. rCIPRCLRSA4 = (U32)LCD_BUFFER_CAM;
  448. }
  450. rCIPRTRGFMT=(PrDstWidth<<16)|(CAM_FLIP_180<<14)|(PrDstHeight);
  452. if (CAM_PVIEW_OUTPUT==CAM_RGB24B)
  453. CalculateBurstSize(PrDstWidth*2, &MainBurstSizeRGB, &RemainedBurstSizeRGB);
  454. else // RGB16B
  455. CalculateBurstSize(PrDstWidth*2, &MainBurstSizeRGB, &RemainedBurstSizeRGB);
  456.     rCIPRCTRL=(MainBurstSizeRGB<<19)|(RemainedBurstSizeRGB<<14);
  458. CalculatePrescalerRatioShift(SrcWidth, PrDstWidth, &PreHorRatio, &H_Shift);
  459. CalculatePrescalerRatioShift(SrcHeight, PrDstHeight, &PreVerRatio, &V_Shift);
  460. MainHorRatio=(SrcWidth<<8)/(PrDstWidth<<H_Shift);
  461. MainVerRatio=(SrcHeight<<8)/(PrDstHeight<<V_Shift);
  462. rCIPRSCPRERATIO=((10-H_Shift-V_Shift)<<28)|(PreHorRatio<<16)|(PreVerRatio);  
  463. rCIPRSCPREDST=((SrcWidth/PreHorRatio)<<16)|(SrcHeight/PreVerRatio);
  464. rCIPRSCCTRL=(1<<31)|(CAM_PVIEW_OUTPUT<<30)|(ScaleUp_H_Pr<<29)|(ScaleUp_V_Pr<<28)|(MainHorRatio<<16)|(MainVerRatio);
  465.     
  466. rCIPRTAREA= PrDstWidth*PrDstHeight;
  467. }
  471. /********************************************************
  472.  CalculateBurstSize - Calculate the busrt lengths
  473.  
  474.  Description:
  475.  - dstHSize: the number of the byte of H Size.
  476.  
  477. */
  478. void CalculateBurstSize(U32 hSize,U32 *mainBurstSize,U32 *remainedBurstSize)
  479. {
  480. U32 tmp;
  481. tmp=(hSize/4)%16;
  482. switch(tmp) {
  483. case 0:
  484. *mainBurstSize=16;
  485. *remainedBurstSize=16;
  486. break;
  487. case 4:
  488. *mainBurstSize=16;
  489. *remainedBurstSize=4;
  490. break;
  491. case 8:
  492. *mainBurstSize=16;
  493. *remainedBurstSize=8;
  494. break;
  495. default: 
  496. tmp=(hSize/4)%8;
  497. switch(tmp) {
  498. case 0:
  499. *mainBurstSize=8;
  500. *remainedBurstSize=8;
  501. break;
  502. case 4:
  503. *mainBurstSize=8;
  504. *remainedBurstSize=4;
  505. default:
  506. *mainBurstSize=4;
  507. tmp=(hSize/4)%4;
  508. *remainedBurstSize= (tmp) ? tmp: 4;
  509. break;
  510. }
  511. break;
  512. }          
  513. }
  517. /********************************************************
  518.  CalculatePrescalerRatioShift - none
  519.  
  520.  Description:
  521.  - none
  522.  
  523. */
  524. void CalculatePrescalerRatioShift(U32 SrcSize, U32 DstSize, U32 *ratio,U32 *shift)
  525. {
  526. if(SrcSize>=64*DstSize) {
  527. Uart_Printf("ERROR: out of the prescaler range: SrcSize/DstSize = %d(< 64)n",SrcSize/DstSize);
  528. while(1);
  529. }
  530. else if(SrcSize>=32*DstSize) {
  531. *ratio=32;
  532. *shift=5;
  533. }
  534. else if(SrcSize>=16*DstSize) {
  535. *ratio=16;
  536. *shift=4;
  537. }
  538. else if(SrcSize>=8*DstSize) {
  539. *ratio=8;
  540. *shift=3;
  541. }
  542. else if(SrcSize>=4*DstSize) {
  543. *ratio=4;
  544. *shift=2;
  545. }
  546. else if(SrcSize>=2*DstSize) {
  547. *ratio=2;
  548. *shift=1;
  549. }
  550. else {
  551. *ratio=1;
  552. *shift=0;
  553. }    
  555. }
  558. /********************************************************
  559.  CamCaptureStart - Start camera capture operation.
  560.  
  561.  Description:
  562.  - mode= CAM_CODEC_CAPTURE_ENABLE_BIT or CAM_PVIEW_CAPTURE_ENABLE_BIT or both
  563.   
  564. */
  565. void CamCaptureStart(U32 mode)
  566. { 
  567.     
  568. if(mode&CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT) {
  569. camCodecStatus=CAM_STARTED;
  570. rCICOSCCTRL|=CAM_CODEC_SACLER_START_BIT;
  571. }
  573. if(mode&CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT) {
  574. camPviewStatus=CAM_STARTED;
  575. rCIPRSCCTRL|=CAM_PVIEW_SACLER_START_BIT;
  576. }
  578. if(mode&CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT) {
  579. camCodecStatus=CAM_STARTED;
  580. rCICOSCCTRL|=CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT;
  581. }
  583. rCIIMGCPT|=CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT|mode;
  584. }
  587. void CamCaptureStop(void)
  588. {
  589. camCodecStatus=CAM_STOP_ISSUED;
  590. camPviewStatus=CAM_STOP_ISSUED;
  591. }
  594. void _CamCodecStopHw(void)
  595. {
  596. rCICOSCCTRL &= ~CAM_CODEC_SACLER_START_BIT; //stop codec scaler.
  597. rCIIMGCPT &= ~CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT; //stop capturing for codec scaler.
  598. if(!(rCIIMGCPT & CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT))
  599. rCIIMGCPT &= ~CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT; //stop capturing for preview scaler if needed.
  600. rCICOCTRL |= (1<<2); //Enable last IRQ at the end of frame capture.
  601.        //NOTE:LastIrqEn bit should be set after clearing CAPTURE_ENABLE_BIT & SCALER_START_BIT
  602. }
  604. void _CamPviewStopHw(void)
  605. {
  606. rCIPRSCCTRL &= ~CAM_PVIEW_SACLER_START_BIT; //stop preview scaler.
  607. rCIIMGCPT &= ~CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT; //stop capturing for preview scaler.
  608. if(!(rCIIMGCPT&CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT))
  609. rCIIMGCPT &= ~CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT; //stop capturing for codec scaler if needed.
  610. rCIPRCTRL |= (1<<2); //Enable last IRQ at the end of frame capture.
  611.         //NOTE:LastIrqEn bit should be set after clearing CAPTURE_ENABLE_BIT & SCALER_START_BIT
  612. }
  615. void __irq CamIsr(void)
  616. {
  618. U32 completedFrameIndex;
  620. if (rSUBSRCPND&BIT_SUB_CAM_C)
  621. {
  622. //Uart_Printf("[C]");
  623. rGPFDAT ^= 1<<5; //capbily
  624. CamCodecIntMask();
  625. rSUBSRCPND |= BIT_SUB_CAM_C;
  626. ClearPending(BIT_CAM);
  627. switch(camCodecStatus) {
  628. case CAM_STOP_ISSUED:
  629. _CamCodecStopHw();
  630. camCodecStatus=CAM_LAST_CAPTURING;
  631. Uart_Printf("cr=%xn", rCICOCTRL);
  632. //Uart_Printf("cS1n");
  633. break;
  634. case CAM_LAST_CAPTURING:
  635. camCodecStatus=CAM_STOPPED;
  636. CamCodecIntMask();
  637. //Uart_Printf("cS2n");
  638. return;
  639. case CAM_STARTED:
  640. flagCaptured_C = 1;
  641. // _CamCodecStopHw();
  642. if(camTestMode&CAM_TEST_MODE_CODEC) {
  643. if(camCodecCaptureCount>0) 
  644. completedFrameIndex=(((rCICOSTATUS>>26)&0x3)+4-2)%4;   
  645. //Uart_Printf("FrameIndex:%dn",completedFrameIndex);
  646. }
  647. else {
  648. //Uart_Printf("Just Capturing without display");
  649. }
  650. break;
  651. case CAM_CODEC_SCALER_BYPASS_STATE:
  652. //Uart_Printf("cBPn");
  653. break;
  654. default:
  655. break;
  656. }
  658. CamCodecIntUnmask();
  659.     camCodecCaptureCount++;  
  660. }
  661. else
  662. {
  663. //Uart_Printf("[P]");
  664. rGPFDAT ^= 1<<4; //capbily
  665. CamPreviewIntMask();
  666. rSUBSRCPND |= BIT_SUB_CAM_P;
  667. ClearPending(BIT_CAM) ;
  668. switch(camPviewStatus) {
  669. case CAM_STOP_ISSUED:
  670. _CamPviewStopHw();
  671. camPviewStatus=CAM_LAST_CAPTURING;  
  672. Uart_Printf("pr=%xn", rCIPRCTRL);
  673. //Uart_Printf("pS1n");
  674. break;
  675. case CAM_LAST_CAPTURING:
  676. camPviewStatus=CAM_STOPPED;
  677. CamPreviewIntMask();
  678. //Uart_Printf("pS2n"); 
  679. return;
  680. case CAM_STARTED:
  681. flagCaptured_P = 1;
  682. if(camTestMode&CAM_TEST_MODE_PVIEW) {
  683. if(camPviewCaptureCount >0) 
  684. completedFrameIndex=(((rCIPRSTATUS>>26)&0x3)+4-2)%4;
  685. //Uart_Printf("FrameIndex:%dn",completedFrameIndex);
  686. }
  687. else {
  688. //Uart_Printf("Preview Image Capturedn");
  689. } 
  690. default:
  691. break;
  692. } 
  694. CamPreviewIntUnmask();
  695. camPviewCaptureCount++;
  696. }
  697. }
  701. /******************************************************************************
  702.  *                                                                            *    
  703.  *                   camera interface interrupts & controls                   *
  704.  *                                                                            *     
  705.  ******************************************************************************/
  708. U32 Conv_YCbCr_Rgb(U8 y0, U8 y1, U8 cb0, U8 cr0)  // second solution... by junon
  709. {
  710. // bit order is
  711. // YCbCr = [Cr0 Y1 Cb0 Y0], RGB=[R1,G1,B1,R0,G0,B0].
  713. int r0, g0, b0, r1, g1, b1;
  714. U32 rgb0, rgb1, rgb;
  715.  
  716. #if 1 // 4 frames/s @192MHz, 12MHz ; 6 frames/s @450MHz, 12MHz
  717. r0 = YCbCrtoR(y0, cb0, cr0);
  718. g0 = YCbCrtoG(y0, cb0, cr0);
  719. b0 = YCbCrtoB(y0, cb0, cr0);
  720. r1 = YCbCrtoR(y1, cb0, cr0);
  721. g1 = YCbCrtoG(y1, cb0, cr0);
  722. b1 = YCbCrtoB(y1, cb0, cr0);
  723. #endif
  725. if (r0>255 ) r0 = 255;
  726. if (r0<0) r0 = 0;
  727. if (g0>255 ) g0 = 255;
  728. if (g0<0) g0 = 0;
  729. if (b0>255 ) b0 = 255;
  730. if (b0<0) b0 = 0;
  732. if (r1>255 ) r1 = 255;
  733. if (r1<0) r1 = 0;
  734. if (g1>255 ) g1 = 255;
  735. if (g1<0) g1 = 0;
  736. if (b1>255 ) b1 = 255;
  737. if (b1<0) b1 = 0;
  739. // 5:6:5 16bit format
  740. rgb0 = (((U16)r0>>3)<<11) | (((U16)g0>>2)<<5) | (((U16)b0>>3)<<0); //RGB565.
  741. rgb1 = (((U16)r1>>3)<<11) | (((U16)g1>>2)<<5) | (((U16)b1>>3)<<0); //RGB565.
  743. rgb = (rgb1<<16) | rgb0;
  745. return(rgb);
  746. }
  749. void Display_Cam_Image(U32 size_x, U32 size_y)
  750. {
  751. U8 *buffer_y, *buffer_cb, *buffer_cr;
  752. U8 y0,y1,cb0,cr0;
  753. int r0,r1,g0,g1,b0,b1;
  754. U32 rgb_data0, rgb_data1; 
  755. U32 x, y;
  756. int temp;
  758. if (CAM_CODEC_4PP)
  759. temp = (((rCICOSTATUS>>26)&0x3)+4-2)%4; // current frame memory block
  760. else
  761. temp = 4;
  762. //Uart_Printf("Current Frame memory %dn", temp);
  764. switch (temp) // current frame mem - 2
  765. {
  766. case 0:
  767. buffer_y = (U8 *)rCICOYSA1;
  768. buffer_cb = (U8 *)rCICOCBSA1;
  769. buffer_cr = (U8 *)rCICOCRSA1;
  770. break;
  771. case 1:
  772. buffer_y = (U8 *)rCICOYSA2;
  773. buffer_cb = (U8 *)rCICOCBSA2;
  774. buffer_cr = (U8 *)rCICOCRSA2;
  775. break;
  776. case 2:
  777. buffer_y = (U8 *)rCICOYSA3;
  778. buffer_cb = (U8 *)rCICOCBSA3;
  779. buffer_cr = (U8 *)rCICOCRSA3;
  780. break;
  781. case 3:
  782. buffer_y = (U8 *)rCICOYSA4;
  783. buffer_cb = (U8 *)rCICOCBSA4;
  784. buffer_cr = (U8 *)rCICOCRSA4;
  785. break;
  786. default :
  787. buffer_y = (U8 *)rCICOYSA1;
  788. buffer_cb = (U8 *)rCICOCBSA1;
  789. buffer_cr = (U8 *)rCICOCRSA1;
  790. break;
  791. }
  793. //Uart_Printf("End setting : Y-0x%x, Cb-0x%x, Cr-0x%xn", buffer_y, buffer_cb, buffer_cr);
  794. #if 0
  795. // for checking converting time 
  796. rGPGCON = (rGPGCON&~(1<<23))|(1<<22); //EINT19 -> GPG11 output
  797. rGPGUP |= (1<<11);
  798. rGPGDAT &= ~(1<<11);
  799. Delay(90);
  800. rGPGDAT |=(1<<11);
  802. rgb_data0 = 0;
  803. #endif
  805. #if CAM_CODEC_OUTPUT==CAM_CCIR420
  806. for (y=0;y<size_y;y++) // YCbCr 4:2:0 format
  807. {
  808. for (x=0;x<size_x;x+=2)
  809. {
  810. rgb_data0 = Conv_YCbCr_Rgb(*buffer_y++, *buffer_y++, *buffer_cb++, *buffer_cr++);
  811. frameBuffer16BitTft240320[y][x/2] = rgb_data0;
  813. if ( (x==(size_x-2)) && ((y%2)==0) ) // when x is last pixel & y is even number
  814. {
  815. buffer_cb -= size_x/2;
  816. buffer_cr -= size_x/2;
  817. } 
  818. }
  819. }
  820. #else
  821. for (y=0;y<size_y;y++) // YCbCr 4:2:2 format
  822. {
  823. for (x=0;x<size_x;x+=2)
  824. { 
  825. rgb_data0 = Conv_YCbCr_Rgb(*buffer_y++, *buffer_y++, *buffer_cb++, *buffer_cr++);
  826. //frameBuffer16BitTft240320[y][x/2] = rgb_data0;
  828. //--- capbily
  829. //frameBuffer16BitTft240320是32位的数组!!!
  830. //in HWSWP=1 16BPP mode d0~d15 is 1st pixel, d16~d31 is 2nd
  831. //in HWSWP=0 16BPP mode d0~d15 is 2nd pixel, d16~d31 is 1st
  833. // U16 lt;
  834. //Uart_Printf("%x,%xn", *buffer_cb, *buffer_cr);
  835. //测试只输出Y(亮度)
  836. // lt = (*buffer_y++)>>3;
  837. // rgb_data0  = ((lt<<11)|(lt<<5)|(lt))<<16; //1st pixel
  838. // lt = (*buffer_y++)>>3;
  839. // rgb_data0 |= (lt<<11)|(lt<<5)|(lt); //2nd pixel
  840. //测试只输出U
  841. // lt   = (*buffer_cb)>>3;
  842. // rgb_data0  = ((lt<<11)|(lt<<5)|(lt))<<16; //1st pixel
  843. // lt   = (*buffer_cb++)>>3;
  844. // rgb_data0 |= (lt<<11)|(lt<<5)|(lt); //2nd pixel
  845. //测试只输出V
  846. // lt   = (*buffer_cr)>>3;
  847. // rgb_data0  = ((lt<<11)|(lt<<5)|(lt))<<16; //1st pixel
  848. // lt   = (*buffer_cr++)>>3;
  849. // rgb_data0 |= (lt<<11)|(lt<<5)|(lt); //2nd pixel
  851. //测试ov9650固定输出U=0x1f,V=0x70的模式
  852. // rgb_data0  = *buffer_y++<<24; //1st pixel
  853. // rgb_data0 |= *buffer_cb++<<16;
  854. // rgb_data0 |= *buffer_y++<<8; //2nd pixel
  855. // rgb_data0 |= *buffer_cr++;
  856. // rgb_data0 &= ~0xff00f800;
  857. // rgb_data0 |= 0x0700;
  859. //测试ov9650输出RGB565格式
  860. // rgb_data0  = *buffer_y++<<24; //1st pixel
  861. // rgb_data0 |= *buffer_cb++<<16;
  862. // rgb_data0 |= *buffer_y++<<8; //2nd pixel
  863. // rgb_data0 |= *buffer_cr++;
  864. //RGB高低交换
  865. // rgb_data0  = *buffer_cb++<<24; //1st pixel
  866. // rgb_data0 |= *buffer_y++<<16;
  867. // rgb_data0 |= *buffer_cr++<<8; //2nd pixel
  868. // rgb_data0 |= *buffer_y++;
  869. // rgb_data0 &= 0xf800f800; //red   only
  870. // rgb_data0 &= 0x07e007e0; //green only
  871. // rgb_data0 &= 0x001f001f; //blue  only
  873. LCD_BUFFER_CAM[y][x/2] = rgb_data0;
  874. //Uart_Printf("%08xn", rgb_data0);
  875. //---
  876. }
  877. } 
  878. #endif
  880. // memcpy((unsigned char*)0x30100000,  frameBuffer16BitTft240320, 320*240*2); // QCIF=178*144*2
  881. #if 0
  882. rGPGDAT &= ~(1<<11);
  883. Delay(30);
  884. rGPGDAT |=(1<<11);
  885. rGPGCON = (rGPGCON&~(1<<22))|(1<<23); // GPG11 output -> EINT19
  886. #endif
  887. }
  889. #if 0
  890. void Display_Cam_Image(int offset_x, int offset_y, int size_x, int size_y)
  891. {
  892. U8* CamFrameAddr, LcdFrameAddr;
  893. int i, temp;
  895. Lcd_MoveViewPort(offset_x, offset_y, USED_LCD_TYPE);
  897. switch(camPviewCaptureCount%4)
  898. {
  899. case 2 : 
  900. temp = rCIPRCLRSA1;
  901. break;
  902. case 3 : 
  903. temp = rCIPRCLRSA2;
  904. break;
  905. case 0 : 
  906. temp = rCIPRCLRSA3;
  907. break;
  908. case 1 :
  909. default:
  910. temp = rCIPRCLRSA4;
  911. break;
  912. }
  914. *CamFrameAddr = temp;
  915. *LcdFrameAddr = LCD_BUFFER_CAM;
  916. for(i=0;i<size_y;i++)
  917. {
  918. memcpy(LcdFrameAddr, CamFrameAddr, size_x*2);
  919. *LcdFrameAddr += size_x*4; // added virtual screen
  920. *CamFrameAddr += size_x*2; 
  921. }
  922. }
  923. #endif
  925. void Test_CamPreview(void)
  926. {
  928. U8 flag;
  929. U32 i,j,k,value;
  931. Uart_Printf("nNow Start Camera Previewn");
  933. //camera global variables
  934. camTestMode=CAM_TEST_MODE_PVIEW;
  935. camCodecCaptureCount=0;
  936. camPviewCaptureCount=0;
  937. camPviewStatus=CAM_STOPPED;
  938. camCodecStatus=CAM_STOPPED;
  939. flagCaptured_P=0;
  941. LCD_Init();
  942. #if defined(LCD_N35) || defined(LCD_T35)
  943. Paint_Bmp(0, 0, 240, 320, camera_pic_240x320);
  944. #endif
  946. Uart_Printf( "preview sc control = %xn" , rCIPRSCCTRL ) ;
  948. // Initialize Camera interface
  949. switch(USED_CAM_TYPE)
  950. {
  951. case CAM_S5X532 : // defualt for test : data-falling edge, ITU601, YCbCr
  952. CamInit(640, 480, 240, 320, 112, 20,  CAM_FRAMEBUFFER_C, CAM_FRAMEBUFFER_P);
  953. break;
  954. case CAM_S5X3A1 : // defualt for test : data-falling edge, YCbCr
  955. CamInit(640, 480, 240, 320, 120, 100, CAM_FRAMEBUFFER_C, CAM_FRAMEBUFFER_P);
  956. rCISRCFMT = rCISRCFMT & ~(1<<31); // ITU656
  957. // rCIGCTRL &= ~(1<<26); // inverse PCLK, test pattern
  958. break;
  959. //--- add by capbily
  960. case CAM_OV7620:
  961. #if defined(LCD_N35) || defined(LCD_T35)
  962. CamInit(240, 180, 240, 180, 100, 100,  CAM_FRAMEBUFFER_C, CAM_FRAMEBUFFER_P);
  963. #elif defined(LCD_A70)
  964. CamInit(800, 480, 800, 480, 0, 0,  CAM_FRAMEBUFFER_C, CAM_FRAMEBUFFER_P);
  965. #elif defined(LCD_L80)
  966. CamInit(640, 480, 640, 480, 0, 0,  CAM_FRAMEBUFFER_C, CAM_FRAMEBUFFER_P);
  967. #elif defined(LCD_VGA1024768)
  968. CamInit(640, 480, 320, 240, 0, 0,  CAM_FRAMEBUFFER_C, CAM_FRAMEBUFFER_P);
  969. #endif
  970. break;
  971. //---
  972. default : 
  973. CamInit(640, 480, 320, 240, 0, 0,  CAM_FRAMEBUFFER_C, CAM_FRAMEBUFFER_P);
  974. break;
  975. }
  976. Uart_Printf("preview sc control = %xn", rCIPRSCCTRL);
  979. // Start Capture
  980. rSUBSRCPND |= BIT_SUB_CAM_C|BIT_SUB_CAM_P;
  981. ClearPending(BIT_CAM);
  982. pISR_CAM = (U32)CamIsr;    
  983. CamPreviewIntUnmask();
  984. CamCaptureStart(CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT);
  985. Uart_Printf("Press 'ESC' key to exit!n");
  986. while (1)
  987. {
  988. if (flagCaptured_P)
  989. {
  990. flagCaptured_P = 0;
  991. // Uart_Printf("Enter Cam A port, count = %dn",camCodecCaptureCount);
  992. }
  993. if ( Uart_GetKey() == ESC_KEY ) break;
  994. }
  995.     
  996. CamCaptureStop();
  998. Uart_Printf("nWait until the current frame capture is completed.n");
  999. while(camPviewStatus!=CAM_STOPPED)
  1000. if (Uart_GetKey()== 'r') break;
  1002. Uart_Printf("CIS format = %xn", rCISRCFMT);
  1003. Uart_Printf("image cap = %xn", rCIIMGCPT);
  1004. Uart_Printf("preview sc control = %xn", rCIPRSCCTRL);
  1005. Uart_Printf("preview control = %xn", rCIPRCTRL);
  1006. Uart_Printf("codec sc control = %xn", rCICOSCCTRL);
  1007. Uart_Printf("codec control = %xn", rCICOCTRL);
  1008. Uart_Printf("pr addr1 = %xn", rCIPRCLRSA1);
  1009. Uart_Printf("pr addr2 = %xn", rCIPRCLRSA2);
  1011. Uart_Printf("camCodecCaptureCount=%dn",camCodecCaptureCount);
  1012. Uart_Printf("camPviewCaptureCount=%dn",camPviewCaptureCount);
  1013. // CamPreviewIntMask();
  1014. }