summaryrefslogtreecommitdiff
path: root/indra/llimage
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llimage')
-rw-r--r--indra/llimage/llimage.cpp257
-rw-r--r--indra/llimage/llimage.h35
-rw-r--r--indra/llimage/llimagebmp.cpp80
-rw-r--r--indra/llimage/llimagebmp.h16
-rw-r--r--indra/llimage/llimagedimensionsinfo.cpp2
-rw-r--r--indra/llimage/llimagedxt.cpp24
-rw-r--r--indra/llimage/llimagedxt.h10
-rw-r--r--indra/llimage/llimagej2c.cpp86
-rw-r--r--indra/llimage/llimagej2c.h41
-rw-r--r--indra/llimage/llimagejpeg.cpp66
-rw-r--r--indra/llimage/llimagejpeg.h8
-rw-r--r--indra/llimage/llimagepng.cpp26
-rw-r--r--indra/llimage/llimagepng.h6
-rw-r--r--indra/llimage/llimagetga.cpp130
-rw-r--r--indra/llimage/llimagetga.h24
-rw-r--r--indra/llimage/llpngwrapper.cpp29
16 files changed, 450 insertions, 390 deletions
diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp
index 08462c7834..fe49e8e011 100644
--- a/indra/llimage/llimage.cpp
+++ b/indra/llimage/llimage.cpp
@@ -705,18 +705,21 @@ void LLImageBase::deleteData()
// virtual
U8* LLImageBase::allocateData(S32 size)
{
+ //make this function thread-safe.
+ static const U32 MAX_BUFFER_SIZE = 4096 * 4096 * 16; //256 MB
+ mBadBufferAllocation = false;
+
if (size < 0)
{
size = mWidth * mHeight * mComponents;
if (size <= 0)
{
- LL_ERRS() << llformat("LLImageBase::allocateData called with bad dimensions: %dx%dx%d",mWidth,mHeight,(S32)mComponents) << LL_ENDL;
+ LL_WARNS() << llformat("LLImageBase::allocateData called with bad dimensions: %dx%dx%d",mWidth,mHeight,(S32)mComponents) << LL_ENDL;
+ mBadBufferAllocation = true;
}
- }
-
- //make this function thread-safe.
- static const U32 MAX_BUFFER_SIZE = 4096 * 4096 * 16 ; //256 MB
- if (size < 1 || size > MAX_BUFFER_SIZE)
+ }
+
+ if (!mBadBufferAllocation && (size < 1 || size > MAX_BUFFER_SIZE))
{
LL_INFOS() << "width: " << mWidth << " height: " << mHeight << " components: " << mComponents << LL_ENDL ;
if(mAllowOverSize)
@@ -725,25 +728,31 @@ U8* LLImageBase::allocateData(S32 size)
}
else
{
- LL_ERRS() << "LLImageBase::allocateData: bad size: " << size << LL_ENDL;
+ LL_WARNS() << "LLImageBase::allocateData: bad size: " << size << LL_ENDL;
+ mBadBufferAllocation = true;
}
}
- if (!mData || size != mDataSize)
+
+ if (!mBadBufferAllocation && (!mData || size != mDataSize))
{
deleteData(); // virtual
- mBadBufferAllocation = false ;
mData = (U8*)ALLOCATE_MEM(sPrivatePoolp, size);
if (!mData)
{
LL_WARNS() << "Failed to allocate image data size [" << size << "]" << LL_ENDL;
- size = 0 ;
- mWidth = mHeight = 0 ;
- mBadBufferAllocation = true ;
+ mBadBufferAllocation = true;
}
- mDataSize = size;
- claimMem(mDataSize);
}
+ if (mBadBufferAllocation)
+ {
+ size = 0;
+ mWidth = mHeight = 0;
+ mData = NULL;
+ }
+ mDataSize = size;
+ claimMem(mDataSize);
+
return mData;
}
@@ -773,7 +782,8 @@ const U8* LLImageBase::getData() const
{
if(mBadBufferAllocation)
{
- LL_ERRS() << "Bad memory allocation for the image buffer!" << LL_ENDL ;
+ LL_WARNS() << "Bad memory allocation for the image buffer!" << LL_ENDL ;
+ return NULL;
}
return mData;
@@ -783,13 +793,14 @@ U8* LLImageBase::getData()
{
if(mBadBufferAllocation)
{
- LL_ERRS() << "Bad memory allocation for the image buffer!" << LL_ENDL ;
+ LL_WARNS() << "Bad memory allocation for the image buffer!" << LL_ENDL;
+ return NULL;
}
return mData;
}
-bool LLImageBase::isBufferInvalid()
+bool LLImageBase::isBufferInvalid() const
{
return mBadBufferAllocation || mData == NULL ;
}
@@ -895,30 +906,30 @@ void LLImageRaw::setDataAndSize(U8 *data, S32 width, S32 height, S8 components)
sGlobalRawMemory += getDataSize();
}
-BOOL LLImageRaw::resize(U16 width, U16 height, S8 components)
+bool LLImageRaw::resize(U16 width, U16 height, S8 components)
{
if ((getWidth() == width) && (getHeight() == height) && (getComponents() == components))
{
- return TRUE;
+ return true;
}
// Reallocate the data buffer.
deleteData();
allocateDataSize(width,height,components);
- return TRUE;
+ return true;
}
-BOOL LLImageRaw::setSubImage(U32 x_pos, U32 y_pos, U32 width, U32 height,
- const U8 *data, U32 stride, BOOL reverse_y)
+bool LLImageRaw::setSubImage(U32 x_pos, U32 y_pos, U32 width, U32 height,
+ const U8 *data, U32 stride, bool reverse_y)
{
if (!getData())
{
- return FALSE;
+ return false;
}
if (!data)
{
- return FALSE;
+ return false;
}
// Should do some simple bounds checking
@@ -933,13 +944,19 @@ BOOL LLImageRaw::setSubImage(U32 x_pos, U32 y_pos, U32 width, U32 height,
data + from_offset, getComponents()*width);
}
- return TRUE;
+ return true;
}
void LLImageRaw::clear(U8 r, U8 g, U8 b, U8 a)
{
llassert( getComponents() <= 4 );
// This is fairly bogus, but it'll do for now.
+ if (isBufferInvalid())
+ {
+ LL_WARNS() << "Invalid image buffer" << LL_ENDL;
+ return;
+ }
+
U8 *pos = getData();
U32 x, y;
for (x = 0; x < getWidth(); x++)
@@ -988,7 +1005,7 @@ void LLImageRaw::verticalFlip()
}
-void LLImageRaw::expandToPowerOfTwo(S32 max_dim, BOOL scale_image)
+void LLImageRaw::expandToPowerOfTwo(S32 max_dim, bool scale_image)
{
// Find new sizes
S32 new_width = expandDimToPowerOfTwo(getWidth(), max_dim);
@@ -997,7 +1014,7 @@ void LLImageRaw::expandToPowerOfTwo(S32 max_dim, BOOL scale_image)
scale( new_width, new_height, scale_image );
}
-void LLImageRaw::contractToPowerOfTwo(S32 max_dim, BOOL scale_image)
+void LLImageRaw::contractToPowerOfTwo(S32 max_dim, bool scale_image)
{
// Find new sizes
S32 new_width = contractDimToPowerOfTwo(getWidth(), MIN_IMAGE_SIZE);
@@ -1067,6 +1084,11 @@ void LLImageRaw::composite( LLImageRaw* src )
{
LLImageRaw* dst = this; // Just for clarity.
+ if (!validateSrcAndDst("LLImageRaw::composite", src, dst))
+ {
+ return;
+ }
+
llassert(3 == src->getComponents());
llassert(3 == dst->getComponents());
@@ -1134,7 +1156,6 @@ void LLImageRaw::compositeUnscaled4onto3( LLImageRaw* src )
llassert( (3 == src->getComponents()) || (4 == src->getComponents()) );
llassert( (src->getWidth() == dst->getWidth()) && (src->getHeight() == dst->getHeight()) );
-
U8* src_data = src->getData();
U8* dst_data = dst->getData();
S32 pixels = getWidth() * getHeight();
@@ -1169,6 +1190,11 @@ void LLImageRaw::copyUnscaledAlphaMask( LLImageRaw* src, const LLColor4U& fill)
{
LLImageRaw* dst = this; // Just for clarity.
+ if (!validateSrcAndDst("LLImageRaw::copyUnscaledAlphaMask", src, dst))
+ {
+ return;
+ }
+
llassert( 1 == src->getComponents() );
llassert( 4 == dst->getComponents() );
llassert( (src->getWidth() == dst->getWidth()) && (src->getHeight() == dst->getHeight()) );
@@ -1191,13 +1217,20 @@ void LLImageRaw::copyUnscaledAlphaMask( LLImageRaw* src, const LLColor4U& fill)
// Fill the buffer with a constant color
void LLImageRaw::fill( const LLColor4U& color )
{
+ if (isBufferInvalid())
+ {
+ LL_WARNS() << "Invalid image buffer" << LL_ENDL;
+ return;
+ }
+
S32 pixels = getWidth() * getHeight();
if( 4 == getComponents() )
{
U32* data = (U32*) getData();
+ U32 rgbaColor = color.asRGBA();
for( S32 i = 0; i < pixels; i++ )
{
- data[i] = color.mAll;
+ data[ i ] = rgbaColor;
}
}
else
@@ -1229,14 +1262,13 @@ LLPointer<LLImageRaw> LLImageRaw::duplicate()
// Src and dst can be any size. Src and dst can each have 3 or 4 components.
void LLImageRaw::copy(LLImageRaw* src)
{
- if (!src)
+ LLImageRaw* dst = this; // Just for clarity.
+
+ if (!validateSrcAndDst("LLImageRaw::copy", src, dst))
{
- LL_WARNS() << "LLImageRaw::copy called with a null src pointer" << LL_ENDL;
return;
}
- LLImageRaw* dst = this; // Just for clarity.
-
if( (src->getWidth() == dst->getWidth()) && (src->getHeight() == dst->getHeight()) )
{
// No scaling needed
@@ -1363,6 +1395,11 @@ void LLImageRaw::copyScaled( LLImageRaw* src )
{
LLImageRaw* dst = this; // Just for clarity.
+ if (!validateSrcAndDst("LLImageRaw::copyScaled", src, dst))
+ {
+ return;
+ }
+
llassert_always( (1 == src->getComponents()) || (3 == src->getComponents()) || (4 == src->getComponents()) );
llassert_always( src->getComponents() == dst->getComponents() );
@@ -1397,86 +1434,83 @@ void LLImageRaw::copyScaled( LLImageRaw* src )
}
-BOOL LLImageRaw::scale( S32 new_width, S32 new_height, BOOL scale_image_data )
+bool LLImageRaw::scale( S32 new_width, S32 new_height, bool scale_image_data )
{
- llassert((1 == getComponents()) || (3 == getComponents()) || (4 == getComponents()) );
+ S32 components = getComponents();
+ if (! ((1 == components) || (3 == components) || (4 == components) ))
+ {
+ LL_WARNS() << "Invalid getComponents value (" << components << ")" << LL_ENDL;
+ return false;
+ }
+
+ if (isBufferInvalid())
+ {
+ LL_WARNS() << "Invalid image buffer" << LL_ENDL;
+ return false;
+ }
S32 old_width = getWidth();
S32 old_height = getHeight();
if( (old_width == new_width) && (old_height == new_height) )
{
- return TRUE; // Nothing to do.
+ return true; // Nothing to do.
}
// Reallocate the data buffer.
if (scale_image_data)
{
- /*
- S32 temp_data_size = old_width * new_height * getComponents();
- llassert_always(temp_data_size > 0);
- std::vector<U8> temp_buffer(temp_data_size);
+ S32 new_data_size = new_width * new_height * components;
- // Vertical
- for( S32 col = 0; col < old_width; col++ )
- {
- copyLineScaled( getData() + (getComponents() * col), &temp_buffer[0] + (getComponents() * col), old_height, new_height, old_width, old_width );
- }
-
- deleteData();
+ if (new_data_size > 0)
+ {
+ U8 *new_data = (U8*)ALLOCATE_MEM(LLImageBase::getPrivatePool(), new_data_size);
+ if(NULL == new_data)
+ {
+ return false;
+ }
- U8* new_buffer = allocateDataSize(new_width, new_height, getComponents());
-
- // Horizontal
- for( S32 row = 0; row < new_height; row++ )
- {
- copyLineScaled( &temp_buffer[0] + (getComponents() * old_width * row), new_buffer + (getComponents() * new_width * row), old_width, new_width, 1, 1 );
+ bilinear_scale(getData(), old_width, old_height, components, old_width*components, new_data, new_width, new_height, components, new_width*components);
+ setDataAndSize(new_data, new_width, new_height, components);
}
- */
-
- S32 new_data_size = new_width * new_height * getComponents();
- llassert_always(new_data_size > 0);
-
- U8 *new_data = (U8*)ALLOCATE_MEM(LLImageBase::getPrivatePool(), new_data_size);
- if(NULL == new_data)
- {
- return FALSE;
- }
-
- bilinear_scale(getData(), old_width, old_height, getComponents(), old_width*getComponents(), new_data, new_width, new_height, getComponents(), new_width*getComponents());
- setDataAndSize(new_data, new_width, new_height, getComponents());
}
else
{
// copy out existing image data
- S32 temp_data_size = old_width * old_height * getComponents();
+ S32 temp_data_size = old_width * old_height * components;
std::vector<U8> temp_buffer(temp_data_size);
memcpy(&temp_buffer[0], getData(), temp_data_size);
// allocate new image data, will delete old data
- U8* new_buffer = allocateDataSize(new_width, new_height, getComponents());
-
- for( S32 row = 0; row < new_height; row++ )
- {
- if (row < old_height)
- {
- memcpy(new_buffer + (new_width * row * getComponents()), &temp_buffer[0] + (old_width * row * getComponents()), getComponents() * llmin(old_width, new_width));
- if (old_width < new_width)
- {
- // pad out rest of row with black
- memset(new_buffer + (getComponents() * ((new_width * row) + old_width)), 0, getComponents() * (new_width - old_width));
- }
- }
- else
- {
- // pad remaining rows with black
- memset(new_buffer + (new_width * row * getComponents()), 0, new_width * getComponents());
- }
- }
- }
-
- return TRUE ;
+ U8* new_buffer = allocateDataSize(new_width, new_height, components);
+
+ if (!new_buffer)
+ {
+ LL_WARNS() << "Failed to allocate new image data buffer" << LL_ENDL;
+ return false;
+ }
+
+ for( S32 row = 0; row < new_height; row++ )
+ {
+ if (row < old_height)
+ {
+ memcpy(new_buffer + (new_width * row * components), &temp_buffer[0] + (old_width * row * components), components * llmin(old_width, new_width));
+ if (old_width < new_width)
+ {
+ // pad out rest of row with black
+ memset(new_buffer + (components * ((new_width * row) + old_width)), 0, components * (new_width - old_width));
+ }
+ }
+ else
+ {
+ // pad remaining rows with black
+ memset(new_buffer + (new_width * row * components), 0, new_width * components);
+ }
+ }
+ }
+
+ return true ;
}
void LLImageRaw::copyLineScaled( U8* in, U8* out, S32 in_pixel_len, S32 out_pixel_len, S32 in_pixel_step, S32 out_pixel_step )
@@ -1690,6 +1724,25 @@ void LLImageRaw::compositeRowScaled4onto3( U8* in, U8* out, S32 in_pixel_len, S3
}
}
+bool LLImageRaw::validateSrcAndDst(std::string func, LLImageRaw* src, LLImageRaw* dst)
+{
+ if (!src || !dst || src->isBufferInvalid() || dst->isBufferInvalid())
+ {
+ LL_WARNS() << func << ": Source: ";
+ if (!src) LL_CONT << "Null pointer";
+ else if (src->isBufferInvalid()) LL_CONT << "Invalid buffer";
+ else LL_CONT << "OK";
+
+ LL_CONT << "; Destination: ";
+ if (!dst) LL_CONT << "Null pointer";
+ else if (dst->isBufferInvalid()) LL_CONT << "Invalid buffer";
+ else LL_CONT << "OK";
+ LL_CONT << "." << LL_ENDL;
+
+ return false;
+ }
+ return true;
+}
//----------------------------------------------------------------------------
@@ -1795,7 +1848,7 @@ bool LLImageRaw::createFromFile(const std::string &filename, bool j2c_lowest_mip
ifs.read ((char*)buffer, length);
ifs.close();
- BOOL success;
+ bool success;
success = image->updateData();
if (success)
@@ -1971,7 +2024,7 @@ S32 LLImageFormatted::calcDiscardLevelBytes(S32 bytes)
//----------------------------------------------------------------------------
// Subclasses that can handle more than 4 channels should override this function.
-BOOL LLImageFormatted::decodeChannels(LLImageRaw* raw_image,F32 decode_time, S32 first_channel, S32 max_channel)
+bool LLImageFormatted::decodeChannels(LLImageRaw* raw_image,F32 decode_time, S32 first_channel, S32 max_channel)
{
llassert( (first_channel == 0) && (max_channel == 4) );
return decode( raw_image, decode_time ); // Loads first 4 channels by default.
@@ -2022,7 +2075,7 @@ void LLImageFormatted::sanityCheck()
//----------------------------------------------------------------------------
-BOOL LLImageFormatted::copyData(U8 *data, S32 size)
+bool LLImageFormatted::copyData(U8 *data, S32 size)
{
if ( data && ((data != getData()) || (size != getDataSize())) )
{
@@ -2030,7 +2083,7 @@ BOOL LLImageFormatted::copyData(U8 *data, S32 size)
allocateData(size);
memcpy(getData(), data, size); /* Flawfinder: ignore */
}
- return TRUE;
+ return true;
}
// LLImageFormatted becomes the owner of data
@@ -2066,7 +2119,7 @@ void LLImageFormatted::appendData(U8 *data, S32 size)
//----------------------------------------------------------------------------
-BOOL LLImageFormatted::load(const std::string &filename, int load_size)
+bool LLImageFormatted::load(const std::string &filename, int load_size)
{
resetLastError();
@@ -2077,12 +2130,12 @@ BOOL LLImageFormatted::load(const std::string &filename, int load_size)
if (!apr_file)
{
setLastError("Unable to open file for reading", filename);
- return FALSE;
+ return false;
}
if (file_size == 0)
{
setLastError("File is empty",filename);
- return FALSE;
+ return false;
}
// Constrain the load size to acceptable values
@@ -2090,7 +2143,7 @@ BOOL LLImageFormatted::load(const std::string &filename, int load_size)
{
load_size = file_size;
}
- BOOL res;
+ bool res;
U8 *data = allocateData(load_size);
apr_size_t bytes_read = load_size;
apr_status_t s = apr_file_read(apr_file, data, &bytes_read); // modifies bytes_read
@@ -2098,7 +2151,7 @@ BOOL LLImageFormatted::load(const std::string &filename, int load_size)
{
deleteData();
setLastError("Unable to read file",filename);
- res = FALSE;
+ res = false;
}
else
{
@@ -2108,7 +2161,7 @@ BOOL LLImageFormatted::load(const std::string &filename, int load_size)
return res;
}
-BOOL LLImageFormatted::save(const std::string &filename)
+bool LLImageFormatted::save(const std::string &filename)
{
resetLastError();
@@ -2117,15 +2170,15 @@ BOOL LLImageFormatted::save(const std::string &filename)
if (!outfile.getFileHandle())
{
setLastError("Unable to open file for writing", filename);
- return FALSE;
+ return false;
}
outfile.write(getData(), getDataSize());
outfile.close() ;
- return TRUE;
+ return true;
}
-// BOOL LLImageFormatted::save(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type)
+// bool LLImageFormatted::save(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type)
// Depricated to remove VFS dependency.
// Use:
// LLVFile::writeFile(image->getData(), image->getDataSize(), vfs, uuid, type);
diff --git a/indra/llimage/llimage.h b/indra/llimage/llimage.h
index cd3f76f1fd..d0bd4a2aef 100644
--- a/indra/llimage/llimage.h
+++ b/indra/llimage/llimage.h
@@ -141,7 +141,7 @@ public:
const U8 *getData() const ;
U8 *getData() ;
- bool isBufferInvalid() ;
+ bool isBufferInvalid() const;
void setSize(S32 width, S32 height, S32 ncomponents);
U8* allocateDataSize(S32 width, S32 height, S32 ncomponents, S32 size = -1); // setSize() + allocateData()
@@ -199,11 +199,11 @@ public:
/*virtual*/ U8* allocateData(S32 size = -1);
/*virtual*/ U8* reallocateData(S32 size);
- BOOL resize(U16 width, U16 height, S8 components);
+ bool resize(U16 width, U16 height, S8 components);
//U8 * getSubImage(U32 x_pos, U32 y_pos, U32 width, U32 height) const;
- BOOL setSubImage(U32 x_pos, U32 y_pos, U32 width, U32 height,
- const U8 *data, U32 stride = 0, BOOL reverse_y = FALSE);
+ bool setSubImage(U32 x_pos, U32 y_pos, U32 width, U32 height,
+ const U8 *data, U32 stride = 0, bool reverse_y = false);
void clear(U8 r=0, U8 g=0, U8 b=0, U8 a=255);
@@ -212,10 +212,10 @@ public:
static S32 biasedDimToPowerOfTwo(S32 curr_dim, S32 max_dim = MAX_IMAGE_SIZE);
static S32 expandDimToPowerOfTwo(S32 curr_dim, S32 max_dim = MAX_IMAGE_SIZE);
static S32 contractDimToPowerOfTwo(S32 curr_dim, S32 min_dim = MIN_IMAGE_SIZE);
- void expandToPowerOfTwo(S32 max_dim = MAX_IMAGE_SIZE, BOOL scale_image = TRUE);
- void contractToPowerOfTwo(S32 max_dim = MAX_IMAGE_SIZE, BOOL scale_image = TRUE);
+ void expandToPowerOfTwo(S32 max_dim = MAX_IMAGE_SIZE, bool scale_image = true);
+ void contractToPowerOfTwo(S32 max_dim = MAX_IMAGE_SIZE, bool scale_image = true);
void biasedScaleToPowerOfTwo(S32 max_dim = MAX_IMAGE_SIZE);
- BOOL scale( S32 new_width, S32 new_height, BOOL scale_image = TRUE );
+ bool scale( S32 new_width, S32 new_height, bool scale_image = true );
// Fill the buffer with a constant color
void fill( const LLColor4U& color );
@@ -277,6 +277,9 @@ protected:
public:
static S32 sGlobalRawMemory;
static S32 sRawImageCount;
+
+private:
+ bool validateSrcAndDst(std::string func, LLImageRaw* src, LLImageRaw* dst);
};
// Compressed representation of image.
@@ -314,23 +317,23 @@ public:
// getRawDiscardLevel() by default returns mDiscardLevel, but may be overridden (LLImageJ2C)
virtual S8 getRawDiscardLevel() { return mDiscardLevel; }
- BOOL load(const std::string& filename, int load_size = 0);
- BOOL save(const std::string& filename);
+ bool load(const std::string& filename, int load_size = 0);
+ bool save(const std::string& filename);
- virtual BOOL updateData() = 0; // pure virtual
+ virtual bool updateData() = 0; // pure virtual
void setData(U8 *data, S32 size);
void appendData(U8 *data, S32 size);
// Loads first 4 channels.
- virtual BOOL decode(LLImageRaw* raw_image, F32 decode_time) = 0;
+ virtual bool decode(LLImageRaw* raw_image, F32 decode_time) = 0;
// Subclasses that can handle more than 4 channels should override this function.
- virtual BOOL decodeChannels(LLImageRaw* raw_image, F32 decode_time, S32 first_channel, S32 max_channel);
+ virtual bool decodeChannels(LLImageRaw* raw_image, F32 decode_time, S32 first_channel, S32 max_channel);
- virtual BOOL encode(const LLImageRaw* raw_image, F32 encode_time) = 0;
+ virtual bool encode(const LLImageRaw* raw_image, F32 encode_time) = 0;
S8 getCodec() const;
- BOOL isDecoding() const { return mDecoding ? TRUE : FALSE; }
- BOOL isDecoded() const { return mDecoded ? TRUE : FALSE; }
+ bool isDecoding() const { return mDecoding; }
+ bool isDecoded() const { return mDecoded; }
void setDiscardLevel(S8 discard_level) { mDiscardLevel = discard_level; }
S8 getDiscardLevel() const { return mDiscardLevel; }
S8 getLevels() const { return mLevels; }
@@ -341,7 +344,7 @@ public:
virtual void setLastError(const std::string& message, const std::string& filename = std::string());
protected:
- BOOL copyData(U8 *data, S32 size); // calls updateData()
+ bool copyData(U8 *data, S32 size); // calls updateData()
protected:
S8 mCodec;
diff --git a/indra/llimage/llimagebmp.cpp b/indra/llimage/llimagebmp.cpp
index a2ce2fee86..2cdd26c22b 100644
--- a/indra/llimage/llimagebmp.cpp
+++ b/indra/llimage/llimagebmp.cpp
@@ -78,7 +78,7 @@ LLImageBMP::LLImageBMP()
mColorPalette( NULL ),
mBitmapOffset( 0 ),
mBitsPerPixel( 0 ),
- mOriginAtTop( FALSE )
+ mOriginAtTop( false )
{
mBitfieldMask[0] = 0;
mBitfieldMask[1] = 0;
@@ -92,7 +92,7 @@ LLImageBMP::~LLImageBMP()
}
-BOOL LLImageBMP::updateData()
+bool LLImageBMP::updateData()
{
resetLastError();
@@ -101,7 +101,7 @@ BOOL LLImageBMP::updateData()
if (!mdata || (0 == getDataSize()))
{
setLastError("Uninitialized instance of LLImageBMP");
- return FALSE;
+ return false;
}
// Read the bitmap headers in order to get all the useful info
@@ -120,12 +120,12 @@ BOOL LLImageBMP::updateData()
if ((mdata[0] != 'B') || (mdata[1] != 'A'))
{
setLastError("OS/2 bitmap array BMP files are not supported");
- return FALSE;
+ return false;
}
else
{
setLastError("Does not appear to be a bitmap file");
- return FALSE;
+ return false;
}
}
@@ -160,12 +160,12 @@ BOOL LLImageBMP::updateData()
llendianswizzleone(header.mNumColors);
llendianswizzleone(header.mNumColorsImportant);
- BOOL windows_nt_version = FALSE;
- BOOL windows_95_version = FALSE;
+ bool windows_nt_version = false;
+ bool windows_95_version = false;
if( 12 == header.mSize )
{
setLastError("Windows 2.x and OS/2 1.x BMP files are not supported");
- return FALSE;
+ return false;
}
else
if( 40 == header.mSize )
@@ -173,7 +173,7 @@ BOOL LLImageBMP::updateData()
if( 3 == header.mCompression )
{
// Windows NT
- windows_nt_version = TRUE;
+ windows_nt_version = true;
}
else
{
@@ -184,32 +184,32 @@ BOOL LLImageBMP::updateData()
if( 12 <= header.mSize && 64 <= header.mSize )
{
setLastError("OS/2 2.x BMP files are not supported");
- return FALSE;
+ return false;
}
else
if( 108 == header.mSize )
{
// BITMAPV4HEADER
- windows_95_version = TRUE;
+ windows_95_version = true;
}
else
if( 108 < header.mSize )
{
// BITMAPV5HEADER or greater
// Should work as long at Microsoft maintained backwards compatibility (which they did in V4 and V5)
- windows_95_version = TRUE;
+ windows_95_version = true;
}
S32 width = header.mWidth;
S32 height = header.mHeight;
if (height < 0)
{
- mOriginAtTop = TRUE;
+ mOriginAtTop = true;
height = -height;
}
else
{
- mOriginAtTop = FALSE;
+ mOriginAtTop = false;
}
mBitsPerPixel = header.mBitsPerPixel;
@@ -228,10 +228,10 @@ BOOL LLImageBMP::updateData()
case 16: // Started work on 16, but doesn't work yet
// These are legal, but we don't support them yet.
setLastError("Unsupported bit depth");
- return FALSE;
+ return false;
default:
setLastError("Unrecognized bit depth");
- return FALSE;
+ return false;
}
setSize(width, height, components);
@@ -244,11 +244,11 @@ BOOL LLImageBMP::updateData()
case 1:
setLastError("8 bit RLE compression not supported.");
- return FALSE;
+ return false;
case 2:
setLastError("4 bit RLE compression not supported.");
- return FALSE;
+ return false;
case 3:
// Windows NT or Windows 95
@@ -256,7 +256,7 @@ BOOL LLImageBMP::updateData()
default:
setLastError("Unsupported compression format.");
- return FALSE;
+ return false;
}
////////////////////////////////////////////////////////////////////
@@ -267,13 +267,13 @@ BOOL LLImageBMP::updateData()
if( (16 != header.mBitsPerPixel) && (32 != header.mBitsPerPixel) )
{
setLastError("Bitfield encoding requires 16 or 32 bits per pixel.");
- return FALSE;
+ return false;
}
if( 0 != header.mNumColors )
{
setLastError("Bitfield encoding is not compatible with a color table.");
- return FALSE;
+ return false;
}
@@ -322,15 +322,15 @@ BOOL LLImageBMP::updateData()
if (!mColorPalette)
{
LL_ERRS() << "Out of memory in LLImageBMP::updateData()" << LL_ENDL;
- return FALSE;
+ return false;
}
memcpy( mColorPalette, mdata + FILE_HEADER_SIZE + BITMAP_HEADER_SIZE + extension_size, color_palette_size ); /* Flawfinder: ignore */
}
- return TRUE;
+ return true;
}
-BOOL LLImageBMP::decode(LLImageRaw* raw_image, F32 decode_time)
+bool LLImageBMP::decode(LLImageRaw* raw_image, F32 decode_time)
{
llassert_always(raw_image);
@@ -341,7 +341,7 @@ BOOL LLImageBMP::decode(LLImageRaw* raw_image, F32 decode_time)
if (!mdata || (0 == getDataSize()))
{
setLastError("llimagebmp trying to decode an image with no data!");
- return FALSE;
+ return false;
}
raw_image->resize(getWidth(), getHeight(), 3);
@@ -349,7 +349,7 @@ BOOL LLImageBMP::decode(LLImageRaw* raw_image, F32 decode_time)
U8* src = mdata + mBitmapOffset;
U8* dst = raw_image->getData();
- BOOL success = FALSE;
+ bool success = false;
switch( mBitsPerPixel )
{
@@ -393,7 +393,7 @@ U32 LLImageBMP::countTrailingZeros( U32 m )
}
-BOOL LLImageBMP::decodeColorMask16( U8* dst, U8* src )
+bool LLImageBMP::decodeColorMask16( U8* dst, U8* src )
{
llassert( 16 == mBitsPerPixel );
@@ -426,10 +426,10 @@ BOOL LLImageBMP::decodeColorMask16( U8* dst, U8* src )
src += alignment_bytes;
}
- return TRUE;
+ return true;
}
-BOOL LLImageBMP::decodeColorMask32( U8* dst, U8* src )
+bool LLImageBMP::decodeColorMask32( U8* dst, U8* src )
{
// Note: alpha is not supported
@@ -445,7 +445,7 @@ BOOL LLImageBMP::decodeColorMask32( U8* dst, U8* src )
if (getWidth() * getHeight() * 4 > getDataSize() - mBitmapOffset)
{ //here we have situation when data size in src less than actually needed
- return FALSE;
+ return false;
}
S32 src_row_span = getWidth() * 4;
@@ -469,11 +469,11 @@ BOOL LLImageBMP::decodeColorMask32( U8* dst, U8* src )
src += alignment_bytes;
}
- return TRUE;
+ return true;
}
-BOOL LLImageBMP::decodeColorTable8( U8* dst, U8* src )
+bool LLImageBMP::decodeColorTable8( U8* dst, U8* src )
{
llassert( (8 == mBitsPerPixel) && (mColorPaletteColors >= 256) );
@@ -482,7 +482,7 @@ BOOL LLImageBMP::decodeColorTable8( U8* dst, U8* src )
if ((getWidth() * getHeight()) + getHeight() * alignment_bytes > getDataSize() - mBitmapOffset)
{ //here we have situation when data size in src less than actually needed
- return FALSE;
+ return false;
}
for( S32 row = 0; row < getHeight(); row++ )
@@ -499,11 +499,11 @@ BOOL LLImageBMP::decodeColorTable8( U8* dst, U8* src )
src += alignment_bytes;
}
- return TRUE;
+ return true;
}
-BOOL LLImageBMP::decodeTruecolor24( U8* dst, U8* src )
+bool LLImageBMP::decodeTruecolor24( U8* dst, U8* src )
{
llassert( 24 == mBitsPerPixel );
llassert( 3 == getComponents() );
@@ -512,7 +512,7 @@ BOOL LLImageBMP::decodeTruecolor24( U8* dst, U8* src )
if ((getWidth() * getHeight() * 3) + getHeight() * alignment_bytes > getDataSize() - mBitmapOffset)
{ //here we have situation when data size in src less than actually needed
- return FALSE;
+ return false;
}
for( S32 row = 0; row < getHeight(); row++ )
@@ -528,10 +528,10 @@ BOOL LLImageBMP::decodeTruecolor24( U8* dst, U8* src )
src += alignment_bytes;
}
- return TRUE;
+ return true;
}
-BOOL LLImageBMP::encode(const LLImageRaw* raw_image, F32 encode_time)
+bool LLImageBMP::encode(const LLImageRaw* raw_image, F32 encode_time)
{
llassert_always(raw_image);
@@ -563,7 +563,7 @@ BOOL LLImageBMP::encode(const LLImageRaw* raw_image, F32 encode_time)
// Allocate the new buffer for the data.
if(!allocateData(file_bytes)) //memory allocation failed
{
- return FALSE ;
+ return false ;
}
magic[0] = 'B'; magic[1] = 'M';
@@ -663,5 +663,5 @@ BOOL LLImageBMP::encode(const LLImageRaw* raw_image, F32 encode_time)
}
}
- return TRUE;
+ return true;
}
diff --git a/indra/llimage/llimagebmp.h b/indra/llimage/llimagebmp.h
index db0b45def0..6a5fa4697d 100644
--- a/indra/llimage/llimagebmp.h
+++ b/indra/llimage/llimagebmp.h
@@ -40,15 +40,15 @@ public:
LLImageBMP();
/*virtual*/ std::string getExtension() { return std::string("bmp"); }
- /*virtual*/ BOOL updateData();
- /*virtual*/ BOOL decode(LLImageRaw* raw_image, F32 decode_time);
- /*virtual*/ BOOL encode(const LLImageRaw* raw_image, F32 encode_time);
+ /*virtual*/ bool updateData();
+ /*virtual*/ bool decode(LLImageRaw* raw_image, F32 decode_time);
+ /*virtual*/ bool encode(const LLImageRaw* raw_image, F32 encode_time);
protected:
- BOOL decodeColorTable8( U8* dst, U8* src );
- BOOL decodeColorMask16( U8* dst, U8* src );
- BOOL decodeTruecolor24( U8* dst, U8* src );
- BOOL decodeColorMask32( U8* dst, U8* src );
+ bool decodeColorTable8( U8* dst, U8* src );
+ bool decodeColorMask16( U8* dst, U8* src );
+ bool decodeTruecolor24( U8* dst, U8* src );
+ bool decodeColorMask32( U8* dst, U8* src );
U32 countTrailingZeros( U32 m );
@@ -58,7 +58,7 @@ protected:
S32 mBitmapOffset;
S32 mBitsPerPixel;
U32 mBitfieldMask[4]; // rgba
- BOOL mOriginAtTop;
+ bool mOriginAtTop;
};
#endif
diff --git a/indra/llimage/llimagedimensionsinfo.cpp b/indra/llimage/llimagedimensionsinfo.cpp
index 5bf3f29b3c..a5e546e977 100644
--- a/indra/llimage/llimagedimensionsinfo.cpp
+++ b/indra/llimage/llimagedimensionsinfo.cpp
@@ -201,7 +201,7 @@ bool LLImageDimensionsInfo::getImageDimensionsJpeg()
cinfo.out_color_space = JCS_RGB;
jpeg_start_decompress (&cinfo);
- mHeight = cinfo.output_width;
+ mWidth = cinfo.output_width;
mHeight = cinfo.output_height;
jpeg_destroy_decompress(&cinfo);
diff --git a/indra/llimage/llimagedxt.cpp b/indra/llimage/llimagedxt.cpp
index 04e0e752eb..0ec83415a0 100644
--- a/indra/llimage/llimagedxt.cpp
+++ b/indra/llimage/llimagedxt.cpp
@@ -172,7 +172,7 @@ LLImageDXT::~LLImageDXT()
}
// virtual
-BOOL LLImageDXT::updateData()
+bool LLImageDXT::updateData()
{
resetLastError();
@@ -182,7 +182,7 @@ BOOL LLImageDXT::updateData()
if (!data || !data_size)
{
setLastError("LLImageDXT uninitialized");
- return FALSE;
+ return false;
}
S32 width, height, miplevelmax;
@@ -216,7 +216,7 @@ BOOL LLImageDXT::updateData()
discard = llmin(discard, miplevelmax);
setDiscardLevel(discard);
- return TRUE;
+ return true;
}
// discard: 0 = largest (last) mip
@@ -257,7 +257,7 @@ void LLImageDXT::setFormat()
}
// virtual
-BOOL LLImageDXT::decode(LLImageRaw* raw_image, F32 time)
+bool LLImageDXT::decode(LLImageRaw* raw_image, F32 time)
{
// *TODO: Test! This has been tweaked since its intial inception,
// but we don't use it any more!
@@ -266,7 +266,7 @@ BOOL LLImageDXT::decode(LLImageRaw* raw_image, F32 time)
if (mFileFormat >= FORMAT_DXT1 && mFileFormat <= FORMAT_DXR5)
{
LL_WARNS() << "Attempt to decode compressed LLImageDXT to Raw (unsupported)" << LL_ENDL;
- return FALSE;
+ return false;
}
S32 width = getWidth(), height = getHeight();
@@ -286,16 +286,16 @@ BOOL LLImageDXT::decode(LLImageRaw* raw_image, F32 time)
if ((!getData()) || (data + image_size > getData() + getDataSize()))
{
setLastError("LLImageDXT trying to decode an image with not enough data!");
- return FALSE;
+ return false;
}
raw_image->resize(width, height, ncomponents);
memcpy(raw_image->getData(), data, image_size); /* Flawfinder: ignore */
- return TRUE;
+ return true;
}
-BOOL LLImageDXT::getMipData(LLPointer<LLImageRaw>& raw, S32 discard)
+bool LLImageDXT::getMipData(LLPointer<LLImageRaw>& raw, S32 discard)
{
if (discard < 0)
{
@@ -310,10 +310,10 @@ BOOL LLImageDXT::getMipData(LLPointer<LLImageRaw>& raw, S32 discard)
S32 height = 0;
calcDiscardWidthHeight(discard, mFileFormat, width, height);
raw = new LLImageRaw(data, width, height, getComponents());
- return TRUE;
+ return true;
}
-BOOL LLImageDXT::encodeDXT(const LLImageRaw* raw_image, F32 time, bool explicit_mips)
+bool LLImageDXT::encodeDXT(const LLImageRaw* raw_image, F32 time, bool explicit_mips)
{
llassert_always(raw_image);
@@ -395,11 +395,11 @@ BOOL LLImageDXT::encodeDXT(const LLImageRaw* raw_image, F32 time, bool explicit_
prev_mipdata = mipdata;
}
- return TRUE;
+ return true;
}
// virtual
-BOOL LLImageDXT::encode(const LLImageRaw* raw_image, F32 time)
+bool LLImageDXT::encode(const LLImageRaw* raw_image, F32 time)
{
return encodeDXT(raw_image, time, false);
}
diff --git a/indra/llimage/llimagedxt.h b/indra/llimage/llimagedxt.h
index a8756ba8ed..a4a9bcf99c 100644
--- a/indra/llimage/llimagedxt.h
+++ b/indra/llimage/llimagedxt.h
@@ -93,21 +93,21 @@ protected:
/*virtual*/ ~LLImageDXT();
private:
- BOOL encodeDXT(const LLImageRaw* raw_image, F32 decode_time, bool explicit_mips);
+ bool encodeDXT(const LLImageRaw* raw_image, F32 decode_time, bool explicit_mips);
public:
LLImageDXT();
/*virtual*/ std::string getExtension() { return std::string("dxt"); }
- /*virtual*/ BOOL updateData();
+ /*virtual*/ bool updateData();
- /*virtual*/ BOOL decode(LLImageRaw* raw_image, F32 decode_time);
- /*virtual*/ BOOL encode(const LLImageRaw* raw_image, F32 encode_time);
+ /*virtual*/ bool decode(LLImageRaw* raw_image, F32 decode_time);
+ /*virtual*/ bool encode(const LLImageRaw* raw_image, F32 encode_time);
/*virtual*/ S32 calcHeaderSize();
/*virtual*/ S32 calcDataSize(S32 discard_level = 0);
- BOOL getMipData(LLPointer<LLImageRaw>& raw, S32 discard=-1);
+ bool getMipData(LLPointer<LLImageRaw>& raw, S32 discard=-1);
void setFormat();
S32 getMipOffset(S32 discard);
diff --git a/indra/llimage/llimagej2c.cpp b/indra/llimage/llimagej2c.cpp
index 7cd59a2983..68694496bc 100644
--- a/indra/llimage/llimagej2c.cpp
+++ b/indra/llimage/llimagej2c.cpp
@@ -31,18 +31,13 @@
#include "llmath.h"
#include "llmemory.h"
#include "llsd.h"
+#include <boost/scoped_ptr.hpp>
-typedef LLImageJ2CImpl* (*CreateLLImageJ2CFunction)();
-typedef void (*DestroyLLImageJ2CFunction)(LLImageJ2CImpl*);
-typedef const char* (*EngineInfoLLImageJ2CFunction)();
-
-// Declare the prototype for theses functions here. Their functionality
-// will be implemented in other files which define a derived LLImageJ2CImpl
-// but only ONE static library which has the implementation for these
-// functions should ever be included.
+// Declare the prototype for this factory function here. It is implemented in
+// other files which define a LLImageJ2CImpl subclass, but only ONE static
+// library which has the implementation for this function should ever be
+// linked.
LLImageJ2CImpl* fallbackCreateLLImageJ2CImpl();
-void fallbackDestroyLLImageJ2CImpl(LLImageJ2CImpl* impl);
-const char* fallbackEngineInfoLLImageJ2CImpl();
// Test data gathering handle
LLImageCompressionTester* LLImageJ2C::sTesterp = NULL ;
@@ -51,17 +46,20 @@ const std::string sTesterName("ImageCompressionTester");
//static
std::string LLImageJ2C::getEngineInfo()
{
- return fallbackEngineInfoLLImageJ2CImpl();
+ // All known LLImageJ2CImpl implementation subclasses are cheap to
+ // construct.
+ boost::scoped_ptr<LLImageJ2CImpl> impl(fallbackCreateLLImageJ2CImpl());
+ return impl->getEngineInfo();
}
LLImageJ2C::LLImageJ2C() : LLImageFormatted(IMG_CODEC_J2C),
mMaxBytes(0),
mRawDiscardLevel(-1),
mRate(DEFAULT_COMPRESSION_RATE),
- mReversible(FALSE),
+ mReversible(false),
mAreaUsedForDataSizeCalcs(0)
{
- mImpl = fallbackCreateLLImageJ2CImpl();
+ mImpl.reset(fallbackCreateLLImageJ2CImpl());
claimMem(mImpl);
// Clear data size table
@@ -83,13 +81,7 @@ LLImageJ2C::LLImageJ2C() : LLImageFormatted(IMG_CODEC_J2C),
}
// virtual
-LLImageJ2C::~LLImageJ2C()
-{
- if ( mImpl )
- {
- fallbackDestroyLLImageJ2CImpl(mImpl);
- }
-}
+LLImageJ2C::~LLImageJ2C() {}
// virtual
void LLImageJ2C::resetLastError()
@@ -111,16 +103,16 @@ S8 LLImageJ2C::getRawDiscardLevel()
return mRawDiscardLevel;
}
-BOOL LLImageJ2C::updateData()
+bool LLImageJ2C::updateData()
{
- BOOL res = TRUE;
+ bool res = true;
resetLastError();
// Check to make sure that this instance has been initialized with data
if (!getData() || (getDataSize() < 16))
{
setLastError("LLImageJ2C uninitialized");
- res = FALSE;
+ res = false;
}
else
{
@@ -142,29 +134,29 @@ BOOL LLImageJ2C::updateData()
return res;
}
-BOOL LLImageJ2C::initDecode(LLImageRaw &raw_image, int discard_level, int* region)
+bool LLImageJ2C::initDecode(LLImageRaw &raw_image, int discard_level, int* region)
{
setDiscardLevel(discard_level != -1 ? discard_level : 0);
return mImpl->initDecode(*this,raw_image,discard_level,region);
}
-BOOL LLImageJ2C::initEncode(LLImageRaw &raw_image, int blocks_size, int precincts_size, int levels)
+bool LLImageJ2C::initEncode(LLImageRaw &raw_image, int blocks_size, int precincts_size, int levels)
{
return mImpl->initEncode(*this,raw_image,blocks_size,precincts_size,levels);
}
-BOOL LLImageJ2C::decode(LLImageRaw *raw_imagep, F32 decode_time)
+bool LLImageJ2C::decode(LLImageRaw *raw_imagep, F32 decode_time)
{
return decodeChannels(raw_imagep, decode_time, 0, 4);
}
-// Returns TRUE to mean done, whether successful or not.
-BOOL LLImageJ2C::decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 first_channel, S32 max_channel_count )
+// Returns true to mean done, whether successful or not.
+bool LLImageJ2C::decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 first_channel, S32 max_channel_count )
{
LLTimer elapsed;
- BOOL res = TRUE;
+ bool res = true;
resetLastError();
@@ -172,13 +164,13 @@ BOOL LLImageJ2C::decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 fir
if (!getData() || (getDataSize() < 16))
{
setLastError("LLImageJ2C uninitialized");
- res = TRUE; // done
+ res = true; // done
}
else
{
// Update the raw discard level
updateRawDiscardLevel();
- mDecoding = TRUE;
+ mDecoding = true;
res = mImpl->decodeImpl(*this, *raw_imagep, decode_time, first_channel, max_channel_count);
}
@@ -191,7 +183,7 @@ BOOL LLImageJ2C::decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 fir
}
else
{
- mDecoding = FALSE;
+ mDecoding = false;
}
}
@@ -210,7 +202,7 @@ BOOL LLImageJ2C::decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 fir
tester->updateDecompressionStats(elapsed.getElapsedTimeF32()) ;
if (res)
{
- // The whole data stream is finally decompressed when res is returned as TRUE
+ // The whole data stream is finally decompressed when res is returned as true
tester->updateDecompressionStats(this->getDataSize(), raw_imagep->getDataSize()) ;
}
}
@@ -219,17 +211,17 @@ BOOL LLImageJ2C::decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 fir
}
-BOOL LLImageJ2C::encode(const LLImageRaw *raw_imagep, F32 encode_time)
+bool LLImageJ2C::encode(const LLImageRaw *raw_imagep, F32 encode_time)
{
return encode(raw_imagep, NULL, encode_time);
}
-BOOL LLImageJ2C::encode(const LLImageRaw *raw_imagep, const char* comment_text, F32 encode_time)
+bool LLImageJ2C::encode(const LLImageRaw *raw_imagep, const char* comment_text, F32 encode_time)
{
LLTimer elapsed;
resetLastError();
- BOOL res = mImpl->encodeImpl(*this, *raw_imagep, comment_text, encode_time, mReversible);
+ bool res = mImpl->encodeImpl(*this, *raw_imagep, comment_text, encode_time, mReversible);
if (!mLastError.empty())
{
LLImage::setLastError(mLastError);
@@ -245,7 +237,7 @@ BOOL LLImageJ2C::encode(const LLImageRaw *raw_imagep, const char* comment_text,
tester->updateCompressionStats(elapsed.getElapsedTimeF32()) ;
if (res)
{
- // The whole data stream is finally compressed when res is returned as TRUE
+ // The whole data stream is finally compressed when res is returned as true
tester->updateCompressionStats(this->getDataSize(), raw_imagep->getDataSize()) ;
}
}
@@ -348,15 +340,15 @@ void LLImageJ2C::setMaxBytes(S32 max_bytes)
mMaxBytes = max_bytes;
}
-void LLImageJ2C::setReversible(const BOOL reversible)
+void LLImageJ2C::setReversible(const bool reversible)
{
mReversible = reversible;
}
-BOOL LLImageJ2C::loadAndValidate(const std::string &filename)
+bool LLImageJ2C::loadAndValidate(const std::string &filename)
{
- BOOL res = TRUE;
+ bool res = true;
resetLastError();
@@ -367,12 +359,12 @@ BOOL LLImageJ2C::loadAndValidate(const std::string &filename)
if (!apr_file)
{
setLastError("Unable to open file for reading", filename);
- res = FALSE;
+ res = false;
}
else if (file_size == 0)
{
setLastError("File is empty",filename);
- res = FALSE;
+ res = false;
}
else
{
@@ -385,7 +377,7 @@ BOOL LLImageJ2C::loadAndValidate(const std::string &filename)
{
FREE_MEM(LLImageBase::getPrivatePool(), data);
setLastError("Unable to read entire file");
- res = FALSE;
+ res = false;
}
else
{
@@ -402,21 +394,21 @@ BOOL LLImageJ2C::loadAndValidate(const std::string &filename)
}
-BOOL LLImageJ2C::validate(U8 *data, U32 file_size)
+bool LLImageJ2C::validate(U8 *data, U32 file_size)
{
resetLastError();
setData(data, file_size);
- BOOL res = updateData();
+ bool res = updateData();
if ( res )
{
// Check to make sure that this instance has been initialized with data
if (!getData() || (0 == getDataSize()))
{
setLastError("LLImageJ2C uninitialized");
- res = FALSE;
+ res = false;
}
else
{
@@ -433,7 +425,7 @@ BOOL LLImageJ2C::validate(U8 *data, U32 file_size)
void LLImageJ2C::decodeFailed()
{
- mDecoding = FALSE;
+ mDecoding = false;
}
void LLImageJ2C::updateRawDiscardLevel()
diff --git a/indra/llimage/llimagej2c.h b/indra/llimage/llimagej2c.h
index ce8195940d..e196f7479e 100644
--- a/indra/llimage/llimagej2c.h
+++ b/indra/llimage/llimagej2c.h
@@ -30,6 +30,7 @@
#include "llimage.h"
#include "llassettype.h"
#include "llmetricperformancetester.h"
+#include <boost/scoped_ptr.hpp>
// JPEG2000 : compression rate used in j2c conversion.
const F32 DEFAULT_COMPRESSION_RATE = 1.f/8.f;
@@ -47,10 +48,10 @@ public:
// Base class overrides
/*virtual*/ std::string getExtension() { return std::string("j2c"); }
- /*virtual*/ BOOL updateData();
- /*virtual*/ BOOL decode(LLImageRaw *raw_imagep, F32 decode_time);
- /*virtual*/ BOOL decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 first_channel, S32 max_channel_count);
- /*virtual*/ BOOL encode(const LLImageRaw *raw_imagep, F32 encode_time);
+ /*virtual*/ bool updateData();
+ /*virtual*/ bool decode(LLImageRaw *raw_imagep, F32 decode_time);
+ /*virtual*/ bool decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 first_channel, S32 max_channel_count);
+ /*virtual*/ bool encode(const LLImageRaw *raw_imagep, F32 encode_time);
/*virtual*/ S32 calcHeaderSize();
/*virtual*/ S32 calcDataSize(S32 discard_level = 0);
/*virtual*/ S32 calcDiscardLevelBytes(S32 bytes);
@@ -59,17 +60,17 @@ public:
/*virtual*/ void resetLastError();
/*virtual*/ void setLastError(const std::string& message, const std::string& filename = std::string());
- BOOL initDecode(LLImageRaw &raw_image, int discard_level, int* region);
- BOOL initEncode(LLImageRaw &raw_image, int blocks_size, int precincts_size, int levels);
+ bool initDecode(LLImageRaw &raw_image, int discard_level, int* region);
+ bool initEncode(LLImageRaw &raw_image, int blocks_size, int precincts_size, int levels);
// Encode with comment text
- BOOL encode(const LLImageRaw *raw_imagep, const char* comment_text, F32 encode_time=0.0);
+ bool encode(const LLImageRaw *raw_imagep, const char* comment_text, F32 encode_time=0.0);
- BOOL validate(U8 *data, U32 file_size);
- BOOL loadAndValidate(const std::string &filename);
+ bool validate(U8 *data, U32 file_size);
+ bool loadAndValidate(const std::string &filename);
// Encode accessors
- void setReversible(const BOOL reversible); // Use non-lossy?
+ void setReversible(const bool reversible); // Use non-lossy?
void setMaxBytes(S32 max_bytes);
S32 getMaxBytes() const { return mMaxBytes; }
@@ -93,8 +94,8 @@ protected:
S8 mRawDiscardLevel;
F32 mRate;
- BOOL mReversible;
- LLImageJ2CImpl *mImpl;
+ bool mReversible;
+ boost::scoped_ptr<LLImageJ2CImpl> mImpl;
std::string mLastError;
// Image compression/decompression tester
@@ -111,23 +112,25 @@ protected:
// Return value:
// true: image size and number of channels was determined
// false: error on decode
- virtual BOOL getMetadata(LLImageJ2C &base) = 0;
+ virtual bool getMetadata(LLImageJ2C &base) = 0;
// Decode the raw image optionally aborting (to continue later) after
// decode_time seconds. Decode at most max_channel_count and start
// decoding channel first_channel.
// Return value:
// true: decoding complete (even if it failed)
// false: time expired while decoding
- virtual BOOL decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count) = 0;
- virtual BOOL encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text, F32 encode_time=0.0,
- BOOL reversible=FALSE) = 0;
- virtual BOOL initDecode(LLImageJ2C &base, LLImageRaw &raw_image, int discard_level = -1, int* region = NULL) = 0;
- virtual BOOL initEncode(LLImageJ2C &base, LLImageRaw &raw_image, int blocks_size = -1, int precincts_size = -1, int levels = 0) = 0;
+ virtual bool decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count) = 0;
+ virtual bool encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text, F32 encode_time=0.0,
+ bool reversible=false) = 0;
+ virtual bool initDecode(LLImageJ2C &base, LLImageRaw &raw_image, int discard_level = -1, int* region = NULL) = 0;
+ virtual bool initEncode(LLImageJ2C &base, LLImageRaw &raw_image, int blocks_size = -1, int precincts_size = -1, int levels = 0) = 0;
+
+ virtual std::string getEngineInfo() const = 0;
friend class LLImageJ2C;
};
-#define LINDEN_J2C_COMMENT_PREFIX "LL_"
+#define LINDEN_J2C_COMMENT_PREFIX "LL_" // Used by LLAppearanceUtility
//
// This class is used for performance data gathering only.
diff --git a/indra/llimage/llimagejpeg.cpp b/indra/llimage/llimagejpeg.cpp
index e419c77ff2..60b2d0faa5 100644
--- a/indra/llimage/llimagejpeg.cpp
+++ b/indra/llimage/llimagejpeg.cpp
@@ -45,7 +45,7 @@ LLImageJPEG::~LLImageJPEG()
delete[] mOutputBuffer;
}
-BOOL LLImageJPEG::updateData()
+bool LLImageJPEG::updateData()
{
resetLastError();
@@ -53,7 +53,7 @@ BOOL LLImageJPEG::updateData()
if (!getData() || (0 == getDataSize()))
{
setLastError("Uninitialized instance of LLImageJPEG");
- return FALSE;
+ return false;
}
////////////////////////////////////////
@@ -79,7 +79,7 @@ BOOL LLImageJPEG::updateData()
if(setjmp(sSetjmpBuffer))
{
jpeg_destroy_decompress(&cinfo);
- return FALSE;
+ return false;
}
try
{
@@ -106,7 +106,7 @@ BOOL LLImageJPEG::updateData()
////////////////////////////////////////
// Step 3: read file parameters with jpeg_read_header()
- jpeg_read_header( &cinfo, TRUE );
+ jpeg_read_header( &cinfo, true );
// Data set by jpeg_read_header
setSize(cinfo.image_width, cinfo.image_height, 3); // Force to 3 components (RGB)
@@ -115,13 +115,13 @@ BOOL LLImageJPEG::updateData()
// More data set by jpeg_read_header
cinfo.num_components;
cinfo.jpeg_color_space; // Colorspace of image
- cinfo.saw_JFIF_marker; // TRUE if a JFIF APP0 marker was seen
+ cinfo.saw_JFIF_marker; // true if a JFIF APP0 marker was seen
cinfo.JFIF_major_version; // Version information from JFIF marker
cinfo.JFIF_minor_version; //
cinfo.density_unit; // Resolution data from JFIF marker
cinfo.X_density;
cinfo.Y_density;
- cinfo.saw_Adobe_marker; // TRUE if an Adobe APP14 marker was seen
+ cinfo.saw_Adobe_marker; // true if an Adobe APP14 marker was seen
cinfo.Adobe_transform; // Color transform code from Adobe marker
*/
}
@@ -129,13 +129,13 @@ BOOL LLImageJPEG::updateData()
{
jpeg_destroy_decompress(&cinfo);
- return FALSE;
+ return false;
}
////////////////////////////////////////
// Step 4: Release JPEG decompression object
jpeg_destroy_decompress(&cinfo);
- return TRUE;
+ return true;
}
// Initialize source --- called by jpeg_read_header
@@ -154,7 +154,7 @@ boolean LLImageJPEG::decodeFillInputBuffer( j_decompress_ptr cinfo )
// Should never get here, since we provide the entire buffer up front.
ERREXIT(cinfo, JERR_INPUT_EMPTY);
- return TRUE;
+ return true;
}
// Skip data --- used to skip over a potentially large amount of
@@ -182,7 +182,7 @@ void LLImageJPEG::decodeTermSource (j_decompress_ptr cinfo)
// Returns true when done, whether or not decode was successful.
-BOOL LLImageJPEG::decode(LLImageRaw* raw_image, F32 decode_time)
+bool LLImageJPEG::decode(LLImageRaw* raw_image, F32 decode_time)
{
llassert_always(raw_image);
@@ -192,7 +192,7 @@ BOOL LLImageJPEG::decode(LLImageRaw* raw_image, F32 decode_time)
if (!getData() || (0 == getDataSize()))
{
setLastError("LLImageJPEG trying to decode an image with no data!");
- return TRUE; // done
+ return true; // done
}
S32 row_stride = 0;
@@ -220,7 +220,7 @@ BOOL LLImageJPEG::decode(LLImageRaw* raw_image, F32 decode_time)
if(setjmp(sSetjmpBuffer))
{
jpeg_destroy_decompress(&cinfo);
- return TRUE; // done
+ return true; // done
}
try
{
@@ -247,11 +247,11 @@ BOOL LLImageJPEG::decode(LLImageRaw* raw_image, F32 decode_time)
////////////////////////////////////////
// Step 3: read file parameters with jpeg_read_header()
- jpeg_read_header(&cinfo, TRUE);
+ jpeg_read_header(&cinfo, true);
// We can ignore the return value from jpeg_read_header since
// (a) suspension is not possible with our data source, and
- // (b) we passed TRUE to reject a tables-only JPEG file as an error.
+ // (b) we passed true to reject a tables-only JPEG file as an error.
// See libjpeg.doc for more info.
setSize(cinfo.image_width, cinfo.image_height, 3); // Force to 3 components (RGB)
@@ -314,7 +314,7 @@ BOOL LLImageJPEG::decode(LLImageRaw* raw_image, F32 decode_time)
catch (int)
{
jpeg_destroy_decompress(&cinfo);
- return TRUE; // done
+ return true; // done
}
// Check to see whether any corrupt-data warnings occurred
@@ -322,10 +322,10 @@ BOOL LLImageJPEG::decode(LLImageRaw* raw_image, F32 decode_time)
{
// TODO: extract the warning to find out what went wrong.
setLastError( "Unable to decode JPEG image.");
- return TRUE; // done
+ return true; // done
}
- return TRUE;
+ return true;
}
@@ -344,11 +344,11 @@ void LLImageJPEG::encodeInitDestination ( j_compress_ptr cinfo )
//
// In typical applications, this should write the entire output buffer
// (ignoring the current state of next_output_byte & free_in_buffer),
-// reset the pointer & count to the start of the buffer, and return TRUE
+// reset the pointer & count to the start of the buffer, and return true
// indicating that the buffer has been dumped.
//
// In applications that need to be able to suspend compression due to output
-// overrun, a FALSE return indicates that the buffer cannot be emptied now.
+// overrun, a false return indicates that the buffer cannot be emptied now.
// In this situation, the compressor will return to its caller (possibly with
// an indication that it has not accepted all the supplied scanlines). The
// application should resume compression after it has made more room in the
@@ -357,7 +357,7 @@ void LLImageJPEG::encodeInitDestination ( j_compress_ptr cinfo )
//
// When suspending, the compressor will back up to a convenient restart point
// (typically the start of the current MCU). next_output_byte & free_in_buffer
-// indicate where the restart point will be if the current call returns FALSE.
+// indicate where the restart point will be if the current call returns false.
// Data beyond this point will be regenerated after resumption, so do not
// write it out when emptying the buffer externally.
@@ -374,7 +374,7 @@ boolean LLImageJPEG::encodeEmptyOutputBuffer( j_compress_ptr cinfo )
if (!new_buffer)
{
LL_ERRS() << "Out of memory in LLImageJPEG::encodeEmptyOutputBuffer( j_compress_ptr cinfo )" << LL_ENDL;
- return FALSE;
+ return false;
}
memcpy( new_buffer, self->mOutputBuffer, self->mOutputBufferSize ); /* Flawfinder: ignore */
delete[] self->mOutputBuffer;
@@ -386,7 +386,7 @@ boolean LLImageJPEG::encodeEmptyOutputBuffer( j_compress_ptr cinfo )
self->mOutputBufferSize = new_buffer_size;
self->claimMem(new_buffer_size);
- return TRUE;
+ return true;
}
// Terminate destination --- called by jpeg_finish_compress
@@ -465,11 +465,11 @@ void LLImageJPEG::errorOutputMessage( j_common_ptr cinfo )
std::string error = buffer ;
LLImage::setLastError(error);
- BOOL is_decode = (cinfo->is_decompressor != 0);
+ bool is_decode = (cinfo->is_decompressor != 0);
LL_WARNS() << "LLImageJPEG " << (is_decode ? "decode " : "encode ") << " failed: " << buffer << LL_ENDL;
}
-BOOL LLImageJPEG::encode( const LLImageRaw* raw_image, F32 encode_time )
+bool LLImageJPEG::encode( const LLImageRaw* raw_image, F32 encode_time )
{
llassert_always(raw_image);
@@ -482,7 +482,7 @@ BOOL LLImageJPEG::encode( const LLImageRaw* raw_image, F32 encode_time )
break;
default:
setLastError("Unable to encode a JPEG image that doesn't have 1 or 3 components.");
- return FALSE;
+ return false;
}
setSize(raw_image->getWidth(), raw_image->getHeight(), raw_image->getComponents());
@@ -531,7 +531,7 @@ BOOL LLImageJPEG::encode( const LLImageRaw* raw_image, F32 encode_time )
mOutputBuffer = NULL;
disclaimMem(mOutputBufferSize);
mOutputBufferSize = 0;
- return FALSE;
+ return false;
}
try
@@ -576,7 +576,7 @@ BOOL LLImageJPEG::encode( const LLImageRaw* raw_image, F32 encode_time )
break;
default:
setLastError("Unable to encode a JPEG image that doesn't have 1 or 3 components.");
- return FALSE;
+ return false;
}
// Now use the library's routine to set default compression parameters.
@@ -585,15 +585,15 @@ BOOL LLImageJPEG::encode( const LLImageRaw* raw_image, F32 encode_time )
jpeg_set_defaults(&cinfo);
// Now you can set any non-default parameters you wish to.
- jpeg_set_quality(&cinfo, mEncodeQuality, TRUE ); // limit to baseline-JPEG values
+ jpeg_set_quality(&cinfo, mEncodeQuality, true ); // limit to baseline-JPEG values
////////////////////////////////////////
// Step 4: Start compressor
//
- // TRUE ensures that we will write a complete interchange-JPEG file.
- // Pass TRUE unless you are very sure of what you're doing.
+ // true ensures that we will write a complete interchange-JPEG file.
+ // Pass true unless you are very sure of what you're doing.
- jpeg_start_compress(&cinfo, TRUE);
+ jpeg_start_compress(&cinfo, true);
////////////////////////////////////////
// Step 5: while (scan lines remain to be written)
@@ -647,8 +647,8 @@ BOOL LLImageJPEG::encode( const LLImageRaw* raw_image, F32 encode_time )
mOutputBuffer = NULL;
disclaimMem(mOutputBufferSize);
mOutputBufferSize = 0;
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
diff --git a/indra/llimage/llimagejpeg.h b/indra/llimage/llimagejpeg.h
index 2142660c81..7a849a8421 100644
--- a/indra/llimage/llimagejpeg.h
+++ b/indra/llimage/llimagejpeg.h
@@ -51,9 +51,9 @@ public:
LLImageJPEG(S32 quality = 75);
/*virtual*/ std::string getExtension() { return std::string("jpg"); }
- /*virtual*/ BOOL updateData();
- /*virtual*/ BOOL decode(LLImageRaw* raw_image, F32 decode_time);
- /*virtual*/ BOOL encode(const LLImageRaw* raw_image, F32 encode_time);
+ /*virtual*/ bool updateData();
+ /*virtual*/ bool decode(LLImageRaw* raw_image, F32 decode_time);
+ /*virtual*/ bool encode(const LLImageRaw* raw_image, F32 encode_time);
void setEncodeQuality( S32 q ) { mEncodeQuality = q; } // on a scale from 1 to 100
S32 getEncodeQuality() { return mEncodeQuality; }
@@ -73,7 +73,7 @@ public:
static void errorEmitMessage(j_common_ptr cinfo, int msg_level);
static void errorOutputMessage(j_common_ptr cinfo);
- static BOOL decompress(LLImageJPEG* imagep);
+ static bool decompress(LLImageJPEG* imagep);
protected:
U8* mOutputBuffer; // temp buffer used during encoding
diff --git a/indra/llimage/llimagepng.cpp b/indra/llimage/llimagepng.cpp
index 7735dc1379..a299602d79 100644
--- a/indra/llimage/llimagepng.cpp
+++ b/indra/llimage/llimagepng.cpp
@@ -47,7 +47,7 @@ LLImagePNG::~LLImagePNG()
// Virtual
// Parse PNG image information and set the appropriate
// width, height and component (channel) information.
-BOOL LLImagePNG::updateData()
+bool LLImagePNG::updateData()
{
resetLastError();
@@ -55,7 +55,7 @@ BOOL LLImagePNG::updateData()
if (!getData() || (0 == getDataSize()))
{
setLastError("Uninitialized instance of LLImagePNG");
- return FALSE;
+ return false;
}
// Decode the PNG data and extract sizing information
@@ -63,25 +63,25 @@ BOOL LLImagePNG::updateData()
if (!pngWrapper.isValidPng(getData()))
{
setLastError("LLImagePNG data does not have a valid PNG header!");
- return FALSE;
+ return false;
}
LLPngWrapper::ImageInfo infop;
if (! pngWrapper.readPng(getData(), getDataSize(), NULL, &infop))
{
setLastError(pngWrapper.getErrorMessage());
- return FALSE;
+ return false;
}
setSize(infop.mWidth, infop.mHeight, infop.mComponents);
- return TRUE;
+ return true;
}
// Virtual
// Decode an in-memory PNG image into the raw RGB or RGBA format
// used within SecondLife.
-BOOL LLImagePNG::decode(LLImageRaw* raw_image, F32 decode_time)
+bool LLImagePNG::decode(LLImageRaw* raw_image, F32 decode_time)
{
llassert_always(raw_image);
@@ -91,7 +91,7 @@ BOOL LLImagePNG::decode(LLImageRaw* raw_image, F32 decode_time)
if (!getData() || (0 == getDataSize()))
{
setLastError("LLImagePNG trying to decode an image with no data!");
- return FALSE;
+ return false;
}
// Decode the PNG data into the raw image
@@ -99,21 +99,21 @@ BOOL LLImagePNG::decode(LLImageRaw* raw_image, F32 decode_time)
if (!pngWrapper.isValidPng(getData()))
{
setLastError("LLImagePNG data does not have a valid PNG header!");
- return FALSE;
+ return false;
}
if (! pngWrapper.readPng(getData(), getDataSize(), raw_image))
{
setLastError(pngWrapper.getErrorMessage());
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
// Virtual
// Encode the in memory RGB image into PNG format.
-BOOL LLImagePNG::encode(const LLImageRaw* raw_image, F32 encode_time)
+bool LLImagePNG::encode(const LLImageRaw* raw_image, F32 encode_time)
{
llassert_always(raw_image);
@@ -133,7 +133,7 @@ BOOL LLImagePNG::encode(const LLImageRaw* raw_image, F32 encode_time)
{
setLastError(pngWrapper.getErrorMessage());
delete[] tmpWriteBuffer;
- return FALSE;
+ return false;
}
// Resize internal buffer and copy from temp
@@ -143,6 +143,6 @@ BOOL LLImagePNG::encode(const LLImageRaw* raw_image, F32 encode_time)
delete[] tmpWriteBuffer;
- return TRUE;
+ return true;
}
diff --git a/indra/llimage/llimagepng.h b/indra/llimage/llimagepng.h
index 1fbd850a2e..ef16f2996f 100644
--- a/indra/llimage/llimagepng.h
+++ b/indra/llimage/llimagepng.h
@@ -38,9 +38,9 @@ public:
LLImagePNG();
/*virtual*/ std::string getExtension() { return std::string("png"); }
- /*virtual*/ BOOL updateData();
- /*virtual*/ BOOL decode(LLImageRaw* raw_image, F32 decode_time);
- /*virtual*/ BOOL encode(const LLImageRaw* raw_image, F32 encode_time);
+ /*virtual*/ bool updateData();
+ /*virtual*/ bool decode(LLImageRaw* raw_image, F32 decode_time);
+ /*virtual*/ bool encode(const LLImageRaw* raw_image, F32 encode_time);
};
#endif
diff --git a/indra/llimage/llimagetga.cpp b/indra/llimage/llimagetga.cpp
index d0ae105ba7..5ad7658ec1 100644
--- a/indra/llimage/llimagetga.cpp
+++ b/indra/llimage/llimagetga.cpp
@@ -61,7 +61,7 @@ LLImageTGA::LLImageTGA()
mColorMapStart( 0 ),
mColorMapLength( 0 ),
mColorMapBytesPerEntry( 0 ),
- mIs15Bit( FALSE ),
+ mIs15Bit( false ),
mAttributeBits(0),
mColorMapDepth(0),
@@ -94,7 +94,7 @@ LLImageTGA::LLImageTGA(const std::string& file_name)
mColorMapStart( 0 ),
mColorMapLength( 0 ),
mColorMapBytesPerEntry( 0 ),
- mIs15Bit( FALSE )
+ mIs15Bit( false )
{
loadFile(file_name);
}
@@ -104,7 +104,7 @@ LLImageTGA::~LLImageTGA()
delete [] mColorMap;
}
-BOOL LLImageTGA::updateData()
+bool LLImageTGA::updateData()
{
resetLastError();
@@ -112,7 +112,7 @@ BOOL LLImageTGA::updateData()
if (!getData() || (0 == getDataSize()))
{
setLastError("LLImageTGA uninitialized");
- return FALSE;
+ return false;
}
// Pull image information from the header...
@@ -185,13 +185,13 @@ BOOL LLImageTGA::updateData()
case 0:
// No image data included in file
setLastError("Unable to load file. TGA file contains no image data.");
- return FALSE;
+ return false;
case 1:
// Colormapped uncompressed
if( 8 != mPixelSize )
{
setLastError("Unable to load file. Colormapped images must have 8 bits per pixel.");
- return FALSE;
+ return false;
}
break;
case 2:
@@ -202,7 +202,7 @@ BOOL LLImageTGA::updateData()
if( 8 != mPixelSize )
{
setLastError("Unable to load file. Monochrome images must have 8 bits per pixel.");
- return FALSE;
+ return false;
}
break;
case 9:
@@ -216,12 +216,12 @@ BOOL LLImageTGA::updateData()
if( 8 != mPixelSize )
{
setLastError("Unable to load file. Monochrome images must have 8 bits per pixel.");
- return FALSE;
+ return false;
}
break;
default:
setLastError("Unable to load file. Unrecoginzed TGA image type.");
- return FALSE;
+ return false;
}
// discard the ID field, if any
@@ -266,8 +266,8 @@ BOOL LLImageTGA::updateData()
mColorMap = new U8[ color_map_bytes ];
if (!mColorMap)
{
- LL_ERRS() << "Out of Memory in BOOL LLImageTGA::updateData()" << LL_ENDL;
- return FALSE;
+ LL_ERRS() << "Out of Memory in bool LLImageTGA::updateData()" << LL_ENDL;
+ return false;
}
memcpy( mColorMap, getData() + mDataOffset, color_map_bytes ); /* Flawfinder: ignore */
}
@@ -302,28 +302,28 @@ BOOL LLImageTGA::updateData()
// if( mAttributeBits != 8 )
// {
// setLastError("Unable to load file. 32 bit TGA image does not have 8 bits of alpha.");
-// return FALSE;
+// return false;
// }
mAttributeBits = 8;
break;
case 15:
case 16:
components = 3;
- mIs15Bit = TRUE; // 16th bit is used for Targa hardware interupts and is ignored.
+ mIs15Bit = true; // 16th bit is used for Targa hardware interupts and is ignored.
break;
case 8:
components = 1;
break;
default:
setLastError("Unable to load file. Unknown pixel size.");
- return FALSE;
+ return false;
}
setSize(width, height, components);
- return TRUE;
+ return true;
}
-BOOL LLImageTGA::decode(LLImageRaw* raw_image, F32 decode_time)
+bool LLImageTGA::decode(LLImageRaw* raw_image, F32 decode_time)
{
llassert_always(raw_image);
@@ -331,7 +331,7 @@ BOOL LLImageTGA::decode(LLImageRaw* raw_image, F32 decode_time)
if (!getData() || (0 == getDataSize()))
{
setLastError("LLImageTGA trying to decode an image with no data!");
- return FALSE;
+ return false;
}
// Copy everything after the header.
@@ -343,18 +343,18 @@ BOOL LLImageTGA::decode(LLImageRaw* raw_image, F32 decode_time)
(getComponents() != 4) )
{
setLastError("TGA images with a number of components other than 1, 3, and 4 are not supported.");
- return FALSE;
+ return false;
}
if( mOriginRightBit )
{
setLastError("TGA images with origin on right side are not supported.");
- return FALSE;
+ return false;
}
- BOOL flipped = (mOriginTopBit != 0);
- BOOL rle_compressed = ((mImageType & 0x08) != 0);
+ bool flipped = (mOriginTopBit != 0);
+ bool rle_compressed = ((mImageType & 0x08) != 0);
if( mColorMap )
{
@@ -366,10 +366,10 @@ BOOL LLImageTGA::decode(LLImageRaw* raw_image, F32 decode_time)
}
}
-BOOL LLImageTGA::decodeTruecolor( LLImageRaw* raw_image, BOOL rle, BOOL flipped )
+bool LLImageTGA::decodeTruecolor( LLImageRaw* raw_image, bool rle, bool flipped )
{
- BOOL success = FALSE;
- BOOL alpha_opaque = FALSE;
+ bool success = false;
+ bool alpha_opaque = false;
if( rle )
{
@@ -404,7 +404,7 @@ BOOL LLImageTGA::decodeTruecolor( LLImageRaw* raw_image, BOOL rle, BOOL flipped
}
else
{
- BOOL alpha_opaque;
+ bool alpha_opaque;
success = decodeTruecolorNonRle( raw_image, alpha_opaque );
if (alpha_opaque && raw_image->getComponents() == 4)
{
@@ -430,9 +430,9 @@ BOOL LLImageTGA::decodeTruecolor( LLImageRaw* raw_image, BOOL rle, BOOL flipped
}
-BOOL LLImageTGA::decodeTruecolorNonRle( LLImageRaw* raw_image, BOOL &alpha_opaque )
+bool LLImageTGA::decodeTruecolorNonRle( LLImageRaw* raw_image, bool &alpha_opaque )
{
- alpha_opaque = TRUE;
+ alpha_opaque = true;
// Origin is the bottom left
U8* dst = raw_image->getData();
@@ -442,7 +442,7 @@ BOOL LLImageTGA::decodeTruecolorNonRle( LLImageRaw* raw_image, BOOL &alpha_opaqu
if (pixels * (mIs15Bit ? 2 : getComponents()) > getDataSize() - mDataOffset)
{ //here we have situation when data size in src less than actually needed
- return FALSE;
+ return false;
}
if (getComponents() == 4)
@@ -456,7 +456,7 @@ BOOL LLImageTGA::decodeTruecolorNonRle( LLImageRaw* raw_image, BOOL &alpha_opaqu
dst[3] = src[3]; // Alpha
if (dst[3] != 255)
{
- alpha_opaque = FALSE;
+ alpha_opaque = false;
}
dst += 4;
src += 4;
@@ -490,7 +490,7 @@ BOOL LLImageTGA::decodeTruecolorNonRle( LLImageRaw* raw_image, BOOL &alpha_opaqu
memcpy(dst, src, pixels); /* Flawfinder: ignore */
}
- return TRUE;
+ return true;
}
void LLImageTGA::decodeColorMapPixel8( U8* dst, const U8* src )
@@ -523,14 +523,14 @@ void LLImageTGA::decodeColorMapPixel32( U8* dst, const U8* src )
}
-BOOL LLImageTGA::decodeColorMap( LLImageRaw* raw_image, BOOL rle, BOOL flipped )
+bool LLImageTGA::decodeColorMap( LLImageRaw* raw_image, bool rle, bool flipped )
{
// If flipped, origin is the top left. Need to reverse the order of the rows.
// Otherwise the origin is the bottom left.
if( 8 != mPixelSize )
{
- return FALSE;
+ return false;
}
U8* src = getData() + mDataOffset;
@@ -544,7 +544,7 @@ BOOL LLImageTGA::decodeColorMap( LLImageRaw* raw_image, BOOL rle, BOOL flipped )
case 2: pixel_decoder = &LLImageTGA::decodeColorMapPixel15; break;
case 3: pixel_decoder = &LLImageTGA::decodeColorMapPixel24; break;
case 4: pixel_decoder = &LLImageTGA::decodeColorMapPixel32; break;
- default: llassert(0); return FALSE;
+ default: llassert(0); return false;
}
if( rle )
@@ -613,12 +613,12 @@ BOOL LLImageTGA::decodeColorMap( LLImageRaw* raw_image, BOOL rle, BOOL flipped )
}
}
- return TRUE;
+ return true;
}
-BOOL LLImageTGA::encode(const LLImageRaw* raw_image, F32 encode_time)
+bool LLImageTGA::encode(const LLImageRaw* raw_image, F32 encode_time)
{
llassert_always(raw_image);
@@ -642,7 +642,7 @@ BOOL LLImageTGA::encode(const LLImageRaw* raw_image, F32 encode_time)
mImageType = 2;
break;
default:
- return FALSE;
+ return false;
}
// Color map stuff (unsupported)
@@ -678,7 +678,7 @@ BOOL LLImageTGA::encode(const LLImageRaw* raw_image, F32 encode_time)
bytes_per_pixel = 4;
break;
default:
- return FALSE;
+ return false;
}
mPixelSize = U8(bytes_per_pixel * 8); // 8, 16, 24, 32 bits per pixel
@@ -765,13 +765,13 @@ BOOL LLImageTGA::encode(const LLImageRaw* raw_image, F32 encode_time)
break;
}
- return TRUE;
+ return true;
}
-BOOL LLImageTGA::decodeTruecolorRle32( LLImageRaw* raw_image, BOOL &alpha_opaque )
+bool LLImageTGA::decodeTruecolorRle32( LLImageRaw* raw_image, bool &alpha_opaque )
{
llassert( getComponents() == 4 );
- alpha_opaque = TRUE;
+ alpha_opaque = true;
U8* dst = raw_image->getData();
U32* dst_pixels = (U32*) dst;
@@ -788,7 +788,7 @@ BOOL LLImageTGA::decodeTruecolorRle32( LLImageRaw* raw_image, BOOL &alpha_opaque
// Read RLE block header
if (src >= last_src)
- return FALSE;
+ return false;
U8 block_header_byte = *src;
src++;
@@ -799,7 +799,7 @@ BOOL LLImageTGA::decodeTruecolorRle32( LLImageRaw* raw_image, BOOL &alpha_opaque
// Encoded (duplicate-pixel) block
if (src + 3 >= last_src)
- return FALSE;
+ return false;
rgba_byte_p[0] = src[2];
rgba_byte_p[1] = src[1];
@@ -807,7 +807,7 @@ BOOL LLImageTGA::decodeTruecolorRle32( LLImageRaw* raw_image, BOOL &alpha_opaque
rgba_byte_p[3] = src[3];
if (rgba_byte_p[3] != 255)
{
- alpha_opaque = FALSE;
+ alpha_opaque = false;
}
src += 4;
@@ -826,7 +826,7 @@ BOOL LLImageTGA::decodeTruecolorRle32( LLImageRaw* raw_image, BOOL &alpha_opaque
do
{
if (src + 3 >= last_src)
- return FALSE;
+ return false;
((U8*)dst_pixels)[0] = src[2];
((U8*)dst_pixels)[1] = src[1];
@@ -834,7 +834,7 @@ BOOL LLImageTGA::decodeTruecolorRle32( LLImageRaw* raw_image, BOOL &alpha_opaque
((U8*)dst_pixels)[3] = src[3];
if (src[3] != 255)
{
- alpha_opaque = FALSE;
+ alpha_opaque = false;
}
src += 4;
dst_pixels++;
@@ -844,10 +844,10 @@ BOOL LLImageTGA::decodeTruecolorRle32( LLImageRaw* raw_image, BOOL &alpha_opaque
}
}
- return TRUE;
+ return true;
}
-BOOL LLImageTGA::decodeTruecolorRle15( LLImageRaw* raw_image )
+bool LLImageTGA::decodeTruecolorRle15( LLImageRaw* raw_image )
{
llassert( getComponents() == 3 );
llassert( mIs15Bit );
@@ -863,7 +863,7 @@ BOOL LLImageTGA::decodeTruecolorRle15( LLImageRaw* raw_image )
// Read RLE block header
if (src >= last_src)
- return FALSE;
+ return false;
U8 block_header_byte = *src;
src++;
@@ -875,7 +875,7 @@ BOOL LLImageTGA::decodeTruecolorRle15( LLImageRaw* raw_image )
do
{
if (src + 2 >= last_src)
- return FALSE;
+ return false;
decodeTruecolorPixel15( dst, src ); // slow
dst += 3;
@@ -890,7 +890,7 @@ BOOL LLImageTGA::decodeTruecolorRle15( LLImageRaw* raw_image )
do
{
if (src + 2 >= last_src)
- return FALSE;
+ return false;
decodeTruecolorPixel15( dst, src );
dst += 3;
@@ -901,12 +901,12 @@ BOOL LLImageTGA::decodeTruecolorRle15( LLImageRaw* raw_image )
}
}
- return TRUE;
+ return true;
}
-BOOL LLImageTGA::decodeTruecolorRle24( LLImageRaw* raw_image )
+bool LLImageTGA::decodeTruecolorRle24( LLImageRaw* raw_image )
{
llassert( getComponents() == 3 );
@@ -921,7 +921,7 @@ BOOL LLImageTGA::decodeTruecolorRle24( LLImageRaw* raw_image )
// Read RLE block header
if (src >= last_src)
- return FALSE;
+ return false;
U8 block_header_byte = *src;
src++;
@@ -933,7 +933,7 @@ BOOL LLImageTGA::decodeTruecolorRle24( LLImageRaw* raw_image )
do
{
if (src + 2 >= last_src)
- return FALSE;
+ return false;
dst[0] = src[2];
dst[1] = src[1];
dst[2] = src[0];
@@ -949,7 +949,7 @@ BOOL LLImageTGA::decodeTruecolorRle24( LLImageRaw* raw_image )
do
{
if (src + 2 >= last_src)
- return FALSE;
+ return false;
dst[0] = src[2];
dst[1] = src[1];
@@ -962,11 +962,11 @@ BOOL LLImageTGA::decodeTruecolorRle24( LLImageRaw* raw_image )
}
}
- return TRUE;
+ return true;
}
-BOOL LLImageTGA::decodeTruecolorRle8( LLImageRaw* raw_image )
+bool LLImageTGA::decodeTruecolorRle8( LLImageRaw* raw_image )
{
llassert( getComponents() == 1 );
@@ -981,7 +981,7 @@ BOOL LLImageTGA::decodeTruecolorRle8( LLImageRaw* raw_image )
// Read RLE block header
if (src >= last_src)
- return FALSE;
+ return false;
U8 block_header_byte = *src;
src++;
@@ -990,7 +990,7 @@ BOOL LLImageTGA::decodeTruecolorRle8( LLImageRaw* raw_image )
if( block_header_byte & 0x80 )
{
if (src >= last_src)
- return FALSE;
+ return false;
// Encoded (duplicate-pixel) block
memset( dst, *src, block_pixel_count );
@@ -1003,7 +1003,7 @@ BOOL LLImageTGA::decodeTruecolorRle8( LLImageRaw* raw_image )
do
{
if (src >= last_src)
- return FALSE;
+ return false;
*dst = *src;
dst++;
@@ -1014,13 +1014,13 @@ BOOL LLImageTGA::decodeTruecolorRle8( LLImageRaw* raw_image )
}
}
- return TRUE;
+ return true;
}
// Decoded and process the image for use in avatar gradient masks.
// Processing happens during the decode for speed.
-BOOL LLImageTGA::decodeAndProcess( LLImageRaw* raw_image, F32 domain, F32 weight )
+bool LLImageTGA::decodeAndProcess( LLImageRaw* raw_image, F32 domain, F32 weight )
{
llassert_always(raw_image);
@@ -1043,14 +1043,14 @@ BOOL LLImageTGA::decodeAndProcess( LLImageRaw* raw_image, F32 domain, F32 weight
if (!getData() || (0 == getDataSize()))
{
setLastError("LLImageTGA trying to decode an image with no data!");
- return FALSE;
+ return false;
}
// Only works for unflipped monochrome RLE images
if( (getComponents() != 1) || (mImageType != 11) || mOriginTopBit || mOriginRightBit )
{
LL_ERRS() << "LLImageTGA trying to alpha-gradient process an image that's not a standard RLE, one component image" << LL_ENDL;
- return FALSE;
+ return false;
}
raw_image->resize(getWidth(), getHeight(), getComponents());
@@ -1136,7 +1136,7 @@ BOOL LLImageTGA::decodeAndProcess( LLImageRaw* raw_image, F32 domain, F32 weight
}
}
}
- return TRUE;
+ return true;
}
// Reads a .tga file and creates an LLImageTGA with its data.
diff --git a/indra/llimage/llimagetga.h b/indra/llimage/llimagetga.h
index 5da3525149..b1f34dcdad 100644
--- a/indra/llimage/llimagetga.h
+++ b/indra/llimage/llimagetga.h
@@ -41,25 +41,25 @@ public:
LLImageTGA(const std::string& file_name);
/*virtual*/ std::string getExtension() { return std::string("tga"); }
- /*virtual*/ BOOL updateData();
- /*virtual*/ BOOL decode(LLImageRaw* raw_image, F32 decode_time=0.0);
- /*virtual*/ BOOL encode(const LLImageRaw* raw_image, F32 encode_time=0.0);
+ /*virtual*/ bool updateData();
+ /*virtual*/ bool decode(LLImageRaw* raw_image, F32 decode_time=0.0);
+ /*virtual*/ bool encode(const LLImageRaw* raw_image, F32 encode_time=0.0);
- BOOL decodeAndProcess(LLImageRaw* raw_image, F32 domain, F32 weight);
+ bool decodeAndProcess(LLImageRaw* raw_image, F32 domain, F32 weight);
private:
- BOOL decodeTruecolor( LLImageRaw* raw_image, BOOL rle, BOOL flipped );
+ bool decodeTruecolor( LLImageRaw* raw_image, bool rle, bool flipped );
- BOOL decodeTruecolorRle8( LLImageRaw* raw_image );
- BOOL decodeTruecolorRle15( LLImageRaw* raw_image );
- BOOL decodeTruecolorRle24( LLImageRaw* raw_image );
- BOOL decodeTruecolorRle32( LLImageRaw* raw_image, BOOL &alpha_opaque );
+ bool decodeTruecolorRle8( LLImageRaw* raw_image );
+ bool decodeTruecolorRle15( LLImageRaw* raw_image );
+ bool decodeTruecolorRle24( LLImageRaw* raw_image );
+ bool decodeTruecolorRle32( LLImageRaw* raw_image, bool &alpha_opaque );
void decodeTruecolorPixel15( U8* dst, const U8* src );
- BOOL decodeTruecolorNonRle( LLImageRaw* raw_image, BOOL &alpha_opaque );
+ bool decodeTruecolorNonRle( LLImageRaw* raw_image, bool &alpha_opaque );
- BOOL decodeColorMap( LLImageRaw* raw_image, BOOL rle, BOOL flipped );
+ bool decodeColorMap( LLImageRaw* raw_image, bool rle, bool flipped );
void decodeColorMapPixel8(U8* dst, const U8* src);
void decodeColorMapPixel15(U8* dst, const U8* src);
@@ -100,7 +100,7 @@ private:
S32 mColorMapLength;
S32 mColorMapBytesPerEntry;
- BOOL mIs15Bit;
+ bool mIs15Bit;
static const U8 s5to8bits[32];
};
diff --git a/indra/llimage/llpngwrapper.cpp b/indra/llimage/llpngwrapper.cpp
index aad139f570..da289ea889 100644
--- a/indra/llimage/llpngwrapper.cpp
+++ b/indra/llimage/llpngwrapper.cpp
@@ -31,6 +31,16 @@
#include "llimage.h"
#include "llpngwrapper.h"
+#include "llexception.h"
+
+namespace {
+// Failure to load an image shouldn't crash the whole viewer.
+struct PngError: public LLContinueError
+{
+ PngError(png_const_charp msg): LLContinueError(msg) {}
+};
+} // anonymous namespace
+
// ---------------------------------------------------------------------------
// LLPngWrapper
// ---------------------------------------------------------------------------
@@ -75,11 +85,10 @@ BOOL LLPngWrapper::isValidPng(U8* src)
}
// Called by the libpng library when a fatal encoding or decoding error
-// occurs. We simply throw the error message and let our try/catch
-// block clean up.
+// occurs. We throw PngError and let our try/catch block clean up.
void LLPngWrapper::errorHandler(png_structp png_ptr, png_const_charp msg)
{
- throw msg;
+ LLTHROW(PngError(msg));
}
// Called by the libpng library when reading (decoding) the PNG file. We
@@ -129,7 +138,7 @@ BOOL LLPngWrapper::readPng(U8* src, S32 dataSize, LLImageRaw* rawImage, ImageInf
this, &errorHandler, NULL);
if (mReadPngPtr == NULL)
{
- throw "Problem creating png read structure";
+ LLTHROW(PngError("Problem creating png read structure"));
}
// Allocate/initialize the memory for image information.
@@ -187,9 +196,9 @@ BOOL LLPngWrapper::readPng(U8* src, S32 dataSize, LLImageRaw* rawImage, ImageInf
mFinalSize = dataPtr.mOffset;
}
- catch (png_const_charp msg)
+ catch (const PngError& msg)
{
- mErrorMessage = msg;
+ mErrorMessage = msg.what();
releaseResources();
return (FALSE);
}
@@ -288,14 +297,14 @@ BOOL LLPngWrapper::writePng(const LLImageRaw* rawImage, U8* dest)
if (mColorType == -1)
{
- throw "Unsupported image: unexpected number of channels";
+ LLTHROW(PngError("Unsupported image: unexpected number of channels"));
}
mWritePngPtr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
NULL, &errorHandler, NULL);
if (!mWritePngPtr)
{
- throw "Problem creating png write structure";
+ LLTHROW(PngError("Problem creating png write structure"));
}
mWriteInfoPtr = png_create_info_struct(mWritePngPtr);
@@ -339,9 +348,9 @@ BOOL LLPngWrapper::writePng(const LLImageRaw* rawImage, U8* dest)
png_write_end(mWritePngPtr, mWriteInfoPtr);
mFinalSize = dataPtr.mOffset;
}
- catch (png_const_charp msg)
+ catch (const PngError& msg)
{
- mErrorMessage = msg;
+ mErrorMessage = msg.what();
releaseResources();
return (FALSE);
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-26 02:32:40 +0000