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

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

压缩解压

开发平台：

C++ Builder

Bmp.c：源码内容
  1. /*==========================================================================
  2. Copyright (c) 2004 ALi Corporation. All Rights Reserved
  4. File: Bmp.c
  6. content:
  8. History: Created by Walace 2005/06/29
  9. ==========================================================================*/
  12. #define _BMP_H_
  14. #include <DP8051XP.H>
  16. #include "TypeDef.h"
  17. #include "Const.h"
  18. #include "Reg5661.h"
  19. #include "Common.h"
  20. #include "OledString.h"
  21. #include "Key.h"
  22. #include "Idma.h"
  23. #include "FileSystem.h"
  24. #include "OLED.h"
  25. #include "IconDefine.h"
  28. #if(PHOTO_SUPPORT_BMP||PHOTO_BMP_DSP_DECODE) //Walace061018#2 bmp dsp decode
  30. #include "Bmp.h"
  31. #include "UiPhoView.h"
  32. #include "VideoDsp.h" //Walace060313#1
  33. #include "UiCommon.h"
  35. #define BMP_HEAD_IDENTIFIER 0x00
  36. #define BMP_HEAD_FILE_SIZE   0x02
  37. #define BMP_HEAD_DATA_OFFSET 0x0A
  38. #define BMP_HEAD_HEAD_SIZE 0x0E
  39. #define BMP_HEAD_WIDTH 0x12
  40. #define BMP_HEAD_HEIGHT 0x16
  41. #define BMP_HEAD_PLANES 0x1A
  42. #define BMP_HEAD_PIXEL_BITS 0x1C
  43. #define BMP_HEAD_COMP_TYPE 0x1E
  44. #define BMP_HEAD_BMP_SIZE 0x22
  45. #define BMP_HEAD_HRESOLUTION 0x26
  46. #define BMP_HEAD_VRESOLUTION 0x2A
  47. #define BMP_HEAD_COLOR_USED 0x2E
  48. #define BMP_HEAD_COLOR_IMP 0x32
  49. #define BMP_HEAD_PALETTE 0x36
  51.  // Constants for the biCompression field...
  52. #define BMP_COMP_RGB       0             /* No compression - straight BGR data */
  53. #define BMP_COMP_RLE8      1             /* 8-bit run-length compression */
  54. #define BMP_COMP_RLE4      2             /* 4-bit run-length compression */
  55. #define BMP_COMP_BITFIELDS 3             /* RGB bitmap with RGB masks */
  57. #define IMG_PRC_ERR            0x00
  58. #define IMG_PRC_NOP            0x00
  59. #define IMG_PRC_SUCCESS    0x01
  60. #define IMG_PRC_COMPLETE  0x02
  62. #define SECTOR_SIZE 512
  64. #define FS_UNOPENED 0xFFFFFFFF
  66. typedef struct               
  67. {
  68.     DWORD dwRMask;
  69.     DWORD dwGMask;
  70.     DWORD dwBMask;
  71.     BYTE     bBOffset;
  72.     BYTE     bBLen;
  73.     BYTE     bGOffset;
  74.     BYTE     bGLen;
  75.     BYTE     bROffset;
  76.     BYTE     bRLen;
  77. }RGBMASK;
  79. #define BMP_COLOR_PATLETTE 0x00
  80. #define BMP_COLOR_MASK 0x01
  82. #define BMP_DIR_BOTTOM_TOP 0x00
  83. #define BMP_DIR_TOP_BOTTOM 0x01
  86. typedef struct                        /**** BMP file info structure ****/
  87. {
  88.    DWORD dwDataOffset;
  89.    WORD   wBitPerPixel;
  90.    DWORD dwColorUsed;
  91.    BYTE     bDataMask;
  92.    DWORD dwCompType;
  93.    BYTE     bColorMode;
  94.    BYTE     bStoreDir;  
  95.    
  96. }BMPHEADERINFO;
  97. #endif
  100. #if(PHOTO_SUPPORT_BMP)  //Walace061018#2 bmp dsp decode
  101. //3==== gxbBmpProcState ============
  103. #define BMP_PRC_IDLE 0x00
  104. #define BMP_PRC_INITIAL 0x01
  105. #define BMP_PRC_SHOW 0x04
  106. #define BMP_PRC_ERR 0x05
  107. #define BMP_PRC_END 0x06
  109. BMPHEADERINFO xdata stBmpHead;
  110. xdata RGBMASK* pMask; //Walace061208#1
  111. xdata PWORD gpwPalette; //Walace061208#1
  113. XBYTE gxbBmpProcState = BMP_PRC_IDLE;
  115. //Walace051214#FullScreen Remove
  116. //XDWORD gxdwFsByteIndex;
  117. //XWORD gxwLineIndex;
  118. #endif
  120. #if(PHOTO_SUPPORT_BMP|PHOTO_BMP_DSP_DECODE) //Walace061018#2 bmp dsp decode
  121. void ReverseHLSB(PBYTE pbData,BYTE bDataSize) 
  122. {
  123.      BYTE bBuff,bIndex;
  125.      for(bIndex=0;bIndex<bDataSize/2;bIndex++)
  126.      { 
  127.          bBuff=*(pbData+bIndex);
  128.   *(pbData+bIndex)=*(pbData+(bDataSize-bIndex-1));
  129.   *(pbData+(bDataSize-bIndex-1))=bBuff;
  130.      }
  131. }
  133. BOOL GetFsData(PBYTE pbTarget,DWORD dwFsByteIndex,PWORD pwDataLen) large //Walace061211#3
  134. {
  135. WORD wGetLen;
  136. WORD wIndex;
  137. WORD wByteIndex;
  138. WORD wDataLen;
  139. DWORD dwTagFileSector;
  140.        
  141. wDataLen = *pwDataLen;
  142. *pwDataLen=0;
  144. while(wDataLen)
  145. {
  146.         wByteIndex = dwFsByteIndex%SECTOR_SIZE;
  147. dwTagFileSector= dwFsByteIndex/SECTOR_SIZE;  
  149. if(dwTagFileSector!=gdwFileSector) //different to current sector
  150. {   
  151. GPIOA_ON(5);
  152. if(FsReadFileSectorNew(dwTagFileSector,FS_DATA_0_0))
  153. gdwFileSector=dwTagFileSector;
  154. else 
  155.       return FALSE;
  156. GPIOA_OFF(5);
  157. }
  158.    
  159.         if(wDataLen>(SECTOR_SIZE-wByteIndex))
  160.        wGetLen=SECTOR_SIZE-wByteIndex;        
  161. else
  162.        wGetLen=wDataLen;
  164.               if(pbTarget!=NULL)
  165.               {
  166. for(wIndex=0;wIndex<wGetLen;wIndex++)
  167. {
  168.     *pbTarget = *(gxbFsData+gxwOffsetDataSec+wIndex+wByteIndex);
  169. pbTarget++;
  170. }
  171.               }
  172.        dwFsByteIndex+=wGetLen;
  173. (*pwDataLen)+=wGetLen;
  174. wDataLen -=wGetLen;
  175. }
  176. return TRUE;
  178. }
  179. #endif
  181. #if(PHOTO_SUPPORT_BMP) //Walace061018#2 bmp dsp decode
  182. void GetSetBitOffset(DWORD dwData,PBYTE pbOffset,PBYTE pbLen) 
  183. {
  184. *pbOffset=0;
  185. *pbLen=0;
  186. while(!((dwData>>(*pbOffset))&0x01))
  187. (*pbOffset)++;
  189. while((dwData>>((*pbLen)+(*pbOffset)))&0x01)
  190. (*pbLen)++;
  192. }
  194. void GetPaletteForOled(void) large //Walace060614#3 use large
  195. {
  196.    BYTE dwColor[4];
  197.    WORD wLen;
  198.    WORD wIndex;
  199.    WORD wColorUsed;
  202.    if(stBmpHead.dwColorUsed!=0x0000)
  203.     wColorUsed = stBmpHead.dwColorUsed;
  204.    else
  205.     wColorUsed = 1<<(stBmpHead.wBitPerPixel);
  206.        
  207.    wLen=4;
  208.    
  209.    for(wIndex=0;wIndex<wColorUsed;wIndex++)
  210.   {       
  211.        GetFsData((PBYTE)dwColor,BMP_HEAD_PALETTE+wIndex*4,&wLen);
  212. *(gpwPalette+wIndex)=0x0000;                              // OLED 2 bytes per pixel   RGB = (5 6 5)
  213. *(gpwPalette+wIndex)|=(((WORD)dwColor[0])>>3)<<OLED_B_OFFSET;  // Bo = (B*2^5)/(2^8) << 11 
  214. *(gpwPalette+wIndex)|=(((WORD)dwColor[1])>>2)<<OLED_G_OFFSET;  // Go = (G*2^6)/(2^8) <<  5
  215.        *(gpwPalette+wIndex)|=(((WORD)dwColor[2])>>3)<<OLED_R_OFFSET; // Ro = (R*2^5)/(2^8) << 0
  216.    }
  217. }
  219. void GetRGBMask(RGBMASK* pMask) large
  220. {
  221. WORD wLen;
  223. if(stBmpHead.dwCompType==BMP_COMP_RGB)
  224. {
  225. switch(stBmpHead.wBitPerPixel)
  226. {
  227. case 16:
  228. pMask->dwRMask = 0x007C0000;
  229. pMask->dwGMask = 0xE0030000;
  230. pMask->dwBMask = 0x1F000000;
  231. break; 
  233. case 24:
  234. case 32:
  235. pMask->dwRMask = 0x0000FF00;
  236. pMask->dwGMask = 0x00FF0000;
  237. pMask->dwBMask = 0xFF000000;
  238. break;
  239. }
  240. }
  241. else // bit field
  242. {
  243. wLen=12; // RGB = 12 byte ( 3*sizeof(DWORD) )
  244. GetFsData((PBYTE)pMask,BMP_HEAD_PALETTE,&wLen);
  245. }
  247. ReverseHLSB((PBYTE)(&(pMask->dwRMask)),stBmpHead.wBitPerPixel/8);   
  248. ReverseHLSB((PBYTE)(&(pMask->dwGMask)),stBmpHead.wBitPerPixel/8);     
  249. ReverseHLSB((PBYTE)(&(pMask->dwBMask)),stBmpHead.wBitPerPixel/8); 
  251.        pMask->dwRMask = pMask->dwRMask>>(32-stBmpHead.wBitPerPixel);
  252. pMask->dwGMask = pMask->dwGMask>>(32-stBmpHead.wBitPerPixel);
  253. pMask->dwBMask = pMask->dwBMask>>(32-stBmpHead.wBitPerPixel);
  255.     GetSetBitOffset(pMask->dwRMask,&(pMask->bROffset),&(pMask->bRLen));
  256. GetSetBitOffset(pMask->dwGMask,&(pMask->bGOffset),&(pMask->bGLen));
  257. GetSetBitOffset(pMask->dwBMask,&(pMask->bBOffset),&(pMask->bBLen));      
  259. }
  262. BOOL  GetBmpConfig(void)  //Walace060817#2
  263. {
  264. DWORD dwBuff=0;
  265. INT iBuff;
  266. WORD wLen;
  267.    
  268. wLen=2;
  269. GetFsData((PBYTE)&dwBuff,BMP_HEAD_IDENTIFIER,&wLen);
  270.    
  271. if(dwBuff!=0x424D0000) // 'BM'=0x4d42 
  272. {
  273. gxbErrCode = ERR_PE_UNSUPPORT_FORMAT; //Walace060817#2
  274. return FALSE;  // only support microsoft type
  275. }
  277.        wLen=4;
  278.    
  279. GetFsData((PBYTE)&(stBmpHead.dwDataOffset),BMP_HEAD_DATA_OFFSET,&wLen);
  280. ReverseHLSB((PBYTE)(&(stBmpHead.dwDataOffset)),4);   
  282. GetFsData((PBYTE)&dwBuff,BMP_HEAD_WIDTH,&wLen);
  283.   ReverseHLSB((PBYTE)&dwBuff,4);
  284. gxwPhoWidth=(WORD)dwBuff;
  286. GetFsData((PBYTE)&dwBuff,BMP_HEAD_HEIGHT,&wLen);
  287. ReverseHLSB((PBYTE)&dwBuff,4);
  288. iBuff=(INT)dwBuff; 
  290. if(iBuff<0)
  291. { stBmpHead.bStoreDir = BMP_DIR_TOP_BOTTOM;
  292.        gxwPhoHeight = (WORD)(-iBuff);
  293. }
  294. else
  295. { stBmpHead.bStoreDir = BMP_DIR_BOTTOM_TOP;
  296.            gxwPhoHeight = (WORD)iBuff;
  297. }
  300. GetFsData((PBYTE)&(stBmpHead.dwColorUsed),BMP_HEAD_COLOR_USED,&wLen);
  301. ReverseHLSB((PBYTE)(&(stBmpHead.dwColorUsed)),4);   
  303. GetFsData((PBYTE)&(stBmpHead.dwCompType),BMP_HEAD_COMP_TYPE,&wLen);
  304. ReverseHLSB((PBYTE)(&(stBmpHead.dwCompType)),4);   
  306. wLen=2;
  307. GetFsData((PBYTE)&(stBmpHead.wBitPerPixel),BMP_HEAD_PIXEL_BITS,&wLen);
  308. ReverseHLSB((PBYTE)(&(stBmpHead.wBitPerPixel)),2);      
  310. /*
  311. =====================================================================
  312. 0x1c    0x1eh       COLOR       R_MASK        G_MASK        B_MASK      4_MASK      DATA
  313. -------------------------------------------------------------------------------------------
  314. 1                1      B_RGB      index   00 00 FF 00      00 FF 00 00    FF 00 00 00  .
  315. 4                4      B_RGB      index   00 00 FF 00      00 FF 00 00    FF 00 00 00                      X
  316. 4RLE           4      B_4RLE     index   00 00 FF 00      00 FF 00 00    FF 00 00 00                      RLE X  (not support)
  317. 8                8      B_RGB      index   00 00 FF 00      00 FF 00 00    FF 00 00 00                       XX
  318. 8RLE           8      B_8RLE     index   00 00 FF 00      00 FF 00 00    FF 00 00 00                      RLE XX (not support)
  321. 16X555     16      B_RGB      555      00 7C 00 00    E0 03 00 00    1F 00 00 00   NONE            XX XX
  322. 16A555     16      B_FIELED   555      00 7C 00 00    E0 03 00 00   1F 00 00 00   00 80 00 00    XX XX
  324. 16X444     16      B_FIELED   444      00 0F 00 00    F0 00 00 00    00 00 0F 00   00 00 00 00    XX XX
  325. 16A444     16      B_FIELED   444      00 0F 00 00    F0 00 00 00    00 00 0F 00   00 0F 00 00    XX XX
  327. 16X565     16      B_FIELED   565      00 F8 00 00    E0 07 00 00    1F 00 00 00   00 00 00 00    XX XX
  329. 24            24      B_RGB       888      00 00 FF 00    00 FF 00 00     FF 00 00 00   NONE             XX XX XX
  331. 32X888R   32      B_FIELED   888      00 00 00 FF    00 00 FF 00     00 FF 00 00   00 00 00 00    XX XX XX XX
  332. 32A888R   32      B_RGB       888      00 00 FF 00    00 FF 00 00     FF 00 00 00   NONE             XX XX XX XX
  334. ======================================================================
  335. OLED       16                                   00 1F             07 E0              F8 00                               XX
  336. ======================================================================
  337. */
  340. if(stBmpHead.wBitPerPixel<=8)
  341. {   
  342. if(stBmpHead.dwCompType==BMP_COMP_RLE4||stBmpHead.dwCompType==BMP_COMP_RLE8)
  343. {
  344. gxbErrCode = ERR_PE_UNSUPPORT_FORMAT; //Walace060817#2
  345. return FALSE; //not support
  346. }
  348.        stBmpHead.bDataMask=  (1<<stBmpHead.wBitPerPixel)-1;
  349. GetPaletteForOled();
  350. stBmpHead.bColorMode=BMP_COLOR_PATLETTE ;
  351. }
  352.        else
  353. {
  354.  GetRGBMask(pMask);
  355.  stBmpHead.bColorMode=BMP_COLOR_MASK;
  356. }
  358.    GetPhoCommonConfig();
  359.    
  360.    //Walace051214#FullScreen
  361.    gxwDwordPerLine = ((DWORD)gxwPhoWidth*stBmpHead.wBitPerPixel+0x1f)>>5;
  362.    return TRUE;
  363. }
  367. BOOL BmpInitial(void)  //Walace060817#2
  368. {
  369.    gdwFileSector=FS_UNOPENED;
  370.    gxbfRotPhoto=FALSE; //Walace070108#2
  371.    gxwYPixel=0; //Walace051214#FullScreen Remove
  372.    gxwLineIndex=0;
  373.    gxwYStep = 0 ; //Walace051214#FullScreen Remove
  374.    gpwPalette=(PWORD)(gxbPhoData+SRAM_BMP_PALETTE_OFFSET);
  375.    pMask=(RGBMASK*)(gxbPhoData+SRAM_BMP_PALETTE_OFFSET);
  376.    FuncProtectMachine(DSP_PROT_SET_ON); //Walace060313#1
  377.    FuncProtectMachine(MCU_PROT_WAIT_RESPONSE); //Walace060313#1
  378.    
  379.    if(!GetBmpConfig())
  380.     return FALSE;
  382.    gxdwFsByteIndex = stBmpHead.dwDataOffset;
  383.    
  384.    return TRUE;   
  385. }
  387. void TransferColorToOled(DWORD dwDataBuff,PWORD pwPixelData) large
  388. {
  389.        DWORD dwBuff;
  391. *pwPixelData=0x0000;          // OLED 2 bytes per pixel   RGB = (5 6 5)
  394. ReverseHLSB((PBYTE)&dwDataBuff,stBmpHead.wBitPerPixel/8); 
  395. dwDataBuff = dwDataBuff>>(32-stBmpHead.wBitPerPixel);
  397.        dwBuff = (dwDataBuff&pMask->dwBMask)>>pMask->bBOffset; 
  398. (*pwPixelData)|= ((dwBuff<<OLED_B_BITS)>>pMask->bBLen)<<OLED_B_OFFSET;    // Bo = (B*2^5)/(2^B-BITS) << 11 
  400.        dwBuff = (dwDataBuff&pMask->dwGMask)>>pMask->bGOffset;
  401. (*pwPixelData)|= ((dwBuff<<OLED_G_BITS)>>pMask->bGLen)<<OLED_G_OFFSET;     // Go = (G*2^6)/(2^G-BITS) << 5 
  403.        dwBuff = (dwDataBuff&pMask->dwRMask)>>pMask->bROffset;
  404. (*pwPixelData)|= ((dwBuff<<OLED_R_BITS)>>pMask->bRLen)<<OLED_R_OFFSET;  // Ro = (R*2^5)/(2^R-BITS) << 0                          
  405. }
  407. //Walace051214#FullScreen
  408. void BmpSendPixelToOled(WORD wCol,WORD wRow,WORD wPixelData)
  409. {
  411. if(gxbfRotPhoto) //Walace070108#2
  412.             RotToCenter(gxwPhotoDispWidth,gxwPhotoDispHeight,&wCol,&wRow);
  413. else 
  414.      MoveToCenter(gxwPhotoDispWidth,gxwPhotoDispHeight,&wCol,&wRow);
  416. if(stBmpHead.bStoreDir==BMP_DIR_BOTTOM_TOP)
  417.        wRow = UI_PHOTO_DISP_SIZE_ROW-1-wRow; //Walace060320#3
  419. if((wCol<UI_PHOTO_DISP_SIZE_COL)&&(wRow<UI_PHOTO_DISP_SIZE_ROW)) //Walace060320#3
  420. {
  421.  #if(LCD_TYPE==TFT_ORISE||LCD_TYPE==TFT_TOPPOLY||LCD_TYPE==TFT_SOLOMON)  // Jeff070125#2
  422.  OledDrawPoint(wCol,wRow,wPixelData);
  423.  #else
  424. OLED_WRITE(OLED_CMD_SET_COL_ADDR) ;
  425. OLED_WRITE(wCol);
  426. OLED_WRITE(wCol);
  428. OLED_WRITE(OLED_CMD_SET_ROW_ADDR) ;
  429. OLED_WRITE(wRow);
  430. OLED_WRITE(wRow);
  432. OLED_SET_DAT();
  433. OLED_WRITE_WDATA(wPixelData) ;
  434. OLED_SET_CMD();
  435. #endif
  436. }
  437. }
  439. //Walace051212#FullScreen start
  440. BYTE BmpShow()
  441. {
  442. BYTE bCount;
  443. DWORD dwDataBuff;
  444. DWORD dwGetIndexPerLine;
  445. WORD wPixelData;
  446.        WORD wGetDataUnit;  //can hold
  447. WORD wPhotoXIndex;
  449. gxwXPixel=0;
  450. gxwXStep=0;
  451. wPhotoXIndex=0;
  452. dwGetIndexPerLine=0;
  454. gxwYStep+=gxwSampleSize;
  456. gxwLineIndex ++;
  457. if(gxwLineIndex>gxwPhoHeight)
  458. return IMG_PRC_COMPLETE; 
  461. if(!(gxwYStep&0x8000))
  462. {
  463. gxdwFsByteIndex+=(gxwDwordPerLine<<2);
  464. return IMG_PRC_SUCCESS;
  465. }
  467. wGetDataUnit = stBmpHead.wBitPerPixel>>3; 
  468. if(!wGetDataUnit)
  469. wGetDataUnit=1;
  471. #if(LCD_TYPE==TFT_ORISE||LCD_TYPE==TFT_TOPPOLY||LCD_TYPE==TFT_SOLOMON) //Walace061020#1   // Jeff070125#2
  472. LCD_ROT90_DISPLAY_DIS();
  473. #endif      
  475. OledCtrlEn();
  476. while(TRUE)
  477. {
  479. OledCtrlDis();
  481. if(!GetFsData((PBYTE)&dwDataBuff,gxdwFsByteIndex+dwGetIndexPerLine,&wGetDataUnit))
  482. return IMG_PRC_ERR;
  484. dwGetIndexPerLine+=wGetDataUnit;
  485. OledCtrlEn();
  487.  
  488. if(stBmpHead.bColorMode==BMP_COLOR_PATLETTE)
  489. {
  490. for(bCount=1;bCount<=(8/stBmpHead.wBitPerPixel);bCount++)
  491. {
  492. wPhotoXIndex++;
  493. if(wPhotoXIndex>gxwPhoWidth)
  494. goto EndOfLine;
  496. gxwXStep+=gxwSampleSize; 
  498. if(!(gxwXStep&0x8000))
  499. continue;
  501. dwDataBuff = ((*(PBYTE)&dwDataBuff)>>(8-stBmpHead.wBitPerPixel*bCount))&stBmpHead.bDataMask;
  502. BmpSendPixelToOled(gxwXPixel,gxwYPixel,gpwPalette[dwDataBuff]);
  503. gxwXPixel++;
  504. gxwXStep&=(~0x8000);
  505. }
  506. }
  507. else
  508. {
  509. wPhotoXIndex++;
  510. if(wPhotoXIndex>gxwPhoWidth)        
  511. goto EndOfLine;
  513. gxwXStep+=gxwSampleSize; 
  515. if(!(gxwXStep&0x8000))
  516. continue;
  518. TransferColorToOled(dwDataBuff,&wPixelData);
  519. BmpSendPixelToOled(gxwXPixel,gxwYPixel,wPixelData);
  521. gxwXPixel++;
  522. gxwXStep&=(~0x8000);
  523. }  
  524. }
  526. EndOfLine:
  528. #if(LCD_TYPE==TFT_ORISE||LCD_TYPE==TFT_TOPPOLY||LCD_TYPE==TFT_SOLOMON) //Walace061020#1   // Jeff070125#2
  529. LCD_ROT90_DISPLAY_DIS();
  530. #endif      
  533. OledCtrlDis();
  534. gxwYPixel++;
  535. gxwYStep&=(~0x8000);
  537. gxdwFsByteIndex+=(gxwDwordPerLine<<2);
  539.    return IMG_PRC_SUCCESS;
  541. }
  542. //Walace051212#FullScreen end
  545. BYTE BmpDispProcess(BYTE bBmpCmd) 
  546. {
  547.    BYTE bRet;
  548.    
  549.    if(bBmpCmd==BMP_CMD_START)
  550.    { 
  551.     gxbBmpProcState = BMP_PRC_INITIAL;
  552.    }
  553.    
  554.   switch(gxbBmpProcState)
  555.   {
  556.    case BMP_PRC_IDLE:
  557.     break;
  559.    case BMP_PRC_INITIAL:
  560. if(BmpInitial())
  561.      gxbBmpProcState = BMP_PRC_SHOW;
  562. else
  563.      gxbBmpProcState = BMP_PRC_ERR;
  564.     break;
  566.    case BMP_PRC_SHOW:
  567.     bRet = BmpShow();
  568.     if(bRet == IMG_PRC_SUCCESS)
  569.    {     gxbBmpProcState = BMP_PRC_SHOW; }
  570. else if(bRet==IMG_PRC_COMPLETE)
  571. {     gxbBmpProcState = BMP_PRC_IDLE; }
  572. else
  573. {    
  574.      gxbBmpProcState = BMP_PRC_ERR;
  575. }
  576.     break;
  577.    case BMP_PRC_ERR:
  578.    gxbBmpProcState = BMP_PRC_IDLE;
  579.  return BMP_SHOW_RET_ERR;
  580.     //break; //Walace060817#4
  582.    case BMP_PRC_END:       
  583.      gxbBmpProcState = BMP_PRC_IDLE;
  584.  return BMP_SHOW_RET_END;
  585.     //break;  //Walace060816#4
  586.   }  
  588. }
  590. #endif //#if(PHOTO_SUPPORT_BMP)
  593. //Walace061018#2 bmp dsp decode
  594. #if(PHOTO_BMP_DSP_DECODE)
  595. BOOL  BmpFormatCheck(void)  
  596. {
  597. BMPHEADERINFO xdata stBmpHead;
  599. DWORD dwBuff=0;
  600. INT iBuff;
  601. WORD wLen;
  602. BOOL fRet;
  604. fRet=TRUE;
  605. dwBuff=0;
  606.    gdwFileSector=FS_UNOPENED;
  608. wLen=2;
  610. GetFsData((PBYTE)&dwBuff,BMP_HEAD_IDENTIFIER,&wLen);
  611.    
  612. if(dwBuff!=0x424D0000) // 'BM'=0x4d42 
  613. {
  614. gxbErrCode = ERR_PE_UNSUPPORT_FORMAT; //Walace060817#2
  615. fRet = FALSE;  // only support microsoft type
  616. goto END_OF_CEHCK_FORMAT;
  617. }
  619.        wLen=4; 
  620. GetFsData((PBYTE)&(stBmpHead.dwDataOffset),BMP_HEAD_DATA_OFFSET,&wLen);
  621. ReverseHLSB((PBYTE)(&(stBmpHead.dwDataOffset)),4);   
  623. GetFsData((PBYTE)&dwBuff,BMP_HEAD_WIDTH,&wLen);
  624.   ReverseHLSB((PBYTE)&dwBuff,4);
  625. gxwPhoWidth=(WORD)dwBuff;
  627. GetFsData((PBYTE)&dwBuff,BMP_HEAD_HEIGHT,&wLen);
  628. ReverseHLSB((PBYTE)&dwBuff,4);
  629. iBuff=(INT)dwBuff; 
  631. if(iBuff<0)
  632. { stBmpHead.bStoreDir = BMP_DIR_TOP_BOTTOM;
  633.        gxwPhoHeight = (WORD)(-iBuff);
  634. }
  635. else
  636. { stBmpHead.bStoreDir = BMP_DIR_BOTTOM_TOP;
  637.            gxwPhoHeight = (WORD)iBuff;
  638. }
  640. GetFsData((PBYTE)&(stBmpHead.dwCompType),BMP_HEAD_COMP_TYPE,&wLen);
  641. ReverseHLSB((PBYTE)(&(stBmpHead.dwCompType)),4);   
  643. wLen=2;
  644. GetFsData((PBYTE)&(stBmpHead.wBitPerPixel),BMP_HEAD_PIXEL_BITS,&wLen);
  645. ReverseHLSB((PBYTE)(&(stBmpHead.wBitPerPixel)),2);      
  647. /*
  648. =====================================================================
  649. 0x1c    0x1eh       COLOR       R_MASK        G_MASK        B_MASK      4_MASK      DATA
  650. -------------------------------------------------------------------------------------------
  651. 1                1      B_RGB      index   00 00 FF 00      00 FF 00 00    FF 00 00 00  .
  652. 4                4      B_RGB      index   00 00 FF 00      00 FF 00 00    FF 00 00 00                      X
  653. 4RLE           4      B_4RLE     index   00 00 FF 00      00 FF 00 00    FF 00 00 00                      RLE X  (not support)
  654. 8                8      B_RGB      index   00 00 FF 00      00 FF 00 00    FF 00 00 00                       XX
  655. 8RLE           8      B_8RLE     index   00 00 FF 00      00 FF 00 00    FF 00 00 00                      RLE XX (not support)
  658. 16X555     16      B_RGB      555      00 7C 00 00    E0 03 00 00    1F 00 00 00   NONE            XX XX
  659. 16A555     16      B_FIELED   555      00 7C 00 00    E0 03 00 00   1F 00 00 00   00 80 00 00    XX XX
  661. 16X444     16      B_FIELED   444      00 0F 00 00    F0 00 00 00    00 00 0F 00   00 00 00 00    XX XX
  662. 16A444     16      B_FIELED   444      00 0F 00 00    F0 00 00 00    00 00 0F 00   00 0F 00 00    XX XX
  664. 16X565     16      B_FIELED   565      00 F8 00 00    E0 07 00 00    1F 00 00 00   00 00 00 00    XX XX
  666. 24            24      B_RGB       888      00 00 FF 00    00 FF 00 00     FF 00 00 00   NONE             XX XX XX
  668. 32X888R   32      B_FIELED   888      00 00 00 FF    00 00 FF 00     00 FF 00 00   00 00 00 00    XX XX XX XX
  669. 32A888R   32      B_RGB       888      00 00 FF 00    00 FF 00 00     FF 00 00 00   NONE             XX XX XX XX
  671. ======================================================================
  672. OLED       16                                   00 1F             07 E0              F8 00                               XX
  673. ======================================================================
  674. */
  676. if(stBmpHead.wBitPerPixel<=8)
  677. {   
  678. if(stBmpHead.dwCompType==BMP_COMP_RLE4||stBmpHead.dwCompType==BMP_COMP_RLE8)
  679. {
  680. gxbErrCode = ERR_PE_UNSUPPORT_FORMAT; //Walace060817#2
  681. fRet = FALSE; //not support
  682. goto END_OF_CEHCK_FORMAT;
  683. }
  684. }
  686. END_OF_CEHCK_FORMAT:
  688.       return fRet;
  689. }
  690. #endif