non
/
ntk
mirror of https://github.com/original-male/ntk
1
0
Fork 0
Code Releases 2 Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
82 Commits
1 Branch
8.9MB
Tree: 7d522d5b6d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7d522d5b6d'
${ noResults }
ntk/src/Fl_BMP_Image.cxx

496 lines
12KB
Raw Blame History 

  1. //

  2. // "$Id: Fl_BMP_Image.cxx 7903 2010-11-28 21:06:39Z matt $"

  3. //

  4. // Fl_BMP_Image routines.

  5. //

  6. // Copyright 1997-2010 by Easy Software Products.

  7. // Image support by Matthias Melcher, Copyright 2000-2009.

  8. //

  9. // This library is free software; you can redistribute it and/or

  10. // modify it under the terms of the GNU Library General Public

  11. // License as published by the Free Software Foundation; either

  12. // version 2 of the License, or (at your option) any later version.

  13. //

  14. // This library is distributed in the hope that it will be useful,

  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of

  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  17. // Library General Public License for more details.

  18. //

  19. // You should have received a copy of the GNU Library General Public

  20. // License along with this library; if not, write to the Free Software

  21. // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

  22. // USA.

  23. //

  24. // Please report all bugs and problems on the following page:

  25. //

  26. //     http://www.fltk.org/str.php

  27. //

  28. // Contents:

  29. //

  30. //   Fl_BMP_Image::Fl_BMP_Image() - Load a BMP image file.

  31. //

  32. 

  33. //

  34. // Include necessary header files...

  35. //

  36. 

  37. #include <FL/Fl_BMP_Image.H>

  38. #include <FL/fl_utf8.h>

  39. #include <config.h>

  40. #include <stdio.h>

  41. #include <stdlib.h>

  42. 

  43. 

  44. //

  45. // BMP definitions...

  46. //

  47. 

  48. #ifndef BI_RGB

  49. #  define BI_RGB       0             // No compression - straight BGR data

  50. #  define BI_RLE8      1             // 8-bit run-length compression

  51. #  define BI_RLE4      2             // 4-bit run-length compression

  52. #  define BI_BITFIELDS 3             // RGB bitmap with RGB masks

  53. #endif // !BI_RGB

  54. 

  55. 

  56. //

  57. // Local functions...

  58. //

  59. 

  60. static int		read_long(FILE *fp);

  61. static unsigned short	read_word(FILE *fp);

  62. static unsigned int	read_dword(FILE *fp);

  63. /** 

  64.   The constructor loads the named BMP image from the given bmp filename.  

  65.   <P>The inherited destructor free all memory and server resources that are used by

  66.   the image.

  67.   <P>The destructor free all memory and server resources that are used by

  68.   the image

  69. */

  70. Fl_BMP_Image::Fl_BMP_Image(const char *bmp) // I - File to read

  71.   : Fl_RGB_Image(0,0,0) {

  72.   FILE		*fp;		// File pointer

  73.   int		info_size,	// Size of info header

  74. 		depth,		// Depth of image (bits)

  75. 		bDepth = 3,	// Depth of image (bytes)

  76. 		compression,	// Type of compression

  77. 		colors_used,	// Number of colors used

  78. 		x, y,		// Looping vars

  79. 		color,		// Color of RLE pixel

  80. 		repcount,	// Number of times to repeat

  81. 		temp,		// Temporary color

  82. 		align,		// Alignment bytes

  83. 		dataSize,	// number of bytes in image data set

  84. 		row_order,	// 1 = normal;  -1 = flipped row order

  85. 		start_y,	// Beginning Y

  86. 		end_y;		// Ending Y

  87.   long		offbits;	// Offset to image data

  88.   uchar		bit,		// Bit in image

  89. 		byte;		// Byte in image

  90.   uchar		*ptr;		// Pointer into pixels

  91.   uchar		colormap[256][3];// Colormap

  92.   uchar		havemask;	// Single bit mask follows image data

  93.   int		use_5_6_5;	// Use 5:6:5 for R:G:B channels in 16 bit images

  94. 

  95. 

  96.   // Open the file...

  97.   if ((fp = fl_fopen(bmp, "rb")) == NULL) return;

  98. 

  99.   // Get the header...

  100.   byte = (uchar)getc(fp);	// Check "BM" sync chars

  101.   bit  = (uchar)getc(fp);

  102.   if (byte != 'B' || bit != 'M') {

  103.     fclose(fp);

  104.     return;

  105.   }

  106. 

  107.   read_dword(fp);		// Skip size

  108.   read_word(fp);		// Skip reserved stuff

  109.   read_word(fp);

  110.   offbits = (long)read_dword(fp);// Read offset to image data

  111. 

  112.   // Then the bitmap information...

  113.   info_size = read_dword(fp);

  114. 

  115. //  printf("offbits = %ld, info_size = %d\n", offbits, info_size);

  116. 

  117.   havemask  = 0;

  118.   row_order = -1;

  119.   use_5_6_5 = 0;

  120. 

  121.   if (info_size < 40) {

  122.     // Old Windows/OS2 BMP header...

  123.     w(read_word(fp));

  124.     h(read_word(fp));

  125.     read_word(fp);

  126.     depth = read_word(fp);

  127.     compression = BI_RGB;

  128.     colors_used = 0;

  129. 

  130.     repcount = info_size - 12;

  131.   } else {

  132.     // New BMP header...

  133.     w(read_long(fp));

  134.     // If the height is negative, the row order is flipped

  135.     temp = read_long(fp);

  136.     if (temp < 0) row_order = 1;

  137.     h(abs(temp));

  138.     read_word(fp);

  139.     depth = read_word(fp);

  140.     compression = read_dword(fp);

  141.     dataSize = read_dword(fp);

  142.     read_long(fp);

  143.     read_long(fp);

  144.     colors_used = read_dword(fp);

  145.     read_dword(fp);

  146. 

  147.     repcount = info_size - 40;

  148. 

  149.     if (!compression && depth>=8 && w()>32/depth) {

  150.       int Bpp = depth/8;

  151.       int maskSize = (((w()*Bpp+3)&~3)*h()) + (((((w()+7)/8)+3)&~3)*h());

  152.       if (maskSize==2*dataSize) {

  153.         havemask = 1;

  154. 	h(h()/2);

  155. 	bDepth = 4;

  156.       }

  157.     }

  158.   }

  159. 

  160. //  printf("w() = %d, h() = %d, depth = %d, compression = %d, colors_used = %d, repcount = %d\n",

  161. //         w(), h(), depth, compression, colors_used, repcount);

  162. 

  163.   // Skip remaining header bytes...

  164.   while (repcount > 0) {

  165.     getc(fp);

  166.     repcount --;

  167.   }

  168. 

  169.   // Check header data...

  170.   if (!w() || !h() || !depth) {

  171.     fclose(fp);

  172.     return;

  173.   }

  174. 

  175.   // Get colormap...

  176.   if (colors_used == 0 && depth <= 8)

  177.     colors_used = 1 << depth;

  178. 

  179.   for (repcount = 0; repcount < colors_used; repcount ++) {

  180.     // Read BGR color...

  181.     if (fread(colormap[repcount], 1, 3, fp)==0) { /* ignore */ }

  182. 

  183.     // Skip pad byte for new BMP files...

  184.     if (info_size > 12) getc(fp);

  185.   }

  186. 

  187.   // Read first dword of colormap. It tells us if 5:5:5 or 5:6:5 for 16 bit

  188.   if (depth == 16)

  189.     use_5_6_5 = (read_dword(fp) == 0xf800);

  190. 

  191.   // Set byte depth for RGBA images

  192.   if (depth == 32)

  193.     bDepth=4;

  194. 

  195.   // Setup image and buffers...

  196.   d(bDepth);

  197.   if (offbits) fseek(fp, offbits, SEEK_SET);

  198. 

  199.   array = new uchar[w() * h() * d()];

  200.   alloc_array = 1;

  201. 

  202.   // Read the image data...

  203.   color = 0;

  204.   repcount = 0;

  205.   align = 0;

  206.   byte  = 0;

  207.   temp  = 0;

  208. 

  209.   if (row_order < 0) {

  210.     start_y = h() - 1;

  211.     end_y   = -1;

  212.   } else {

  213.     start_y = 0;

  214.     end_y   = h();

  215.   }

  216. 

  217.   for (y = start_y; y != end_y; y += row_order) {

  218.     ptr = (uchar *)array + y * w() * d();

  219. 

  220.     switch (depth)

  221.     {

  222.       case 1 : // Bitmap

  223.           for (x = w(), bit = 128; x > 0; x --) {

  224. 	    if (bit == 128) byte = (uchar)getc(fp);

  225. 

  226. 	    if (byte & bit) {

  227. 	      *ptr++ = colormap[1][2];

  228. 	      *ptr++ = colormap[1][1];

  229. 	      *ptr++ = colormap[1][0];

  230. 	    } else {

  231. 	      *ptr++ = colormap[0][2];

  232. 	      *ptr++ = colormap[0][1];

  233. 	      *ptr++ = colormap[0][0];

  234. 	    }

  235. 

  236. 	    if (bit > 1)

  237. 	      bit >>= 1;

  238. 	    else

  239. 	      bit = 128;

  240. 	  }

  241. 

  242.           // Read remaining bytes to align to 32 bits...

  243. 	  for (temp = (w() + 7) / 8; temp & 3; temp ++) {

  244. 	    getc(fp);

  245. 	  }

  246.           break;

  247. 

  248.       case 4 : // 16-color

  249.           for (x = w(), bit = 0xf0; x > 0; x --) {

  250. 	    // Get a new repcount as needed...

  251. 	    if (repcount == 0) {

  252.               if (compression != BI_RLE4) {

  253. 		repcount = 2;

  254. 		color = -1;

  255.               } else {

  256. 		while (align > 0) {

  257. 	          align --;

  258. 		  getc(fp);

  259.         	}

  260. 

  261. 		if ((repcount = getc(fp)) == 0) {

  262. 		  if ((repcount = getc(fp)) == 0) {

  263. 		    // End of line...

  264.                     x ++;

  265. 		    continue;

  266. 		  } else if (repcount == 1) {

  267.                     // End of image...

  268. 		    break;

  269. 		  } else if (repcount == 2) {

  270. 		    // Delta...

  271. 		    repcount = getc(fp) * getc(fp) * w();

  272. 		    color = 0;

  273. 		  } else {

  274. 		    // Absolute...

  275. 		    color = -1;

  276. 		    align = ((4 - (repcount & 3)) / 2) & 1;

  277. 		  }

  278. 		} else {

  279. 	          color = getc(fp);

  280. 		}

  281. 	      }

  282. 	    }

  283. 

  284.             // Get a new color as needed...

  285. 	    repcount --;

  286. 

  287. 	    // Extract the next pixel...

  288.             if (bit == 0xf0) {

  289. 	      // Get the next color byte as needed...

  290.               if (color < 0) temp = getc(fp);

  291. 	      else temp = color;

  292. 

  293.               // Copy the color value...

  294. 	      *ptr++ = colormap[(temp >> 4) & 15][2];

  295. 	      *ptr++ = colormap[(temp >> 4) & 15][1];

  296. 	      *ptr++ = colormap[(temp >> 4) & 15][0];

  297. 

  298. 	      bit  = 0x0f;

  299. 	    } else {

  300. 	      bit  = 0xf0;

  301. 

  302.               // Copy the color value...

  303. 	      *ptr++ = colormap[temp & 15][2];

  304. 	      *ptr++ = colormap[temp & 15][1];

  305. 	      *ptr++ = colormap[temp & 15][0];

  306. 	    }

  307. 

  308. 	  }

  309. 

  310. 	  if (!compression) {

  311.             // Read remaining bytes to align to 32 bits...

  312. 	    for (temp = (w() + 1) / 2; temp & 3; temp ++) {

  313. 	      getc(fp);

  314. 	    }

  315. 	  }

  316.           break;

  317. 

  318.       case 8 : // 256-color

  319.           for (x = w(); x > 0; x --) {

  320. 	    // Get a new repcount as needed...

  321.             if (compression != BI_RLE8) {

  322. 	      repcount = 1;

  323. 	      color = -1;

  324.             }

  325. 

  326. 	    if (repcount == 0) {

  327. 	      while (align > 0) {

  328. 	        align --;

  329. 		getc(fp);

  330.               }

  331. 

  332. 	      if ((repcount = getc(fp)) == 0) {

  333. 		if ((repcount = getc(fp)) == 0) {

  334. 		  // End of line...

  335.                   x ++;

  336. 		  continue;

  337. 		} else if (repcount == 1) {

  338. 		  // End of image...

  339. 		  break;

  340. 		} else if (repcount == 2) {

  341. 		  // Delta...

  342. 		  repcount = getc(fp) * getc(fp) * w();

  343. 		  color = 0;

  344. 		} else {

  345. 		  // Absolute...

  346. 		  color = -1;

  347. 		  align = (2 - (repcount & 1)) & 1;

  348. 		}

  349. 	      } else {

  350. 	        color = getc(fp);

  351.               }

  352.             }

  353. 

  354.             // Get a new color as needed...

  355.             if (color < 0) temp = getc(fp);

  356. 	    else temp = color;

  357. 

  358.             repcount --;

  359. 

  360.             // Copy the color value...

  361. 	    *ptr++ = colormap[temp][2];

  362. 	    *ptr++ = colormap[temp][1];

  363. 	    *ptr++ = colormap[temp][0];

  364. 	    if (havemask) ptr++;

  365. 	  }

  366. 

  367. 	  if (!compression) {

  368.             // Read remaining bytes to align to 32 bits...

  369. 	    for (temp = w(); temp & 3; temp ++) {

  370. 	      getc(fp);

  371. 	    }

  372. 	  }

  373.           break;

  374. 

  375.       case 16 : // 16-bit 5:5:5 or 5:6:5 RGB

  376.           for (x = w(); x > 0; x --, ptr += bDepth) {

  377. 	    uchar b = getc(fp), a = getc(fp) ;

  378. 	    if (use_5_6_5) {

  379. 		ptr[2] = (uchar)(( b << 3 ) & 0xf8);

  380. 		ptr[1] = (uchar)(((a << 5) & 0xe0) | ((b >> 3) & 0x1c));

  381. 		ptr[0] = (uchar)(a & 0xf8);

  382. 	    } else {

  383. 		ptr[2] = (uchar)((b << 3) & 0xf8);

  384. 		ptr[1] = (uchar)(((a << 6) & 0xc0) | ((b >> 2) & 0x38));

  385. 		ptr[0] = (uchar)((a<<1) & 0xf8);

  386. 	    }

  387. 	  }

  388. 

  389.           // Read remaining bytes to align to 32 bits...

  390. 	  for (temp = w() * 2; temp & 3; temp ++) {

  391. 	    getc(fp);

  392. 	  }

  393.           break;

  394. 

  395.       case 24 : // 24-bit RGB

  396.           for (x = w(); x > 0; x --, ptr += bDepth) {

  397. 	    ptr[2] = (uchar)getc(fp);

  398. 	    ptr[1] = (uchar)getc(fp);

  399. 	    ptr[0] = (uchar)getc(fp);

  400. 	  }

  401. 

  402.           // Read remaining bytes to align to 32 bits...

  403. 	  for (temp = w() * 3; temp & 3; temp ++) {

  404. 	    getc(fp);

  405. 	  }

  406.           break;

  407. 		  

  408.       case 32 : // 32-bit RGBA

  409.          for (x = w(); x > 0; x --, ptr += bDepth) {

  410.             ptr[2] = (uchar)getc(fp);

  411.             ptr[1] = (uchar)getc(fp);

  412.             ptr[0] = (uchar)getc(fp);

  413.             ptr[3] = (uchar)getc(fp);

  414.           }

  415.           break;

  416.     }

  417.   }

  418.   

  419.   if (havemask) {

  420.     for (y = h() - 1; y >= 0; y --) {

  421.       ptr = (uchar *)array + y * w() * d() + 3;

  422.       for (x = w(), bit = 128; x > 0; x --, ptr+=bDepth) {

  423. 	if (bit == 128) byte = (uchar)getc(fp);

  424. 	if (byte & bit)

  425. 	  *ptr = 0;

  426. 	else

  427. 	  *ptr = 255;

  428. 	if (bit > 1)

  429. 	  bit >>= 1;

  430. 	else

  431. 	  bit = 128;

  432.       }

  433.       // Read remaining bytes to align to 32 bits...

  434.       for (temp = (w() + 7) / 8; temp & 3; temp ++)

  435. 	getc(fp);

  436.     }

  437.   }

  438. 

  439.   // Close the file and return...

  440.   fclose(fp);

  441. }

  442. 

  443. 

  444. //

  445. // 'read_word()' - Read a 16-bit unsigned integer.

  446. //

  447. 

  448. static unsigned short	// O - 16-bit unsigned integer

  449. read_word(FILE *fp) {	// I - File to read from

  450.   unsigned char b0, b1;	// Bytes from file

  451. 

  452.   b0 = (uchar)getc(fp);

  453.   b1 = (uchar)getc(fp);

  454. 

  455.   return ((b1 << 8) | b0);

  456. }

  457. 

  458. 

  459. //

  460. // 'read_dword()' - Read a 32-bit unsigned integer.

  461. //

  462. 

  463. static unsigned int		// O - 32-bit unsigned integer

  464. read_dword(FILE *fp) {		// I - File to read from

  465.   unsigned char b0, b1, b2, b3;	// Bytes from file

  466. 

  467.   b0 = (uchar)getc(fp);

  468.   b1 = (uchar)getc(fp);

  469.   b2 = (uchar)getc(fp);

  470.   b3 = (uchar)getc(fp);

  471. 

  472.   return ((((((b3 << 8) | b2) << 8) | b1) << 8) | b0);

  473. }

  474. 

  475. 

  476. //

  477. // 'read_long()' - Read a 32-bit signed integer.

  478. //

  479. 

  480. static int			// O - 32-bit signed integer

  481. read_long(FILE *fp) {		// I - File to read from

  482.   unsigned char b0, b1, b2, b3;	// Bytes from file

  483. 

  484.   b0 = (uchar)getc(fp);

  485.   b1 = (uchar)getc(fp);

  486.   b2 = (uchar)getc(fp);

  487.   b3 = (uchar)getc(fp);

  488. 

  489.   return ((int)(((((b3 << 8) | b2) << 8) | b1) << 8) | b0);

  490. }

  491. 

  492. 

  493. //

  494. // End of "$Id: Fl_BMP_Image.cxx 7903 2010-11-28 21:06:39Z matt $".

  495. //