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

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

游戏引擎

开发平台：

C++ Builder

llimage.cpp：源码内容
  1. /** 
  2.  * @file llimage.cpp
  3.  * @brief Base class for images.
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "linden_common.h"
  35. #include "llimage.h"
  37. #include "llmath.h"
  38. #include "v4coloru.h"
  39. #include "llmemtype.h"
  41. #include "llimagebmp.h"
  42. #include "llimagetga.h"
  43. #include "llimagej2c.h"
  44. #include "llimagejpeg.h"
  45. #include "llimagepng.h"
  46. #include "llimagedxt.h"
  47. #include "llimageworker.h"
  49. //---------------------------------------------------------------------------
  50. // LLImage
  51. //---------------------------------------------------------------------------
  53. //static
  54. std::string LLImage::sLastErrorMessage;
  55. LLMutex* LLImage::sMutex = NULL;
  57. //static
  58. void LLImage::initClass()
  59. {
  60. sMutex = new LLMutex(NULL);
  61. LLImageJ2C::openDSO();
  62. }
  64. //static
  65. void LLImage::cleanupClass()
  66. {
  67. LLImageJ2C::closeDSO();
  68. delete sMutex;
  69. sMutex = NULL;
  70. }
  72. //static
  73. const std::string& LLImage::getLastError()
  74. {
  75. static const std::string noerr("No Error");
  76. return sLastErrorMessage.empty() ? noerr : sLastErrorMessage;
  77. }
  79. //static
  80. void LLImage::setLastError(const std::string& message)
  81. {
  82. LLMutexLock m(sMutex);
  83. sLastErrorMessage = message;
  84. }
  86. //---------------------------------------------------------------------------
  87. // LLImageBase
  88. //---------------------------------------------------------------------------
  90. LLImageBase::LLImageBase()
  91. : mData(NULL),
  92.   mDataSize(0),
  93.   mWidth(0),
  94.   mHeight(0),
  95.   mComponents(0),
  96.   mMemType(LLMemType::MTYPE_IMAGEBASE)
  97. {
  98. mBadBufferAllocation = FALSE ;
  99. }
  101. // virtual
  102. LLImageBase::~LLImageBase()
  103. {
  104. deleteData(); // virtual
  105. }
  107. // virtual
  108. void LLImageBase::dump()
  109. {
  110. llinfos << "LLImageBase mComponents " << mComponents
  111. << " mData " << mData
  112. << " mDataSize " << mDataSize
  113. << " mWidth " << mWidth
  114. << " mHeight " << mHeight
  115. << llendl;
  116. }
  118. // virtual
  119. void LLImageBase::sanityCheck()
  120. {
  121. if (mWidth > MAX_IMAGE_SIZE
  122. || mHeight > MAX_IMAGE_SIZE
  123. || mDataSize > (S32)MAX_IMAGE_DATA_SIZE
  124. || mComponents > (S8)MAX_IMAGE_COMPONENTS
  125. )
  126. {
  127. llerrs << "Failed LLImageBase::sanityCheck "
  128.    << "width " << mWidth
  129.    << "height " << mHeight
  130.    << "datasize " << mDataSize
  131.    << "components " << mComponents
  132.    << "data " << mData
  133.    << llendl;
  134. }
  135. }
  137. BOOL LLImageBase::sSizeOverride = FALSE;
  139. // virtual
  140. void LLImageBase::deleteData()
  141. {
  142. delete[] mData;
  143. mData = NULL;
  144. mDataSize = 0;
  145. }
  147. // virtual
  148. U8* LLImageBase::allocateData(S32 size)
  149. {
  150. LLMemType mt1(mMemType);
  152. if (size < 0)
  153. {
  154. size = mWidth * mHeight * mComponents;
  155. if (size <= 0)
  156. {
  157. llerrs << llformat("LLImageBase::allocateData called with bad dimensions: %dx%dx%d",mWidth,mHeight,mComponents) << llendl;
  158. }
  159. }
  160. else if (size <= 0 || (size > 4096*4096*16 && sSizeOverride == FALSE))
  161. {
  162. llerrs << "LLImageBase::allocateData: bad size: " << size << llendl;
  163. }
  165. if (!mData || size != mDataSize)
  166. {
  167. deleteData(); // virtual
  168. mBadBufferAllocation = FALSE ;
  169. mData = new U8[size];
  170. if (!mData)
  171. {
  172. llwarns << "allocate image data: " << size << llendl;
  173. size = 0 ;
  174. mWidth = mHeight = 0 ;
  175. mBadBufferAllocation = TRUE ;
  176. }
  177. mDataSize = size;
  178. }
  180. return mData;
  181. }
  183. // virtual
  184. U8* LLImageBase::reallocateData(S32 size)
  185. {
  186. LLMemType mt1(mMemType);
  187. U8 *new_datap = new U8[size];
  188. if (!new_datap)
  189. {
  190. llwarns << "Out of memory in LLImageBase::reallocateData" << llendl;
  191. return 0;
  192. }
  193. if (mData)
  194. {
  195. S32 bytes = llmin(mDataSize, size);
  196. memcpy(new_datap, mData, bytes); /* Flawfinder: ignore */
  197. delete[] mData;
  198. }
  199. mData = new_datap;
  200. mDataSize = size;
  201. return mData;
  202. }
  204. const U8* LLImageBase::getData() const
  205. { 
  206. if(mBadBufferAllocation)
  207. {
  208. llerrs << "Bad memory allocation for the image buffer!" << llendl ;
  209. }
  211. return mData; 
  212. } // read only
  214. U8* LLImageBase::getData()
  215. { 
  216. if(mBadBufferAllocation)
  217. {
  218. llerrs << "Bad memory allocation for the image buffer!" << llendl ;
  219. }
  221. return mData; 
  222. }
  224. BOOL LLImageBase::isBufferInvalid()
  225. {
  226. return mBadBufferAllocation || mData == NULL ;
  227. }
  229. void LLImageBase::setSize(S32 width, S32 height, S32 ncomponents)
  230. {
  231. mWidth = width;
  232. mHeight = height;
  233. mComponents = ncomponents;
  234. }
  236. U8* LLImageBase::allocateDataSize(S32 width, S32 height, S32 ncomponents, S32 size)
  237. {
  238. setSize(width, height, ncomponents);
  239. return allocateData(size); // virtual
  240. }
  242. //---------------------------------------------------------------------------
  243. // LLImageRaw
  244. //---------------------------------------------------------------------------
  246. S32 LLImageRaw::sGlobalRawMemory = 0;
  247. S32 LLImageRaw::sRawImageCount = 0;
  249. LLImageRaw::LLImageRaw()
  250. : LLImageBase()
  251. {
  252. mMemType = LLMemType::MTYPE_IMAGERAW;
  253. ++sRawImageCount;
  254. }
  256. LLImageRaw::LLImageRaw(U16 width, U16 height, S8 components)
  257. : LLImageBase()
  258. {
  259. mMemType = LLMemType::MTYPE_IMAGERAW;
  260. llassert( S32(width) * S32(height) * S32(components) <= MAX_IMAGE_DATA_SIZE );
  261. allocateDataSize(width, height, components);
  262. ++sRawImageCount;
  263. }
  265. LLImageRaw::LLImageRaw(U8 *data, U16 width, U16 height, S8 components)
  266. : LLImageBase()
  267. {
  268. mMemType = LLMemType::MTYPE_IMAGERAW;
  269. if(allocateDataSize(width, height, components))
  270. {
  271. memcpy(getData(), data, width*height*components);
  272. }
  273. ++sRawImageCount;
  274. }
  276. LLImageRaw::LLImageRaw(const std::string& filename, bool j2c_lowest_mip_only)
  277. : LLImageBase()
  278. {
  279. createFromFile(filename, j2c_lowest_mip_only);
  280. }
  282. LLImageRaw::~LLImageRaw()
  283. {
  284. // NOTE: ~LLimageBase() call to deleteData() calls LLImageBase::deleteData()
  285. //        NOT LLImageRaw::deleteData()
  286. deleteData();
  287. --sRawImageCount;
  288. }
  290. // virtual
  291. U8* LLImageRaw::allocateData(S32 size)
  292. {
  293. U8* res = LLImageBase::allocateData(size);
  294. sGlobalRawMemory += getDataSize();
  295. return res;
  296. }
  298. // virtual
  299. U8* LLImageRaw::reallocateData(S32 size)
  300. {
  301. sGlobalRawMemory -= getDataSize();
  302. U8* res = LLImageBase::reallocateData(size);
  303. sGlobalRawMemory += getDataSize();
  304. return res;
  305. }
  307. // virtual
  308. void LLImageRaw::deleteData()
  309. {
  310. sGlobalRawMemory -= getDataSize();
  311. LLImageBase::deleteData();
  312. }
  314. void LLImageRaw::setDataAndSize(U8 *data, S32 width, S32 height, S8 components) 
  315. { 
  316. if(data == getData())
  317. {
  318. return ;
  319. }
  321. deleteData();
  323. LLImageBase::setSize(width, height, components) ;
  324. LLImageBase::setDataAndSize(data, width * height * components) ;
  326. sGlobalRawMemory += getDataSize();
  327. }
  329. BOOL LLImageRaw::resize(U16 width, U16 height, S8 components)
  330. {
  331. if ((getWidth() == width) && (getHeight() == height) && (getComponents() == components))
  332. {
  333. return TRUE;
  334. }
  335. // Reallocate the data buffer.
  336. deleteData();
  338. allocateDataSize(width,height,components);
  340. return TRUE;
  341. }
  343. U8 * LLImageRaw::getSubImage(U32 x_pos, U32 y_pos, U32 width, U32 height) const
  344. {
  345. LLMemType mt1(mMemType);
  346. U8 *data = new U8[width*height*getComponents()];
  348. // Should do some simple bounds checking
  349. if (!data)
  350. {
  351. llerrs << "Out of memory in LLImageRaw::getSubImage" << llendl;
  352. return NULL;
  353. }
  355. U32 i;
  356. for (i = y_pos; i < y_pos+height; i++)
  357. {
  358. memcpy(data + i*width*getComponents(), /* Flawfinder: ignore */
  359. getData() + ((y_pos + i)*getWidth() + x_pos)*getComponents(), getComponents()*width);
  360. }
  361. return data;
  362. }
  364. BOOL LLImageRaw::setSubImage(U32 x_pos, U32 y_pos, U32 width, U32 height,
  365.  const U8 *data, U32 stride, BOOL reverse_y)
  366. {
  367. if (!getData())
  368. {
  369. return FALSE;
  370. }
  371. if (!data)
  372. {
  373. return FALSE;
  374. }
  376. // Should do some simple bounds checking
  378. U32 i;
  379. for (i = 0; i < height; i++)
  380. {
  381. const U32 row = reverse_y ? height - 1 - i : i;
  382. const U32 from_offset = row * ((stride == 0) ? width*getComponents() : stride);
  383. const U32 to_offset = (y_pos + i)*getWidth() + x_pos;
  384. memcpy(getData() + to_offset*getComponents(), /* Flawfinder: ignore */
  385. data + from_offset, getComponents()*width);
  386. }
  388. return TRUE;
  389. }
  391. void LLImageRaw::clear(U8 r, U8 g, U8 b, U8 a)
  392. {
  393. llassert( getComponents() <= 4 );
  394. // This is fairly bogus, but it'll do for now.
  395. U8 *pos = getData();
  396. U32 x, y;
  397. for (x = 0; x < getWidth(); x++)
  398. {
  399. for (y = 0; y < getHeight(); y++)
  400. {
  401. *pos = r;
  402. pos++;
  403. if (getComponents() == 1)
  404. {
  405. continue;
  406. }
  407. *pos = g;
  408. pos++;
  409. if (getComponents() == 2)
  410. {
  411. continue;
  412. }
  413. *pos = b;
  414. pos++;
  415. if (getComponents() == 3)
  416. {
  417. continue;
  418. }
  419. *pos = a;
  420. pos++;
  421. }
  422. }
  423. }
  425. // Reverses the order of the rows in the image
  426. void LLImageRaw::verticalFlip()
  427. {
  428. LLMemType mt1(mMemType);
  429. S32 row_bytes = getWidth() * getComponents();
  430. llassert(row_bytes > 0);
  431. std::vector<U8> line_buffer(row_bytes);
  432. S32 mid_row = getHeight() / 2;
  433. for( S32 row = 0; row < mid_row; row++ )
  434. {
  435. U8* row_a_data = getData() + row * row_bytes;
  436. U8* row_b_data = getData() + (getHeight() - 1 - row) * row_bytes;
  437. memcpy( &line_buffer[0], row_a_data,  row_bytes );
  438. memcpy( row_a_data,  row_b_data,  row_bytes );
  439. memcpy( row_b_data,  &line_buffer[0], row_bytes );
  440. }
  441. }
  444. void LLImageRaw::expandToPowerOfTwo(S32 max_dim, BOOL scale_image)
  445. {
  446. // Find new sizes
  447. S32 new_width = MIN_IMAGE_SIZE;
  448. S32 new_height = MIN_IMAGE_SIZE;
  450. while( (new_width < getWidth()) && (new_width < max_dim) )
  451. {
  452. new_width <<= 1;
  453. }
  455. while( (new_height < getHeight()) && (new_height < max_dim) )
  456. {
  457. new_height <<= 1;
  458. }
  460. scale( new_width, new_height, scale_image );
  461. }
  463. void LLImageRaw::contractToPowerOfTwo(S32 max_dim, BOOL scale_image)
  464. {
  465. // Find new sizes
  466. S32 new_width = max_dim;
  467. S32 new_height = max_dim;
  469. while( (new_width > getWidth()) && (new_width > MIN_IMAGE_SIZE) )
  470. {
  471. new_width >>= 1;
  472. }
  474. while( (new_height > getHeight()) && (new_height > MIN_IMAGE_SIZE) )
  475. {
  476. new_height >>= 1;
  477. }
  479. scale( new_width, new_height, scale_image );
  480. }
  482. void LLImageRaw::biasedScaleToPowerOfTwo(S32 max_dim)
  483. {
  484. // Strong bias towards rounding down (to save bandwidth)
  485. // No bias would mean THRESHOLD == 1.5f;
  486. const F32 THRESHOLD = 1.75f; 
  488. // Find new sizes
  489. S32 larger_w = max_dim; // 2^n >= mWidth
  490. S32 smaller_w = max_dim; // 2^(n-1) <= mWidth
  491. while( (smaller_w > getWidth()) && (smaller_w > MIN_IMAGE_SIZE) )
  492. {
  493. larger_w = smaller_w;
  494. smaller_w >>= 1;
  495. }
  496. S32 new_width = ( (F32)getWidth() / smaller_w > THRESHOLD ) ? larger_w : smaller_w;
  499. S32 larger_h = max_dim; // 2^m >= mHeight
  500. S32 smaller_h = max_dim; // 2^(m-1) <= mHeight
  501. while( (smaller_h > getHeight()) && (smaller_h > MIN_IMAGE_SIZE) )
  502. {
  503. larger_h = smaller_h;
  504. smaller_h >>= 1;
  505. }
  506. S32 new_height = ( (F32)getHeight() / smaller_h > THRESHOLD ) ? larger_h : smaller_h;
  509. scale( new_width, new_height );
  510. }
  515. // Calculates (U8)(255*(a/255.f)*(b/255.f) + 0.5f).  Thanks, Jim Blinn!
  516. inline U8 LLImageRaw::fastFractionalMult( U8 a, U8 b )
  517. {
  518. U32 i = a * b + 128;
  519. return U8((i + (i>>8)) >> 8);
  520. }
  523. void LLImageRaw::composite( LLImageRaw* src )
  524. {
  525. LLImageRaw* dst = this;  // Just for clarity.
  527. llassert(3 == src->getComponents());
  528. llassert(3 == dst->getComponents());
  530. if( 3 == dst->getComponents() )
  531. {
  532. if( (src->getWidth() == dst->getWidth()) && (src->getHeight() == dst->getHeight()) )
  533. {
  534. // No scaling needed
  535. if( 3 == src->getComponents() )
  536. {
  537. copyUnscaled( src );  // alpha is one so just copy the data.
  538. }
  539. else
  540. {
  541. compositeUnscaled4onto3( src );
  542. }
  543. }
  544. else
  545. {
  546. if( 3 == src->getComponents() )
  547. {
  548. copyScaled( src );  // alpha is one so just copy the data.
  549. }
  550. else
  551. {
  552. compositeScaled4onto3( src );
  553. }
  554. }
  555. }
  556. }
  558. // Src and dst can be any size.  Src has 4 components.  Dst has 3 components.
  559. void LLImageRaw::compositeScaled4onto3(LLImageRaw* src)
  560. {
  561. LLMemType mt1(mMemType);
  562. llinfos << "compositeScaled4onto3" << llendl;
  564. LLImageRaw* dst = this;  // Just for clarity.
  566. llassert( (4 == src->getComponents()) && (3 == dst->getComponents()) );
  568. S32 temp_data_size = src->getWidth() * dst->getHeight() * src->getComponents();
  569. llassert_always(temp_data_size > 0);
  570. std::vector<U8> temp_buffer(temp_data_size);
  572. // Vertical: scale but no composite
  573. for( S32 col = 0; col < src->getWidth(); col++ )
  574. {
  575. copyLineScaled( src->getData() + (src->getComponents() * col), &temp_buffer[0] + (src->getComponents() * col), src->getHeight(), dst->getHeight(), src->getWidth(), src->getWidth() );
  576. }
  578. // Horizontal: scale and composite
  579. for( S32 row = 0; row < dst->getHeight(); row++ )
  580. {
  581. compositeRowScaled4onto3( &temp_buffer[0] + (src->getComponents() * src->getWidth() * row), dst->getData() + (dst->getComponents() * dst->getWidth() * row), src->getWidth(), dst->getWidth() );
  582. }
  583. }
  586. // Src and dst are same size.  Src has 4 components.  Dst has 3 components.
  587. void LLImageRaw::compositeUnscaled4onto3( LLImageRaw* src )
  588. {
  589. /*
  590. //test fastFractionalMult()
  591. {
  592. U8 i = 255;
  593. U8 j = 255;
  594. do
  595. {
  596. do
  597. {
  598. llassert( fastFractionalMult(i, j) == (U8)(255*(i/255.f)*(j/255.f) + 0.5f) );
  599. } while( j-- );
  600. } while( i-- );
  601. }
  602. */
  604. LLImageRaw* dst = this;  // Just for clarity.
  606. llassert( (3 == src->getComponents()) || (4 == src->getComponents()) );
  607. llassert( (src->getWidth() == dst->getWidth()) && (src->getHeight() == dst->getHeight()) );
  610. U8* src_data = src->getData();
  611. U8* dst_data = dst->getData();
  612. S32 pixels = getWidth() * getHeight();
  613. while( pixels-- )
  614. {
  615. U8 alpha = src_data[3];
  616. if( alpha )
  617. {
  618. if( 255 == alpha )
  619. {
  620. dst_data[0] = src_data[0];
  621. dst_data[1] = src_data[1];
  622. dst_data[2] = src_data[2];
  623. }
  624. else
  625. {
  627. U8 transparency = 255 - alpha;
  628. dst_data[0] = fastFractionalMult( dst_data[0], transparency ) + fastFractionalMult( src_data[0], alpha );
  629. dst_data[1] = fastFractionalMult( dst_data[1], transparency ) + fastFractionalMult( src_data[1], alpha );
  630. dst_data[2] = fastFractionalMult( dst_data[2], transparency ) + fastFractionalMult( src_data[2], alpha );
  631. }
  632. }
  634. src_data += 4;
  635. dst_data += 3;
  636. }
  637. }
  639. // Fill the buffer with a constant color
  640. void LLImageRaw::fill( const LLColor4U& color )
  641. {
  642. S32 pixels = getWidth() * getHeight();
  643. if( 4 == getComponents() )
  644. {
  645. U32* data = (U32*) getData();
  646. for( S32 i = 0; i < pixels; i++ )
  647. {
  648. data[i] = color.mAll;
  649. }
  650. }
  651. else
  652. if( 3 == getComponents() )
  653. {
  654. U8* data = getData();
  655. for( S32 i = 0; i < pixels; i++ )
  656. {
  657. data[0] = color.mV[0];
  658. data[1] = color.mV[1];
  659. data[2] = color.mV[2];
  660. data += 3;
  661. }
  662. }
  663. }
  668. // Src and dst can be any size.  Src and dst can each have 3 or 4 components.
  669. void LLImageRaw::copy(LLImageRaw* src)
  670. {
  671. if (!src)
  672. {
  673. llwarns << "LLImageRaw::copy called with a null src pointer" << llendl;
  674. return;
  675. }
  677. LLImageRaw* dst = this;  // Just for clarity.
  679. if( (src->getWidth() == dst->getWidth()) && (src->getHeight() == dst->getHeight()) )
  680. {
  681. // No scaling needed
  682. if( src->getComponents() == dst->getComponents() )
  683. {
  684. copyUnscaled( src );
  685. }
  686. else
  687. if( 3 == src->getComponents() )
  688. {
  689. copyUnscaled3onto4( src );
  690. }
  691. else
  692. {
  693. // 4 == src->getComponents()
  694. copyUnscaled4onto3( src );
  695. }
  696. }
  697. else
  698. {
  699. // Scaling needed
  700. // No scaling needed
  701. if( src->getComponents() == dst->getComponents() )
  702. {
  703. copyScaled( src );
  704. }
  705. else
  706. if( 3 == src->getComponents() )
  707. {
  708. copyScaled3onto4( src );
  709. }
  710. else
  711. {
  712. // 4 == src->getComponents()
  713. copyScaled4onto3( src );
  714. }
  715. }
  716. }
  718. // Src and dst are same size.  Src and dst have same number of components.
  719. void LLImageRaw::copyUnscaled(LLImageRaw* src)
  720. {
  721. LLImageRaw* dst = this;  // Just for clarity.
  723. llassert( (1 == src->getComponents()) || (3 == src->getComponents()) || (4 == src->getComponents()) );
  724. llassert( src->getComponents() == dst->getComponents() );
  725. llassert( (src->getWidth() == dst->getWidth()) && (src->getHeight() == dst->getHeight()) );
  727. memcpy( dst->getData(), src->getData(), getWidth() * getHeight() * getComponents() ); /* Flawfinder: ignore */
  728. }
  731. // Src and dst can be any size.  Src has 3 components.  Dst has 4 components.
  732. void LLImageRaw::copyScaled3onto4(LLImageRaw* src)
  733. {
  734. llassert( (3 == src->getComponents()) && (4 == getComponents()) );
  736. // Slow, but simple.  Optimize later if needed.
  737. LLImageRaw temp( src->getWidth(), src->getHeight(), 4);
  738. temp.copyUnscaled3onto4( src );
  739. copyScaled( &temp );
  740. }
  743. // Src and dst can be any size.  Src has 4 components.  Dst has 3 components.
  744. void LLImageRaw::copyScaled4onto3(LLImageRaw* src)
  745. {
  746. llassert( (4 == src->getComponents()) && (3 == getComponents()) );
  748. // Slow, but simple.  Optimize later if needed.
  749. LLImageRaw temp( src->getWidth(), src->getHeight(), 3);
  750. temp.copyUnscaled4onto3( src );
  751. copyScaled( &temp );
  752. }
  755. // Src and dst are same size.  Src has 4 components.  Dst has 3 components.
  756. void LLImageRaw::copyUnscaled4onto3( LLImageRaw* src )
  757. {
  758. LLImageRaw* dst = this;  // Just for clarity.
  760. llassert( (3 == dst->getComponents()) && (4 == src->getComponents()) );
  761. llassert( (src->getWidth() == dst->getWidth()) && (src->getHeight() == dst->getHeight()) );
  763. S32 pixels = getWidth() * getHeight();
  764. U8* src_data = src->getData();
  765. U8* dst_data = dst->getData();
  766. for( S32 i=0; i<pixels; i++ )
  767. {
  768. dst_data[0] = src_data[0];
  769. dst_data[1] = src_data[1];
  770. dst_data[2] = src_data[2];
  771. src_data += 4;
  772. dst_data += 3;
  773. }
  774. }
  777. // Src and dst are same size.  Src has 3 components.  Dst has 4 components.
  778. void LLImageRaw::copyUnscaled3onto4( LLImageRaw* src )
  779. {
  780. LLImageRaw* dst = this;  // Just for clarity.
  781. llassert( 3 == src->getComponents() );
  782. llassert( 4 == dst->getComponents() );
  783. llassert( (src->getWidth() == dst->getWidth()) && (src->getHeight() == dst->getHeight()) );
  785. S32 pixels = getWidth() * getHeight();
  786. U8* src_data = src->getData();
  787. U8* dst_data = dst->getData();
  788. for( S32 i=0; i<pixels; i++ )
  789. {
  790. dst_data[0] = src_data[0];
  791. dst_data[1] = src_data[1];
  792. dst_data[2] = src_data[2];
  793. dst_data[3] = 255;
  794. src_data += 3;
  795. dst_data += 4;
  796. }
  797. }
  800. // Src and dst can be any size.  Src and dst have same number of components.
  801. void LLImageRaw::copyScaled( LLImageRaw* src )
  802. {
  803. LLMemType mt1(mMemType);
  804. LLImageRaw* dst = this;  // Just for clarity.
  806. llassert_always( (1 == src->getComponents()) || (3 == src->getComponents()) || (4 == src->getComponents()) );
  807. llassert_always( src->getComponents() == dst->getComponents() );
  809. if( (src->getWidth() == dst->getWidth()) && (src->getHeight() == dst->getHeight()) )
  810. {
  811. memcpy( dst->getData(), src->getData(), getWidth() * getHeight() * getComponents() ); /* Flawfinder: ignore */
  812. return;
  813. }
  815. S32 temp_data_size = src->getWidth() * dst->getHeight() * getComponents();
  816. llassert_always(temp_data_size > 0);
  817. std::vector<U8> temp_buffer(temp_data_size);
  819. // Vertical
  820. for( S32 col = 0; col < src->getWidth(); col++ )
  821. {
  822. copyLineScaled( src->getData() + (getComponents() * col), &temp_buffer[0] + (getComponents() * col), src->getHeight(), dst->getHeight(), src->getWidth(), src->getWidth() );
  823. }
  825. // Horizontal
  826. for( S32 row = 0; row < dst->getHeight(); row++ )
  827. {
  828. copyLineScaled( &temp_buffer[0] + (getComponents() * src->getWidth() * row), dst->getData() + (getComponents() * dst->getWidth() * row), src->getWidth(), dst->getWidth(), 1, 1 );
  829. }
  830. }
  832. //scale down image by not blending a pixel with its neighbors.
  833. BOOL LLImageRaw::scaleDownWithoutBlending( S32 new_width, S32 new_height)
  834. {
  835. LLMemType mt1(mMemType);
  837. S8 c = getComponents() ;
  838. llassert((1 == c) || (3 == c) || (4 == c) );
  840. S32 old_width = getWidth();
  841. S32 old_height = getHeight();
  843. S32 new_data_size = old_width * new_height * c ;
  844. llassert_always(new_data_size > 0);
  846. F32 ratio_x = (F32)old_width / new_width ;
  847. F32 ratio_y = (F32)old_height / new_height ;
  848. if( ratio_x < 1.0f || ratio_y < 1.0f )
  849. {
  850. return TRUE;  // Nothing to do.
  851. }
  852. ratio_x -= 1.0f ;
  853. ratio_y -= 1.0f ;
  855. U8* new_data = new U8[new_data_size] ;
  856. llassert_always(new_data != NULL) ;
  858. U8* old_data = getData() ;
  859. S32 i, j, k, s, t;
  860. for(i = 0, s = 0, t = 0 ; i < new_height ; i++)
  861. {
  862. for(j = 0 ; j < new_width ; j++)
  863. {
  864. for(k = 0 ; k < c ; k++)
  865. {
  866. new_data[s++] = old_data[t++] ;
  867. }
  868. t += (S32)(ratio_x * c + 0.1f) ;
  869. }
  870. t += (S32)(ratio_y * old_width * c + 0.1f) ;
  871. }
  873. setDataAndSize(new_data, new_width, new_height, c) ;
  875. return TRUE ;
  876. }
  878. BOOL LLImageRaw::scale( S32 new_width, S32 new_height, BOOL scale_image_data )
  879. {
  880. LLMemType mt1(mMemType);
  881. llassert((1 == getComponents()) || (3 == getComponents()) || (4 == getComponents()) );
  883. S32 old_width = getWidth();
  884. S32 old_height = getHeight();
  886. if( (old_width == new_width) && (old_height == new_height) )
  887. {
  888. return TRUE;  // Nothing to do.
  889. }
  891. // Reallocate the data buffer.
  893. if (scale_image_data)
  894. {
  895. S32 temp_data_size = old_width * new_height * getComponents();
  896. llassert_always(temp_data_size > 0);
  897. std::vector<U8> temp_buffer(temp_data_size);
  899. // Vertical
  900. for( S32 col = 0; col < old_width; col++ )
  901. {
  902. copyLineScaled( getData() + (getComponents() * col), &temp_buffer[0] + (getComponents() * col), old_height, new_height, old_width, old_width );
  903. }
  905. deleteData();
  907. U8* new_buffer = allocateDataSize(new_width, new_height, getComponents());
  909. // Horizontal
  910. for( S32 row = 0; row < new_height; row++ )
  911. {
  912. copyLineScaled( &temp_buffer[0] + (getComponents() * old_width * row), new_buffer + (getComponents() * new_width * row), old_width, new_width, 1, 1 );
  913. }
  914. }
  915. else
  916. {
  917. // copy out existing image data
  918. S32 temp_data_size = old_width * old_height * getComponents();
  919. std::vector<U8> temp_buffer(temp_data_size);
  920. memcpy(&temp_buffer[0], getData(), temp_data_size);
  922. // allocate new image data, will delete old data
  923. U8* new_buffer = allocateDataSize(new_width, new_height, getComponents());
  925. for( S32 row = 0; row < new_height; row++ )
  926. {
  927. if (row < old_height)
  928. {
  929. memcpy(new_buffer + (new_width * row * getComponents()), &temp_buffer[0] + (old_width * row * getComponents()), getComponents() * llmin(old_width, new_width));
  930. if (old_width < new_width)
  931. {
  932. // pad out rest of row with black
  933. memset(new_buffer + (getComponents() * ((new_width * row) + old_width)), 0, getComponents() * (new_width - old_width));
  934. }
  935. }
  936. else
  937. {
  938. // pad remaining rows with black
  939. memset(new_buffer + (new_width * row * getComponents()), 0, new_width * getComponents());
  940. }
  941. }
  942. }
  944. return TRUE ;
  945. }
  947. void LLImageRaw::copyLineScaled( U8* in, U8* out, S32 in_pixel_len, S32 out_pixel_len, S32 in_pixel_step, S32 out_pixel_step )
  948. {
  949. const S32 components = getComponents();
  950. llassert( components >= 1 && components <= 4 );
  952. const F32 ratio = F32(in_pixel_len) / out_pixel_len; // ratio of old to new
  953. const F32 norm_factor = 1.f / ratio;
  955. S32 goff = components >= 2 ? 1 : 0;
  956. S32 boff = components >= 3 ? 2 : 0;
  957. for( S32 x = 0; x < out_pixel_len; x++ )
  958. {
  959. // Sample input pixels in range from sample0 to sample1.
  960. // Avoid floating point accumulation error... don't just add ratio each time.  JC
  961. const F32 sample0 = x * ratio;
  962. const F32 sample1 = (x+1) * ratio;
  963. const S32 index0 = llfloor(sample0); // left integer (floor)
  964. const S32 index1 = llfloor(sample1); // right integer (floor)
  965. const F32 fract0 = 1.f - (sample0 - F32(index0)); // spill over on left
  966. const F32 fract1 = sample1 - F32(index1); // spill-over on right
  968. if( index0 == index1 )
  969. {
  970. // Interval is embedded in one input pixel
  971. S32 t0 = x * out_pixel_step * components;
  972. S32 t1 = index0 * in_pixel_step * components;
  973. U8* outp = out + t0;
  974. U8* inp = in + t1;
  975. for (S32 i = 0; i < components; ++i)
  976. {
  977. *outp = *inp;
  978. ++outp;
  979. ++inp;
  980. }
  981. }
  982. else
  983. {
  984. // Left straddle
  985. S32 t1 = index0 * in_pixel_step * components;
  986. F32 r = in[t1 + 0] * fract0;
  987. F32 g = in[t1 + goff] * fract0;
  988. F32 b = in[t1 + boff] * fract0;
  989. F32 a = 0;
  990. if( components == 4)
  991. {
  992. a = in[t1 + 3] * fract0;
  993. }
  995. // Central interval
  996. if (components < 4)
  997. {
  998. for( S32 u = index0 + 1; u < index1; u++ )
  999. {
  1000. S32 t2 = u * in_pixel_step * components;
  1001. r += in[t2 + 0];
  1002. g += in[t2 + goff];
  1003. b += in[t2 + boff];
  1004. }
  1005. }
  1006. else
  1007. {
  1008. for( S32 u = index0 + 1; u < index1; u++ )
  1009. {
  1010. S32 t2 = u * in_pixel_step * components;
  1011. r += in[t2 + 0];
  1012. g += in[t2 + 1];
  1013. b += in[t2 + 2];
  1014. a += in[t2 + 3];
  1015. }
  1016. }
  1018. // right straddle
  1019. // Watch out for reading off of end of input array.
  1020. if( fract1 && index1 < in_pixel_len )
  1021. {
  1022. S32 t3 = index1 * in_pixel_step * components;
  1023. if (components < 4)
  1024. {
  1025. U8 in0 = in[t3 + 0];
  1026. U8 in1 = in[t3 + goff];
  1027. U8 in2 = in[t3 + boff];
  1028. r += in0 * fract1;
  1029. g += in1 * fract1;
  1030. b += in2 * fract1;
  1031. }
  1032. else
  1033. {
  1034. U8 in0 = in[t3 + 0];
  1035. U8 in1 = in[t3 + 1];
  1036. U8 in2 = in[t3 + 2];
  1037. U8 in3 = in[t3 + 3];
  1038. r += in0 * fract1;
  1039. g += in1 * fract1;
  1040. b += in2 * fract1;
  1041. a += in3 * fract1;
  1042. }
  1043. }
  1045. r *= norm_factor;
  1046. g *= norm_factor;
  1047. b *= norm_factor;
  1048. a *= norm_factor;  // skip conditional
  1050. S32 t4 = x * out_pixel_step * components;
  1051. out[t4 + 0] = U8(llround(r));
  1052. if (components >= 2)
  1053. out[t4 + 1] = U8(llround(g));
  1054. if (components >= 3)
  1055. out[t4 + 2] = U8(llround(b));
  1056. if( components == 4)
  1057. out[t4 + 3] = U8(llround(a));
  1058. }
  1059. }
  1060. }
  1062. void LLImageRaw::compositeRowScaled4onto3( U8* in, U8* out, S32 in_pixel_len, S32 out_pixel_len )
  1063. {
  1064. llassert( getComponents() == 3 );
  1066. const S32 IN_COMPONENTS = 4;
  1067. const S32 OUT_COMPONENTS = 3;
  1069. const F32 ratio = F32(in_pixel_len) / out_pixel_len; // ratio of old to new
  1070. const F32 norm_factor = 1.f / ratio;
  1072. for( S32 x = 0; x < out_pixel_len; x++ )
  1073. {
  1074. // Sample input pixels in range from sample0 to sample1.
  1075. // Avoid floating point accumulation error... don't just add ratio each time.  JC
  1076. const F32 sample0 = x * ratio;
  1077. const F32 sample1 = (x+1) * ratio;
  1078. const S32 index0 = S32(sample0); // left integer (floor)
  1079. const S32 index1 = S32(sample1); // right integer (floor)
  1080. const F32 fract0 = 1.f - (sample0 - F32(index0)); // spill over on left
  1081. const F32 fract1 = sample1 - F32(index1); // spill-over on right
  1083. U8 in_scaled_r;
  1084. U8 in_scaled_g;
  1085. U8 in_scaled_b;
  1086. U8 in_scaled_a;
  1088. if( index0 == index1 )
  1089. {
  1090. // Interval is embedded in one input pixel
  1091. S32 t1 = index0 * IN_COMPONENTS;
  1092. in_scaled_r = in[t1 + 0];
  1093. in_scaled_g = in[t1 + 0];
  1094. in_scaled_b = in[t1 + 0];
  1095. in_scaled_a = in[t1 + 0];
  1096. }
  1097. else
  1098. {
  1099. // Left straddle
  1100. S32 t1 = index0 * IN_COMPONENTS;
  1101. F32 r = in[t1 + 0] * fract0;
  1102. F32 g = in[t1 + 1] * fract0;
  1103. F32 b = in[t1 + 2] * fract0;
  1104. F32 a = in[t1 + 3] * fract0;
  1106. // Central interval
  1107. for( S32 u = index0 + 1; u < index1; u++ )
  1108. {
  1109. S32 t2 = u * IN_COMPONENTS;
  1110. r += in[t2 + 0];
  1111. g += in[t2 + 1];
  1112. b += in[t2 + 2];
  1113. a += in[t2 + 3];
  1114. }
  1116. // right straddle
  1117. // Watch out for reading off of end of input array.
  1118. if( fract1 && index1 < in_pixel_len )
  1119. {
  1120. S32 t3 = index1 * IN_COMPONENTS;
  1121. r += in[t3 + 0] * fract1;
  1122. g += in[t3 + 1] * fract1;
  1123. b += in[t3 + 2] * fract1;
  1124. a += in[t3 + 3] * fract1;
  1125. }
  1127. r *= norm_factor;
  1128. g *= norm_factor;
  1129. b *= norm_factor;
  1130. a *= norm_factor;
  1132. in_scaled_r = U8(llround(r));
  1133. in_scaled_g = U8(llround(g));
  1134. in_scaled_b = U8(llround(b));
  1135. in_scaled_a = U8(llround(a));
  1136. }
  1138. if( in_scaled_a )
  1139. {
  1140. if( 255 == in_scaled_a )
  1141. {
  1142. out[0] = in_scaled_r;
  1143. out[1] = in_scaled_g;
  1144. out[2] = in_scaled_b;
  1145. }
  1146. else
  1147. {
  1148. U8 transparency = 255 - in_scaled_a;
  1149. out[0] = fastFractionalMult( out[0], transparency ) + fastFractionalMult( in_scaled_r, in_scaled_a );
  1150. out[1] = fastFractionalMult( out[1], transparency ) + fastFractionalMult( in_scaled_g, in_scaled_a );
  1151. out[2] = fastFractionalMult( out[2], transparency ) + fastFractionalMult( in_scaled_b, in_scaled_a );
  1152. }
  1153. }
  1154. out += OUT_COMPONENTS;
  1155. }
  1156. }
  1159. //----------------------------------------------------------------------------
  1161. static struct
  1162. {
  1163. const char* exten;
  1164. EImageCodec codec;
  1165. }
  1166. file_extensions[] =
  1167. {
  1168. { "bmp", IMG_CODEC_BMP },
  1169. { "tga", IMG_CODEC_TGA },
  1170. { "j2c", IMG_CODEC_J2C },
  1171. { "jp2", IMG_CODEC_J2C },
  1172. { "texture", IMG_CODEC_J2C },
  1173. { "jpg", IMG_CODEC_JPEG },
  1174. { "jpeg", IMG_CODEC_JPEG },
  1175. { "mip", IMG_CODEC_DXT },
  1176. { "dxt", IMG_CODEC_DXT },
  1177. { "png", IMG_CODEC_PNG }
  1178. };
  1179. #define NUM_FILE_EXTENSIONS LL_ARRAY_SIZE(file_extensions)
  1181. static std::string find_file(std::string &name, S8 *codec)
  1182. {
  1183. std::string tname;
  1184. for (int i=0; i<(int)(NUM_FILE_EXTENSIONS); i++)
  1185. {
  1186. tname = name + "." + std::string(file_extensions[i].exten);
  1187. llifstream ifs(tname, llifstream::binary);
  1188. if (ifs.is_open())
  1189. {
  1190. ifs.close();
  1191. if (codec)
  1192. *codec = file_extensions[i].codec;
  1193. return std::string(file_extensions[i].exten);
  1194. }
  1195. }
  1196. return std::string("");
  1197. }
  1199. EImageCodec LLImageBase::getCodecFromExtension(const std::string& exten)
  1200. {
  1201. for (int i=0; i<(int)(NUM_FILE_EXTENSIONS); i++)
  1202. {
  1203. if (exten == file_extensions[i].exten)
  1204. return file_extensions[i].codec;
  1205. }
  1206. return IMG_CODEC_INVALID;
  1207. }
  1209. bool LLImageRaw::createFromFile(const std::string &filename, bool j2c_lowest_mip_only)
  1210. {
  1211. std::string name = filename;
  1212. size_t dotidx = name.rfind('.');
  1213. S8 codec = IMG_CODEC_INVALID;
  1214. std::string exten;
  1216. deleteData(); // delete any existing data
  1218. if (dotidx != std::string::npos)
  1219. {
  1220. exten = name.substr(dotidx+1);
  1221. LLStringUtil::toLower(exten);
  1222. codec = getCodecFromExtension(exten);
  1223. }
  1224. else
  1225. {
  1226. exten = find_file(name, &codec);
  1227. name = name + "." + exten;
  1228. }
  1229. if (codec == IMG_CODEC_INVALID)
  1230. {
  1231. return false; // format not recognized
  1232. }
  1234. llifstream ifs(name, llifstream::binary);
  1235. if (!ifs.is_open())
  1236. {
  1237. // SJB: changed from llinfos to lldebugs to reduce spam
  1238. lldebugs << "Unable to open image file: " << name << llendl;
  1239. return false;
  1240. }
  1242. ifs.seekg (0, std::ios::end);
  1243. int length = ifs.tellg();
  1244. if (j2c_lowest_mip_only && length > 2048)
  1245. {
  1246. length = 2048;
  1247. }
  1248. ifs.seekg (0, std::ios::beg);
  1250. if (!length)
  1251. {
  1252. llinfos << "Zero length file file: " << name << llendl;
  1253. return false;
  1254. }
  1256. LLPointer<LLImageFormatted> image;
  1257. switch(codec)
  1258. {
  1259.   //case IMG_CODEC_RGB:
  1260.   case IMG_CODEC_BMP:
  1261. image = new LLImageBMP();
  1262. break;
  1263.   case IMG_CODEC_TGA:
  1264. image = new LLImageTGA();
  1265. break;
  1266.   case IMG_CODEC_JPEG:
  1267. image = new LLImageJPEG();
  1268. break;
  1269.   case IMG_CODEC_J2C:
  1270. image = new LLImageJ2C();
  1271. break;
  1272.   case IMG_CODEC_DXT:
  1273. image = new LLImageDXT();
  1274. break;
  1275.   default:
  1276. return false;
  1277. }
  1278. llassert(image.notNull());
  1280. U8 *buffer = image->allocateData(length);
  1281. ifs.read ((char*)buffer, length);
  1282. ifs.close();
  1284. BOOL success;
  1286. success = image->updateData();
  1287. if (success)
  1288. {
  1289. if (j2c_lowest_mip_only && codec == IMG_CODEC_J2C)
  1290. {
  1291. S32 width = image->getWidth();
  1292. S32 height = image->getHeight();
  1293. S32 discard_level = 0;
  1294. while (width > 1 && height > 1 && discard_level < MAX_DISCARD_LEVEL)
  1295. {
  1296. width >>= 1;
  1297. height >>= 1;
  1298. discard_level++;
  1299. }
  1300. ((LLImageJ2C *)((LLImageFormatted*)image))->setDiscardLevel(discard_level);
  1301. }
  1302. success = image->decode(this, 100000.0f);
  1303. }
  1305. image = NULL; // deletes image
  1306. if (!success)
  1307. {
  1308. deleteData();
  1309. llwarns << "Unable to decode image" << name << llendl;
  1310. return false;
  1311. }
  1313. return true;
  1314. }
  1316. //---------------------------------------------------------------------------
  1317. // LLImageFormatted
  1318. //---------------------------------------------------------------------------
  1320. //static
  1321. S32 LLImageFormatted::sGlobalFormattedMemory = 0;
  1323. LLImageFormatted::LLImageFormatted(S8 codec)
  1324. : LLImageBase(),
  1325.   mCodec(codec),
  1326.   mDecoding(0),
  1327.   mDecoded(0),
  1328.   mDiscardLevel(0)
  1329. {
  1330. mMemType = LLMemType::MTYPE_IMAGEFORMATTED;
  1331. }
  1333. // virtual
  1334. LLImageFormatted::~LLImageFormatted()
  1335. {
  1336. // NOTE: ~LLimageBase() call to deleteData() calls LLImageBase::deleteData()
  1337. //        NOT LLImageFormatted::deleteData()
  1338. deleteData();
  1339. }
  1341. //----------------------------------------------------------------------------
  1343. //virtual
  1344. void LLImageFormatted::resetLastError()
  1345. {
  1346. LLImage::setLastError("");
  1347. }
  1349. //virtual
  1350. void LLImageFormatted::setLastError(const std::string& message, const std::string& filename)
  1351. {
  1352. std::string error = message;
  1353. if (!filename.empty())
  1354. error += std::string(" FILE: ") + filename;
  1355. LLImage::setLastError(error);
  1356. }
  1358. //----------------------------------------------------------------------------
  1360. // static
  1361. LLImageFormatted* LLImageFormatted::createFromType(S8 codec)
  1362. {
  1363. LLImageFormatted* image;
  1364. switch(codec)
  1365. {
  1366.   case IMG_CODEC_BMP:
  1367. image = new LLImageBMP();
  1368. break;
  1369.   case IMG_CODEC_TGA:
  1370. image = new LLImageTGA();
  1371. break;
  1372.   case IMG_CODEC_JPEG:
  1373. image = new LLImageJPEG();
  1374. break;
  1375.   case IMG_CODEC_PNG:
  1376. image = new LLImagePNG();
  1377. break;
  1378.   case IMG_CODEC_J2C:
  1379. image = new LLImageJ2C();
  1380. break;
  1381.   case IMG_CODEC_DXT:
  1382. image = new LLImageDXT();
  1383. break;
  1384.   default:
  1385. image = NULL;
  1386. break;
  1387. }
  1388. return image;
  1389. }
  1391. // static
  1392. LLImageFormatted* LLImageFormatted::createFromExtension(const std::string& instring)
  1393. {
  1394. std::string exten;
  1395. size_t dotidx = instring.rfind('.');
  1396. if (dotidx != std::string::npos)
  1397. {
  1398. exten = instring.substr(dotidx+1);
  1399. }
  1400. else
  1401. {
  1402. exten = instring;
  1403. }
  1404. S8 codec = getCodecFromExtension(exten);
  1405. return createFromType(codec);
  1406. }
  1407. //----------------------------------------------------------------------------
  1409. // virtual
  1410. void LLImageFormatted::dump()
  1411. {
  1412. LLImageBase::dump();
  1414. llinfos << "LLImageFormatted"
  1415. << " mDecoding " << mDecoding
  1416. << " mCodec " << S32(mCodec)
  1417. << " mDecoded " << mDecoded
  1418. << llendl;
  1419. }
  1421. //----------------------------------------------------------------------------
  1423. S32 LLImageFormatted::calcDataSize(S32 discard_level)
  1424. {
  1425. if (discard_level < 0)
  1426. {
  1427. discard_level = mDiscardLevel;
  1428. }
  1429. S32 w = getWidth() >> discard_level;
  1430. S32 h = getHeight() >> discard_level;
  1431. w = llmax(w, 1);
  1432. h = llmax(h, 1);
  1433. return w * h * getComponents();
  1434. }
  1436. S32 LLImageFormatted::calcDiscardLevelBytes(S32 bytes)
  1437. {
  1438. llassert(bytes >= 0);
  1439. S32 discard_level = 0;
  1440. while (1)
  1441. {
  1442. S32 bytes_needed = calcDataSize(discard_level); // virtual
  1443. if (bytes_needed <= bytes)
  1444. {
  1445. break;
  1446. }
  1447. discard_level++;
  1448. if (discard_level > MAX_IMAGE_MIP)
  1449. {
  1450. return -1;
  1451. }
  1452. }
  1453. return discard_level;
  1454. }
  1457. //----------------------------------------------------------------------------
  1459. // Subclasses that can handle more than 4 channels should override this function.
  1460. BOOL LLImageFormatted::decodeChannels(LLImageRaw* raw_image,F32  decode_time, S32 first_channel, S32 max_channel)
  1461. {
  1462. llassert( (first_channel == 0) && (max_channel == 4) );
  1463. return decode( raw_image, decode_time );  // Loads first 4 channels by default.
  1464. } 
  1466. //----------------------------------------------------------------------------
  1468. // virtual
  1469. U8* LLImageFormatted::allocateData(S32 size)
  1470. {
  1471. U8* res = LLImageBase::allocateData(size); // calls deleteData()
  1472. sGlobalFormattedMemory += getDataSize();
  1473. return res;
  1474. }
  1476. // virtual
  1477. U8* LLImageFormatted::reallocateData(S32 size)
  1478. {
  1479. sGlobalFormattedMemory -= getDataSize();
  1480. U8* res = LLImageBase::reallocateData(size);
  1481. sGlobalFormattedMemory += getDataSize();
  1482. return res;
  1483. }
  1485. // virtual
  1486. void LLImageFormatted::deleteData()
  1487. {
  1488. sGlobalFormattedMemory -= getDataSize();
  1489. LLImageBase::deleteData();
  1490. }
  1492. //----------------------------------------------------------------------------
  1494. // virtual
  1495. void LLImageFormatted::sanityCheck()
  1496. {
  1497. LLImageBase::sanityCheck();
  1499. if (mCodec >= IMG_CODEC_EOF)
  1500. {
  1501. llerrs << "Failed LLImageFormatted::sanityCheck "
  1502.    << "decoding " << S32(mDecoding)
  1503.    << "decoded " << S32(mDecoded)
  1504.    << "codec " << S32(mCodec)
  1505.    << llendl;
  1506. }
  1507. }
  1509. //----------------------------------------------------------------------------
  1511. BOOL LLImageFormatted::copyData(U8 *data, S32 size)
  1512. {
  1513. if ( data && ((data != getData()) || (size != getDataSize())) )
  1514. {
  1515. deleteData();
  1516. allocateData(size);
  1517. memcpy(getData(), data, size); /* Flawfinder: ignore */
  1518. }
  1519. return TRUE;
  1520. }
  1522. // LLImageFormatted becomes the owner of data
  1523. void LLImageFormatted::setData(U8 *data, S32 size)
  1524. {
  1525. if (data && data != getData())
  1526. {
  1527. deleteData();
  1528. setDataAndSize(data, size); // Access private LLImageBase members
  1529. sGlobalFormattedMemory += getDataSize();
  1530. }
  1531. }
  1533. void LLImageFormatted::appendData(U8 *data, S32 size)
  1534. {
  1535. if (data)
  1536. {
  1537. if (!getData())
  1538. {
  1539. setData(data, size);
  1540. }
  1541. else 
  1542. {
  1543. S32 cursize = getDataSize();
  1544. S32 newsize = cursize + size;
  1545. reallocateData(newsize);
  1546. memcpy(getData() + cursize, data, size);
  1547. }
  1548. }
  1549. }
  1551. //----------------------------------------------------------------------------
  1553. BOOL LLImageFormatted::load(const std::string &filename)
  1554. {
  1555. resetLastError();
  1557. S32 file_size = 0;
  1558. LLAPRFile infile ;
  1559. infile.open(filename, LL_APR_RB, NULL, &file_size);
  1560. apr_file_t* apr_file = infile.getFileHandle();
  1561. if (!apr_file)
  1562. {
  1563. setLastError("Unable to open file for reading", filename);
  1564. return FALSE;
  1565. }
  1566. if (file_size == 0)
  1567. {
  1568. setLastError("File is empty",filename);
  1569. return FALSE;
  1570. }
  1572. BOOL res;
  1573. U8 *data = allocateData(file_size);
  1574. apr_size_t bytes_read = file_size;
  1575. apr_status_t s = apr_file_read(apr_file, data, &bytes_read); // modifies bytes_read
  1576. if (s != APR_SUCCESS || (S32) bytes_read != file_size)
  1577. {
  1578. deleteData();
  1579. setLastError("Unable to read entire file",filename);
  1580. res = FALSE;
  1581. }
  1582. else
  1583. {
  1584. res = updateData();
  1585. }
  1587. return res;
  1588. }
  1590. BOOL LLImageFormatted::save(const std::string &filename)
  1591. {
  1592. resetLastError();
  1594. LLAPRFile outfile ;
  1595. outfile.open(filename, LL_APR_WB);
  1596. if (!outfile.getFileHandle())
  1597. {
  1598. setLastError("Unable to open file for writing", filename);
  1599. return FALSE;
  1600. }
  1602. outfile.write(getData(),  getDataSize());
  1603. outfile.close() ;
  1604. return TRUE;
  1605. }
  1607. // BOOL LLImageFormatted::save(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type)
  1608. // Depricated to remove VFS dependency.
  1609. // Use:
  1610. // LLVFile::writeFile(image->getData(), image->getDataSize(), vfs, uuid, type);
  1612. //----------------------------------------------------------------------------
  1614. S8 LLImageFormatted::getCodec() const
  1615. {
  1616. return mCodec;
  1617. }
  1619. //============================================================================
  1621. static void avg4_colors4(const U8* a, const U8* b, const U8* c, const U8* d, U8* dst)
  1622. {
  1623. dst[0] = (U8)(((U32)(a[0]) + b[0] + c[0] + d[0])>>2);
  1624. dst[1] = (U8)(((U32)(a[1]) + b[1] + c[1] + d[1])>>2);
  1625. dst[2] = (U8)(((U32)(a[2]) + b[2] + c[2] + d[2])>>2);
  1626. dst[3] = (U8)(((U32)(a[3]) + b[3] + c[3] + d[3])>>2);
  1627. }
  1629. static void avg4_colors3(const U8* a, const U8* b, const U8* c, const U8* d, U8* dst)
  1630. {
  1631. dst[0] = (U8)(((U32)(a[0]) + b[0] + c[0] + d[0])>>2);
  1632. dst[1] = (U8)(((U32)(a[1]) + b[1] + c[1] + d[1])>>2);
  1633. dst[2] = (U8)(((U32)(a[2]) + b[2] + c[2] + d[2])>>2);
  1634. }
  1636. static void avg4_colors2(const U8* a, const U8* b, const U8* c, const U8* d, U8* dst)
  1637. {
  1638. dst[0] = (U8)(((U32)(a[0]) + b[0] + c[0] + d[0])>>2);
  1639. dst[1] = (U8)(((U32)(a[1]) + b[1] + c[1] + d[1])>>2);
  1640. }
  1642. //static
  1643. void LLImageBase::generateMip(const U8* indata, U8* mipdata, S32 width, S32 height, S32 nchannels)
  1644. {
  1645. llassert(width > 0 && height > 0);
  1646. U8* data = mipdata;
  1647. S32 in_width = width*2;
  1648. for (S32 h=0; h<height; h++)
  1649. {
  1650. for (S32 w=0; w<width; w++)
  1651. {
  1652. switch(nchannels)
  1653. {
  1654.   case 4:
  1655. avg4_colors4(indata, indata+4, indata+4*in_width, indata+4*in_width+4, data);
  1656. break;
  1657.   case 3:
  1658. avg4_colors3(indata, indata+3, indata+3*in_width, indata+3*in_width+3, data);
  1659. break;
  1660.   case 2:
  1661. avg4_colors2(indata, indata+2, indata+2*in_width, indata+2*in_width+2, data);
  1662. break;
  1663.   case 1:
  1664. *(U8*)data = (U8)(((U32)(indata[0]) + indata[1] + indata[in_width] + indata[in_width+1])>>2);
  1665. break;
  1666.   default:
  1667. llerrs << "generateMmip called with bad num channels" << llendl;
  1668. }
  1669. indata += nchannels*2;
  1670. data += nchannels;
  1671. }
  1672. indata += nchannels*in_width; // skip odd lines
  1673. }
  1674. }
  1677. //============================================================================
  1679. //static
  1680. F32 LLImageBase::calc_download_priority(F32 virtual_size, F32 visible_pixels, S32 bytes_sent)
  1681. {
  1682. F32 w_priority;
  1684. F32 bytes_weight = 1.f;
  1685. if (!bytes_sent)
  1686. {
  1687. bytes_weight = 20.f;
  1688. }
  1689. else if (bytes_sent < 1000)
  1690. {
  1691. bytes_weight = 1.f;
  1692. }
  1693. else if (bytes_sent < 2000)
  1694. {
  1695. bytes_weight = 1.f/1.5f;
  1696. }
  1697. else if (bytes_sent < 4000)
  1698. {
  1699. bytes_weight = 1.f/3.f;
  1700. }
  1701. else if (bytes_sent < 8000)
  1702. {
  1703. bytes_weight = 1.f/6.f;
  1704. }
  1705. else if (bytes_sent < 16000)
  1706. {
  1707. bytes_weight = 1.f/12.f;
  1708. }
  1709. else if (bytes_sent < 32000)
  1710. {
  1711. bytes_weight = 1.f/20.f;
  1712. }
  1713. else if (bytes_sent < 64000)
  1714. {
  1715. bytes_weight = 1.f/32.f;
  1716. }
  1717. else
  1718. {
  1719. bytes_weight = 1.f/64.f;
  1720. }
  1721. bytes_weight *= bytes_weight;
  1724. //llinfos << "VS: " << virtual_size << llendl;
  1725. F32 virtual_size_factor = virtual_size / (10.f*10.f);
  1727. // The goal is for weighted priority to be <= 0 when we've reached a point where
  1728. // we've sent enough data.
  1729. //llinfos << "BytesSent: " << bytes_sent << llendl;
  1730. //llinfos << "BytesWeight: " << bytes_weight << llendl;
  1731. //llinfos << "PreLog: " << bytes_weight * virtual_size_factor << llendl;
  1732. w_priority = (F32)log10(bytes_weight * virtual_size_factor);
  1734. //llinfos << "PreScale: " << w_priority << llendl;
  1736. // We don't want to affect how MANY bytes we send based on the visible pixels, but the order
  1737. // in which they're sent.  We post-multiply so we don't change the zero point.
  1738. if (w_priority > 0.f)
  1739. {
  1740. F32 pixel_weight = (F32)log10(visible_pixels + 1)*3.0f;
  1741. w_priority *= pixel_weight;
  1742. }
  1744. return w_priority;
  1745. }
  1747. //============================================================================