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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
camif.c
资源名称：mini2440_uCos2_ucgui.rar　[点击查看]
上传用户：zbk8730
上传日期：2017-08-10
资源大小：12168k
文件大小：29k
源码类别：

uCOS

开发平台：

C/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 (c) 2004 SAMSUNG Electronics.
  10. # However, Anybody can use this code without our permission.  
  11. *************************************************************/
  13. #include <ctype.h>
  14. #include "def.h"
  15. #include "2440addr.h"
  16. #include "2440lib.h"
  17. #include "camif.h"
  18. #include "lcdlib.h"
  19. #include "glib.h"
  20. #include "camproset.h" // for camera setting
  21. //#include ".bmppqvga16bsm5.h"
  22. #include ".bmp422jpeg.h"
  23. #include ".bmp420jpeg.h"
  24. #include ".bmpforeman_cif_420.H"
  26. volatile U32 camTestMode;
  27. volatile U32 camCodecCaptureCount;
  28. volatile U32 camPviewCaptureCount;
  29. volatile U32 camCodecStatus;
  30. volatile U32 camPviewStatus;
  31. volatile U32 amount;
  33. U32 save_GPJCON, save_GPJDAT, save_GPJUP;
  35. U8 flagCaptured_P = 0;
  36. U8 flagCaptured_C = 0;
  39. void * func_camera_test[][2]=
  40. {
  41. (void *)Test_CamPreview, "Preview Test ",
  42. (void *)Test_CamCodec, "Codec Test ",
  43. (void *)Camera_Iic_Test, "IIC interface test ",
  44. (void *)Test_YCbCr_to_RGB, "YCbCr2RGB test",
  45. 0,0
  46. };
  48. void Camera_Test(void)
  49. {
  50. int i;
  52. Uart_Printf("n======  Camera Interface Test Start ======n");
  54. CamReset();
  56. // Initializing camif
  57. rCLKCON |= (1<<19); // enable camclk
  58. CamPortSet();
  59. ChangeUPllValue(60, 4, 1); // UPLL clock = 96MHz, PLL input 16.9344MHz
  60. rCLKDIVN|=(1<<3); // UCLK 48MHz setting for UPLL 96MHz
  61. // 0:48MHz, 1:24MHz, 2:16MHz, 3:12MHz...
  62. // Camera clock = UPLL/[(CAMCLK_DIV+1)X2]
  63. Uart_Printf("1...n");
  64. switch(USED_CAM_TYPE)
  65. {
  66. case CAM_AU70H :
  67. if (AU70H_VIDEO_SIZE==1152)
  68. SetCAMClockDivider(CAMCLK24000000); //Set Camera Clock for SXGA
  69. if (AU70H_VIDEO_SIZE==640)
  70. SetCAMClockDivider(CAMCLK16000000); //Set Camera Clock for VGA
  71. break;
  72. case CAM_S5X3A1 :
  73. SetCAMClockDivider(CAMCLK24000000); //Set Camera Clock for SXGA
  74. break;
  75. default :  // 24MHz
  76. SetCAMClockDivider(CAMCLK24000000); //Set Camera Clock 24MHz s5x532, ov7620
  77. break;
  78. }
  80. Uart_Printf("2...n");
  81. // Initializing camera module
  82. CamModuleReset(); // s5x532 must do this..
  83. Delay(500); // ready time of s5x433, s5x532 IIC interface. needed...
  84. CameraModuleSetting();
  86. Uart_Printf("Initializing end...n");
  88. while(1)
  89. {
  90. i=0;
  91. Uart_Printf("nn");
  92. while(1)
  93. {   //display menu
  94. Uart_Printf("%2d:%sn",i,func_camera_test[i][1]);
  95. i++;
  96. if((int)(func_camera_test[i][0])==0)
  97. {
  98. Uart_Printf("n");
  99. break;
  100. }
  101. if((i%4)==0)
  102. Uart_Printf("n");
  103. }
  105. Uart_Printf("nPress only Enter key to exit : ");
  106. i = Uart_GetIntNum();
  107. if(i==-1) break; // return.
  108. if(i>=0 && (i<((sizeof(func_camera_test)-1)/8)) ) // select and execute...
  109. ( (void (*)(void)) (func_camera_test[i][0]) )();
  110. }
  112. Uart_Printf("n====== Camera IF Test program end ======n");
  114. // CamModuleReset(); // s5x532 must do this..
  115. rCLKCON &= ~(1<<19); // disable camclk
  117. }
  120. void CamPortSet(void)
  121. {
  122. save_GPJCON = rGPJCON;
  123. save_GPJDAT = rGPJDAT;
  124. save_GPJUP = rGPJUP;
  126. rGPJCON = 0x2aaaaaa;
  127. rGPJDAT = 0;
  128. rGPJUP = 0;
  129. }
  131. void CamPortReturn(void)
  132. {
  133. rGPJCON = save_GPJCON;
  134. rGPJDAT = save_GPJDAT;
  135. rGPJUP = save_GPJUP;
  136. }
  138. void CamPreviewIntUnmask(void)
  139. {
  140.     rINTSUBMSK &= ~(BIT_SUB_CAM_P);//INT CAMERA Port A ENABLE 
  141.     rINTMSK &= ~(BIT_CAM);
  142. }
  144. void CamCodecIntUnmask(void)
  145. {
  146.     rINTSUBMSK &= ~(BIT_SUB_CAM_C);//INT CAMERA Port B ENABLE 
  147.     rINTMSK &= ~(BIT_CAM);
  148. }
  150. void CamPreviewIntMask(void)
  151. {
  152.     rINTSUBMSK |= BIT_SUB_CAM_P;//INT CAMERA Port A ENABLE 
  153.     rINTMSK |= (BIT_CAM);
  154. }
  156. void CamCodecIntMask(void)
  157. {
  158.     rINTSUBMSK |= BIT_SUB_CAM_C;//INT CAMERA Port B ENABLE 
  159.     rINTMSK |= (BIT_CAM);
  160. }
  163. /******************************************************
  164.  *                                                                       *    
  165.  *                       camera interface initialization                     *
  166.  *                                                                             *     
  167.  *******************************************************/
  169. void CamReset(void)
  170. {
  171. rCIGCTRL |= (1<<31); //camera I/F soft reset
  172. Delay(10);
  173. rCIGCTRL &= ~(1<<31);
  174. }
  176. void CamModuleReset(void)
  177. {
  178. switch(USED_CAM_TYPE)
  179. {
  180. case CAM_OV7620 : // reset - active high
  181. case CAM_S5X532 : // reset - active low, but H/W inverted.. so, in this case active high
  182. case CAM_S5X433 : // reset - active low, but H/W inverted.. so, in this case active high
  183. case CAM_S5X3A1 : // reset - active low, but H/W inverted.. so, in this case active high
  184. rCIGCTRL |= (1<<30);   //external camera reset high
  185. Delay(30);
  186. rCIGCTRL &= ~(1<<30); //external camera reset low
  187. break;
  188. case CAM_AU70H : // reset - active low
  189. default :
  190. rCIGCTRL &= ~(1<<30); //external camera reset low
  191. Delay(10);
  192. rCIGCTRL |= (1<<30); //external camera reset high
  193. break;
  194. }
  195. }
  197. // 0:48MHz, 1:24MHz, 2:16MHz, 3:12MHz...
  198. // Camera clock = UPLL/[(CAMCLK_DIV+1)X2]
  199. void SetCAMClockDivider(int divn) 
  200. {
  201. rCAMDIVN = (rCAMDIVN & ~(0xf))|(1<<4)|(divn); // CAMCLK is divided..
  202. }
  204. /* Description of Parameters
  205. CoDstWidth: Destination Width of Codec Path
  206. CoDstHeight: Destination Height of Codec Path
  207. PrDstWidth: Destination Width of Preview Path
  208. PrDstHeight: Destination Height of Preview Path
  209. WinHorOffset: Size of Window Offset for Horizontal Direction
  210. WinVerOffset: Size of Window Offset for Vertical Direction
  211. CoFrameBuffer: Start Address for Codec DMA
  212. PrFrameBuffer: Start Address for Previe DMA
  213. */
  214. void CamInit(U32 CoDstWidth, U32 CoDstHeight, U32 PrDstWidth, U32 PrDstHeight, 
  215. U32 WinHorOffset, U32 WinVerOffset,  U32 CoFrameBuffer, U32 PrFrameBuffer)
  216. {
  217. U32 WinOfsEn;
  218. U32 divisor, multiplier;
  219. U32 MainBurstSizeY, RemainedBurstSizeY, MainBurstSizeC, RemainedBurstSizeC, MainBurstSizeRGB, RemainedBurstSizeRGB;
  220. U32 H_Shift, V_Shift, PreHorRatio, PreVerRatio, MainHorRatio, MainVerRatio;
  221. U32 SrcWidth, SrcHeight;
  222. U32 ScaleUp_H_Co, ScaleUp_V_Co, ScaleUp_H_Pr, ScaleUp_V_Pr;
  224. //constant for calculating codec dma address
  225. if(CAM_CODEC_OUTPUT)
  226. divisor=2; //CCIR-422
  227. else
  228. divisor=4; //CCIR-420
  230. //constant for calculating preview dma address
  231. if(CAM_PVIEW_OUTPUT)
  232. multiplier=4;
  233. else
  234. multiplier=2;
  236. if(WinHorOffset==0 && WinVerOffset==0)
  237. WinOfsEn=0;
  238. else
  239. WinOfsEn=1;
  241. SrcWidth=CAM_SRC_HSIZE-WinHorOffset*2;
  242. SrcHeight=CAM_SRC_VSIZE-WinVerOffset*2;
  244. if(SrcWidth>=CoDstWidth) ScaleUp_H_Co=0; //down
  245. else ScaleUp_H_Co=1; //up
  247. if(SrcHeight>=CoDstHeight) ScaleUp_V_Co=0;
  248. else ScaleUp_V_Co=1;
  250. if(SrcWidth>=PrDstWidth) ScaleUp_H_Pr=0; //down
  251. else ScaleUp_H_Pr=1; //up
  253. if(SrcHeight>=PrDstHeight) ScaleUp_V_Pr=0;   // edited 040225
  254. else ScaleUp_V_Pr=1;
  256. ////////////////// common control setting
  257. rCIGCTRL |= (1<<26)|(0<<27); // inverse PCLK, test pattern
  258. rCIWDOFST = (1<<30)|(0xf<<12); // clear overflow 
  259. rCIWDOFST = 0;
  260. rCIWDOFST=(WinOfsEn<<31)|(WinHorOffset<<16)|(WinVerOffset);
  261. rCISRCFMT=(CAM_ITU601<<31)|(0<<30)|(0<<29)|(CAM_SRC_HSIZE<<16)|(CAM_ORDER_YCBYCR<<14)|(CAM_SRC_VSIZE);
  263. ////////////////// codec port setting
  264. if (CAM_CODEC_4PP)
  265. {
  266. rCICOYSA1=CoFrameBuffer;
  267. rCICOYSA2=rCICOYSA1+CoDstWidth*CoDstHeight+2*CoDstWidth*CoDstHeight/divisor;
  268. rCICOYSA3=rCICOYSA2+CoDstWidth*CoDstHeight+2*CoDstWidth*CoDstHeight/divisor;
  269. rCICOYSA4=rCICOYSA3+CoDstWidth*CoDstHeight+2*CoDstWidth*CoDstHeight/divisor;
  271. rCICOCBSA1=rCICOYSA1+CoDstWidth*CoDstHeight;
  272. rCICOCBSA2=rCICOYSA2+CoDstWidth*CoDstHeight;
  273. rCICOCBSA3=rCICOYSA3+CoDstWidth*CoDstHeight;
  274. rCICOCBSA4=rCICOYSA4+CoDstWidth*CoDstHeight;
  276. rCICOCRSA1=rCICOCBSA1+CoDstWidth*CoDstHeight/divisor;
  277. rCICOCRSA2=rCICOCBSA2+CoDstWidth*CoDstHeight/divisor;
  278. rCICOCRSA3=rCICOCBSA3+CoDstWidth*CoDstHeight/divisor;
  279. rCICOCRSA4=rCICOCBSA4+CoDstWidth*CoDstHeight/divisor;
  280. }
  281. else
  282. {
  283. rCICOYSA1=CoFrameBuffer;
  284. rCICOYSA2=rCICOYSA1;
  285. rCICOYSA3=rCICOYSA1;
  286. rCICOYSA4=rCICOYSA1;
  288. rCICOCBSA1=rCICOYSA1+CoDstWidth*CoDstHeight;
  289. rCICOCBSA2=rCICOCBSA1;
  290. rCICOCBSA3=rCICOCBSA1;
  291. rCICOCBSA4=rCICOCBSA1;
  293. rCICOCRSA1=rCICOCBSA1+CoDstWidth*CoDstHeight/divisor;
  294. rCICOCRSA2=rCICOCRSA1;
  295. rCICOCRSA3=rCICOCRSA1;
  296. rCICOCRSA4=rCICOCRSA1;
  297. }
  298. rCICOTRGFMT=(CAM_CODEC_IN_422<<31)|(CAM_CODEC_OUTPUT<<30)|(CoDstWidth<<16)|(CAM_FLIP_NORMAL<<14)|(CoDstHeight);
  300. CalculateBurstSize(CoDstWidth, &MainBurstSizeY, &RemainedBurstSizeY);
  301. CalculateBurstSize(CoDstWidth/2, &MainBurstSizeC, &RemainedBurstSizeC);
  302. rCICOCTRL=(MainBurstSizeY<<19)|(RemainedBurstSizeY<<14)|(MainBurstSizeC<<9)|(RemainedBurstSizeC<<4);
  304. CalculatePrescalerRatioShift(SrcWidth, CoDstWidth, &PreHorRatio, &H_Shift);
  305. CalculatePrescalerRatioShift(SrcHeight, CoDstHeight, &PreVerRatio, &V_Shift);
  306. MainHorRatio=(SrcWidth<<8)/(CoDstWidth<<H_Shift);
  307. MainVerRatio=(SrcHeight<<8)/(CoDstHeight<<V_Shift);
  308.     
  309. rCICOSCPRERATIO=((10-H_Shift-V_Shift)<<28)|(PreHorRatio<<16)|(PreVerRatio);
  310. rCICOSCPREDST=((SrcWidth/PreHorRatio)<<16)|(SrcHeight/PreVerRatio); 
  311. rCICOSCCTRL=(CAM_SCALER_BYPASS_OFF<<31)|(ScaleUp_H_Co<<30)|(ScaleUp_V_Co<<29)|(MainHorRatio<<16)|(MainVerRatio);
  313. rCICOTAREA=CoDstWidth*CoDstHeight;
  315. ///////////////// preview port setting
  316. if (CAM_PVIEW_4PP) // codec view mode
  317. {
  318. rCIPRCLRSA1=PrFrameBuffer;
  319. rCIPRCLRSA2=rCIPRCLRSA1+PrDstWidth*PrDstHeight*multiplier;
  320. rCIPRCLRSA3=rCIPRCLRSA2+PrDstWidth*PrDstHeight*multiplier;
  321. rCIPRCLRSA4=rCIPRCLRSA3+PrDstWidth*PrDstHeight*multiplier;
  322. }
  323. else // direct preview mode
  324. {
  325. rCIPRCLRSA1=LCDFRAMEBUFFER;
  326. rCIPRCLRSA2=LCDFRAMEBUFFER;
  327. rCIPRCLRSA3=LCDFRAMEBUFFER;
  328. rCIPRCLRSA4=LCDFRAMEBUFFER;
  329. }
  331. rCIPRTRGFMT=(PrDstWidth<<16)|(CAM_FLIP_NORMAL<<14)|(PrDstHeight);
  333. if (CAM_PVIEW_OUTPUT==CAM_RGB24B)
  334. CalculateBurstSize(PrDstWidth*4, &MainBurstSizeRGB, &RemainedBurstSizeRGB);
  335. else // RGB16B
  336. CalculateBurstSize(PrDstWidth*2, &MainBurstSizeRGB, &RemainedBurstSizeRGB);
  337.     rCIPRCTRL=(MainBurstSizeRGB<<19)|(RemainedBurstSizeRGB<<14);
  339. CalculatePrescalerRatioShift(SrcWidth, PrDstWidth, &PreHorRatio, &H_Shift);
  340. CalculatePrescalerRatioShift(SrcHeight, PrDstHeight, &PreVerRatio, &V_Shift);
  341. MainHorRatio=(SrcWidth<<8)/(PrDstWidth<<H_Shift);
  342. MainVerRatio=(SrcHeight<<8)/(PrDstHeight<<V_Shift);
  343. rCIPRSCPRERATIO=((10-H_Shift-V_Shift)<<28)|(PreHorRatio<<16)|(PreVerRatio);  
  344. rCIPRSCPREDST=((SrcWidth/PreHorRatio)<<16)|(SrcHeight/PreVerRatio);
  345. rCIPRSCCTRL=(1<<31)|(CAM_PVIEW_OUTPUT<<30)|(ScaleUp_H_Pr<<29)|(ScaleUp_V_Pr<<28)|(MainHorRatio<<16)|(MainVerRatio);
  346.     
  347. rCIPRTAREA= PrDstWidth*PrDstHeight;
  348. }
  352. /********************************************************
  353.  CalculateBurstSize - Calculate the busrt lengths
  354.  
  355.  Description:
  356.  - dstHSize: the number of the byte of H Size.
  357.  
  358. */
  359. void CalculateBurstSize(U32 hSize,U32 *mainBurstSize,U32 *remainedBurstSize)
  360. {
  361. U32 tmp;
  362. tmp=(hSize/4)%16;
  363. switch(tmp) {
  364. case 0:
  365. *mainBurstSize=16;
  366. *remainedBurstSize=16;
  367. break;
  368. case 4:
  369. *mainBurstSize=16;
  370. *remainedBurstSize=4;
  371. break;
  372. case 8:
  373. *mainBurstSize=16;
  374. *remainedBurstSize=8;
  375. break;
  376. default: 
  377. tmp=(hSize/4)%8;
  378. switch(tmp) {
  379. case 0:
  380. *mainBurstSize=8;
  381. *remainedBurstSize=8;
  382. break;
  383. case 4:
  384. *mainBurstSize=8;
  385. *remainedBurstSize=4;
  386. default:
  387. *mainBurstSize=4;
  388. tmp=(hSize/4)%4;
  389. *remainedBurstSize= (tmp) ? tmp: 4;
  390. break;
  391. }
  392. break;
  393. }          
  394. }
  398. /********************************************************
  399.  CalculatePrescalerRatioShift - none
  400.  
  401.  Description:
  402.  - none
  403.  
  404. */
  405. void CalculatePrescalerRatioShift(U32 SrcSize, U32 DstSize, U32 *ratio,U32 *shift)
  406. {
  407. if(SrcSize>=64*DstSize) {
  408. Uart_Printf("ERROR: out of the prescaler range: SrcSize/DstSize = %d(< 64)n",SrcSize/DstSize);
  409. while(1);
  410. }
  411. else if(SrcSize>=32*DstSize) {
  412. *ratio=32;
  413. *shift=5;
  414. }
  415. else if(SrcSize>=16*DstSize) {
  416. *ratio=16;
  417. *shift=4;
  418. }
  419. else if(SrcSize>=8*DstSize) {
  420. *ratio=8;
  421. *shift=3;
  422. }
  423. else if(SrcSize>=4*DstSize) {
  424. *ratio=4;
  425. *shift=2;
  426. }
  427. else if(SrcSize>=2*DstSize) {
  428. *ratio=2;
  429. *shift=1;
  430. }
  431. else {
  432. *ratio=1;
  433. *shift=0;
  434. }    
  435. }
  438. /********************************************************
  439.  CamCaptureStart - Start camera capture operation.
  440.  
  441.  Description:
  442.  - mode= CAM_CODEC_CAPTURE_ENABLE_BIT or CAM_PVIEW_CAPTURE_ENABLE_BIT or both
  443.   
  444. */
  445. void CamCaptureStart(U32 mode)
  446. { 
  447.     
  448. if(mode&CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT) {
  449. camCodecStatus=CAM_STARTED;
  450. rCICOSCCTRL|=CAM_CODEC_SACLER_START_BIT;
  451. }
  453. if(mode&CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT) {
  454. camPviewStatus=CAM_STARTED;
  455. rCIPRSCCTRL|=CAM_PVIEW_SACLER_START_BIT;
  456. }
  458. if(mode&CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT) {
  459. camCodecStatus=CAM_STARTED;
  460. rCICOSCCTRL|=CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT;
  461. }
  463. rCIIMGCPT|=CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT|mode;
  464. }
  467. void CamCaptureStop(void)
  468. {
  469. camCodecStatus=CAM_STOP_ISSUED;
  470. camPviewStatus=CAM_STOP_ISSUED;
  471. }
  474. void _CamCodecStopHw(void)
  475. {
  476. rCICOSCCTRL &= ~CAM_CODEC_SACLER_START_BIT; //stop codec scaler.
  477. rCIIMGCPT &= ~CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT; //stop capturing for codec scaler.
  478. if(!(rCIIMGCPT & CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT))
  479. rCIIMGCPT &= ~CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT; //stop capturing for preview scaler if needed.
  480. rCICOCTRL |= (1<<2); //Enable last IRQ at the end of frame capture.
  481.        //NOTE:LastIrqEn bit should be set after clearing CAPTURE_ENABLE_BIT & SCALER_START_BIT
  482. }
  484. void _CamPviewStopHw(void)
  485. {
  486. rCIPRSCCTRL &= ~CAM_PVIEW_SACLER_START_BIT; //stop preview scaler.
  487. rCIIMGCPT &= ~CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT; //stop capturing for preview scaler.
  488. if(!(rCIIMGCPT&CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT))
  489. rCIIMGCPT &= ~CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT; //stop capturing for codec scaler if needed.
  490. rCIPRCTRL |= (1<<2); //Enable last IRQ at the end of frame capture.
  491.         //NOTE:LastIrqEn bit should be set after clearing CAPTURE_ENABLE_BIT & SCALER_START_BIT
  492. }
  495. void __irq CamIsr(void)
  496. {
  498. U32 completedFrameIndex;
  500. if (rSUBSRCPND&BIT_SUB_CAM_C)
  501. {
  502. Uart_Printf("[C]");
  503. CamCodecIntMask();
  504. rSUBSRCPND |= BIT_SUB_CAM_C;
  505. ClearPending(BIT_CAM);
  506. switch(camCodecStatus) {
  507. case CAM_STOP_ISSUED:
  508. _CamCodecStopHw();
  509. camCodecStatus=CAM_LAST_CAPTURING;
  510. Uart_Printf("cr=%xn", rCICOCTRL);
  511. //Uart_Printf("cS1n");
  512. break;
  513. case CAM_LAST_CAPTURING:
  514. camCodecStatus=CAM_STOPPED;
  515. CamCodecIntMask();
  516. //Uart_Printf("cS2n");
  517. return;
  518. case CAM_STARTED:
  519. flagCaptured_C = 1;
  520. // _CamCodecStopHw();
  521. if(camTestMode&CAM_TEST_MODE_CODEC) {
  522. if(camCodecCaptureCount>0) 
  523. completedFrameIndex=(((rCICOSTATUS>>26)&0x3)+4-2)%4;   
  524. //Uart_Printf("FrameIndex:%dn",completedFrameIndex);
  525. }
  526. else {
  527. //Uart_Printf("Just Capturing without display");
  528. }
  529. break;
  530. case CAM_CODEC_SCALER_BYPASS_STATE:
  531. //Uart_Printf("cBPn");
  532. break;
  533. default:
  534. break;
  535. }
  537. CamCodecIntUnmask();
  538.     camCodecCaptureCount++;  
  539. }
  540. else
  541. {
  542. Uart_Printf("[P]"); 
  543. CamPreviewIntMask();
  544. rSUBSRCPND |= BIT_SUB_CAM_P;
  545. ClearPending(BIT_CAM) 
  546. switch(camPviewStatus) {
  547. case CAM_STOP_ISSUED:
  548. _CamPviewStopHw();
  549. camPviewStatus=CAM_LAST_CAPTURING;  
  550. Uart_Printf("pr=%xn", rCIPRCTRL);
  551. //Uart_Printf("pS1n");
  552. break;
  553. case CAM_LAST_CAPTURING:
  554. camPviewStatus=CAM_STOPPED;
  555. CamPreviewIntMask();
  556. //Uart_Printf("pS2n"); 
  557. return;
  558. case CAM_STARTED:
  559. flagCaptured_P = 1;
  560. if(camTestMode&CAM_TEST_MODE_PVIEW) {
  561. if(camPviewCaptureCount >0) 
  562. completedFrameIndex=(((rCIPRSTATUS>>26)&0x3)+4-2)%4;
  563. //Uart_Printf("FrameIndex:%dn",completedFrameIndex);
  564. }
  565. else {
  566. //Uart_Printf("Preview Image Capturedn");
  567. } 
  568. default:
  569. break;
  570. } 
  572. CamPreviewIntUnmask();
  573. camPviewCaptureCount++;
  574. }
  575. }
  579. /******************************************************************************
  580.  *                                                                            *    
  581.  *                   camera interface interrupts & controls                   *
  582.  *                                                                            *     
  583.  ******************************************************************************/
  586. U32 Conv_YCbCr_Rgb(U8 y0, U8 y1, U8 cb0, U8 cr0)  // second solution... by junon
  587. {
  588. // bit order is
  589. // YCbCr = [Cr0 Y1 Cb0 Y0], RGB=[R1,G1,B1,R0,G0,B0].
  591. int r0, g0, b0, r1, g1, b1;
  592. U32 rgb0, rgb1, rgb;
  593.  
  594. #if 1 // 4 frames/s @192MHz, 12MHz ; 6 frames/s @450MHz, 12MHz
  595. r0 = YCbCrtoR(y0, cb0, cr0);
  596. g0 = YCbCrtoG(y0, cb0, cr0);
  597. b0 = YCbCrtoB(y0, cb0, cr0);
  598. r1 = YCbCrtoR(y1, cb0, cr0);
  599. g1 = YCbCrtoG(y1, cb0, cr0);
  600. b1 = YCbCrtoB(y1, cb0, cr0);
  601. #endif
  603. if (r0>255 ) r0 = 255;
  604. if (r0<0) r0 = 0;
  605. if (g0>255 ) g0 = 255;
  606. if (g0<0) g0 = 0;
  607. if (b0>255 ) b0 = 255;
  608. if (b0<0) b0 = 0;
  610. if (r1>255 ) r1 = 255;
  611. if (r1<0) r1 = 0;
  612. if (g1>255 ) g1 = 255;
  613. if (g1<0) g1 = 0;
  614. if (b1>255 ) b1 = 255;
  615. if (b1<0) b1 = 0;
  617. // 5:6:5 16bit format
  618. rgb0 = (((U16)r0>>3)<<11) | (((U16)g0>>2)<<5) | (((U16)b0>>3)<<0); //RGB565.
  619. rgb1 = (((U16)r1>>3)<<11) | (((U16)g1>>2)<<5) | (((U16)b1>>3)<<0); //RGB565.
  621. rgb = (rgb1<<16) | rgb0;
  623. return(rgb);
  624. }
  627. void Display_Cam_Image(U32 size_x, U32 size_y)
  628. {
  629. U8 *buffer_y, *buffer_cb, *buffer_cr;
  630. U8 y0,y1,cb0,cr0;
  631. int r0,r1,g0,g1,b0,b1;
  632. U32 rgb_data0, rgb_data1; 
  633. U32 x, y;
  634. int temp;
  636. if (CAM_CODEC_4PP)
  637. temp = (((rCICOSTATUS>>26)&0x3)+4-2)%4; // current frame memory block
  638. else
  639. temp = 4;
  640. //Uart_Printf("Current Frame memory %dn", temp);
  642. switch (temp) // current frame mem - 2
  643. {
  644. case 0:
  645. buffer_y = (U8 *)rCICOYSA1;
  646. buffer_cb = (U8 *)rCICOCBSA1;
  647. buffer_cr = (U8 *)rCICOCRSA1;
  648. break;
  649. case 1:
  650. buffer_y = (U8 *)rCICOYSA2;
  651. buffer_cb = (U8 *)rCICOCBSA2;
  652. buffer_cr = (U8 *)rCICOCRSA2;
  653. break;
  654. case 2:
  655. buffer_y = (U8 *)rCICOYSA3;
  656. buffer_cb = (U8 *)rCICOCBSA3;
  657. buffer_cr = (U8 *)rCICOCRSA3;
  658. break;
  659. case 3:
  660. buffer_y = (U8 *)rCICOYSA4;
  661. buffer_cb = (U8 *)rCICOCBSA4;
  662. buffer_cr = (U8 *)rCICOCRSA4;
  663. break;
  664. default :
  665. buffer_y = (U8 *)rCICOYSA1;
  666. buffer_cb = (U8 *)rCICOCBSA1;
  667. buffer_cr = (U8 *)rCICOCRSA1;
  668. break;
  669. }
  671. //Uart_Printf("End setting : Y-0x%x, Cb-0x%x, Cr-0x%xn", buffer_y, buffer_cb, buffer_cr);
  672. #if 0
  673. // for checking converting time 
  674. rGPGCON = (rGPGCON&~(1<<23))|(1<<22); //EINT19 -> GPG11 output
  675. rGPGUP |= (1<<11);
  676. rGPGDAT &= ~(1<<11);
  677. Delay(90);
  678. rGPGDAT |=(1<<11);
  680. rgb_data0 = 0;
  681. #endif
  683. #if CAM_CODEC_OUTPUT==CAM_CCIR420
  684. for (y=0;y<size_y;y++) // YCbCr 4:2:0 format
  685. {
  686. for (x=0;x<size_x;x+=2)
  687. {
  688. rgb_data0 = Conv_YCbCr_Rgb(*buffer_y++, *buffer_y++, *buffer_cb++, *buffer_cr++);
  689. frameBuffer16BitTft240320[y][x/2] = rgb_data0;
  691. if ( (x==(size_x-2)) && ((y%2)==0) ) // when x is last pixel & y is even number
  692. {
  693. buffer_cb -= size_x/2;
  694. buffer_cr -= size_x/2;
  695. } 
  696. }
  697. }
  698. #else
  699. for (y=0;y<size_y;y++) // YCbCr 4:2:2 format
  700. {
  701. for (x=0;x<size_x;x+=2)
  702. { 
  703. rgb_data0 = Conv_YCbCr_Rgb(*buffer_y++, *buffer_y++, *buffer_cb++, *buffer_cr++);
  704. frameBuffer16BitTft240320[y][x/2] = rgb_data0;
  705. }
  706. } 
  707. #endif
  709. // memcpy((unsigned char*)0x30100000,  frameBuffer16BitTft240320, 320*240*2); // QCIF=178*144*2
  710. #if 0
  711. rGPGDAT &= ~(1<<11);
  712. Delay(30);
  713. rGPGDAT |=(1<<11);
  714. rGPGCON = (rGPGCON&~(1<<22))|(1<<23); // GPG11 output -> EINT19
  715. #endif
  716. }
  718. #if 0
  719. void Display_Cam_Image(int offset_x, int offset_y, int size_x, int size_y)
  720. {
  721. U8* CamFrameAddr, LcdFrameAddr;
  722. int i, temp;
  724. Lcd_MoveViewPort(offset_x, offset_y, USED_LCD_TYPE);
  726. switch(camPviewCaptureCount%4)
  727. {
  728. case 2 : 
  729. temp = rCIPRCLRSA1;
  730. break;
  731. case 3 : 
  732. temp = rCIPRCLRSA2;
  733. break;
  734. case 0 : 
  735. temp = rCIPRCLRSA3;
  736. break;
  737. case 1 :
  738. default:
  739. temp = rCIPRCLRSA4;
  740. break;
  741. }
  743. *CamFrameAddr = temp;
  744. *LcdFrameAddr = LCDFRAMEBUFFER;
  745. for(i=0;i<size_y;i++)
  746. {
  747. memcpy(LcdFrameAddr, CamFrameAddr, size_x*2);
  748. *LcdFrameAddr += size_x*4; // added virtual screen
  749. *CamFrameAddr += size_x*2; 
  750. }
  751. }
  752. #endif
  754. void Test_CamPreview(void)
  755. {
  757. U8 flag;
  758. U32 i,j,k,value, *data;
  760. Uart_Printf("n[ Camera Preview Test ]n");
  762. //camera global variables
  763. camTestMode=CAM_TEST_MODE_PVIEW;
  764. camCodecCaptureCount=0;
  765. camPviewCaptureCount=0;
  766. camPviewStatus=CAM_STOPPED;
  767. camCodecStatus=CAM_STOPPED;
  768. flagCaptured_P=0;
  770. //Initialize LCD
  771. #if CAM_PVIEW_OUTPUT==CAM_RGB24B
  772. Lcd_Start(MODE_TFT_24BIT_240320);
  773. Lcd_EnvidOnOff(0);
  774. // for 240x320 24bit setting
  775. rLCDCON5 &= ~1; // halfword swap disable -> Camera data is halfword swap type, 24bit
  776. rLCDSADDR3 &= ~(0x7ff<<11); // offset size 0
  777. rLCDSADDR2=M5D( (LCDFRAMEBUFFER+(LCD_XSIZE_TFT_240320*LCD_YSIZE_TFT_240320*4))>>1 );
  778. Lcd_EnvidOnOff(1);
  779. data = (U32 *)LCDFRAMEBUFFER;
  780. for (i=0;i<240*320;i++) // 24bpp test
  781. {
  782. if (i<240*80) *data++ = 0x000000ff; // blue
  783. else if ((i<240*160)&&(i>=240*80)) *data++ = 0x0000ff00; //green
  784. else if ((i<240*240)&&(i>=240*160)) *data++ = 0x00ff0000; //red
  785. else if (i>=240*240) *data++ = 0xff000000; // black
  786. }
  787. #else // RGB16B
  788. Lcd_Start(MODE_TFT_16BIT_240320);
  789. Lcd_EnvidOnOff(0);
  790. // for 240x320 16bit haltword swap type setting
  791. rLCDCON5 |= 1; // halfword swap enable -> Camera data is halfword swap type, 16bit
  792. rLCDSADDR3 &= ~(0x7ff<<11); // offset size 0
  793. rLCDSADDR2=M5D( (LCDFRAMEBUFFER+(LCD_XSIZE_TFT_240320*LCD_YSIZE_TFT_240320*2))>>1 );
  794. Lcd_EnvidOnOff(1);
  795. data = (U32 *)LCDFRAMEBUFFER;
  796. for (i=0;i<240*160;i++) // 16bpp test
  797. { 
  798. if (i<240*40) *data++ = 0x001f001f; // blue
  799. else if ((i<240*80)&&(i>=240*40)) *data++ = 0x07e007e0; //green
  800. else if ((i<240*120)&&(i>=240*80)) *data++ = 0xf800f800; //red
  801. else if (i>=240*120) *data++ = 0xf800001f; // blue & red
  802. }
  803. #endif
  804. Uart_Printf("nTFT 64K color mode test 1. Press any key!n");
  805. Uart_Getch(); 
  806.  
  807.  Uart_Printf(" preview sc control = %xn", rCIPRSCCTRL);
  809. // Initialize Camera interface
  810. switch(USED_CAM_TYPE)
  811. {
  812. case CAM_S5X532 : // defualt for test : data-falling edge, ITU601, YCbCr
  813. CamInit(640, 480, 240, 320, 112, 20,  CAM_FRAMEBUFFER_C, CAM_FRAMEBUFFER_P);
  814. break;
  815. case CAM_S5X3A1 : // defualt for test : data-falling edge, YCbCr
  816. CamInit(640, 480, 240, 320, 120, 100, CAM_FRAMEBUFFER_C, CAM_FRAMEBUFFER_P);
  817. rCISRCFMT = rCISRCFMT & ~(1<<31); // ITU656
  818. // rCIGCTRL &= ~(1<<26); // inverse PCLK, test pattern
  819. break;
  820. default : 
  821. CamInit(640, 480, 240, 320, 0, 0,  CAM_FRAMEBUFFER_C, CAM_FRAMEBUFFER_P);
  822. break;
  823. }
  824. Uart_Printf(" preview sc control = %xn", rCIPRSCCTRL);
  826. // Start Capture
  827. rSUBSRCPND |= BIT_SUB_CAM_C|BIT_SUB_CAM_P;
  828. ClearPending(BIT_CAM);
  829. pISR_CAM = (U32)CamIsr;    
  830. CamPreviewIntUnmask();
  831. CamCaptureStart(CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT);
  832. Uart_Printf("Press Enter key to exit!n");
  833. while (1)
  834. {
  835. if (flagCaptured_P)
  836. {
  837. flagCaptured_P = 0;
  838. // Uart_Printf("Enter Cam A port, count = %dn",camCodecCaptureCount);
  839. }
  840. if (Uart_GetKey()== 'r') break;
  841. }
  842.     
  843. CamCaptureStop();
  845. Uart_Printf("nWait until the current frame capture is completed.n");
  846. while(camPviewStatus!=CAM_STOPPED)
  847. if (Uart_GetKey()== 'r') break;
  849. Uart_Printf(" CIS format = %xn", rCISRCFMT);
  850. Uart_Printf(" image cap = %xn", rCIIMGCPT);
  851. Uart_Printf(" preview sc control = %xn", rCIPRSCCTRL);
  852. Uart_Printf(" preview control = %xn", rCIPRCTRL);
  853. Uart_Printf(" codec sc control = %xn", rCICOSCCTRL);
  854. Uart_Printf(" codec control = %xn", rCICOCTRL);
  855. Uart_Printf(" pr addr1 = %xn", rCIPRCLRSA1);
  856. Uart_Printf(" pr addr2 = %xn", rCIPRCLRSA2);
  859. Uart_Printf("camCodecCaptureCount=%dn",camCodecCaptureCount);
  860. Uart_Printf("camPviewCaptureCount=%dn",camPviewCaptureCount);
  861. // CamPreviewIntMask();
  862. }
  866. void Test_CamCodec(void)
  867. {
  869. U8 flag, fBypass='1';
  870. U32 i,j,k,value, *data;
  872. Uart_Printf("n[ Camera Codec Test ]n");
  874. //camera global variables
  875. camTestMode=CAM_TEST_MODE_CODEC;
  876. camCodecCaptureCount=0;
  877. camPviewCaptureCount=0;
  878. camPviewStatus=CAM_STOPPED;
  879. camCodecStatus=CAM_STOPPED;
  880. flagCaptured_C=0;
  882. //Initialize LCD
  883. Lcd_Start(MODE_TFT_16BIT_240320);
  884. Glib_FilledRectangle(0,0,239,79,0x001f); // B
  885. Glib_FilledRectangle(0,80,239,159,0x07e0); // G
  886. Glib_FilledRectangle(0,160,239,239,0xf800); // R
  887. Glib_FilledRectangle(0,240,239,319,0xffff);   
  888. Uart_Printf("nTFT 64K color mode test 1. Press any key!n");
  889. Uart_Getch(); 
  891. // Initialize Camera interface
  892. switch(USED_CAM_TYPE)
  893. {
  894. case CAM_S5X532 : // defualt for test : data-falling edge, ITU601, YCbCr
  895. CamInit(240, 320, 240, 320, 112, 20,  CAM_FRAMEBUFFER_C, CAM_FRAMEBUFFER_P);
  896. break;
  897. case CAM_S5X3A1 : // defualt for test : data-falling edge, ITU601, YCbCr
  898. CamInit(240, 320, 240, 320, 0, 0, CAM_FRAMEBUFFER_C, CAM_FRAMEBUFFER_P);
  899. rCISRCFMT &= ~(1<<31); // ITU656
  900. break;
  901. default : 
  902. CamInit(240, 320, 240, 320, 0, 0,  CAM_FRAMEBUFFER_C, CAM_FRAMEBUFFER_P);
  903. break;
  904. }
  906. // Start Capture
  907. rSUBSRCPND |= BIT_SUB_CAM_C|BIT_SUB_CAM_P;
  908. ClearPending(BIT_CAM);
  909. pISR_CAM = (U32)CamIsr;    
  910. CamCodecIntUnmask();
  912. Uart_Printf("Select Code mode : 1. Scaler mode(D)   2. Bypass moden");
  913. fBypass = Uart_Getch();
  914. if (fBypass=='2'){
  915. CamInit(CAM_SRC_HSIZE, CAM_SRC_VSIZE, 240, 320, 0, 0, CAM_FRAMEBUFFER_C, CAM_FRAMEBUFFER_P);
  916. CamCaptureStart(CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT); //bypass
  917. }
  918. else
  919. CamCaptureStart(CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT); //scaler
  921. // for test simultanious
  922. // rCIIMGCPT |= CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT;
  923. // rCIPRSCCTRL |= CAM_PVIEW_SACLER_START_BIT;
  926. Uart_Printf("Press Enter key to exit!n");
  927. while (1)
  928. {
  929. if (flagCaptured_C)
  930. {
  931. flagCaptured_C = 0;
  932. if (fBypass=='2')
  933. Display_Cam_Image(CAM_SRC_HSIZE, CAM_SRC_VSIZE);
  934. else 
  935. Display_Cam_Image(240, 320);
  936. // Uart_Printf("Enter Cam B port, count = %dn",camPviewCaptureCount);
  937. }
  938. // if (camCodecCaptureCount>=1) 
  939. // { 
  940. // Uart_Printf("cnt = %dn", camCodecCaptureCount); 
  941. //     break;
  942. // }
  943. if (Uart_GetKey()== 'r') break;
  944. }
  945.     
  946. CamCaptureStop();
  948. Uart_Printf("nWait until the current frame capture is completed.n");
  949. while(camCodecStatus!=CAM_STOPPED)
  950. if (Uart_GetKey()== 'r') break;
  952. Uart_Printf(" CIS format = %xn", rCISRCFMT);
  953. Uart_Printf(" image cap = %xn", rCIIMGCPT);
  954. Uart_Printf(" preview sc control = %xn", rCIPRSCCTRL);
  955. Uart_Printf(" preview control = %xn", rCIPRCTRL);
  956. Uart_Printf(" codec sc control = %xn", rCICOSCCTRL);
  957. Uart_Printf(" codec control = %xn", rCICOCTRL);
  958. Uart_Printf(" codec status = %xn", rCICOSTATUS);
  960. Uart_Printf("camCodecCaptureCount=%dn",camCodecCaptureCount);
  961. Uart_Printf("camPviewCaptureCount=%dn",camPviewCaptureCount);
  962. // CamCodecIntMask();
  963. }
  966. void Test_YCbCr_to_RGB(void)
  967. {
  968. U8 *buffer_y, *buffer_cb, *buffer_cr;
  969. int size_x, size_y, R, G, B, rgb_data; 
  970. int x, y;
  971. int pos_x = 0;
  972. int pos_y = 0;
  973. U8 cSelType = 0;
  974. U8 *cBuffer;
  976. Lcd_Start(MODE_TFT_16BIT_240320);
  978. size_x = PQVGA_XSIZE;
  979. size_y = PQVGA_YSIZE;
  981. Uart_Printf("Select   1. 420[D] PQVGA    2. 422 PQVGA    3. 420 CIF  : n");
  982. cSelType = Uart_Getch();
  983. if (cSelType == 'r') cSelType = '1';
  985. switch (cSelType)
  986. {
  987. case '1' : 
  988. cBuffer = (U8 *)c420jpeg;
  989. break;
  990. case '2' : 
  991. cBuffer = (U8 *)c422jpeg;
  992. break;
  993. case '3' : 
  994. cBuffer = (U8 *)foreman_cif_420;
  995. size_x = CIF_XSIZE;
  996. size_y = CIF_YSIZE;
  997. break;
  998. }
  1000. buffer_y = (U8 *)(cBuffer);
  1001. buffer_cb = (U8 *)(cBuffer + size_x*size_y); // add y size
  1002. buffer_cr = (U8 *)(buffer_cb + size_x*size_y/4); // add y,cb size
  1003. if (cSelType == '2')
  1004. buffer_cr = (U8 *)(buffer_cb + size_x*size_y/2); // add y,cb size
  1007. Uart_Printf("End setting : Y-0x%x, Cb-0x%x, Cr-0x%xn", buffer_y, buffer_cb, buffer_cr);
  1008. Uart_Printf("Address : Y-0x%x, foreman-0x%x, fa-0x%xn", *buffer_y, cBuffer, *cBuffer);
  1010. Glib_FilledRectangle(0,0,239,159,0xaaaa);   
  1011. Glib_FilledRectangle(0,160,239,320,0xf800);   
  1012. Uart_Printf("nTFT 64K color mode test 1. Press any key!n");
  1013. Uart_Getch(); 
  1015. for (y=0;y<size_y;y++) // YCbCr 4:2:0 format
  1016. for (x=0;x<size_x;x++)
  1017. {
  1018. R = YCbCrtoR(*buffer_y, *buffer_cb, *buffer_cr);
  1019. G = YCbCrtoG(*buffer_y, *buffer_cb, *buffer_cr);
  1020. B = YCbCrtoB(*buffer_y, *buffer_cb, *buffer_cr);
  1022. if (R>255 ) R = 255;
  1023. if (G>255 ) G = 255;
  1024. if (B>255 ) B = 255;
  1025. if (R<0 ) R = 0;
  1026. if (G<0 ) G = 0;
  1027. if (B<0 ) B = 0;
  1029. // 5:6:5 16bit format
  1030. rgb_data =(R&0xf8)<<8;  // R 5bits
  1031. rgb_data|=(G&0xfc)<<3; // G 6bits
  1032. rgb_data|=(B&0xf8)>>3; // B 5bits
  1033. PutPixel(pos_x+x, pos_y+y, rgb_data);
  1035. // next usable bits..
  1036. buffer_y++;
  1037. if (x%2) // when x is odd number
  1038. {
  1039. buffer_cb++;
  1040. buffer_cr++;
  1041. }
  1042. if (cSelType != '2')
  1043. if ( (x==(size_x-1)) && ((y%2)==0) ) // when x is last pixel & y is even number
  1044. {
  1045. buffer_cb -= size_x/2;
  1046. buffer_cr -= size_x/2;
  1047. }
  1048. }
  1050.     Uart_Printf("Virtual Screen Test(TFT 64K color). Press any key[ijkm\r]!n");
  1051.     MoveViewPort(MODE_TFT_16BIT_240320); // user can adjust screen..
  1052.     
  1053.     Lcd_MoveViewPort(0,0,MODE_TFT_16BIT_240320); // return 0,0
  1054.     Glib_ClearScr(0, MODE_TFT_16BIT_240320);
  1055.     Lcd_EnvidOnOff(0);
  1056.     Lcd_PowerEnable(0, 0);
  1057.     Lcd_Port_Return();
  1058.     
  1059. }