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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
dibbmp.cpp
资源名称：GTIFFSample.zip　[点击查看]
上传用户：lbr_007
上传日期：2019-05-31
资源大小：282k
文件大小：13k
源码类别：

传真(Fax)编程

开发平台：

Visual C++

dibbmp.cpp：源码内容
  1. // dibbmp.cpp
  2. //
  4. #include "stdafx.h"
  5. #include <dibbmp.h>
  7. #define EVEN_NUMBER(i) ((i%2)==0?1:0)
  9. int OpenBMP2DIB(const char * filename, DIBSection& dib)
  10. {
  11. int result = 0;
  13. FILE * fp = fopen(filename,"rb");
  14. if (fp)
  15. {
  16.   // seek to the end of the file
  17. fseek(fp,0l,SEEK_END);
  19.   // get the file position in bytes (file size)
  20. UINT32 fileSize = ftell(fp);
  22.   // seek back to the beginning again
  23. fseek(fp,0l,SEEK_SET);
  25.   // if the file has data: pull it in and interpret
  26. if (fileSize > 0)
  27. {
  28. unsigned char * fileData = new unsigned char[fileSize];
  30. if (fileData)
  31. {
  32. memset(fileData,0,(size_t)fileSize);
  34. if (fread(fileData,sizeof(char),fileSize,fp) == fileSize)
  35. {
  36. result = ReadDIBFile(fileSize,fileData,dib);
  37. }
  39.   // ok, the file data has been pulled in and hopefully
  40.   // it has been interpreted, so we have no more use for it
  41. delete [] fileData;
  42. }
  43. }
  44. }
  46. return result;
  47. }
  49. int SaveDIB2BMP(const char * filename, DIBSection& dib)
  50. {
  51. int result = 0;
  53. FILE * fp = fopen(filename,"wb");
  54. if (fp)
  55. {
  56. if (dib.IsCreated())
  57. {
  58. BITMAPFILEHEADER bmfHeader;
  59. BITMAPINFO bmInfo;
  61.   // zero out everything
  62. memset(&bmfHeader,0,sizeof(BITMAPFILEHEADER));
  63. memset(&bmInfo,0,sizeof(BITMAPINFO));
  65. UINT32 h = dib.Height();
  66. UINT32 w = dib.Width();
  67. UINT32 rowBytes = w * 3;
  68. UINT32 totalRowBytes = ((((int) rowBytes * 8) + 31) & ~31) >> 3;
  69. UINT32 tw = dib.GetTotalWidth();
  71. UINT32 sizeBMF = sizeof(BITMAPFILEHEADER);
  72. UINT32 sizeBMI = sizeof(BITMAPINFOHEADER);
  74.   // now set up necessary members of the file header
  75. memcpy(&bmfHeader.bfType,"BM",2);
  76. bmfHeader.bfSize = sizeBMF + sizeBMI + (totalRowBytes * h);
  77. bmfHeader.bfOffBits = sizeBMF + sizeBMI;
  79.   // now set up bitmap info structure
  80.   // only going to save bitmaps as 24-bit true color...these
  81.   // days there isn't much point in saving less than 24-bit
  82. bmInfo.bmiHeader.biSizeImage = totalRowBytes * h;
  83. bmInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  84. bmInfo.bmiHeader.biCompression = BI_RGB;
  85. bmInfo.bmiHeader.biPlanes = 1;
  86. bmInfo.bmiHeader.biBitCount = 24;
  87. bmInfo.bmiHeader.biWidth = w;
  88. bmInfo.bmiHeader.biHeight = h;
  90. if (fwrite(&bmfHeader,1,sizeBMF,fp) == sizeBMF)
  91. {
  92. if (fwrite(&bmInfo,1,sizeBMI,fp) == sizeBMI)
  93. {
  94. unsigned char * dibPtr = (unsigned char *)dib.GetBits();
  95. unsigned char * rowPtr;
  96. UINT32 off, row;
  98. switch (dib.GetBitCount()){
  99. case 24:
  100. {
  101.   // assume success
  102. result++;
  104. for (row=0; row<h; row++){
  105. off = 3 * tw * row;
  106. rowPtr = &dibPtr[off];
  108. if (fwrite(rowPtr,1,totalRowBytes,fp) != totalRowBytes)
  109. {
  110. result = 0;
  111. }
  112. }
  113. }
  114. break;
  115. case 32:
  116. {
  117. }
  118. break;
  119. }
  120. }
  121. }
  122. }
  124. fclose(fp);
  125. }
  127. return result;
  128. }
  130. int ReadDIBFile(UINT32 dataSize, unsigned char * dataBits, DIBSection& dib)
  131. {
  132. int result = 0;
  134. BITMAPFILEHEADER bmfHeader;
  135. BITMAPINFO bmInfo;
  136. UINT32 off = 0;
  138.   // check to see if we actually have some data to interpret
  139. if ((dataSize > 0) && dataBits)
  140. {
  141. unsigned long bmfHeaderSize = sizeof(bmfHeader);
  143. if ((off + bmfHeaderSize) > dataSize)
  144. {
  145.   // doh
  146. return result;
  147. }
  148. memcpy(&bmfHeader,&dataBits[off],bmfHeaderSize);
  149. off += bmfHeaderSize;
  151. unsigned long bmInfoSize = sizeof(BITMAPINFOHEADER);
  153. if ((off + bmInfoSize) > dataSize)
  154. {
  155.   // doh
  156. return result;
  157. }
  158. memcpy(&bmInfo,&dataBits[off],bmInfoSize);
  159. off += bmInfoSize;
  161. int nColors = bmInfo.bmiHeader.biClrUsed ? bmInfo.bmiHeader.biClrUsed : 
  162. 1 << bmInfo.bmiHeader.biBitCount;
  164. int w = bmInfo.bmiHeader.biWidth;
  165. int h = bmInfo.bmiHeader.biHeight;
  166. int bitcount = 24;
  168. if ((w > 0) && (h > 0))
  169. {
  170. dib.Create(w,h,bitcount);
  172. if (dib.IsCreated())
  173. {
  174. unsigned char * dst = (unsigned char *)dib.GetBits();
  175. unsigned long total_width = dib.GetTotalWidth();
  176. DWORD remainder = dataSize - bmfHeaderSize - bmInfo.bmiHeader.biSize;
  178. if ((off + remainder) > dataSize)
  179. {
  180. return result;
  181. }
  182. unsigned char * bits = new unsigned char[remainder];
  183. if (!bits)
  184. {
  185.   // outta memory
  186. return result;
  187. }
  189. memcpy(bits,&dataBits[off],remainder);
  191. int compr = BI_RGB;
  193.   // different encoding schemes are used for different bit counts
  194. switch (bmInfo.bmiHeader.biBitCount){
  195. case 1:
  196. {
  197. unsigned char * src = &bits[nColors*sizeof(RGBQUAD)];
  198. RGBQUAD * color_src = (RGBQUAD *)bits;
  200. INT32 color_index;
  201. INT32 dest_index;
  203. UINT32 pix_data_length = (w * h) / 8;
  204. CompBlock block(pix_data_length,src);
  205. short num;
  207. INT32 byte_count = bitcount/8;
  209. for (int row=0;row<h;row++){
  210. for (int col=0;col<w;col++){
  211. block.PopNumber(1,num);
  212. color_index = num;
  214. dest_index = byte_count*(row * total_width + col);
  215. dst[dest_index] = color_src[color_index].rgbBlue;
  216. dst[++dest_index] = color_src[color_index].rgbGreen;
  217. dst[++dest_index] = color_src[color_index].rgbRed;
  218. }
  219. }
  221. result++;
  222. }
  223. break;
  224. case 4:
  225. {
  226. if (bmInfo.bmiHeader.biCompression == BI_RGB)
  227. {
  228. unsigned char * src = &bits[nColors*sizeof(RGBQUAD)];
  229. RGBQUAD * color_src = (RGBQUAD *)bits;
  231. INT32 dest_index;
  233. UINT32 bytes_per_row = (w * 4 + 7)/8;
  234. if (!EVEN_NUMBER(bytes_per_row)) bytes_per_row += 3;
  236. UINT32 total_bytes = bytes_per_row * h;
  237. UINT32 extra_pixels = bytes_per_row*2 - w;
  239. CompBlock block(total_bytes,src);
  240. short num;
  242. INT32 byte_count = bitcount/8;
  244. int row = 0;
  245. int col = 0;
  247. UINT32 pixel = 0;
  248. UINT32 total_pixels = w * h;
  250. while (pixel < total_pixels){
  251. block.PopNumber(4,num);
  252. dest_index = byte_count*(row * total_width + col);
  253. dst[dest_index] = color_src[num].rgbBlue;
  254. dst[++dest_index] = color_src[num].rgbGreen;
  255. dst[++dest_index] = color_src[num].rgbRed;
  256. col++;
  257. if (col == w)
  258. {
  259. row++;
  260. col = 0;
  261. for (int i=0;i<extra_pixels;i++) block.PopNumber(4,num);
  262. }
  263. pixel++;
  264. }
  266. result++;
  267. }
  268. else if (bmInfo.bmiHeader.biCompression == BI_RLE4)
  269. {
  270. unsigned char * src = &bits[nColors*sizeof(RGBQUAD)];
  271. RGBQUAD * color_src = (RGBQUAD *)bits;
  273. INT32 dest_index;
  274. INT32 byte_count = bitcount/8;
  276. UINT32 found_end = 0;
  277. INT32 ndx = 0;
  278. UINT32 repeats;
  279. UINT32 code;
  280. int row = 0;
  281. int col = 0;
  283. while (!found_end){
  284. code = src[ndx++];
  286. if (code == 0)
  287. {
  288. code = src[ndx++];
  289. if (code == 0)
  290. {
  291. row++;
  292. col = 0;
  293. }
  294. else if (code == 1)
  295. {
  296. found_end++;
  297. }
  298. else if (code == 2)
  299. {
  300. code = src[ndx++];
  301. col += code;
  302. code = src[ndx++];
  303. row += code;
  304. }
  305. else
  306. {
  307.   // here we have a bunch of literal values
  308. repeats = code;
  309. UINT32 color1, color2;
  311. for (int i=0;i<repeats;i++){
  312. code = src[ndx++];
  314. dest_index = byte_count * (row * total_width + col);
  315. col++;
  317. color1 = (code >> 4) & 15;
  318. color2 = (code & 15);
  320. if (EVEN_NUMBER(i))
  321. {
  322. dst[dest_index] = color_src[color2].rgbBlue;
  323. dst[++dest_index] = color_src[color2].rgbGreen;
  324. dst[++dest_index] = color_src[color2].rgbRed;
  325. }
  326. else
  327. {
  328. dst[dest_index] = color_src[color1].rgbBlue;
  329. dst[++dest_index] = color_src[color1].rgbGreen;
  330. dst[++dest_index] = color_src[color1].rgbRed;
  331. }
  332. }
  334. if ((repeats%2) != 0) ndx++;
  335. }
  336. }
  337. else
  338. {
  339.   // here we're handling repeats
  340. repeats = code;
  341. code = src[ndx++];
  342. UINT32 color1 = (code >> 4) & 15;
  343. UINT32 color2 = (code & 15);
  345. for (int i=0;i<repeats;i++){
  346. dest_index = byte_count * (row * total_width + col);
  347. col++;
  349. if (EVEN_NUMBER(i))
  350. {
  351. dst[dest_index] = color_src[color2].rgbBlue;
  352. dst[++dest_index] = color_src[color2].rgbGreen;
  353. dst[++dest_index] = color_src[color2].rgbRed;
  354. }
  355. else
  356. {
  357. dst[dest_index] = color_src[color1].rgbBlue;
  358. dst[++dest_index] = color_src[color1].rgbGreen;
  359. dst[++dest_index] = color_src[color1].rgbRed;
  360. }
  361. }
  362. }
  363. }
  365. result++;
  366. }
  367. }
  368. break;
  369. case 8:
  370. {
  371. switch (bmInfo.bmiHeader.biCompression){
  372. case BI_RGB:
  373. {
  374. unsigned char * src = &bits[nColors*sizeof(RGBQUAD)];
  375. RGBQUAD * color_src = (RGBQUAD *)bits;
  377. INT32 color_index;
  378. INT32 dest_index;
  379. INT32 byte_count = bitcount/8;
  381. for (int row=0;row<h;row++){
  382. for (int col=0;col<w;col++){
  383. color_index = src[row*total_width + col];
  384. dest_index = byte_count*(row * total_width + col);
  385. dst[dest_index] = color_src[color_index].rgbBlue;
  386. dst[++dest_index] = color_src[color_index].rgbGreen;
  387. dst[++dest_index] = color_src[color_index].rgbRed;
  388. }
  389. }
  391. result++;
  392. }
  393. break;
  394. case BI_RLE8:
  395. {
  396. unsigned char * src = &bits[nColors*sizeof(RGBQUAD)];
  397. RGBQUAD * color_src = (RGBQUAD *)bits;
  399. INT32 dest_index;
  400. INT32 byte_count = bitcount/8;
  402. UINT32 found_end = 0;
  403. INT32 ndx = 0;
  404. UINT32 repeats;
  405. UINT32 code;
  406. int row = 0;
  407. int col = 0;
  409. while (!found_end){
  410. code = src[ndx++];
  412. if (code == 0)
  413. {
  414. code = src[ndx++];
  415. if (code == 0)
  416. {
  417. row++;
  418. col = 0;
  419. }
  420. else if (code == 1)
  421. {
  422. found_end++;
  423. }
  424. else if (code == 2)
  425. {
  426. code = src[ndx++];
  427. col += code;
  428. code = src[ndx++];
  429. row += code;
  430. }
  431. else
  432. {
  433.   // here we have a bunch of literal values
  434. repeats = code;
  436. for (int i=0;i<repeats;i++){
  437. code = src[ndx++];
  439. dest_index = byte_count * (row * total_width + col);
  440. col++;
  442. dst[dest_index] = color_src[code].rgbBlue;
  443. dst[++dest_index] = color_src[code].rgbGreen;
  444. dst[++dest_index] = color_src[code].rgbRed;
  445. }
  447. if ((repeats%2) != 0) ndx++;
  448. }
  449. }
  450. else
  451. {
  452.   // here we're handling repeats
  453. repeats = code;
  454. code = src[ndx++];
  456. for (int i=0;i<repeats;i++){
  457. dest_index = byte_count * (row * total_width + col);
  458. col++;
  460. dst[dest_index] = color_src[code].rgbBlue;
  461. dst[++dest_index] = color_src[code].rgbGreen;
  462. dst[++dest_index] = color_src[code].rgbRed;
  463. }
  464. }
  465. }
  467. result++;
  468. }
  469. break;
  470. }
  471. }
  472. break;
  473. case 16:
  474. {
  475. switch (bmInfo.bmiHeader.biCompression){
  476. case BI_RGB:
  477. {
  478. }
  479. break;
  480. case BI_BITFIELDS:
  481. {
  482. }
  483. break;
  484. }
  485. }
  486. break;
  487. case 24:
  488. {
  489.   // assuming compression equals BI_RGB
  490. unsigned long dst_offset;
  491. unsigned long src_offset;
  493. UINT32 bytespp, dst_row_bytes, src_row_bytes;
  495. bytespp = bitcount/8;
  496. dst_row_bytes = total_width * bytespp;
  497. //row_mod = 4 - (w%4);
  498. src_row_bytes = (w * bytespp);
  500. src_row_bytes = ((((int) src_row_bytes * 8) + 31) & ~31) >> 3;
  502. for (int row=0;row<h;row++){
  503. dst_offset = row * dst_row_bytes;
  504. src_offset = row * src_row_bytes;
  505. memcpy(&dst[dst_offset],&bits[src_offset],src_row_bytes);
  506. }
  508. result++;
  509. }
  510. break;
  511. case 32:
  512. {
  513. switch (bmInfo.bmiHeader.biCompression){
  514. case BI_RGB:
  515. {
  516. }
  517. break;
  518. case BI_BITFIELDS:
  519. {
  520. }
  521. break;
  522. }
  523. }
  524. break;
  525. }
  527. delete [] bits;
  528. }
  529. }
  530. }
  532. return result;
  533. }