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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llimagebmp.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：15k
源码类别：

游戏引擎

开发平台：

C++ Builder

llimagebmp.cpp：源码内容
  1. /** 
  2.  * @file llimagebmp.cpp
  3.  *
  4.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  5.  * 
  6.  * Copyright (c) 2001-2010, Linden Research, Inc.
  7.  * 
  8.  * Second Life Viewer Source Code
  9.  * The source code in this file ("Source Code") is provided by Linden Lab
  10.  * to you under the terms of the GNU General Public License, version 2.0
  11.  * ("GPL"), unless you have obtained a separate licensing agreement
  12.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  13.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  14.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  15.  * 
  16.  * There are special exceptions to the terms and conditions of the GPL as
  17.  * it is applied to this Source Code. View the full text of the exception
  18.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  19.  * online at
  20.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  21.  * 
  22.  * By copying, modifying or distributing this software, you acknowledge
  23.  * that you have read and understood your obligations described above,
  24.  * and agree to abide by those obligations.
  25.  * 
  26.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  27.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  28.  * COMPLETENESS OR PERFORMANCE.
  29.  * $/LicenseInfo$
  30.  */
  32. #include "linden_common.h"
  34. #include "llimagebmp.h"
  35. #include "llerror.h"
  37. #include "llendianswizzle.h"
  40. /**
  41.  * @struct LLBMPHeader
  42.  *
  43.  * This struct helps deal with bmp files.
  44.  */
  45. struct LLBMPHeader
  46. {
  47. S32 mSize;
  48. S32 mWidth;
  49. S32 mHeight;
  50. S16 mPlanes;
  51. S16 mBitsPerPixel;
  52. S16 mCompression;
  53. S16 mAlignmentPadding; // pads out to next word boundary
  54. S32 mImageSize;
  55. S32 mHorzPelsPerMeter;
  56. S32 mVertPelsPerMeter;
  57. S32 mNumColors;
  58. S32 mNumColorsImportant;
  59. };
  61. /**
  62.  * @struct Win95BmpHeaderExtension
  63.  */
  64. struct Win95BmpHeaderExtension
  65. {
  66. U32 mReadMask;
  67. U32 mGreenMask;
  68. U32 mBlueMask;
  69. U32 mAlphaMask;
  70. U32 mColorSpaceType;
  71. U16 mRed[3]; // Red CIE endpoint
  72. U16 mGreen[3]; // Green CIE endpoint
  73. U16 mBlue[3]; // Blue CIE endpoint
  74. U32 mGamma[3];  // Gamma scale for r g and b
  75. };
  77. /**
  78.  * LLImageBMP
  79.  */
  80. LLImageBMP::LLImageBMP() 
  81. :
  82. LLImageFormatted(IMG_CODEC_BMP),
  83. mColorPaletteColors( 0 ),
  84. mColorPalette( NULL ),
  85. mBitmapOffset( 0 ),
  86. mBitsPerPixel( 0 ),
  87. mOriginAtTop( FALSE )
  88. {
  89. mBitfieldMask[0] = 0;
  90. mBitfieldMask[1] = 0;
  91. mBitfieldMask[2] = 0;
  92. mBitfieldMask[3] = 0;
  93. }
  95. LLImageBMP::~LLImageBMP()
  96. {
  97. delete[] mColorPalette;
  98. }
  101. BOOL LLImageBMP::updateData()
  102. {
  103. resetLastError();
  105. // Check to make sure that this instance has been initialized with data
  106. U8* mdata = getData();
  107. if (!mdata || (0 == getDataSize()))
  108. {
  109. setLastError("Uninitialized instance of LLImageBMP");
  110. return FALSE;
  111. }
  113. // Read the bitmap headers in order to get all the useful info
  114. // about this image
  116. ////////////////////////////////////////////////////////////////////
  117. // Part 1: "File Header"
  118. // 14 bytes consisting of
  119. // 2 bytes: either BM or BA
  120. // 4 bytes: file size in bytes
  121. // 4 bytes: reserved (always 0)
  122. // 4 bytes: bitmap offset (starting position of image data in bytes)
  123. const S32 FILE_HEADER_SIZE = 14;
  124. if ((mdata[0] != 'B') || (mdata[1] != 'M'))
  125.     {
  126. if ((mdata[0] != 'B') || (mdata[1] != 'A'))
  127. {
  128. setLastError("OS/2 bitmap array BMP files are not supported");
  129. return FALSE;
  130. }
  131. else
  132. {
  133. setLastError("Does not appear to be a bitmap file");
  134. return FALSE;
  135. }
  136. }
  138. mBitmapOffset = mdata[13];
  139. mBitmapOffset <<= 8; mBitmapOffset += mdata[12];
  140. mBitmapOffset <<= 8; mBitmapOffset += mdata[11];
  141. mBitmapOffset <<= 8; mBitmapOffset += mdata[10];
  144. ////////////////////////////////////////////////////////////////////
  145. // Part 2: "Bitmap Header"
  146. const S32 BITMAP_HEADER_SIZE = 40;
  147. LLBMPHeader header;
  148. llassert( sizeof( header ) == BITMAP_HEADER_SIZE );
  150. memcpy( /* Flawfinder: ignore */
  151. (void*)&header,
  152. mdata + FILE_HEADER_SIZE,
  153. BITMAP_HEADER_SIZE);
  155. // convert BMP header from little endian (no-op on little endian builds)
  156. llendianswizzleone(header.mSize);
  157. llendianswizzleone(header.mWidth);
  158. llendianswizzleone(header.mHeight);
  159. llendianswizzleone(header.mPlanes);
  160. llendianswizzleone(header.mBitsPerPixel);
  161. llendianswizzleone(header.mCompression);
  162. llendianswizzleone(header.mAlignmentPadding);
  163. llendianswizzleone(header.mImageSize);
  164. llendianswizzleone(header.mHorzPelsPerMeter);
  165. llendianswizzleone(header.mVertPelsPerMeter);
  166. llendianswizzleone(header.mNumColors);
  167. llendianswizzleone(header.mNumColorsImportant);
  169. BOOL windows_nt_version = FALSE;
  170. BOOL windows_95_version = FALSE;
  171. if( 12 == header.mSize )
  172. {
  173. setLastError("Windows 2.x and OS/2 1.x BMP files are not supported");
  174. return FALSE;
  175. }
  176. else
  177. if( 40 == header.mSize )
  178. {
  179. if( 3 == header.mCompression )
  180. {
  181. // Windows NT
  182. windows_nt_version = TRUE;
  183. }
  184. else
  185. {
  186. // Windows 3.x
  187. }
  188. }
  189. else
  190. if( 12 <= header.mSize && 64 <= header.mSize )
  191. {
  192. setLastError("OS/2 2.x BMP files are not supported");
  193. return FALSE;
  194. }
  195. else
  196. if( 108 == header.mSize )
  197. {
  198. // BITMAPV4HEADER
  199. windows_95_version = TRUE;
  200. }
  201. else
  202. if( 108 < header.mSize )
  203. {
  204. // BITMAPV5HEADER or greater
  205. // Should work as long at Microsoft maintained backwards compatibility (which they did in V4 and V5)
  206. windows_95_version = TRUE;
  207. }
  209. S32 width = header.mWidth;
  210. S32 height = header.mHeight;
  211. if (height < 0)
  212. {
  213. mOriginAtTop = TRUE;
  214. height = -height;
  215. }
  216. else
  217. {
  218. mOriginAtTop = FALSE;
  219. }
  221. mBitsPerPixel = header.mBitsPerPixel;
  222. S32 components;
  223. switch( mBitsPerPixel )
  224. {
  225. case 8:
  226. components = 1;
  227. break;
  228. case 24:
  229. case 32:
  230. components = 3;
  231. break;
  232. case 1:
  233. case 4:
  234. case 16: // Started work on 16, but doesn't work yet
  235. // These are legal, but we don't support them yet.
  236. setLastError("Unsupported bit depth");
  237. return FALSE;
  238. default:
  239. setLastError("Unrecognized bit depth");
  240. return FALSE;
  241. }
  243. setSize(width, height, components);
  245. switch( header.mCompression )
  246. {
  247. case 0:
  248. // Uncompressed
  249. break;
  251. case 1:
  252. setLastError("8 bit RLE compression not supported.");
  253. return FALSE;
  255. case 2: 
  256. setLastError("4 bit RLE compression not supported.");
  257. return FALSE;
  259. case 3:
  260. // Windows NT or Windows 95
  261. break;
  263. default:
  264. setLastError("Unsupported compression format.");
  265. return FALSE;
  266. }
  268. ////////////////////////////////////////////////////////////////////
  269. // Part 3: Bitfield Masks and other color data
  270. S32 extension_size = 0;
  271. if( windows_nt_version )
  272. {
  273. if( (16 != header.mBitsPerPixel) && (32 != header.mBitsPerPixel) )
  274. {
  275. setLastError("Bitfield encoding requires 16 or 32 bits per pixel.");
  276. return FALSE;
  277. }
  279. if( 0 != header.mNumColors )
  280. {
  281. setLastError("Bitfield encoding is not compatible with a color table.");
  282. return FALSE;
  283. }
  286. extension_size = 4 * 3;
  287. memcpy( mBitfieldMask, mdata + FILE_HEADER_SIZE + BITMAP_HEADER_SIZE, extension_size); /* Flawfinder: ignore */
  288. }
  289. else
  290. if( windows_95_version )
  291. {
  292. Win95BmpHeaderExtension win_95_extension;
  293. extension_size = sizeof( win_95_extension );
  295. llassert( sizeof( win_95_extension ) + BITMAP_HEADER_SIZE == 108 );
  296. memcpy( &win_95_extension, mdata + FILE_HEADER_SIZE + BITMAP_HEADER_SIZE, sizeof( win_95_extension ) ); /* Flawfinder: ignore */
  298. if( 3 == header.mCompression )
  299. {
  300. memcpy( mBitfieldMask, mdata + FILE_HEADER_SIZE + BITMAP_HEADER_SIZE, 4 * 4); /* Flawfinder: ignore */
  301. }
  303. // Color correction ignored for now
  304. }
  307. ////////////////////////////////////////////////////////////////////
  308. // Part 4: Color Palette (optional)
  309. // Note: There's no color palette if there are 16 or more bits per pixel
  310. S32 color_palette_size = 0;
  311. mColorPaletteColors = 0;
  312. if( header.mBitsPerPixel < 16 )
  313. {
  314. if( 0 == header.mNumColors )
  315. {
  316. mColorPaletteColors = (1 << header.mBitsPerPixel);
  317. }
  318. else
  319. {
  320. mColorPaletteColors = header.mNumColors;
  321. }
  322. }
  323. color_palette_size = mColorPaletteColors * 4;
  325. if( 0 != mColorPaletteColors )
  326. {
  327. mColorPalette = new U8[color_palette_size];
  328. if (!mColorPalette)
  329. {
  330. llerrs << "Out of memory in LLImageBMP::updateData()" << llendl;
  331. return FALSE;
  332. }
  333. memcpy( mColorPalette, mdata + FILE_HEADER_SIZE + BITMAP_HEADER_SIZE + extension_size, color_palette_size ); /* Flawfinder: ignore */
  334. }
  336. return TRUE;
  337. }
  339. BOOL LLImageBMP::decode(LLImageRaw* raw_image, F32 decode_time)
  340. {
  341. llassert_always(raw_image);
  343. resetLastError();
  345. // Check to make sure that this instance has been initialized with data
  346. U8* mdata = getData();
  347. if (!mdata || (0 == getDataSize()))
  348. {
  349. setLastError("llimagebmp trying to decode an image with no data!");
  350. return FALSE;
  351. }
  353. raw_image->resize(getWidth(), getHeight(), 3);
  355. U8* src = mdata + mBitmapOffset;
  356. U8* dst = raw_image->getData();
  358. BOOL success = FALSE;
  360. switch( mBitsPerPixel )
  361. {
  362. case 8:
  363. if( mColorPaletteColors >= 256 )
  364. {
  365. success = decodeColorTable8( dst, src );
  366. }
  367. break;
  369. case 16:
  370. success = decodeColorMask16( dst, src );
  371. break;
  373. case 24:
  374. success = decodeTruecolor24( dst, src );
  375. break;
  377. case 32:
  378. success = decodeColorMask32( dst, src );
  379. break;
  380. }
  382. if( success && mOriginAtTop )
  383. {
  384. raw_image->verticalFlip();
  385. }
  387. return success;
  388. }
  390. U32 LLImageBMP::countTrailingZeros( U32 m )
  391. {
  392. U32 shift_count = 0;
  393. while( !(m & 1) )
  394. {
  395. shift_count++;
  396. m >>= 1;
  397. }
  398. return shift_count;
  399. }
  402. BOOL LLImageBMP::decodeColorMask16( U8* dst, U8* src )
  403. {
  404. llassert( 16 == mBitsPerPixel );
  406. if( !mBitfieldMask[0] && !mBitfieldMask[1] && !mBitfieldMask[2] )
  407. {
  408. // Use default values
  409. mBitfieldMask[0] = 0x00007C00;
  410. mBitfieldMask[1] = 0x000003E0;
  411. mBitfieldMask[2] = 0x0000001F;
  412. }
  414. S32 src_row_span = getWidth() * 2;
  415. S32 alignment_bytes = (3 * src_row_span) % 4;  // round up to nearest multiple of 4
  417. U32 r_shift = countTrailingZeros( mBitfieldMask[2] );
  418. U32 g_shift = countTrailingZeros( mBitfieldMask[1] );
  419. U32 b_shift = countTrailingZeros( mBitfieldMask[0] );
  421. for( S32 row = 0; row < getHeight(); row++ )
  422. {
  423. for( S32 col = 0; col < getWidth(); col++ )
  424. {
  425. U32 value = *((U16*)src);
  426. dst[0] = U8((value & mBitfieldMask[2]) >> r_shift); // Red
  427. dst[1] = U8((value & mBitfieldMask[1]) >> g_shift); // Green
  428. dst[2] = U8((value & mBitfieldMask[0]) >> b_shift); // Blue
  429. src += 2;
  430. dst += 3;
  431. }
  432. src += alignment_bytes;
  433. }
  435. return TRUE;
  436. }
  438. BOOL LLImageBMP::decodeColorMask32( U8* dst, U8* src )
  439. {
  440. // Note: alpha is not supported
  442. llassert( 32 == mBitsPerPixel );
  444. if( !mBitfieldMask[0] && !mBitfieldMask[1] && !mBitfieldMask[2] )
  445. {
  446. // Use default values
  447. mBitfieldMask[0] = 0x00FF0000;
  448. mBitfieldMask[1] = 0x0000FF00;
  449. mBitfieldMask[2] = 0x000000FF;
  450. }
  453. S32 src_row_span = getWidth() * 4;
  454. S32 alignment_bytes = (3 * src_row_span) % 4;  // round up to nearest multiple of 4
  456. U32 r_shift = countTrailingZeros( mBitfieldMask[0] );
  457. U32 g_shift = countTrailingZeros( mBitfieldMask[1] );
  458. U32 b_shift = countTrailingZeros( mBitfieldMask[2] );
  460. for( S32 row = 0; row < getHeight(); row++ )
  461. {
  462. for( S32 col = 0; col < getWidth(); col++ )
  463. {
  464. U32 value = *((U32*)src);
  465. dst[0] = U8((value & mBitfieldMask[0]) >> r_shift); // Red
  466. dst[1] = U8((value & mBitfieldMask[1]) >> g_shift); // Green
  467. dst[2] = U8((value & mBitfieldMask[2]) >> b_shift); // Blue
  468. src += 4;
  469. dst += 3;
  470. }
  471. src += alignment_bytes;
  472. }
  474. return TRUE;
  475. }
  478. BOOL LLImageBMP::decodeColorTable8( U8* dst, U8* src )
  479. {
  480. llassert( (8 == mBitsPerPixel) && (mColorPaletteColors >= 256) );
  482. S32 src_row_span = getWidth() * 1;
  483. S32 alignment_bytes = (3 * src_row_span) % 4;  // round up to nearest multiple of 4
  485. for( S32 row = 0; row < getHeight(); row++ )
  486. {
  487. for( S32 col = 0; col < getWidth(); col++ )
  488. {
  489. S32 index = 4 * src[0];
  490. dst[0] = mColorPalette[index + 2]; // Red
  491. dst[1] = mColorPalette[index + 1]; // Green
  492. dst[2] = mColorPalette[index + 0]; // Blue
  493. src++;
  494. dst += 3;
  495. }
  496. src += alignment_bytes;
  497. }
  499. return TRUE;
  500. }
  503. BOOL LLImageBMP::decodeTruecolor24( U8* dst, U8* src )
  504. {
  505. llassert( 24 == mBitsPerPixel );
  506. llassert( 3 == getComponents() );
  507. S32 src_row_span = getWidth() * 3;
  508. S32 alignment_bytes = (3 * src_row_span) % 4;  // round up to nearest multiple of 4
  510. for( S32 row = 0; row < getHeight(); row++ )
  511. {
  512. for( S32 col = 0; col < getWidth(); col++ )
  513. {
  514. dst[0] = src[2]; // Red
  515. dst[1] = src[1]; // Green
  516. dst[2] = src[0]; // Blue
  517. src += 3;
  518. dst += 3;
  519. }
  520. src += alignment_bytes;
  521. }
  523. return TRUE;
  524. }
  526. BOOL LLImageBMP::encode(const LLImageRaw* raw_image, F32 encode_time)
  527. {
  528. llassert_always(raw_image);
  530. resetLastError();
  532. S32 src_components = raw_image->getComponents();
  533. S32 dst_components =  ( src_components < 3 ) ? 1 : 3;
  535. if( (2 == src_components) || (4 == src_components) )
  536. {
  537. llinfos << "Dropping alpha information during BMP encoding" << llendl;
  538. }
  540. setSize(raw_image->getWidth(), raw_image->getHeight(), dst_components);
  542. U8 magic[14];
  543. LLBMPHeader header;
  544. int header_bytes = 14+sizeof(header);
  545. llassert(header_bytes == 54);
  546. if (getComponents() == 1)
  547. {
  548. header_bytes += 1024; // Need colour LUT.
  549. }
  550. int line_bytes = getComponents() * getWidth();
  551. int alignment_bytes = (3 * line_bytes) % 4;
  552. line_bytes += alignment_bytes;
  553. int file_bytes = line_bytes*getHeight() + header_bytes;
  555. // Allocate the new buffer for the data.
  556. if(!allocateData(file_bytes)) //memory allocation failed
  557. {
  558. return FALSE ;
  559. }
  561. magic[0] = 'B'; magic[1] = 'M';
  562. magic[2] = (U8) file_bytes;
  563. magic[3] = (U8)(file_bytes>>8);
  564. magic[4] = (U8)(file_bytes>>16);
  565. magic[5] = (U8)(file_bytes>>24);
  566. magic[6] = magic[7] = magic[8] = magic[9] = 0;
  567. magic[10] = (U8) header_bytes;
  568. magic[11] = (U8)(header_bytes>>8);
  569. magic[12] = (U8)(header_bytes>>16);
  570. magic[13] = (U8)(header_bytes>>24);
  571. header.mSize = 40;
  572. header.mWidth = getWidth();
  573. header.mHeight = getHeight();
  574. header.mPlanes = 1;
  575. header.mBitsPerPixel = (getComponents()==1)?8:24;
  576. header.mCompression = 0;
  577. header.mAlignmentPadding = 0;
  578. header.mImageSize = 0;
  579. #if LL_DARWIN
  580. header.mHorzPelsPerMeter = header.mVertPelsPerMeter = 2834; // 72dpi
  581. #else
  582. header.mHorzPelsPerMeter = header.mVertPelsPerMeter = 0;
  583. #endif
  584. header.mNumColors = header.mNumColorsImportant = 0;
  586. // convert BMP header to little endian (no-op on little endian builds)
  587. llendianswizzleone(header.mSize);
  588. llendianswizzleone(header.mWidth);
  589. llendianswizzleone(header.mHeight);
  590. llendianswizzleone(header.mPlanes);
  591. llendianswizzleone(header.mBitsPerPixel);
  592. llendianswizzleone(header.mCompression);
  593. llendianswizzleone(header.mAlignmentPadding);
  594. llendianswizzleone(header.mImageSize);
  595. llendianswizzleone(header.mHorzPelsPerMeter);
  596. llendianswizzleone(header.mVertPelsPerMeter);
  597. llendianswizzleone(header.mNumColors);
  598. llendianswizzleone(header.mNumColorsImportant);
  600. U8* mdata = getData();
  602. // Output magic, then header, then the palette table, then the data.
  603. U32 cur_pos = 0;
  604. memcpy(mdata, magic, 14);
  605. cur_pos += 14;
  606. memcpy(mdata+cur_pos, &header, 40); /* Flawfinder: ignore */
  607. cur_pos += 40;
  608. if (getComponents() == 1)
  609. {
  610. S32 n;
  611. for (n=0; n < 256; n++)
  612. {
  613. mdata[cur_pos++] = (U8)n;
  614. mdata[cur_pos++] = (U8)n;
  615. mdata[cur_pos++] = (U8)n;
  616. mdata[cur_pos++] = 0;
  617. }
  618. }
  620. // Need to iterate through, because we need to flip the RGB.
  621. const U8* src = raw_image->getData();
  622. U8* dst = mdata + cur_pos;
  624. for( S32 row = 0; row < getHeight(); row++ )
  625. {
  626. for( S32 col = 0; col < getWidth(); col++ )
  627. {
  628. switch( src_components )
  629. {
  630. case 1:
  631. *dst++ = *src++;
  632. break;
  633. case 2:
  634. {
  635. U32 lum = src[0];
  636. U32 alpha = src[1];
  637. *dst++ = (U8)(lum * alpha / 255);
  638. src += 2;
  639. break;
  640. }
  641. case 3:
  642. case 4:
  643. dst[0] = src[2];
  644. dst[1] = src[1];
  645. dst[2] = src[0];
  646. src += src_components;
  647. dst += 3;
  648. break;
  649. }
  651. }
  652. for( S32 i = 0; i < alignment_bytes; i++ )
  653. {
  654. *dst++ = 0;
  655. }
  656. }
  658. return TRUE;
  659. }