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

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

游戏引擎

开发平台：

C++ Builder

llimagetga.cpp：源码内容
  1. /** 
  2.  * @file llimagetga.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 "llimagetga.h"
  36. #include "lldir.h"
  37. #include "llerror.h"
  38. #include "llmath.h"
  39. #include "llpointer.h"
  41. // For expanding 5-bit pixel values to 8-bit with best rounding
  42. // static
  43. const U8 LLImageTGA::s5to8bits[32] = 
  44. {
  45. 0,   8,  16,  25,  33,  41,  49,  58,
  46.    66,  74,  82,  90,  99, 107, 115, 123,
  47.   132, 140, 148, 156, 165, 173, 181, 189,
  48.   197, 206, 214, 222, 230, 239, 247, 255
  49. };
  51. inline void LLImageTGA::decodeTruecolorPixel15( U8* dst, const U8* src )
  52. {
  53.     // We expand 5 bit data to 8 bit sample width.
  54.     // The format of the 16-bit (LSB first) input word is
  55.     // xRRRRRGGGGGBBBBB
  56. U32 t = U32(src[0]) + (U32(src[1]) << 8);
  57.     dst[2] = s5to8bits[t & 0x1F];  // blue
  58.     t >>= 5;
  59.     dst[1] = s5to8bits[t & 0x1F];  // green
  60.     t >>= 5;
  61.     dst[0] = s5to8bits[t & 0x1F];  // red
  62. }
  64. LLImageTGA::LLImageTGA() 
  65. : LLImageFormatted(IMG_CODEC_TGA),
  66.   mColorMap( NULL ),
  67.   mColorMapStart( 0 ),
  68.   mColorMapLength( 0 ),
  69.   mColorMapBytesPerEntry( 0 ),
  70.   mIs15Bit( FALSE ),
  72.   mAttributeBits(0),
  73.   mColorMapDepth(0),
  74.   mColorMapIndexHi(0),
  75.   mColorMapIndexLo(0),
  76.   mColorMapLengthHi(0),
  77.   mColorMapLengthLo(0),
  78.   mColorMapType(0),
  79.   mDataOffset(0),
  80.   mHeightHi(0),
  81.   mHeightLo(0),
  82.   mIDLength(0),
  83.   mImageType(0),
  84.   mInterleave(0),
  85.   mOriginRightBit(0),
  86.   mOriginTopBit(0),
  87.   mPixelSize(0),
  88.   mWidthHi(0),
  89.   mWidthLo(0),
  90.   mXOffsetHi(0),
  91.   mXOffsetLo(0),
  92.   mYOffsetHi(0),
  93.   mYOffsetLo(0)
  94. {
  95. }
  97. LLImageTGA::LLImageTGA(const std::string& file_name) 
  98. : LLImageFormatted(IMG_CODEC_TGA),
  99.   mColorMap( NULL ),
  100.   mColorMapStart( 0 ),
  101.   mColorMapLength( 0 ),
  102.   mColorMapBytesPerEntry( 0 ),
  103.   mIs15Bit( FALSE )
  104. {
  105. loadFile(file_name);
  106. }
  108. LLImageTGA::~LLImageTGA()
  109. {
  110. delete [] mColorMap;
  111. }
  113. BOOL LLImageTGA::updateData()
  114. {
  115. resetLastError();
  117. // Check to make sure that this instance has been initialized with data
  118. if (!getData() || (0 == getDataSize()))
  119. {
  120. setLastError("LLImageTGA uninitialized");
  121. return FALSE;
  122. }
  124. // Pull image information from the header...
  125. U8 flags;
  126. U8 junk[256];
  128. /****************************************************************************
  129. **
  130. ** For more information about the original Truevision TGA(tm) file format,
  131. ** or for additional information about the new extensions to the
  132. ** Truevision TGA file, refer to the "Truevision TGA File Format
  133. ** Specification Version 2.0" available from Truevision or your
  134. ** Truevision dealer.
  135. **
  136. **  FILE STRUCTURE FOR THE ORIGINAL TRUEVISION TGA FILE
  137. **   FIELD 1 : NUMBER OF CHARACTERS IN ID FIELD (1 BYTES)
  138. **   FIELD 2 : COLOR MAP TYPE (1 BYTES)
  139. **   FIELD 3 : IMAGE TYPE CODE (1 BYTES)
  140. ** = 0 NO IMAGE DATA INCLUDED
  141. ** = 1 UNCOMPRESSED, COLOR-MAPPED IMAGE
  142. ** = 2 UNCOMPRESSED, TRUE-COLOR IMAGE
  143. ** = 3 UNCOMPRESSED, BLACK AND WHITE IMAGE
  144. ** = 9 RUN-LENGTH ENCODED COLOR-MAPPED IMAGE
  145. ** = 10 RUN-LENGTH ENCODED TRUE-COLOR IMAGE
  146. ** = 11 RUN-LENGTH ENCODED BLACK AND WHITE IMAGE
  147. **   FIELD 4 : COLOR MAP SPECIFICATION (5 BYTES)
  148. ** 4.1 : COLOR MAP ORIGIN (2 BYTES)
  149. ** 4.2 : COLOR MAP LENGTH (2 BYTES)
  150. ** 4.3 : COLOR MAP ENTRY SIZE (2 BYTES)
  151. **   FIELD 5 : IMAGE SPECIFICATION (10 BYTES)
  152. ** 5.1 : X-ORIGIN OF IMAGE (2 BYTES)
  153. ** 5.2 : Y-ORIGIN OF IMAGE (2 BYTES)
  154. ** 5.3 : WIDTH OF IMAGE (2 BYTES)
  155. ** 5.4 : HEIGHT OF IMAGE (2 BYTES)
  156. ** 5.5 : IMAGE PIXEL SIZE (1 BYTE)
  157. ** 5.6 : IMAGE DESCRIPTOR BYTE (1 BYTE) 
  158. **   FIELD 6 : IMAGE ID FIELD (LENGTH SPECIFIED BY FIELD 1)
  159. **   FIELD 7 : COLOR MAP DATA (BIT WIDTH SPECIFIED BY FIELD 4.3 AND
  160. ** NUMBER OF COLOR MAP ENTRIES SPECIFIED IN FIELD 4.2)
  161. **   FIELD 8 : IMAGE DATA FIELD (WIDTH AND HEIGHT SPECIFIED IN
  162. ** FIELD 5.3 AND 5.4)
  163. ****************************************************************************/
  165. mDataOffset = 0;
  166. mIDLength = *(getData()+mDataOffset++);
  167. mColorMapType = *(getData()+mDataOffset++);
  168. mImageType = *(getData()+mDataOffset++);
  169. mColorMapIndexLo = *(getData()+mDataOffset++);
  170. mColorMapIndexHi = *(getData()+mDataOffset++);
  171. mColorMapLengthLo = *(getData()+mDataOffset++);
  172. mColorMapLengthHi = *(getData()+mDataOffset++);
  173. mColorMapDepth = *(getData()+mDataOffset++);
  174. mXOffsetLo = *(getData()+mDataOffset++);
  175. mXOffsetHi = *(getData()+mDataOffset++);
  176. mYOffsetLo = *(getData()+mDataOffset++);
  177. mYOffsetHi = *(getData()+mDataOffset++);
  178. mWidthLo = *(getData()+mDataOffset++);
  179. mWidthHi = *(getData()+mDataOffset++);
  180. mHeightLo = *(getData()+mDataOffset++);
  181. mHeightHi = *(getData()+mDataOffset++);
  182. mPixelSize = *(getData()+mDataOffset++);
  183. flags = *(getData()+mDataOffset++);
  184. mAttributeBits = flags & 0xf;
  185. mOriginRightBit = (flags & 0x10) >> 4;
  186. mOriginTopBit = (flags & 0x20) >> 5;
  187. mInterleave = (flags & 0xc0) >> 6;
  189. switch( mImageType )
  190. {
  191. case 0:
  192. // No image data included in file
  193. setLastError("Unable to load file.  TGA file contains no image data.");
  194. return FALSE;
  195. case 1:
  196. // Colormapped uncompressed
  197. if( 8 != mPixelSize )
  198. {
  199. setLastError("Unable to load file.  Colormapped images must have 8 bits per pixel.");
  200. return FALSE;
  201. }
  202. break;
  203. case 2:
  204. // Truecolor uncompressed
  205. break;
  206. case 3:
  207. // Monochrome uncompressed
  208. if( 8 != mPixelSize )
  209. {
  210. setLastError("Unable to load file.  Monochrome images must have 8 bits per pixel.");
  211. return FALSE;
  212. }
  213. break;
  214. case 9:
  215. // Colormapped, RLE
  216. break;
  217. case 10:
  218. // Truecolor, RLE
  219. break;
  220. case 11:
  221. // Monochrome, RLE
  222. if( 8 != mPixelSize )
  223. {
  224. setLastError("Unable to load file.  Monochrome images must have 8 bits per pixel.");
  225. return FALSE;
  226. }
  227. break;
  228. default:
  229. setLastError("Unable to load file.  Unrecoginzed TGA image type.");
  230. return FALSE;
  231. }
  233. // discard the ID field, if any
  234. if (mIDLength)
  235. {
  236. memcpy(junk, getData()+mDataOffset, mIDLength); /* Flawfinder: ignore */
  237. mDataOffset += mIDLength;
  238. }
  240. // check to see if there's a colormap since even rgb files can have them
  241. S32 color_map_bytes = 0;
  242. if( (1 == mColorMapType) && (mColorMapDepth > 0) )
  243. {
  244. mColorMapStart = (S32(mColorMapIndexHi) << 8) + mColorMapIndexLo;
  245. mColorMapLength = (S32(mColorMapLengthHi) << 8) + mColorMapLengthLo;
  247. if( mColorMapDepth > 24 )
  248. {
  249. mColorMapBytesPerEntry = 4;
  250. }
  251. else
  252. if( mColorMapDepth > 16 )
  253. {
  254. mColorMapBytesPerEntry = 3;
  255. }
  256. else
  257. if( mColorMapDepth > 8 )
  258. {
  259. mColorMapBytesPerEntry = 2;
  260. }
  261. else
  262. {
  263. mColorMapBytesPerEntry = 1;
  264. }
  265. color_map_bytes = mColorMapLength * mColorMapBytesPerEntry;
  267. // Note: although it's legal for TGA files to have color maps and not use them
  268. // (some programs actually do this and use the color map for other ends), we'll
  269. // only allocate memory for one if _we_ intend to use it.
  270. if ( (1 == mImageType) || (9 == mImageType)  )
  271. {
  272. mColorMap = new U8[ color_map_bytes ];  
  273. if (!mColorMap)
  274. {
  275. llerrs << "Out of Memory in BOOL LLImageTGA::updateData()" << llendl;
  276. return FALSE;
  277. }
  278. memcpy( mColorMap, getData() + mDataOffset, color_map_bytes ); /* Flawfinder: ignore */
  279. }
  281. mDataOffset += color_map_bytes;
  282. }
  284. // heights are read as bytes to prevent endian problems
  285. S32 height = (S32(mHeightHi) << 8) + mHeightLo;
  286. S32 width = (S32(mWidthHi) << 8) + mWidthLo;
  288. // make sure that it's a pixel format that we understand
  289. S32 bits_per_pixel;
  290. if( mColorMap )
  291. {
  292. bits_per_pixel = mColorMapDepth;
  293. }
  294. else
  295. {
  296. bits_per_pixel = mPixelSize;
  297. }
  299. S32 components;
  300. switch(bits_per_pixel)
  301. {
  302. case 24:
  303. components = 3;
  304. break;
  305. case 32:
  306. components = 4;
  307. // Don't enforce this.  ACDSee doesn't bother to set the attributes bits correctly. Arrgh!
  308. // if( mAttributeBits != 8 )
  309. // {
  310. // setLastError("Unable to load file. 32 bit TGA image does not have 8 bits of alpha.");
  311. // return FALSE;
  312. // }
  313. mAttributeBits = 8;
  314. break;
  315. case 15:
  316. case 16:
  317. components = 3;
  318. mIs15Bit = TRUE;  // 16th bit is used for Targa hardware interupts and is ignored.
  319. break;
  320. case 8:
  321. components = 1;
  322. break;
  323. default:
  324. setLastError("Unable to load file. Unknown pixel size.");
  325. return FALSE;
  326. }
  327. setSize(width, height, components);
  329. return TRUE;
  330. }
  332. BOOL LLImageTGA::decode(LLImageRaw* raw_image, F32 decode_time)
  333. {
  334. llassert_always(raw_image);
  336. // Check to make sure that this instance has been initialized with data
  337. if (!getData() || (0 == getDataSize()))
  338. {
  339. setLastError("LLImageTGA trying to decode an image with no data!");
  340. return FALSE;
  341. }
  343. // Copy everything after the header.
  345. raw_image->resize(getWidth(), getHeight(), getComponents());
  347. if( (getComponents() != 1) &&
  348. (getComponents() != 3) &&
  349. (getComponents() != 4) )
  350. {
  351. setLastError("TGA images with a number of components other than 1, 3, and 4 are not supported.");
  352. return FALSE;
  353. }
  356. if( mOriginRightBit )
  357. {
  358. setLastError("TGA images with origin on right side are not supported.");
  359. return FALSE;
  360. }
  362. BOOL flipped = (mOriginTopBit != 0);
  363. BOOL rle_compressed = ((mImageType & 0x08) != 0);
  365. if( mColorMap )
  366. {
  367. return decodeColorMap( raw_image, rle_compressed, flipped );
  368. }
  369. else
  370. {
  371. return decodeTruecolor( raw_image, rle_compressed, flipped );
  372. }
  373. }
  375. BOOL LLImageTGA::decodeTruecolor( LLImageRaw* raw_image, BOOL rle, BOOL flipped )
  376. {
  377. BOOL success = FALSE;
  378. BOOL alpha_opaque = FALSE;
  379. if( rle )
  380. {
  382. switch( getComponents() )
  383. {
  384. case 1:
  385. success = decodeTruecolorRle8( raw_image );
  386. break;
  387. case 3:
  388. if( mIs15Bit )
  389. {
  390. success = decodeTruecolorRle15( raw_image );
  391. }
  392. else
  393. {
  394. success = decodeTruecolorRle24( raw_image );
  395. }
  396. break;
  397. case 4:
  398. success = decodeTruecolorRle32( raw_image, alpha_opaque );
  399. if (alpha_opaque)
  400. {
  401. // alpha was entirely opaque
  402. // convert to 24 bit image
  403. LLPointer<LLImageRaw> compacted_image = new LLImageRaw(raw_image->getWidth(), raw_image->getHeight(), 3);
  404. compacted_image->copy(raw_image);
  405. raw_image->resize(raw_image->getWidth(), raw_image->getHeight(), 3);
  406. raw_image->copy(compacted_image);
  407. }
  408. break;
  409. }
  410. }
  411. else
  412. {
  413. BOOL alpha_opaque;
  414. success = decodeTruecolorNonRle( raw_image, alpha_opaque );
  415. if (alpha_opaque && raw_image->getComponents() == 4)
  416. {
  417. // alpha was entirely opaque
  418. // convert to 24 bit image
  419. LLPointer<LLImageRaw> compacted_image = new LLImageRaw(raw_image->getWidth(), raw_image->getHeight(), 3);
  420. compacted_image->copy(raw_image);
  421. raw_image->resize(raw_image->getWidth(), raw_image->getHeight(), 3);
  422. raw_image->copy(compacted_image);
  423. }
  424. }
  426. if( success && flipped )
  427. {
  428. // This works because the Targa definition requires that RLE blocks never
  429. // encode pixels from more than one scanline.
  430. // (On the other hand, it's not as fast as writing separate flipped versions as 
  431. // we did with TruecolorNonRle.)
  432. raw_image->verticalFlip();
  433. }
  435. return success;
  436. }
  439. BOOL LLImageTGA::decodeTruecolorNonRle( LLImageRaw* raw_image, BOOL &alpha_opaque )
  440. {
  441. alpha_opaque = TRUE;
  443. // Origin is the bottom left
  444. U8* dst = raw_image->getData();
  445. U8* src = getData() + mDataOffset;
  446. S32 pixels = getWidth() * getHeight();
  448. if (getComponents() == 4)
  449. {
  450. while( pixels-- )
  451. {
  452. // Our data is stored in RGBA.  TGA stores them as BGRA (little-endian ARGB)
  453. dst[0] = src[2]; // Red
  454. dst[1] = src[1]; // Green
  455. dst[2] = src[0]; // Blue
  456. dst[3] = src[3]; // Alpha
  457. if (dst[3] != 255)
  458. {
  459. alpha_opaque = FALSE;
  460. }
  461. dst += 4;
  462. src += 4;
  463. }
  464. }
  465. else if (getComponents() == 3)
  466. {
  467. if( mIs15Bit )
  468. {
  469. while( pixels-- )
  470. {
  471. decodeTruecolorPixel15( dst, src );
  472. dst += 3;
  473. src += 2;
  474. }
  475. }
  476. else
  477. {
  478. while( pixels-- )
  479. {
  480. dst[0] = src[2]; // Red
  481. dst[1] = src[1]; // Green
  482. dst[2] = src[0]; // Blue
  483. dst += 3;
  484. src += 3;
  485. }
  486. }
  487. }
  488. else if (getComponents() == 1)
  489. {
  490. memcpy(dst, src, pixels); /* Flawfinder: ignore */
  491. }
  493. return TRUE;
  494. }
  496. void LLImageTGA::decodeColorMapPixel8( U8* dst, const U8* src )
  497. {
  498. S32 index = llclamp( *src - mColorMapStart, 0, mColorMapLength - 1 );
  499. dst[0] = mColorMap[ index ];
  500. }
  502. void LLImageTGA::decodeColorMapPixel15( U8* dst, const U8* src )
  503. {
  504. S32 index = llclamp( *src - mColorMapStart, 0, mColorMapLength - 1 );
  505. decodeTruecolorPixel15( dst, mColorMap + 2 * index );
  506. }
  508. void LLImageTGA::decodeColorMapPixel24( U8* dst, const U8* src )
  509. {
  510. S32 index = 3 * llclamp( *src - mColorMapStart, 0, mColorMapLength - 1 );
  511. dst[0] = mColorMap[ index + 2 ]; // Red
  512. dst[1] = mColorMap[ index + 1 ]; // Green
  513. dst[2] = mColorMap[ index + 0 ]; // Blue
  514. }
  516. void LLImageTGA::decodeColorMapPixel32( U8* dst, const U8* src )
  517. {
  518. S32 index = 4 * llclamp( *src - mColorMapStart, 0, mColorMapLength - 1 );
  519. dst[0] = mColorMap[ index + 2 ]; // Red
  520. dst[1] = mColorMap[ index + 1 ]; // Green
  521. dst[2] = mColorMap[ index + 0 ]; // Blue
  522. dst[3] = mColorMap[ index + 3 ]; // Alpha
  523. }
  526. BOOL LLImageTGA::decodeColorMap( LLImageRaw* raw_image, BOOL rle, BOOL flipped )
  527. {
  528. // If flipped, origin is the top left.  Need to reverse the order of the rows.
  529. // Otherwise the origin is the bottom left.
  531. if( 8 != mPixelSize )
  532. {
  533. return FALSE;
  534. }
  536. U8* src = getData() + mDataOffset;
  537. U8* dst = raw_image->getData(); // start from the top
  539. void (LLImageTGA::*pixel_decoder)( U8*, const U8* );
  541. switch( mColorMapBytesPerEntry )
  542. {
  543. case 1: pixel_decoder = &LLImageTGA::decodeColorMapPixel8;  break;
  544. case 2: pixel_decoder = &LLImageTGA::decodeColorMapPixel15; break;
  545. case 3: pixel_decoder = &LLImageTGA::decodeColorMapPixel24; break;
  546. case 4: pixel_decoder = &LLImageTGA::decodeColorMapPixel32; break;
  547. default: llassert(0); return FALSE;
  548. }
  550. if( rle )
  551. {
  552. U8* last_dst = dst + getComponents() * (getHeight() * getWidth() - 1);
  553. while( dst <= last_dst )
  554. {
  555. // Read RLE block header
  556. U8 block_header_byte = *src;
  557. src++;
  559. U8 block_pixel_count = (block_header_byte & 0x7F) + 1;
  560. if( block_header_byte & 0x80 )
  561. {
  562. // Encoded (duplicate-pixel) block
  563. do
  564. {
  565. (this->*pixel_decoder)( dst, src );
  566. dst += getComponents();
  567. block_pixel_count--;
  568. }
  569. while( block_pixel_count > 0 );
  570. src++;
  571. }
  572. else 
  573. {
  574. // Unencoded block
  575. do
  576. {
  577. (this->*pixel_decoder)( dst, src );
  578. dst += getComponents();
  579. src++;
  580. block_pixel_count--;
  581. }
  582. while( block_pixel_count > 0 );
  583. }
  584. }
  586. raw_image->verticalFlip();
  587. }
  588. else
  589. {
  590. S32 src_row_bytes = getWidth();
  591. S32 dst_row_bytes = getWidth() * getComponents();
  593. if( flipped )
  594. {
  595. U8* src_last_row_start = src + (getHeight() - 1) * src_row_bytes;
  596. src = src_last_row_start; // start from the bottom
  597. src_row_bytes *= -1;
  598. }
  601. S32 i;
  602. S32 j;
  604. for( S32 row = 0; row < getHeight(); row++ )
  605. {
  606. for( i = 0, j = 0; j < getWidth(); i += getComponents(), j++ )
  607. {
  608. (this->*pixel_decoder)( dst + i, src + j );
  609. }
  611. dst += dst_row_bytes;
  612. src += src_row_bytes;
  613. }
  614. }
  616. return TRUE;
  617. }
  621. BOOL LLImageTGA::encode(const LLImageRaw* raw_image, F32 encode_time)
  622. {
  623. llassert_always(raw_image);
  625. deleteData();
  627. setSize(raw_image->getWidth(), raw_image->getHeight(), raw_image->getComponents());
  629. // Data from header
  630. mIDLength = 0; // Length of identifier string
  631. mColorMapType = 0; // 0 = No Map
  633. // Supported: 2 = Uncompressed true color, 3 = uncompressed monochrome without colormap
  634. switch( getComponents() )
  635. {
  636. case 1:
  637. mImageType = 3;
  638. break;
  639. case 2:  // Interpret as intensity plus alpha
  640. case 3:
  641. case 4:
  642. mImageType = 2;
  643. break;
  644. default:
  645. return FALSE;
  646. }
  648. // Color map stuff (unsupported)
  649. mColorMapIndexLo = 0; // First color map entry (low order byte)
  650. mColorMapIndexHi = 0; // First color map entry (high order byte)
  651. mColorMapLengthLo = 0; // Color map length (low order byte)
  652. mColorMapLengthHi = 0; // Color map length (high order byte)
  653. mColorMapDepth = 0; // Size of color map entry (15, 16, 24, or 32 bits)
  655. // Image offset relative to origin.
  656. mXOffsetLo = 0; // X offset from origin (low order byte)
  657. mXOffsetHi = 0; // X offset from origin (hi order byte)
  658. mYOffsetLo = 0; // Y offset from origin (low order byte)
  659. mYOffsetHi = 0; // Y offset from origin (hi order byte)
  661. // Height and width
  662. mWidthLo = U8(getWidth() & 0xFF); // Width (low order byte)
  663. mWidthHi = U8((getWidth() >> 8) & 0xFF); // Width (hi order byte)
  664. mHeightLo = U8(getHeight() & 0xFF); // Height (low order byte)
  665. mHeightHi = U8((getHeight() >> 8) & 0xFF); // Height (hi order byte)
  667. S32 bytes_per_pixel;
  668. switch( getComponents() )
  669. {
  670. case 1:
  671. bytes_per_pixel = 1;
  672. break;
  673. case 3:
  674. bytes_per_pixel = 3;
  675. break;
  676. case 2:  // Interpret as intensity plus alpha.  Store as RGBA.
  677. case 4:
  678. bytes_per_pixel = 4;
  679. break;
  680. default:
  681. return FALSE;
  682. }
  683. mPixelSize = U8(bytes_per_pixel * 8); // 8, 16, 24, 32 bits per pixel
  685. mAttributeBits = (4 == bytes_per_pixel) ? 8 : 0; // 4 bits: number of attribute bits (alpha) per pixel
  686. mOriginRightBit = 0; // 1 bit: origin, 0 = left, 1 = right
  687. mOriginTopBit = 0; // 1 bit: origin, 0 = bottom, 1 = top
  688. mInterleave = 0; // 2 bits: interleaved flag, 0 = none, 1 = interleaved 2, 2 = interleaved 4
  691. const S32 TGA_HEADER_SIZE = 18;
  692. const S32 COLOR_MAP_SIZE = 0;
  693. mDataOffset = TGA_HEADER_SIZE + mIDLength + COLOR_MAP_SIZE; // Offset from start of data to the actual header.
  695. S32 pixels = getWidth() * getHeight();
  696. S32 datasize = mDataOffset + bytes_per_pixel * pixels;
  697. U8* dst = allocateData(datasize);
  699. // Write header
  700. *(dst++) = mIDLength;
  701. *(dst++) = mColorMapType;
  702. *(dst++) = mImageType;
  703. *(dst++) = mColorMapIndexLo;
  704. *(dst++) = mColorMapIndexHi;
  705. *(dst++) = mColorMapLengthLo;
  706. *(dst++) = mColorMapLengthHi;
  707. *(dst++) = mColorMapDepth;
  708. *(dst++) = mXOffsetLo;
  709. *(dst++) = mXOffsetHi;
  710. *(dst++) = mYOffsetLo;
  711. *(dst++) = mYOffsetHi;
  712. *(dst++) = mWidthLo;
  713. *(dst++) = mWidthHi;
  714. *(dst++) = mHeightLo;
  715. *(dst++) = mHeightHi;
  716. *(dst++) = mPixelSize;
  717. *(dst++) =
  718. ((mInterleave & 3) << 5) |
  719. ((mOriginTopBit & 1) << 4) |
  720. ((mOriginRightBit & 1) << 3) |
  721. ((mAttributeBits & 0xF) << 0);
  723. // Write pixels
  724. const U8* src = raw_image->getData();
  725. llassert( dst == getData() + mDataOffset );
  726. S32 i = 0;
  727. S32 j = 0;
  728. switch( getComponents() )
  729. {
  730. case 1:
  731. memcpy( dst, src, bytes_per_pixel * pixels ); /* Flawfinder: ignore */
  732. break;
  734. case 2:
  735. while( pixels-- )
  736. {
  737. dst[i + 0] = src[j + 0]; // intensity
  738. dst[i + 1] = src[j + 0]; // intensity
  739. dst[i + 2] = src[j + 0]; // intensity
  740. dst[i + 3] = src[j + 1]; // alpha
  741. i += 4;
  742. j += 2;
  743. }
  744. break;
  746. case 3:
  747. while( pixels-- )
  748. {
  749. dst[i + 0] = src[i + 2]; // blue
  750. dst[i + 1] = src[i + 1]; // green
  751. dst[i + 2] = src[i + 0]; // red
  752. i += 3;
  753. }
  754. break;
  756. case 4:
  757. while( pixels-- )
  758. {
  759. dst[i + 0] = src[i + 2]; // blue
  760. dst[i + 1] = src[i + 1]; // green
  761. dst[i + 2] = src[i + 0]; // red
  762. dst[i + 3] = src[i + 3]; // alpha
  763. i += 4;
  764. }
  765. break;
  766. }
  768. return TRUE;
  769. }
  771. BOOL LLImageTGA::decodeTruecolorRle32( LLImageRaw* raw_image, BOOL &alpha_opaque )
  772. {
  773. llassert( getComponents() == 4 );
  774. alpha_opaque = TRUE;
  776. U8* dst = raw_image->getData();
  777. U32* dst_pixels = (U32*) dst;
  779. U8* src = getData() + mDataOffset;
  780. U8* last_src = src + getDataSize();
  782. U32 rgba;
  783. U8* rgba_byte_p = (U8*) &rgba;
  785. U32* last_dst_pixel = dst_pixels + getHeight() * getWidth() - 1;
  786. while( dst_pixels <= last_dst_pixel )
  787. {
  788. // Read RLE block header
  790. if (src >= last_src)
  791. return FALSE;
  793. U8 block_header_byte = *src;
  794. src++;
  796. U32 block_pixel_count = (block_header_byte & 0x7F) + 1;
  797. if( block_header_byte & 0x80 )
  798. {
  799. // Encoded (duplicate-pixel) block
  801. if (src + 3 >= last_src)
  802. return FALSE;
  804. rgba_byte_p[0] = src[2];
  805. rgba_byte_p[1] = src[1];
  806. rgba_byte_p[2] = src[0];
  807. rgba_byte_p[3] = src[3];
  808. if (rgba_byte_p[3] != 255)
  809. {
  810. alpha_opaque = FALSE;
  811. }
  813. src += 4;
  814. register U32 value = rgba;
  815. do
  816. {
  817. *dst_pixels = value;
  818. dst_pixels++;
  819. block_pixel_count--;
  820. }
  821. while( block_pixel_count > 0 );
  822. }
  823. else 
  824. {
  825. // Unencoded block
  826. do
  827. {
  828. if (src + 3 >= last_src)
  829. return FALSE;
  831. ((U8*)dst_pixels)[0] = src[2];
  832. ((U8*)dst_pixels)[1] = src[1];
  833. ((U8*)dst_pixels)[2] = src[0];
  834. ((U8*)dst_pixels)[3] = src[3];
  835. if (src[3] != 255)
  836. {
  837. alpha_opaque = FALSE;
  838. }
  839. src += 4;
  840. dst_pixels++;
  841. block_pixel_count--;
  842. }
  843. while( block_pixel_count > 0 );
  844. }
  845. }
  847. return TRUE; 
  848. }
  850. BOOL LLImageTGA::decodeTruecolorRle15( LLImageRaw* raw_image )
  851. {
  852. llassert( getComponents() == 3 );
  853. llassert( mIs15Bit );
  855. U8* dst = raw_image->getData();
  856. U8* src = getData() + mDataOffset;
  858. U8* last_src = src + getDataSize();
  859. U8* last_dst = dst + getComponents() * (getHeight() * getWidth() - 1);
  861. while( dst <= last_dst )
  862. {
  863. // Read RLE block header
  865. if (src >= last_src)
  866. return FALSE;
  868. U8 block_header_byte = *src;
  869. src++;
  871. U8 block_pixel_count = (block_header_byte & 0x7F) + 1;
  872. if( block_header_byte & 0x80 )
  873. {
  874. // Encoded (duplicate-pixel) block
  875. do
  876. {
  877. if (src + 2 >= last_src)
  878. return FALSE;
  880. decodeTruecolorPixel15( dst, src );   // slow
  881. dst += 3;
  882. block_pixel_count--;
  883. }
  884. while( block_pixel_count > 0 );
  885. src += 2;
  886. }
  887. else 
  888. {
  889. // Unencoded block
  890. do
  891. {
  892. if (src + 2 >= last_src)
  893. return FALSE;
  895. decodeTruecolorPixel15( dst, src );
  896. dst += 3;
  897. src += 2;
  898. block_pixel_count--;
  899. }
  900. while( block_pixel_count > 0 );
  901. }
  902. }
  904. return TRUE;
  905. }
  909. BOOL LLImageTGA::decodeTruecolorRle24( LLImageRaw* raw_image )
  910. {
  911. llassert( getComponents() == 3 );
  913. U8* dst = raw_image->getData();
  914. U8* src = getData() + mDataOffset;
  916. U8* last_src = src + getDataSize();
  917. U8* last_dst = dst + getComponents() * (getHeight() * getWidth() - 1);
  919. while( dst <= last_dst )
  920. {
  921. // Read RLE block header
  923. if (src >= last_src)
  924. return FALSE;
  926. U8 block_header_byte = *src;
  927. src++;
  929. U8 block_pixel_count = (block_header_byte & 0x7F) + 1;
  930. if( block_header_byte & 0x80 )
  931. {
  932. // Encoded (duplicate-pixel) block
  933. do
  934. {
  935. if (src + 2 >= last_src)
  936. return FALSE;
  937. dst[0] = src[2];
  938. dst[1] = src[1];
  939. dst[2] = src[0];
  940. dst += 3;
  941. block_pixel_count--;
  942. }
  943. while( block_pixel_count > 0 );
  944. src += 3;
  945. }
  946. else 
  947. {
  948. // Unencoded block
  949. do
  950. {
  951. if (src + 2 >= last_src)
  952. return FALSE;
  954. dst[0] = src[2];
  955. dst[1] = src[1];
  956. dst[2] = src[0];
  957. dst += 3;
  958. src += 3;
  959. block_pixel_count--;
  960. }
  961. while( block_pixel_count > 0 );
  962. }
  963. }
  965. return TRUE;
  966. }
  969. BOOL LLImageTGA::decodeTruecolorRle8( LLImageRaw* raw_image )
  970. {
  971. llassert( getComponents() == 1 );
  973. U8* dst = raw_image->getData();
  974. U8* src = getData() + mDataOffset;
  976. U8* last_src = src + getDataSize();
  977. U8* last_dst = dst + getHeight() * getWidth() - 1;
  979. while( dst <= last_dst )
  980. {
  981. // Read RLE block header
  983. if (src >= last_src)
  984. return FALSE;
  986. U8 block_header_byte = *src;
  987. src++;
  989. U8 block_pixel_count = (block_header_byte & 0x7F) + 1;
  990. if( block_header_byte & 0x80 )
  991. {
  992. if (src >= last_src)
  993. return FALSE;
  995. // Encoded (duplicate-pixel) block
  996. memset( dst, *src, block_pixel_count );
  997. dst += block_pixel_count;
  998. src++;
  999. }
  1000. else 
  1001. {
  1002. // Unencoded block
  1003. do
  1004. {
  1005. if (src >= last_src)
  1006. return FALSE;
  1008. *dst = *src;
  1009. dst++;
  1010. src++;
  1011. block_pixel_count--;
  1012. }
  1013. while( block_pixel_count > 0 );
  1014. }
  1015. }
  1017. return TRUE;
  1018. }
  1021. // Decoded and process the image for use in avatar gradient masks.
  1022. // Processing happens during the decode for speed.
  1023. BOOL LLImageTGA::decodeAndProcess( LLImageRaw* raw_image, F32 domain, F32 weight )
  1024. {
  1025. llassert_always(raw_image);
  1027. // "Domain" isn't really the right word.  It refers to the width of the 
  1028. // ramp portion of the function that relates input and output pixel values.
  1029. // A domain of 0 gives a step function.
  1030. // 
  1031. //   |                      /----------------
  1032. //  O|                     / |
  1033. //  u|                    /  |
  1034. //  t|                   /   |
  1035. // p|------------------/    |
  1036. //  u|                  |    | 
  1037. //  t|<---------------->|<-->|
  1038. //  |  "offset"         "domain"
  1039. //   |
  1040. // --+---Input--------------------------------
  1041. //   |
  1043. if (!getData() || (0 == getDataSize()))
  1044. {
  1045. setLastError("LLImageTGA trying to decode an image with no data!");
  1046. return FALSE;
  1047. }
  1049. // Only works for unflipped monochrome RLE images
  1050. if( (getComponents() != 1) || (mImageType != 11) || mOriginTopBit || mOriginRightBit ) 
  1051. {
  1052. llerrs << "LLImageTGA trying to alpha-gradient process an image that's not a standard RLE, one component image" << llendl;
  1053. return FALSE;
  1054. }
  1056. raw_image->resize(getWidth(), getHeight(), getComponents());
  1058. U8* dst = raw_image->getData();
  1059. U8* src = getData() + mDataOffset;
  1060. U8* last_dst = dst + getHeight() * getWidth() - 1;
  1062. if( domain > 0 )
  1063. {
  1064. // Process using a look-up table (lut)
  1065. const S32 LUT_LEN = 256;
  1066. U8 lut[LUT_LEN];
  1067. S32 i;
  1069. F32 scale = 1.f / domain;
  1070. F32 offset = (1.f - domain) * llclampf( 1.f - weight );
  1071. F32 bias = -(scale * offset);
  1073. for( i = 0; i < LUT_LEN; i++ )
  1074. {
  1075. lut[i] = (U8)llclampb( 255.f * ( i/255.f * scale + bias ) );
  1076. }
  1078. while( dst <= last_dst )
  1079. {
  1080. // Read RLE block header
  1081. U8 block_header_byte = *src;
  1082. src++;
  1084. U8 block_pixel_count = (block_header_byte & 0x7F) + 1;
  1085. if( block_header_byte & 0x80 )
  1086. {
  1087. // Encoded (duplicate-pixel) block
  1088. memset( dst, lut[ *src ], block_pixel_count );
  1089. dst += block_pixel_count;
  1090. src++;
  1091. }
  1092. else 
  1093. {
  1094. // Unencoded block
  1095. do
  1096. {
  1097. *dst = lut[ *src ];
  1098. dst++;
  1099. src++;
  1100. block_pixel_count--;
  1101. }
  1102. while( block_pixel_count > 0 );
  1103. }
  1104. }
  1105. }
  1106. else
  1107. {
  1108. // Process using a simple comparison agains a threshold
  1109. const U8 threshold = (U8)(0xFF * llclampf( 1.f - weight ));
  1111. while( dst <= last_dst )
  1112. {
  1113. // Read RLE block header
  1114. U8 block_header_byte = *src;
  1115. src++;
  1117. U8 block_pixel_count = (block_header_byte & 0x7F) + 1;
  1118. if( block_header_byte & 0x80 )
  1119. {
  1120. // Encoded (duplicate-pixel) block
  1121. memset( dst, ((*src >= threshold) ? 0xFF : 0), block_pixel_count );
  1122. dst += block_pixel_count;
  1123. src++;
  1124. }
  1125. else 
  1126. {
  1127. // Unencoded block
  1128. do
  1129. {
  1130. *dst = (*src >= threshold) ? 0xFF : 0;
  1131. dst++;
  1132. src++;
  1133. block_pixel_count--;
  1134. }
  1135. while( block_pixel_count > 0 );
  1136. }
  1137. }
  1138. }
  1139. return TRUE;
  1140. }
  1142. // Reads a .tga file and creates an LLImageTGA with its data.
  1143. bool LLImageTGA::loadFile( const std::string& path )
  1144. {
  1145. S32 len = path.size();
  1146. if( len < 5 )
  1147. {
  1148. return false;
  1149. }
  1151. std::string extension = gDirUtilp->getExtension(path);
  1152. if( "tga" != extension )
  1153. {
  1154. return false;
  1155. }
  1157. LLFILE* file = LLFile::fopen(path, "rb"); /* Flawfinder: ignore */
  1158. if( !file )
  1159. {
  1160. llwarns << "Couldn't open file " << path << llendl;
  1161. return false;
  1162. }
  1164. S32 file_size = 0;
  1165. if (!fseek(file, 0, SEEK_END))
  1166. {
  1167. file_size = ftell(file);
  1168. fseek(file, 0, SEEK_SET);
  1169. }
  1171. U8* buffer = allocateData(file_size);
  1172. S32 bytes_read = fread(buffer, 1, file_size, file);
  1173. if( bytes_read != file_size )
  1174. {
  1175. deleteData();
  1176. llwarns << "Couldn't read file " << path << llendl;
  1177. return false;
  1178. }
  1180. fclose( file );
  1182. if( !updateData() )
  1183. {
  1184. llwarns << "Couldn't decode file " << path << llendl;
  1185. deleteData();
  1186. return false;
  1187. }
  1188. return true;
  1189. }