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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 压缩解压 > 查看源码
Jpg.c
资源名称：SDK_M5661.rar　[点击查看]
上传用户：hjhsjcl
上传日期：2020-09-25
资源大小：11378k
文件大小：30k
源码类别：

压缩解压

开发平台：

C++ Builder

Jpg.c：源码内容
  1. /*==========================================================================
  2. Copyright (c) 2004 ALi Corporation. All Rights Reserved
  4. File: Jpg.c
  6. content:
  8. History: Created by Walace 2005/01/12
  9. ==========================================================================*/
  11. #define _JPG_H_
  13. #include <DP8051XP.H>
  15. #include "TypeDef.h"
  16. #include "Const.h"
  17. #include "Reg5661.h"
  18. #include "Common.h"
  19. #include "OledString.h"
  20. #include "Key.h"
  21. #include "Idma.h"
  22. #include "FileSystem.h"
  23. #include "IconDefine.h"
  24. #include "OLED.h"
  25. #include "UiCommon.h"
  27. #if(PHOTO_BMP_DSP_DECODE)
  28. #include "Bmp.h"
  29. #endif
  31. #if(PHOTO_SUPPORT_JPG)
  33. #include "Jpg.h"
  34. #include "UiPhoView.h"
  35. #include "VideoDsp.h"  //Walace060309#3
  36. //3 ================================
  37. #define DSP_BLOCK_SIZE 256
  39. //3==== JPGGetImageFromDsp =========
  40. #define IMG_PRC_ERR            0x00
  41. #define IMG_PRC_NOP            0x00
  42. #define IMG_PRC_SUCCESS    0x01
  43. #define IMG_PRC_COMPLETE  0x02
  45. //3 == Dsp command ===============
  46. #define DSP_REQ_START      0x01
  47. #define DSP_REQ_END      0x02
  51. //3 ==== gxbJpgProcState ============
  53. #define JPG_PRC_IDLE 0x00
  54. #define JPG_PRC_INITIAL 0x01
  55. #define JPG_PRC_DATA_TO_DSP 0x02
  56. #define JPG_PRC_GET_FROM_DSP 0x03
  57. #define JPG_PRC_SHOW 0x04
  58. #define JPG_PRC_ERR 0x05
  59. #define JPG_PRC_END 0x06
  63. #define DSP_JPG_COLOR_CODE_RGB   0
  64. #define DSP_JPG_COLOR_CODE_BGR 1
  67. #define DSP_JPG_START_FLAG       0x0000 
  68. //Walace051214#FullScreen
  69. #define DSP_JPG_NO_SHRINK_FLAG      0x1FF0   // 0:Dsp shrink 1:Dsp no shrink
  71. #define DSP_JPG_PHOTO_WIDTH  0x1FF1    //The real pixel number of one row
  72. #define DSP_JPG_PHOTO_HEIGHT 0x1FF2   //The real pixel number of one column
  75. #define DSP_JPG_WIDTH_SIZE       0x1FF3  // set lcd width size
  76. #define DSP_JPG_HEIGHT_SIZE      0x1FF4  // set lcd height size
  77. #define DSP_JPG_LCD_TYPE           0x1FF5  // 0:STN 1:OLED
  79. #define DSP_JPG_ERR_MSG 0x1FF6  // 0:No error 1:format not support
  81. #define JPEG_DSP_NO_ERR 0x00 //Walace060816#4
  82. #define JPEG_FORMAT_NOT_SUPPORT 0x01 //Walace060816#4
  84. #define DSP_JPG_INPUT_ADDR     0x1FF7  // Dsp inbuffer address
  85. #define DSP_JPG_INPUT_FLAG       0x1FF8  // 1:FW write 512 bytes to DSP  2: FW write complete
  86. #define DSP_JPG_OUTPUT_ADDR    0x1FF9  // Dsp outbuffer address
  87. #define DSP_JPG_OUTPUT_FLAG    0x1FFA  // 1:FW could get 512 bytes form dsp 2: get data complete
  88. #define DSP_JPG_DEC_FINISH        0x1FFB  // 0: image decode not finish 1:image decode finish
  89. #define DSP_JPG_BLOCK_WIDTH 0x1FFC  // MCU width
  90. #define DSP_JPG_BLOCK_HEIGHT 0x1FFD  // MCU Height
  91. #define DSP_JPG_BLOCK_COLS        0x1FFE  // Image total coloumns
  92. #define DSP_JPG_BLOCK_PAGES 0x1FFF  // Image total pages
  95. XBYTE gxbJpgProcState = JPG_PRC_IDLE;
  98. //Walace061018#2 bmp dsp decode  start
  99. BOOL JpgShow(void);
  100. #if(PHOTO_BMP_DSP_DECODE)
  101. BOOL BmpShow(void);
  102. #endif
  104. #if(DSP_BMP_DEBUG)
  105. void BmpDspDebug(void);
  106. #endif
  107. //Walace061018#2 bmp dsp decode end
  109. //Walace051214#FullScreen move to UiPhotoView.h
  110. /*
  111. BOOL gfGetPhoConfig;
  113. //3 == Photo process parameters =================
  114. //XDWORD gxdwBlockTotalNum; //Walace051202#2
  115. XWORD gxwMcuSize;
  116. XWORD gxwBlockHeight;
  117. XWORD gxwBlockWidth;
  118. XWORD gxwBlockColNum;
  119. XWORD gxwBlockPageNum;
  120. XDWORD gxdwCurrentBlockNum; //Walace051202#2 word->dword
  121. */
  122. //3==============================================================
  123. void JpgSetMonitorSizeTypeToDsp(BYTE bWidth,BYTE bHeight,BYTE bLcdType) 
  124. {
  125. WORD wDspVal;
  126. wDspVal = (WORD)bWidth;
  127. IdmaPioDmxW(&wDspVal, DSP_JPG_WIDTH_SIZE, 1, DSP_W16); //Set finish data transfer
  128. wDspVal = (WORD)bHeight;
  129. IdmaPioDmxW(&wDspVal, DSP_JPG_HEIGHT_SIZE, 1, DSP_W16); //Set finish data transfer
  130. wDspVal = (WORD)bLcdType;
  131. IdmaPioDmxW(&wDspVal, DSP_JPG_LCD_TYPE, 1, DSP_W16);  //Walace051115#1
  132. wDspVal = (WORD)FALSE; // shrink  //Walace051212#FullScreen
  133. //wDspVal = (WORD)TRUE; // no shrink    //Walace051212#FullScreen
  134.        IdmaPioDmxW(&wDspVal, DSP_JPG_NO_SHRINK_FLAG,1,DSP_W16);
  136. }
  139. BYTE CheckImageIn(void) large
  140. {
  141. WORD wDspVal;
  142. IdmaPioDmxR(DSP_JPG_INPUT_FLAG, &wDspVal, 1,DSP_W16);
  143. return (BYTE)wDspVal;
  144. }
  146. //==============================================================
  148. BYTE CheckImageOut(void) large
  149. {
  150. WORD wDspVal;
  151. IdmaPioDmxR(DSP_JPG_OUTPUT_FLAG, &wDspVal, 1,DSP_W16);
  152. return (BYTE)wDspVal;
  153. }
  155. //==============================================================
  157. BOOL JpgFillDataToDsp(void) 
  158. {
  159.    WORD wDspVal;
  160.    
  161.    //2  fill sram buffer from file with 512 bytes
  163.    // gdwFileSectory : current sector number send to dsp
  164.    if(gdwFileSector<(stPhoFileInf.dwFileTotalSector))
  165.    {
  166.        if(CheckImageIn()!=DSP_REQ_START) //check dsp request data
  167.         return TRUE;
  169.     if(FsReadFileSectorNew(gdwFileSector++,FS_DATA_0_0)) //read a sector
  170.     {
  171.     
  172. IdmaPioDmxR(DSP_JPG_INPUT_ADDR,&wDspVal,1,DSP_W16); //get DSP write index
  174. //Send 512 bytes to DSP
  175. obRACTL |= RA_INIT;
  176. obSOURCEPATHCTRL &= 0xef; //source buffer disable
  177. obTARGETPATHCTRL &= 0xef;    //target buffer disable
  178. obRACTL &= RA_NORMAL_J;
  179. obRACTL |= RA_COPY_MODE_EN;
  180. obRAINIADRL = (SRAM_DATA_ADDR+gxwOffsetDataSec) & 0xFF; //set RA sddress
  181. obRAINIADRH = (((SRAM_DATA_ADDR+gxwOffsetDataSec) >> 8) & 0x1F);
  182. obRAINIADRH |= 0x80;
  183. obTARGETPATHCTRL=0x36; //set Target IDMA, buffer EN
  184. IdmaDmxW(wDspVal,256,DSP_W16); //IDMA from SRAM to DSP
  185. obRACTL |= 0x80; //DMA EN 
  187.        while(obIDMAREQ)  //polling IDMA request inactive
  188. {;}
  190. obRACTL &= 0x7F; //DMA Dis
  191. obRACTL &= RA_COPY_MODE_DIS;
  193. wDspVal=DSP_REQ_END;
  194. IdmaPioDmxW(&wDspVal, DSP_JPG_INPUT_FLAG, 1, DSP_W16); //Set finish data transfer
  195. return TRUE;
  196.     }
  197.       else
  198.       { 
  199.         // Warring! this retun value must be return with FALSE,but now return TRUE for the bug of DSP
  200.           // return TRUE;     //Walace060816#4
  201.              return FALSE;
  202.         }
  203.     }
  204.     return TRUE;
  205. }
  207. //==============================================================
  209. BOOL JpgGetConfig(void)  //Walace051202#4
  210. {
  211.     //WORD wDspVal; //Walace051202#4
  213.     IdmaPioDmxR(DSP_JPG_BLOCK_PAGES, &gxwBlockPageNum, 1,DSP_W16);
  214.     IdmaPioDmxR(DSP_JPG_BLOCK_COLS, &gxwBlockColNum, 1,DSP_W16);
  215.     IdmaPioDmxR(DSP_JPG_BLOCK_WIDTH, &gxwBlockWidth, 1,DSP_W16);
  216.     IdmaPioDmxR(DSP_JPG_BLOCK_HEIGHT, &gxwBlockHeight, 1,DSP_W16);
  217.     IdmaPioDmxR(DSP_JPG_PHOTO_WIDTH, &gxwPhoWidth, 1,DSP_W16);
  218.     IdmaPioDmxR(DSP_JPG_PHOTO_HEIGHT, &gxwPhoHeight, 1,DSP_W16);
  220. /* //Walace051202#4
  221. IdmaPioDmxR(DSP_JPG_ERR_MSG,&wDspVal,1,DSP_W16);
  222. if(wDspVal!=JPEG_DSP_NO_ERR)
  223. {
  224. gxbErrCode = ERR_PE_UNSUPPORT_FORMAT;
  225. return FALSE;
  226. }
  227. */
  228.  //   gxdwBlockTotalNum =gxwBlockPageNum*gxwBlockColNum; //Walace051202#2
  229.     gxwMcuSize = gxwBlockWidth * gxwBlockHeight;
  232.   //  OledShowNumber(gxwPhoWidth,WORD0,LINE0,6);
  233.  //   OledShowNumber(gxwPhoHeight,WORD0,LINE1,6);
  234.     GetPhoCommonConfig();
  235. /*
  236.     OledShowNumber(gxwPhoWidth,WORD0,PAGE0,6);
  237.     OledShowNumber(gxwPhoHeight,WORD0,PAGE1,6);
  238.     OledShowNumber(gxwBlockColNum,WORD0,PAGE2,6);
  239.     OledShowNumber(gxwBlockPageNum,WORD0,PAGE3,6);
  240.     OledShowNumber(gxwBlockWidth,WORD0,PAGE4,6);
  241.     OledShowNumber(gxwBlockHeight,WORD0,PAGE5,6);
  242.     OledShowNumber(gxwPhotoDispWidth,WORD0,PAGE6,6);
  243.     OledShowNumber(gxwPhotoDispHeight,WORD0,PAGE7,6);
  245.     OledShowNumber(gxwSampleSize,WORD3,PAGE0,6);
  246.     OledShowNumber(gxbfRotPhoto,WORD3,PAGE1,6);
  247.     */
  248. /*
  249.     OledShowNumber(gxwBlockColNum,WORD3,PAGE2,6);
  250.     OledShowNumber(gxwBlockPageNum,WORD3,PAGE3,6);
  251.     OledShowNumber(gxwBlockWidth,WORD3,PAGE4,6);
  252.     OledShowNumber(gxwBlockHeight,WORD3,PAGE5,6);
  253.     OledShowNumber(gxwPhotoDispWidth,WORD3,PAGE6,6);
  254.     OledShowNumber(gxwPhotoDispHeight,WORD3,PAGE7,6);
  255.     
  257.     gxbLcdCounter=0;
  258.     while(1)
  259.      {}
  260. */
  261. return TRUE; //Walace051202#4
  262. }
  264. //Walace061018#2 bmp dsp decode
  265. #if(PHOTO_BMP_DSP_DECODE)
  266. BOOL BmpGetConfig(void)
  267. {
  268. IdmaPioDmxR(DSP_JPG_PHOTO_WIDTH, &gxwPhoWidth, 1,DSP_W16);
  269. IdmaPioDmxR(DSP_JPG_PHOTO_HEIGHT, &gxwPhoHeight, 1,DSP_W16);
  271. gxbfRotPhoto=FALSE; //Walace070108#2
  273. #if(UI_PHOTO_DISP_SIZE_COL>UI_PHOTO_DISP_SIZE_ROW)
  274. gxbfRotPhoto =      (gxwPhoWidth<gxwPhoHeight) //Walace070108#2
  275.                 && ((gxwPhoWidth>UI_PHOTO_DISP_SIZE_COL)||(gxwPhoHeight>UI_PHOTO_DISP_SIZE_ROW));
  276. #else
  277. gxbfRotPhoto =     (gxwPhoWidth>gxwPhoHeight) //Walace070108#2
  278.                 && ((gxwPhoWidth>UI_PHOTO_DISP_SIZE_COL)||(gxwPhoHeight>UI_PHOTO_DISP_SIZE_ROW));
  279. #endif
  281. gxwXPixel = 0;
  282. gxwYPixel = gxwPhoHeight-1;
  284. return TRUE;
  285. }
  286. #endif
  289. //--------------------------------------------------------------------------------
  290. //Walace060816#4 
  291. #define GET_JPEG_DATA_NONE 0x00 
  292. #define GET_JPEG_DATA_DONE 0x01
  293. #define GET_JPEG_CONFIG_ERR 0x02
  295. BYTE  JpgGetImageFromDsp()  //Walace060816#4
  296. {
  297.    //2 Get image data from dsp 512 bytes to Sram
  298.        WORD wDspVal;
  299.        WORD SramAddr=SRAM_PHOTO_DATA_START;
  300.    
  301. if(CheckImageOut()==DSP_REQ_START) //DSP request send out a sector
  302. {
  303. GPIOA_ON(5);
  304. if (!gfGetPhoConfig)  // browse image at firt times need to get required parameter
  305. {
  306. //Walace061018#2 bmp dsp decode start
  307. #if(PHOTO_BMP_DSP_DECODE)
  308. switch(gxbPhotoType)
  309. {   
  310. case PHO_TYPE_JPG:
  311.                       if(!JpgGetConfig())  //Walace060816#4
  312. return GET_JPEG_CONFIG_ERR;  
  313.     break;
  315. case PHO_TYPE_BMP:
  316.           if(!BmpGetConfig())
  317. return GET_JPEG_CONFIG_ERR;  
  318. break;
  319. }
  320. #else
  321.                      if(!JpgGetConfig())  //Walace060816#4
  322. return GET_JPEG_CONFIG_ERR;  
  323. #endif
  324. //Walace061018#2 bmp dsp decode end
  325.    
  326.       gfGetPhoConfig=TRUE;
  327. }
  328.               // get image output address
  329. IdmaPioDmxR(DSP_JPG_OUTPUT_ADDR,&wDspVal,1,DSP_W16);
  331. //Get 512 bytes from DSP
  332. obRACTL = RA_INIT;
  333. //obSOURCEPATHCTRL &= 0xef; //source buffer disable
  334. //obTARGETPATHCTRL &= 0xef;       //target buffer disable
  335. obRACTL &= RA_NORMAL_J;
  338. obRAINIADRL = SRAM_DMA_ADDRESS & 0xFF; //set RA address
  339. obRAINIADRH = ((SRAM_DMA_ADDRESS >> 8) & 0x1F);
  340. obRAINIADRH |= 0x80;
  342. obRABANKSIZEL=0x00; //Set RA size 512B
  343. obRABANKSIZEH=0x02;
  345. obMODSEL3 &= NOTBYPASS_RAJ;  //allen050601: force NotBypassRa 
  347. obSOURCEPATHCTRL=0x36; //set Source IDMA, buffer EN
  348. obTARGETPATHCTRL=0x37; //Target SRAM
  350. obDOWNLOADADDRL=(SramAddr>>3)&0xFF; //SRAM Address
  351. obDOWNLOADADDRH=(SramAddr>>11)&0x3f;
  352. obDOWNLOADADDRH |= 0xc0;//to sram, reload address
  353. obDOWNLOADADDRH&=0xBF; //normal
  355. // obTARGETPATHCTRL=0x37; //set Target RA, buffer EN
  357. IdmaDmxR(wDspVal,256); //IDMA from DSP to SRAM
  358. obRACTL |= 0x80; //DMA EN 
  359. while(obIDMAREQ)  //polling IDMA request inactive
  360. {;}
  362. obRACTL |= 0x10; //DMA SEND
  364. while(!(obRASTATUS & 0x80))
  365. {;}
  367. obRACTL &= 0x7F; //DMA Dis
  368. obIDMACTRL&=IDMA_ACT_DIS;
  370. wDspVal=DSP_REQ_END;
  371. IdmaPioDmxW(&wDspVal, DSP_JPG_OUTPUT_FLAG, 1,DSP_W16); //Set finish data transfer  
  372. GPIOA_OFF(5);
  373. return GET_JPEG_DATA_DONE; //Walace060816#4 start
  374. }
  375.    return GET_JPEG_DATA_NONE;   //Walace060816#4 start
  376. }
  377. //==============================================================
  379. //Walace061018#2 bmp dsp decode
  380. BOOL JpgBmpShow(void)
  381. {
  382. switch(gxbPhotoType)
  383. {   
  384. case PHO_TYPE_JPG:
  385.           return JpgShow();
  387. #if(PHOTO_BMP_DSP_DECODE)
  388. case PHO_TYPE_BMP:
  389.           return BmpShow();
  390. #endif
  391. }
  392. }
  394. //Walace051212#FullScreen
  395. BOOL JpgShow(void) 
  396. {
  397.    //2 2 Send Sram data to OLED
  398.    WORD McuNum;
  399.    WORD wBi,wXi,wYi;
  400.    WORD wCol,wRow;
  401.    PWORD pwData;
  403.    pwData=(PWORD)gxbPhoData;
  404.    
  405.    McuNum=DSP_BLOCK_SIZE/gxwMcuSize;
  407.    OledCtrlEn();
  408.    
  409.    #if(LCD_TYPE==TFT_ORISE||LCD_TYPE==TFT_TOPPOLY||LCD_TYPE==TFT_SOLOMON)   // Jeff070125#2
  410.    LCD_ROT90_DISPLAY_EN();
  411.    #endif
  413.    for(wBi=0;wBi<McuNum;wBi++)
  414.    {
  415.     if((gxdwCurrentBlockNum%gxwBlockColNum)==0)
  416.     {
  417.     gxwXStart=0;
  418. gxwXStep=0;
  419. gxwYStart=gxwYPixel;
  420. gxwYStepStart = gxwYStep;
  421.     }
  422. else
  423. {
  424. gxwYStep = gxwYStepStart;
  425. }
  426.        gxwXStepStart=gxwXStep;
  427.    
  428. gxwYPixel = gxwYStart;
  430.        for(wYi=0;wYi<gxwBlockHeight;wYi++)
  431.        {
  432. gxwYStep+=gxwSampleSize;
  435. if(!(gxwYStep&0x8000))
  436. {
  437. pwData+=gxwBlockWidth;
  438. continue;
  439. }
  441.               gxwYPixel++;
  442. gxwYStep&=(~0x8000);
  443. gxwXPixel = gxwXStart;
  446. gxwXStep=gxwXStepStart;
  448.         for(wXi=0;wXi<gxwBlockWidth;wXi++)
  449.         {
  450. gxwXStep+=gxwSampleSize;
  451.                      
  452.  
  453. if(!(gxwXStep&0x8000))
  454. {
  455. pwData++;
  456. continue;
  457. }
  459. gxwXPixel++;
  460. gxwXStep&=(~0x8000);
  463. //if((gxwXPixel<=gxwPhoWidth)&&(gxwYPixel<=gxwPhoHeight))   //Walace060320#1  //Walace060713#1 
  464. if((gxwXPixel<=gxwPhotoDispWidth)&&(gxwYPixel<=gxwPhotoDispHeight))   
  465. {
  466. //Walace060713#1 start
  467. //wCol=gxwXPixel; 
  468. //wRow=gxwYPixel;
  470. wCol=gxwXPixel-1;
  471. wRow=gxwYPixel-1;
  472. //Walace060713#1 end
  474.       if(gxbfRotPhoto) //Walace070108#2
  475.    RotToCenter(gxwPhotoDispWidth,gxwPhotoDispHeight,&wCol,&wRow);
  476.       else //if(gxwSampleSize<0x8000) //Walace060725#2
  477.    MoveToCenter(gxwPhotoDispWidth,gxwPhotoDispHeight,&wCol,&wRow);
  479. //if((wCol<OLED_MAX_COL)&&(wRow<OLED_MAX_ROW)) //Walace060320#3 //Walace060713#1
  480. if((wCol<UI_PHOTO_DISP_SIZE_COL)&&(wRow<UI_PHOTO_DISP_SIZE_ROW)) //Walace070103#2
  481. {
  483.  #if(LCD_TYPE==TFT_ORISE||LCD_TYPE==TFT_TOPPOLY)   // Jeff070125#2
  484. TftSetWindow(wCol,wRow,1,1);
  485. TFT_MEMORY_WRITE_START();
  486. OLED_WRITE(*((PBYTE)(pwData)+1)) ;
  487. OLED_WRITE(*((PBYTE)pwData)) ; 
  488.  #elif(LCD_TYPE==TFT_SOLOMON) //Jim#TftSolomn
  489. TftSetWindow(wRow,UI_PHOTO_DISP_SIZE_COL-wCol-1,1,1);
  490. TFT_MEMORY_WRITE_START();
  491. LCD_WRITE(*((PBYTE)(pwData)+1)) ;
  492. LCD_WRITE(*((PBYTE)pwData)) ; 
  493.  #else
  494. OLED_WRITE(OLED_CMD_SET_COL_ADDR) ;
  495. OLED_WRITE(wCol);
  496. OLED_WRITE(wCol);
  498. OLED_WRITE(OLED_CMD_SET_ROW_ADDR) ;
  499. OLED_WRITE(wRow);
  500. OLED_WRITE(wRow);
  503. OLED_SET_DAT();
  504.               #if(OLED_COLOR_FIELD_TYPE==OLED_FIELD_BGR565)
  505. OLED_WRITE(*((PBYTE)pwData)) ; 
  506. OLED_WRITE(*((PBYTE)(pwData)+1)) ;
  507. #else
  508. OLED_WRITE(*((PBYTE)(pwData)+1)) ;
  509. OLED_WRITE(*((PBYTE)pwData)) ;    
  510. #endif
  512. OLED_SET_CMD();
  513. #endif
  514. }
  515.  }
  516.  pwData++;
  517.         }
  519.        }
  521. // CommonDelay(0xFFFF);
  522. // CommonDelay(0xFFFF);
  525.    
  526. gxwXStart = gxwXPixel;
  527. gxwXStepStart = gxwXStep;
  529.        gxdwCurrentBlockNum++;  
  530.    
  531.   ////Walace051202#2 
  532. //if(gxwCurrentBlockNum>=gxwBlockTotalNum))    
  533.        if(gxdwCurrentBlockNum>=((DWORD)gxwBlockPageNum*gxwBlockColNum))  
  534.        {
  535. #if(LCD_TYPE==TFT_ORISE||LCD_TYPE==TFT_TOPPOLY||LCD_TYPE==TFT_SOLOMON) //Walace061020#1  // Jeff070125#2
  536. LCD_ROT90_DISPLAY_DIS();
  537. #endif     
  539.           OledCtrlDis();
  540.       return TRUE;
  541.        }
  542.    }
  544. #if(LCD_TYPE==TFT_ORISE||LCD_TYPE==TFT_TOPPOLY||LCD_TYPE==TFT_SOLOMON) //Walace061020#1  // Jeff070125#2
  545. LCD_ROT90_DISPLAY_DIS();
  546. #endif       
  548.    OledCtrlDis();   
  549.    return FALSE; 
  550.   
  551. }
  553. //Walace061018#2 bmp dsp decode start
  554. #if(PHOTO_BMP_DSP_DECODE)
  555. BOOL BmpShow(void)
  556. {
  557. WORD wBi;
  558. WORD wCol,wRow;
  559. PWORD pwData;
  560.   
  561. pwData=(PWORD)gxbPhoData;
  563. OledCtrlEn();
  565. #if(LCD_TYPE==TFT_ORISE||LCD_TYPE==TFT_TOPPOLY||LCD_TYPE==TFT_SOLOMON)  // Jeff070125#2
  566. LCD_ROT90_DISPLAY_EN();
  567. #endif
  569. //GPIOA_ON(6); //Walace070117#6 remove
  571. for(wBi=0;wBi<DSP_BLOCK_SIZE;wBi++)
  572. {
  573. wCol=gxwXPixel;
  574. wRow=gxwYPixel;
  576.       if(gxbfRotPhoto) //Walace070108#2
  577.    RotToCenter(gxwPhoWidth,gxwPhoHeight,&wCol,&wRow);
  578.       else
  579.    MoveToCenter(gxwPhoWidth,gxwPhoHeight,&wCol,&wRow);
  582. //if((wCol<OLED_MAX_COL)&&(wRow<OLED_MAX_ROW)) //Walace060320#3 //Walace060713#1 
  583. if((wCol<UI_PHOTO_DISP_SIZE_COL)&&(wRow<UI_PHOTO_DISP_SIZE_ROW)) //Walace070103#2
  584. {
  586.  #if(LCD_TYPE==TFT_ORISE||LCD_TYPE==TFT_TOPPOLY||LCD_TYPE==TFT_SOLOMON)  // Jeff070125#2
  587. TftSetWindow(wCol,wRow,1,1);
  588. TFT_MEMORY_WRITE_START();
  589. OLED_WRITE(*((PBYTE)(pwData)+1)) ;
  590. OLED_WRITE(*((PBYTE)pwData)) ; 
  591.  #else
  592. OLED_WRITE(OLED_CMD_SET_COL_ADDR) ;
  593. OLED_WRITE(wCol);
  594. OLED_WRITE(wCol);
  596. OLED_WRITE(OLED_CMD_SET_ROW_ADDR) ;
  597. OLED_WRITE(wRow);
  598. OLED_WRITE(wRow);
  601. OLED_SET_DAT();
  603.               #if(OLED_COLOR_FIELD_TYPE==OLED_FIELD_BGR565)
  604. OLED_WRITE(*((PBYTE)pwData)) ; 
  605. OLED_WRITE(*((PBYTE)(pwData)+1)) ;
  606. #else
  607. OLED_WRITE(*((PBYTE)(pwData)+1)) ;
  608. OLED_WRITE(*((PBYTE)pwData)) ;    
  609. #endif
  611. OLED_SET_CMD();
  612. #endif
  613. }
  615. pwData++;
  617. gxwXPixel++;
  618. if(gxwXPixel>=gxwPhoWidth)
  619. {
  620. if(gxwYPixel==0)
  621. {
  622. #if(LCD_TYPE==TFT_ORISE||LCD_TYPE==TFT_TOPPOLY||LCD_TYPE==TFT_SOLOMON)  // Jeff070125#2
  623. LCD_ROT90_DISPLAY_DIS();
  624. #endif
  625. GPIOA_OFF(6);
  626. OledCtrlDis();
  627. return TRUE;
  628. }
  629. gxwXPixel=0;
  630. gxwYPixel--;
  631. }
  632. }
  634. #if(LCD_TYPE==TFT_ORISE||LCD_TYPE==TFT_TOPPOLY||LCD_TYPE==TFT_SOLOMON)  // Jeff070125#2
  635. LCD_ROT90_DISPLAY_DIS();
  636. #endif
  637. //GPIOA_OFF(6); //Walace070117#6 remove
  638. OledCtrlDis();
  640. return FALSE;
  641. }
  642. #endif
  643. //Walace061018#2 bmp dsp decode end
  645. //==============================================================
  646. /* //Walace060309#3
  647. void SetDspStart(void) 
  648. {
  649.        BYTE cbDspSt[3]={0x18,0x03,0x0f};
  650. IdmaPioPmW(cbDspSt, 0, 1);
  651. }
  652. */
  653. //==============================================================
  654. //Walace060309#3
  655. void JpegDspInit(void) 
  656. {
  657. IDMA_READY_EN();
  658. DSP_CLK_SET_49();  //Walace060804#2
  659. DSP_RESET();
  660. DSP_ENABLE();
  661. }
  663. //Walace060309#3
  664. BOOL DownloadJpegDsp(void) 
  665. {
  667. //WORD wDspPmIdx,wDspDmxIdx,wDspDmy1Idx;
  668. WORD wDmyStrAddr;
  669. WORD wProgAddr;
  670. BYTE bProgLen;
  672. DSP_RESET();  //Walace060309#3
  673. DSP_ENABLE();
  675. DSP_PM_SIZE(DSP_PM_16BIT|DSP_PM_SIZE_6K); //set pm size 6k 24bit mode
  676. DSP_DMX_SIZE(DSP_DMX_24B_8K|DSP_DMX_16B_5K);
  677. DSP_DMY_SIZE(DSP_DMY_24B_4K|DSP_DMY_16B_6K);
  679. wDmyStrAddr=0x2000;
  680. //SET_DSP_16_MODE();
  681. /* //Walace060309#3
  682.        switch(bPhotoType)
  683.        {
  684.           case PHO_TYPE_JPG:
  685.    wDspPmIdx=PM_DSP_JPG_PM;
  686. wDspDmxIdx=PM_DSP_JPG_DMX;
  687. wDspDmy1Idx=PM_DSP_JPG_DMY;
  688.    break;
  689.           default:
  690.    return FALSE;
  691.    break;
  692.        }
  693. */
  695. if(NandReadPhySec(gxwAddrPMI,1,SRAM_DATA_ADDR)) //Download PM
  696. {
  697. wProgAddr=(((WORD)gxbFsData[PM_DSP_JPG_PM+1])<<8)|gxbFsData[PM_DSP_JPG_PM];
  698. bProgLen=gxbFsData[PM_DSP_JPG_PM+2];
  699. IdmaPmW(1,((((DWORD)bProgLen)<<9)/3)-1); //set idma and change length from sector to PM word(24bit)
  700. if(!NandReadPhySec(wProgAddr,bProgLen,0xFFFF))
  701. goto Err_Dsp_Download;
  702. }
  704. if(NandReadPhySec(gxwAddrPMI,1,SRAM_DATA_ADDR)) //Download DMX
  705. {
  706. wProgAddr=(((WORD)gxbFsData[PM_DSP_JPG_DMX+1])<<8)|gxbFsData[PM_DSP_JPG_DMX];
  707. bProgLen=gxbFsData[PM_DSP_JPG_DMX+2];
  708. //IdmaDmxW(0,((DWORD)bProgLen)<<8,DSP_W16); //set idma and change length from sector to 16bis
  709. if(obPMSIZE&0x80) //16bit mode
  710. IdmaDmxW(0,((DWORD)bProgLen)<<8,DSP_W16); //set idma and change length from sector to 16bis
  711. else //24bit mode
  712. IdmaDmxW(0,(((DWORD)bProgLen)<<9)/3,DSP_W24);
  713. if(!NandReadPhySec(wProgAddr,bProgLen,0xFFFF))
  714. goto Err_Dsp_Download;
  716. }
  718. if(NandReadPhySec(gxwAddrPMI,1,SRAM_DATA_ADDR)) //Download DMY
  719. {
  720. wProgAddr=(((WORD)gxbFsData[PM_DSP_JPG_DMY+1])<<8)|gxbFsData[PM_DSP_JPG_DMY];
  721. bProgLen=gxbFsData[PM_DSP_JPG_DMY+2];
  722. //IdmaDmyW(0x2000,(((DWORD)bProgLen)<<9)/3,DSP_W24); //set idma and change length from sector to 24 bits
  723. IdmaDmyW(wDmyStrAddr,(((DWORD)bProgLen)<<9)/3,DSP_W24);
  724. if(!NandReadPhySec(wProgAddr,bProgLen,0xFFFF))
  725. goto Err_Dsp_Download;
  726. }
  728. obIDMACTRL&=IDMA_ACT_DIS;
  729. return TRUE;
  731. Err_Dsp_Download:
  732.  IDMA_REQUEST_DISABLE();
  733.  DSP_RESET();
  734.  DSP_ENABLE(); //Dsp normal
  735. return FALSE;
  736. }
  739. //void JpgInitial()  //Walace060816#4 
  740. BOOL JpgInitial()  
  741. {
  742. //3. == file variable initial and open file ==========
  744.     gfGetPhoConfig=FALSE;
  745.  //   gxdwBlockTotalNum =0; //Walace051202#2
  746.     gxwMcuSize=0;
  747.     gxwBlockHeight=0;
  748.     gxwBlockWidth=0;
  749.     gxwBlockColNum=0;
  750.     gxwBlockPageNum=0;
  751.     gxdwCurrentBlockNum=0;
  752.     gdwFileSector=0;
  754.     gxwPhoWidth=0;
  755.     gxwPhoHeight=0;
  757. //Walace05121#FullScreen
  758.     gxwXStart=0;
  759.     gxwYStart=0;
  760.     gxwXPixel=0;
  761.     gxwYPixel=0;
  763.     gxwXStep=0;
  764.     gxwYStep=0;
  765.     gxwXStepStart=0;
  766.     gxwYStepStart=0;
  767. //==========================
  769.      //Walace060309#3 start
  770.       obSYSINT0MASK &= (~(CDC_INT_EN|I2S_INT_EN));  
  771.       JpegDspInit();
  772.       ClkDspEn();
  773.  
  774.       if(!DownloadJpegDsp())  //Walace060816#4 start
  775. {  
  776. gxbErrCode = ERR_PE_DSP_CODE_ERROR;
  777. return FALSE;   
  778.        }
  779.      //Walace060309#3 end   
  780.      #if(OLED_COLOR_FIELD_TYPE==OLED_FIELD_BGR565)      //Walace051115#1
  781.      JpgSetMonitorSizeTypeToDsp(UI_PHOTO_DISP_SIZE_COL,UI_PHOTO_DISP_SIZE_ROW,DSP_JPG_COLOR_CODE_BGR);  //Walace060320#3
  782.      #else 
  783.      JpgSetMonitorSizeTypeToDsp(UI_PHOTO_DISP_SIZE_COL,UI_PHOTO_DISP_SIZE_ROW,DSP_JPG_COLOR_CODE_RGB);  //Walace060320#3 
  784.      #endif
  785.  
  786.      SetDspStart();
  787.  
  788.      return TRUE; //Walace060816#4
  789. }
  791. //Walace060816#4 start 
  793. #define JPEG_FORMAT_CHECK_TAG 0x01
  794. #define JPEG_FORMAT_CHECK_TYPE 0x02
  796. //===================================
  797. // No differential , Huffman coding
  798. #define JPEG_FORMAT_HUFF_BASELINE 0xC0           
  799. #define JPEG_FORMAT_HUFF_SEQ 0xC1    
  800. #define JPEG_FORMAT_HUFF_PRG 0xC2          
  801. #define JPEG_FORMAT_HUFF_LOSS 0xC3         
  803. //===================================
  804. // Differential , Huffman coding
  805. #define JPEG_FORMAT_HUFF_DIFF_SEQ 0xC5
  806. #define JPEG_FORMAT_HUFF_DIFF_PRG 0xC6
  807. #define JPEG_FORMAT_HUFF_DIFF_LOSS 0xC7
  809. //===================================
  810. // No differential , Arithmetic coding
  811. #define JPEG_FORMAT_RESERVED 0xC8
  812. #define JPEG_FORMAT_ARI_SEQ 0xC9    
  813. #define JPEG_FORMAT_ARI_PRG 0xCA          
  814. #define JPEG_FORMAT_ARI_LOSS 0xCB    
  816. //===================================
  817. // Differential , Arithmetic coding
  818. #define JPEG_FORMAT_ARI_DIFF_SEQ 0xCD    
  819. #define JPEG_FORMAT_ARI_DIFF_PRG 0xCE          
  820. #define JPEG_FORMAT_ARI_DIFF_LOSS 0xCF    
  822. #if(1) //Walace060915#1 start
  823. //Walace060926#1 VideoResume
  824. //Remove ParserGetField() to Common.c and Common.h
  825. #define JPEG_MAKER 0xFF
  827. #define SOF0 0xFFC0
  828. #define SOF1 0xFFC1
  829. #define SOF2 0xFFC2
  830. #define SOF3 0xFFC3
  831. #define SOF5 0xFFC5
  832. #define SOF6 0xFFC6
  833. #define SOF7 0xFFC7
  835. #define JPEG_RESERVE 0xFFC8
  837. #define SOF9 0xFFC9
  838. #define SOF10 0xFFCA
  839. #define SOF11 0xFFCB
  841. #define SOF13 0xFFCD
  842. #define SOF14 0xFFCE
  843. #define SOF15 0xFFCF
  845. #define DHT 0xFFC4
  847. #define DAC 0xFFCC
  849. #define RST0 0xFFD0
  850. #define RST1 0xFFD1
  851. #define RST2 0xFFD2
  852. #define RST3 0xFFD3
  853. #define RST4 0xFFD4
  854. #define RST5 0xFFD5
  855. #define RST6 0xFFD6
  856. #define RST7 0xFFD7
  859. #define SOI 0xFFD8
  860. #define EOI 0xFFD9
  861. #define SOS 0xFFDA
  862. #define DQT 0xFFDB
  863. #define DNL 0xFFDC
  864. #define DRI  0xFFDD
  865. #define DHP 0xFFDE
  867. #define EXP 0xFFDE
  869. #define APP0 0xFFE0
  870. #define APP1 0xFFE1
  872. #define JPG0 0xFFF0 //0xFFF0~0xFFFD
  873. #define COM 0xFFFE 
  876. #define FIRST_SEARCH TRUE
  877. #define CONT_SEARCH FALSE
  878. #define REVERSE_DATA TRUE
  879. #define NORMAL_DATA FALSE
  881. #define GET_MARKER 0x01
  882. #define GET_SOI_MAKER 0x02
  884. BOOL SearchSoiInAppn(PWORD pwAddrOffset) 
  885. {
  886. BYTE bStates;
  887. WORD wLength;
  888. BYTE bTemp;
  890. ParserGetField(&wLength, 2, pwAddrOffset, FIRST_SEARCH, NORMAL_DATA);
  891. wLength -= 2; //substract 2 bytes length field
  893. //Walace070429#1
  894. (*pwAddrOffset)+=wLength;
  895. return TRUE;
  897. bStates=GET_MARKER;
  899. while(wLength)
  900. {
  901. ParserGetField(&bTemp, 1, pwAddrOffset, FIRST_SEARCH, NORMAL_DATA);
  902. wLength--;
  903. switch(bStates)
  904. {
  905. case GET_MARKER:
  906. if(bTemp==JPEG_MAKER)
  907. bStates=GET_SOI_MAKER;
  908. break;
  910. case GET_SOI_MAKER:
  911. if(bTemp==(SOI&JPEG_MAKER))
  912. {
  913. return TRUE; 
  914. }
  915. else if(bTemp!=JPEG_MAKER)
  916. {
  917. bStates=GET_MARKER;    
  918. }
  919. break;   
  920. }
  921. }
  922. return FALSE;
  923. }
  926. BOOL JpegFormatCheck()
  927. {
  928. WORD wMaker,wAddrOffset,wLength;
  929. BYTE bKeepSpeed;
  930. //BYTE bKey;
  931. //WORD wCounter;
  932. BOOL fAppSpace;
  933. bKeepSpeed = obCLKMCUDIVF;
  934. SetSysSpeed(0x02);
  936. gxbErrCode = ERR_NO_ERROR;
  937. wLength=0;
  938. wAddrOffset = 512; //for read a sector in ParserGetField
  939. gdwFileSector = 0;
  942. //wCounter=0;
  944. if(!ParserGetField(&wMaker, 2, &wAddrOffset, FIRST_SEARCH, NORMAL_DATA))
  945. goto END_PARSE;
  947. //bKey=KEY_INVALID;
  948. fAppSpace = FALSE;
  950. if(wMaker!=SOI)
  951. {
  952. gxbErrCode = ERR_PE_UNSUPPORT_FORMAT;
  953. goto END_PARSE;
  954. }
  956. while(TRUE)
  957. {
  958. if(!ParserGetField(&wMaker, 2, &wAddrOffset, FIRST_SEARCH, NORMAL_DATA))
  959. goto END_PARSE;
  961. switch(wMaker)
  962. { 
  963. case SOF0:
  964. case SOF2: //Walace070103#1
  965. goto END_PARSE;
  966. case SOF1:
  967. //case SOF2: //Walace070103#1
  968. case SOF3:
  969. case SOF5:
  970. case SOF6:
  971. case SOF7:
  972. case SOF9:
  973. case SOF10:
  974. case SOF11:
  975. case SOF13:
  976. case SOF14:
  977. case SOF15:
  978. gxbErrCode = ERR_PE_UNSUPPORT_FORMAT;
  979. goto END_PARSE;
  981.    case SOI:  
  982.    case EOI: 
  983.        case SOS:
  984.     break;
  986. case APP0:
  987. case APP1: 
  988. if(!fAppSpace)
  989. {
  990. fAppSpace = SearchSoiInAppn(&wAddrOffset);
  991. break;
  992. }
  993. default:
  994. if(!ParserGetField(&wLength, 2, &wAddrOffset, FIRST_SEARCH, NORMAL_DATA))
  995. goto END_PARSE;
  997. wAddrOffset += wLength-2;
  998. break;
  999. }
  1000. }
  1002. END_PARSE:
  1004. gdwFileSector=0;
  1005. SetSysSpeed(bKeepSpeed);
  1007. if(gxbErrCode==ERR_FS_EOF)
  1008. {
  1009. gxbErrCode=ERR_PE_UNSUPPORT_FORMAT;
  1010. }
  1012. return (gxbErrCode==ERR_NO_ERROR);
  1014. }
  1016. #else
  1018. BOOL JpegFormatCheck()
  1019. {
  1020. BYTE bKeepSpeed;
  1021. BYTE bCheckState;
  1022. WORD wDataIndex;
  1024. bCheckState = JPEG_FORMAT_CHECK_TAG;
  1025. bKeepSpeed = obCLKMCUDIVF;
  1026. SetSysSpeed(0x02);
  1028. gdwFileSector=0;
  1029. while(gdwFileSector<(stPhoFileInf.dwFileTotalSector))
  1030. {
  1031. if(!FsReadFileSectorNew(gdwFileSector++,FS_DATA_0_0)) //read a sector
  1032. return FALSE;
  1034. wDataIndex=0;
  1035. while(wDataIndex<512)
  1036. {
  1037. switch(bCheckState)
  1038. {
  1039. case JPEG_FORMAT_CHECK_TAG:
  1040. if(gxbFsData[wDataIndex+gxwOffsetDataSec]==0xFF)
  1041. bCheckState=JPEG_FORMAT_CHECK_TYPE;
  1042. break;
  1044. case JPEG_FORMAT_CHECK_TYPE:
  1045. switch(gxbFsData[wDataIndex+gxwOffsetDataSec])
  1046. {
  1047. case JPEG_FORMAT_HUFF_BASELINE:
  1048. /* Walace060818#1
  1049. case JPEG_FORMAT_HUFF_SEQ:
  1050. case JPEG_FORMAT_HUFF_LOSS:
  1051. case JPEG_FORMAT_HUFF_DIFF_SEQ:
  1052. case JPEG_FORMAT_HUFF_DIFF_LOSS:
  1053. case JPEG_FORMAT_ARI_SEQ:
  1054. case JPEG_FORMAT_ARI_LOSS:
  1055. case JPEG_FORMAT_ARI_DIFF_SEQ:
  1056. case JPEG_FORMAT_ARI_DIFF_LOSS:
  1057. */
  1058. gdwFileSector=0;
  1059. SetSysSpeed(bKeepSpeed);
  1060. return TRUE;
  1062. case JPEG_FORMAT_HUFF_PRG:
  1063. case JPEG_FORMAT_HUFF_DIFF_PRG:
  1064. case JPEG_FORMAT_ARI_PRG:
  1065. case JPEG_FORMAT_ARI_DIFF_PRG:
  1066. // Walace060818#1
  1067. case JPEG_FORMAT_HUFF_SEQ:
  1068. case JPEG_FORMAT_HUFF_LOSS:
  1069. case JPEG_FORMAT_HUFF_DIFF_SEQ:
  1070. case JPEG_FORMAT_HUFF_DIFF_LOSS:
  1071. case JPEG_FORMAT_ARI_SEQ:
  1072. case JPEG_FORMAT_ARI_LOSS:
  1073. case JPEG_FORMAT_ARI_DIFF_SEQ:
  1074. case JPEG_FORMAT_ARI_DIFF_LOSS:
  1075. //
  1076. goto JPEG_TYPE_CHECK_END;
  1078. default:
  1079. bCheckState=JPEG_FORMAT_CHECK_TAG;
  1080. break;
  1081. }
  1083. break;
  1084. }
  1085. wDataIndex++;
  1086. }
  1087. }
  1089. JPEG_TYPE_CHECK_END:
  1091. gdwFileSector=0;
  1092. gxbErrCode = ERR_PE_UNSUPPORT_FORMAT;
  1093. SetSysSpeed(bKeepSpeed);
  1094. return FALSE;
  1095. }
  1096. #endif
  1097. //Walace060816#4 end
  1098. //Walace060915#1 end
  1100. //Walace060816#4 start
  1101. BOOL JpgDispProcess(BYTE bJpgCmd)  
  1102. {
  1103.   if(bJpgCmd==JPG_CMD_START)
  1104.   {
  1105.    gxbJpgProcState = JPG_PRC_INITIAL;
  1106.   }
  1107.   else if(bJpgCmd==JPG_CMD_CHECK_FORMAT)
  1108.   {
  1109.    gxbJpgProcState=JPG_PRC_IDLE;
  1110. switch(gxbPhotoType)
  1111. {   
  1112. case PHO_TYPE_JPG:
  1113.           return JpegFormatCheck();
  1115. #if(PHOTO_BMP_DSP_DECODE)
  1116. case PHO_TYPE_BMP:
  1117.         return BmpFormatCheck();
  1118. #endif
  1119. }
  1120.   }
  1122.   
  1123.   switch(gxbJpgProcState)
  1124.   {
  1125.    case JPG_PRC_IDLE:
  1126.     break;
  1128.    case JPG_PRC_INITIAL:
  1129.     #if(DSP_BMP_DEBUG)
  1130.     BmpDspDebug();
  1131. #endif
  1133. if(JpgInitial())
  1134. gxbJpgProcState = JPG_PRC_DATA_TO_DSP;
  1135. else
  1136. gxbJpgProcState = JPG_PRC_END;
  1137.     break;
  1139.    case JPG_PRC_DATA_TO_DSP:
  1140.     if(JpgFillDataToDsp())
  1141.          gxbJpgProcState = JPG_PRC_GET_FROM_DSP;
  1142. else
  1143.             //gxbJpgProcState = JPG_PRC_ERR; 
  1144.             gxbJpgProcState = JPG_PRC_END;
  1145.     break;
  1147.    case JPG_PRC_GET_FROM_DSP:
  1148.     /* 
  1149.     if(JpgGetImageFromDsp())
  1150.    gxbJpgProcState = JPG_PRC_SHOW;
  1151. else
  1152. gxbJpgProcState = JPG_PRC_DATA_TO_DSP;
  1153.     break;
  1154.     */    
  1155.     switch(JpgGetImageFromDsp())
  1156.     {
  1157.     case GET_JPEG_DATA_NONE:
  1158. gxbJpgProcState = JPG_PRC_DATA_TO_DSP;
  1159. break;
  1161. case GET_JPEG_DATA_DONE:
  1162. gxbJpgProcState = JPG_PRC_SHOW;
  1163. break;
  1165. case GET_JPEG_CONFIG_ERR:
  1166. gxbJpgProcState = JPG_PRC_END;
  1167. break;
  1168.     }
  1169. break;
  1171.    case JPG_PRC_SHOW:
  1172.     if(JpgBmpShow())    //Walace061018#2 bmp dsp decode
  1173.              gxbJpgProcState = JPG_PRC_END;
  1174.        else             
  1175.      gxbJpgProcState = JPG_PRC_DATA_TO_DSP;
  1176.            break;
  1178.    case JPG_PRC_END:       
  1179.      gxbJpgProcState = JPG_PRC_IDLE;
  1180.  return TRUE;
  1181.   }
  1182.   return FALSE;
  1183. }
  1184. //Walace060816#4 ebd
  1186. #endif //#if(PHOTO_SUPPORT_JPG)
  1189. #if(DSP_BMP_DEBUG)
  1190. void BmpDspDebug(void)
  1191. {
  1192. WORD wDspVal;
  1193. SetSysSpeed(0x02);
  1194. JpgInitial();
  1195. while(1)
  1196. {
  1197. JpgFillDataToDsp();
  1198. if(CheckImageOut()==DSP_REQ_START)
  1199. {
  1200. wDspVal=DSP_REQ_END;
  1201. IdmaPioDmxW(&wDspVal, DSP_JPG_INPUT_FLAG, 1, DSP_W16); //Set finish data transfer
  1202. }
  1203. if(gdwFileSector<(stPhoFileInf.dwFileTotalSector))
  1204. {
  1205. OledShowNumber(1234,WORD0,LINE0,4);
  1206. while(1){}
  1207. }
  1208. }
  1209. }
  1210. #endif
  1211. //================= =============================================