Pull merge from lindenlab/viewer-release. Fixed some conflicts and compile errors

13 files changed, 104 insertions, 78 deletions

diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp
index 18e08b94a6..d336eeaabc 100755
--- a/indra/llimage/llimage.cpp
+++ b/indra/llimage/llimage.cpp
@@ -26,6 +26,7 @@
 
 #include "linden_common.h"
 
+#include "llimageworker.h"
 #include "llimage.h"
 
 #include "llmath.h"
@@ -37,7 +38,6 @@
 #include "llimagejpeg.h"
 #include "llimagepng.h"
 #include "llimagedxt.h"
-#include "llimageworker.h"
 #include "llmemory.h"
 
 //---------------------------------------------------------------------------
@@ -89,15 +89,15 @@ void LLImage::setLastError(const std::string& message)
 //---------------------------------------------------------------------------
 
 LLImageBase::LLImageBase()
-	: mData(NULL),
-	  mDataSize(0),
-	  mWidth(0),
-	  mHeight(0),
-	  mComponents(0),
-	  mBadBufferAllocation(false),
-	  mAllowOverSize(false)
-{
-}
+:	LLTrace::MemTrackable<LLImageBase>("LLImage"),
+	mData(NULL),
+	mDataSize(0),
+	mWidth(0),
+	mHeight(0),
+	mComponents(0),
+	mBadBufferAllocation(false),
+	mAllowOverSize(false)
+{}
 
 // virtual
 LLImageBase::~LLImageBase()
@@ -127,12 +127,12 @@ void LLImageBase::destroyPrivatePool()
 // virtual
 void LLImageBase::dump()
 {
-	llinfos << "LLImageBase mComponents " << mComponents
+	LL_INFOS() << "LLImageBase mComponents " << mComponents
 		<< " mData " << mData
 		<< " mDataSize " << mDataSize
 		<< " mWidth " << mWidth
 		<< " mHeight " << mHeight
-		<< llendl;
+		<< LL_ENDL;
 }
 
 // virtual
@@ -144,13 +144,13 @@ void LLImageBase::sanityCheck()
 		|| mComponents > (S8)MAX_IMAGE_COMPONENTS
 		)
 	{
-		llerrs << "Failed LLImageBase::sanityCheck "
+		LL_ERRS() << "Failed LLImageBase::sanityCheck "
 			   << "width " << mWidth
 			   << "height " << mHeight
 			   << "datasize " << mDataSize
 			   << "components " << mComponents
 			   << "data " << mData
-			   << llendl;
+			   << LL_ENDL;
 	}
 }
 
@@ -158,8 +158,9 @@ void LLImageBase::sanityCheck()
 void LLImageBase::deleteData()
 {
 	FREE_MEM(sPrivatePoolp, mData) ;
-	mData = NULL;
+	disclaimMem(mDataSize);
 	mDataSize = 0;
+	mData = NULL;
 }
 
 // virtual
@@ -170,7 +171,7 @@ U8* LLImageBase::allocateData(S32 size)
 		size = mWidth * mHeight * mComponents;
 		if (size <= 0)
 		{
-			llerrs << llformat("LLImageBase::allocateData called with bad dimensions: %dx%dx%d",mWidth,mHeight,(S32)mComponents) << llendl;
+			LL_ERRS() << llformat("LLImageBase::allocateData called with bad dimensions: %dx%dx%d",mWidth,mHeight,(S32)mComponents) << LL_ENDL;
 		}
 	}
 	
@@ -178,14 +179,14 @@ U8* LLImageBase::allocateData(S32 size)
 	static const U32 MAX_BUFFER_SIZE = 4096 * 4096 * 16 ; //256 MB
 	if (size < 1 || size > MAX_BUFFER_SIZE) 
 	{
-		llinfos << "width: " << mWidth << " height: " << mHeight << " components: " << mComponents << llendl ;
+		LL_INFOS() << "width: " << mWidth << " height: " << mHeight << " components: " << mComponents << LL_ENDL ;
 		if(mAllowOverSize)
 		{
-			llinfos << "Oversize: " << size << llendl ;
+			LL_INFOS() << "Oversize: " << size << LL_ENDL ;
 		}
 		else
 		{
-			llerrs << "LLImageBase::allocateData: bad size: " << size << llendl;
+			LL_ERRS() << "LLImageBase::allocateData: bad size: " << size << LL_ENDL;
 		}
 	}
 	if (!mData || size != mDataSize)
@@ -195,12 +196,13 @@ U8* LLImageBase::allocateData(S32 size)
 		mData = (U8*)ALLOCATE_MEM(sPrivatePoolp, size);
 		if (!mData)
 		{
-			llwarns << "Failed to allocate image data size [" << size << "]" << llendl;
+			LL_WARNS() << "Failed to allocate image data size [" << size << "]" << LL_ENDL;
 			size = 0 ;
 			mWidth = mHeight = 0 ;
 			mBadBufferAllocation = true ;
 		}
 		mDataSize = size;
+		claimMem(mDataSize);
 	}
 
 	return mData;
@@ -212,7 +214,7 @@ U8* LLImageBase::reallocateData(S32 size)
 	U8 *new_datap = (U8*)ALLOCATE_MEM(sPrivatePoolp, size);
 	if (!new_datap)
 	{
-		llwarns << "Out of memory in LLImageBase::reallocateData" << llendl;
+		LL_WARNS() << "Out of memory in LLImageBase::reallocateData" << LL_ENDL;
 		return 0;
 	}
 	if (mData)
@@ -222,7 +224,9 @@ U8* LLImageBase::reallocateData(S32 size)
 		FREE_MEM(sPrivatePoolp, mData) ;
 	}
 	mData = new_datap;
+	disclaimMem(mDataSize);
 	mDataSize = size;
+	claimMem(mDataSize);
 	return mData;
 }
 
@@ -230,7 +234,7 @@ const U8* LLImageBase::getData() const
 { 
 	if(mBadBufferAllocation)
 	{
-		llerrs << "Bad memory allocation for the image buffer!" << llendl ;
+		LL_ERRS() << "Bad memory allocation for the image buffer!" << LL_ENDL ;
 	}
 
 	return mData; 
@@ -240,7 +244,7 @@ U8* LLImageBase::getData()
 { 
 	if(mBadBufferAllocation)
 	{
-		llerrs << "Bad memory allocation for the image buffer!" << llendl ;
+		LL_ERRS() << "Bad memory allocation for the image buffer!" << LL_ENDL ;
 	}
 
 	return mData; 
@@ -288,7 +292,6 @@ LLImageRaw::LLImageRaw(U16 width, U16 height, S8 components)
 LLImageRaw::LLImageRaw(U8 *data, U16 width, U16 height, S8 components, bool no_copy)
 	: LLImageBase()
 {
-
 	if(no_copy)
 	{
 		setDataAndSize(data, width, height, components);
@@ -559,7 +562,7 @@ void LLImageRaw::composite( LLImageRaw* src )
 // Src and dst can be any size.  Src has 4 components.  Dst has 3 components.
 void LLImageRaw::compositeScaled4onto3(LLImageRaw* src)
 {
-	llinfos << "compositeScaled4onto3" << llendl;
+	LL_INFOS() << "compositeScaled4onto3" << LL_ENDL;
 
 	LLImageRaw* dst = this;  // Just for clarity.
 
@@ -702,7 +705,7 @@ void LLImageRaw::copy(LLImageRaw* src)
 {
 	if (!src)
 	{
-		llwarns << "LLImageRaw::copy called with a null src pointer" << llendl;
+		LL_WARNS() << "LLImageRaw::copy called with a null src pointer" << LL_ENDL;
 		return;
 	}
 
@@ -1219,8 +1222,8 @@ bool LLImageRaw::createFromFile(const std::string &filename, bool j2c_lowest_mip
 	llifstream ifs(name, llifstream::binary);
 	if (!ifs.is_open())
 	{
-		// SJB: changed from llinfos to lldebugs to reduce spam
-		lldebugs << "Unable to open image file: " << name << llendl;
+		// SJB: changed from LL_INFOS() to LL_DEBUGS() to reduce spam
+		LL_DEBUGS() << "Unable to open image file: " << name << LL_ENDL;
 		return false;
 	}
 	
@@ -1234,7 +1237,7 @@ bool LLImageRaw::createFromFile(const std::string &filename, bool j2c_lowest_mip
 
 	if (!length)
 	{
-		llinfos << "Zero length file file: " << name << llendl;
+		LL_INFOS() << "Zero length file file: " << name << LL_ENDL;
 		return false;
 	}
 	
@@ -1270,7 +1273,7 @@ bool LLImageRaw::createFromFile(const std::string &filename, bool j2c_lowest_mip
 	if (!success)
 	{
 		deleteData();
-		llwarns << "Unable to decode image" << name << llendl;
+		LL_WARNS() << "Unable to decode image" << name << LL_ENDL;
 		return false;
 	}
 
@@ -1375,11 +1378,11 @@ void LLImageFormatted::dump()
 {
 	LLImageBase::dump();
 
-	llinfos << "LLImageFormatted"
+	LL_INFOS() << "LLImageFormatted"
 			<< " mDecoding " << mDecoding
 			<< " mCodec " << S32(mCodec)
 			<< " mDecoded " << mDecoded
-			<< llendl;
+			<< LL_ENDL;
 }
 
 //----------------------------------------------------------------------------
@@ -1462,11 +1465,11 @@ void LLImageFormatted::sanityCheck()
 
 	if (mCodec >= IMG_CODEC_EOF)
 	{
-		llerrs << "Failed LLImageFormatted::sanityCheck "
+		LL_ERRS() << "Failed LLImageFormatted::sanityCheck "
 			   << "decoding " << S32(mDecoding)
 			   << "decoded " << S32(mDecoded)
 			   << "codec " << S32(mCodec)
-			   << llendl;
+			   << LL_ENDL;
 	}
 }
 
@@ -1613,7 +1616,10 @@ static void avg4_colors2(const U8* a, const U8* b, const U8* c, const U8* d, U8*
 void LLImageBase::setDataAndSize(U8 *data, S32 size)
 { 
 	ll_assert_aligned(data, 16);
-	mData = data; mDataSize = size; 
+	mData = data; 
+	disclaimMem(mDataSize); 
+	mDataSize = size; 
+	claimMem(mDataSize);
 }	
 
 //static
@@ -1641,7 +1647,7 @@ void LLImageBase::generateMip(const U8* indata, U8* mipdata, S32 width, S32 heig
 				*(U8*)data = (U8)(((U32)(indata[0]) + indata[1] + indata[in_width] + indata[in_width+1])>>2);
 				break;
 			  default:
-				llerrs << "generateMmip called with bad num channels" << llendl;
+				LL_ERRS() << "generateMmip called with bad num channels" << LL_ENDL;
 			}
 			indata += nchannels*2;
 			data += nchannels;
@@ -1698,17 +1704,17 @@ F32 LLImageBase::calc_download_priority(F32 virtual_size, F32 visible_pixels, S3
 	bytes_weight *= bytes_weight;
 
 
-	//llinfos << "VS: " << virtual_size << llendl;
+	//LL_INFOS() << "VS: " << virtual_size << LL_ENDL;
 	F32 virtual_size_factor = virtual_size / (10.f*10.f);
 
 	// The goal is for weighted priority to be <= 0 when we've reached a point where
 	// we've sent enough data.
-	//llinfos << "BytesSent: " << bytes_sent << llendl;
-	//llinfos << "BytesWeight: " << bytes_weight << llendl;
-	//llinfos << "PreLog: " << bytes_weight * virtual_size_factor << llendl;
+	//LL_INFOS() << "BytesSent: " << bytes_sent << LL_ENDL;
+	//LL_INFOS() << "BytesWeight: " << bytes_weight << LL_ENDL;
+	//LL_INFOS() << "PreLog: " << bytes_weight * virtual_size_factor << LL_ENDL;
 	w_priority = (F32)log10(bytes_weight * virtual_size_factor);
 
-	//llinfos << "PreScale: " << w_priority << llendl;
+	//LL_INFOS() << "PreScale: " << w_priority << LL_ENDL;
 
 	// We don't want to affect how MANY bytes we send based on the visible pixels, but the order
 	// in which they're sent.  We post-multiply so we don't change the zero point.
diff --git a/indra/llimage/llimage.h b/indra/llimage/llimage.h
index c1ba1e3c21..cd3f76f1fd 100755
--- a/indra/llimage/llimage.h
+++ b/indra/llimage/llimage.h
@@ -29,8 +29,8 @@
 
 #include "lluuid.h"
 #include "llstring.h"
-#include "llthread.h"
 #include "llpointer.h"
+#include "lltrace.h"
 
 const S32 MIN_IMAGE_MIP =  2; // 4x4, only used for expand/contract power of 2
 const S32 MAX_IMAGE_MIP = 11; // 2048x2048
@@ -111,7 +111,9 @@ protected:
 //============================================================================
 // Image base class
 
-class LLImageBase : public LLThreadSafeRefCount
+class LLImageBase 
+:	public LLThreadSafeRefCount,
+	public LLTrace::MemTrackable<LLImageBase>
 {
 protected:
 	virtual ~LLImageBase();
@@ -163,6 +165,8 @@ public:
 	static void destroyPrivatePool() ;
 	static LLPrivateMemoryPool* getPrivatePool() {return sPrivatePoolp;}
 
+	//static LLTrace::MemStatHandle sMemStat;
+
 private:
 	U8 *mData;
 	S32 mDataSize;
diff --git a/indra/llimage/llimagebmp.cpp b/indra/llimage/llimagebmp.cpp
index 60b1c628d7..8573fe0d91 100755
--- a/indra/llimage/llimagebmp.cpp
+++ b/indra/llimage/llimagebmp.cpp
@@ -321,7 +321,7 @@ BOOL LLImageBMP::updateData()
 		mColorPalette = new U8[color_palette_size];
 		if (!mColorPalette)
 		{
-			llerrs << "Out of memory in LLImageBMP::updateData()" << llendl;
+			LL_ERRS() << "Out of memory in LLImageBMP::updateData()" << LL_ENDL;
 			return FALSE;
 		}
 		memcpy( mColorPalette, mdata + FILE_HEADER_SIZE + BITMAP_HEADER_SIZE + extension_size, color_palette_size );	/* Flawfinder: ignore */
@@ -528,7 +528,7 @@ BOOL LLImageBMP::encode(const LLImageRaw* raw_image, F32 encode_time)
 
 	if( (2 == src_components) || (4 == src_components) )
 	{
-		llinfos << "Dropping alpha information during BMP encoding" << llendl;
+		LL_INFOS() << "Dropping alpha information during BMP encoding" << LL_ENDL;
 	}
 
 	setSize(raw_image->getWidth(), raw_image->getHeight(), dst_components);
diff --git a/indra/llimage/llimagedimensionsinfo.cpp b/indra/llimage/llimagedimensionsinfo.cpp
index c6bfa50b40..5bf3f29b3c 100755
--- a/indra/llimage/llimagedimensionsinfo.cpp
+++ b/indra/llimage/llimagedimensionsinfo.cpp
@@ -77,7 +77,7 @@ bool LLImageDimensionsInfo::getImageDimensionsBmp()
 	const S32 DATA_LEN = 26; // BMP header (14) + DIB header size (4) + width (4) + height (4)
 	if (!checkFileLength(DATA_LEN))
 	{
-		llwarns << "Premature end of file" << llendl;
+		LL_WARNS() << "Premature end of file" << LL_ENDL;
 		return false;
 	}
 
@@ -89,7 +89,7 @@ bool LLImageDimensionsInfo::getImageDimensionsBmp()
 	// We only support Windows bitmaps (BM), according to LLImageBMP::updateData().
 	if (signature[0] != 'B' || signature[1] != 'M')
 	{
-		llwarns << "Not a BMP" << llendl;
+		LL_WARNS() << "Not a BMP" << LL_ENDL;
 		return false;
 	}
 
@@ -108,7 +108,7 @@ bool LLImageDimensionsInfo::getImageDimensionsTga()
 	// Make sure the file is long enough.
 	if (!checkFileLength(TGA_FILE_HEADER_SIZE + 1 /* width */ + 1 /* height */))
 	{
-		llwarns << "Premature end of file" << llendl;
+		LL_WARNS() << "Premature end of file" << LL_ENDL;
 		return false;
 	}
 
@@ -127,7 +127,7 @@ bool LLImageDimensionsInfo::getImageDimensionsPng()
 	// Make sure the file is long enough.
 	if (!checkFileLength(PNG_MAGIC_SIZE + 8 + sizeof(S32) * 2 /* width, height */))
 	{
-		llwarns << "Premature end of file" << llendl;
+		LL_WARNS() << "Premature end of file" << LL_ENDL;
 		return false;
 	}
 
@@ -139,7 +139,7 @@ bool LLImageDimensionsInfo::getImageDimensionsPng()
 	// Make sure it's a PNG file.
 	if (memcmp(signature, png_magic, PNG_MAGIC_SIZE) != 0)
 	{
-		llwarns << "Not a PNG" << llendl;
+		LL_WARNS() << "Not a PNG" << LL_ENDL;
 		return false;
 	}
 
@@ -156,7 +156,7 @@ void on_jpeg_error(j_common_ptr cinfo)
 {
 	(void) cinfo;
 	sJpegErrorEncountered = true;
-	llwarns << "Libjpeg has encountered an error!" << llendl;
+	LL_WARNS() << "Libjpeg has encountered an error!" << LL_ENDL;
 }
 
 bool LLImageDimensionsInfo::getImageDimensionsJpeg()
@@ -172,17 +172,17 @@ bool LLImageDimensionsInfo::getImageDimensionsJpeg()
 
 	/* Make sure this is a JPEG file. */
 	const size_t JPEG_MAGIC_SIZE = 2;
-	const uint8_t jpeg_magic[JPEG_MAGIC_SIZE] = {0xFF, 0xD8};
-	uint8_t signature[JPEG_MAGIC_SIZE];
+	const U8 jpeg_magic[JPEG_MAGIC_SIZE] = {0xFF, 0xD8};
+	U8 signature[JPEG_MAGIC_SIZE];
 
 	if (fread(signature, sizeof(signature), 1, fp) != 1)
 	{
-		llwarns << "Premature end of file" << llendl;
+		LL_WARNS() << "Premature end of file" << LL_ENDL;
 		return false;
 	}
 	if (memcmp(signature, jpeg_magic, JPEG_MAGIC_SIZE) != 0)
 	{
-		llwarns << "Not a JPEG" << llendl;
+		LL_WARNS() << "Not a JPEG" << LL_ENDL;
 		return false;
 	}
 	fseek(fp, 0, SEEK_SET); // go back to start of the file
diff --git a/indra/llimage/llimagedimensionsinfo.h b/indra/llimage/llimagedimensionsinfo.h
index 382fdb2a0e..8f716c5d02 100755
--- a/indra/llimage/llimagedimensionsinfo.h
+++ b/indra/llimage/llimagedimensionsinfo.h
@@ -27,6 +27,8 @@
 #ifndef LL_LLIMAGEDIMENSIONSINFO_H
 #define LL_LLIMAGEDIMENSIONSINFO_H
 
+#include "llapr.h"
+
 //-----------------------------------------------------------------------------
 // LLImageDimensionsInfo
 // helper class to get image dimensions WITHOUT loading image to memore
diff --git a/indra/llimage/llimagedxt.cpp b/indra/llimage/llimagedxt.cpp
index 34c6793522..04e0e752eb 100755
--- a/indra/llimage/llimagedxt.cpp
+++ b/indra/llimage/llimagedxt.cpp
@@ -52,7 +52,7 @@ S32 LLImageDXT::formatBits(EFileFormat format)
 	  case FORMAT_RGB8:		return 24;
 	  case FORMAT_RGBA8:	return 32;
 	  default:
-		llerrs << "LLImageDXT::Unknown format: " << format << llendl;
+		LL_ERRS() << "LLImageDXT::Unknown format: " << format << LL_ENDL;
 		return 0;
 	}
 };
@@ -82,7 +82,7 @@ S32 LLImageDXT::formatComponents(EFileFormat format)
 	  case FORMAT_RGB8:		return 3;
 	  case FORMAT_RGBA8:	return 4;
 	  default:
-		llerrs << "LLImageDXT::Unknown format: " << format << llendl;
+		LL_ERRS() << "LLImageDXT::Unknown format: " << format << LL_ENDL;
 		return 0;
 	}
 };
@@ -207,7 +207,7 @@ BOOL LLImageDXT::updateData()
 
 	if (data_size < mHeaderSize)
 	{
-		llerrs << "LLImageDXT: not enough data" << llendl;
+		LL_ERRS() << "LLImageDXT: not enough data" << LL_ENDL;
 	}
 	S32 ncomponents = formatComponents(mFileFormat);
 	setSize(width, height, ncomponents);
@@ -224,7 +224,7 @@ S32 LLImageDXT::getMipOffset(S32 discard)
 {
 	if (mFileFormat >= FORMAT_DXT1 && mFileFormat <= FORMAT_DXT5)
 	{
-		llerrs << "getMipOffset called with old (unsupported) format" << llendl;
+		LL_ERRS() << "getMipOffset called with old (unsupported) format" << LL_ENDL;
 	}
 	S32 width = getWidth(), height = getHeight();
 	S32 num_mips = calcNumMips(width, height);
@@ -251,7 +251,7 @@ void LLImageDXT::setFormat()
 	{
 	  case 3: mFileFormat = FORMAT_DXR1; break;
 	  case 4: mFileFormat = FORMAT_DXR3; break;
-	  default: llerrs << "LLImageDXT::setFormat called with ncomponents = " << ncomponents << llendl;
+	  default: LL_ERRS() << "LLImageDXT::setFormat called with ncomponents = " << ncomponents << LL_ENDL;
 	}
 	mHeaderSize = calcHeaderSize();
 }
@@ -265,7 +265,7 @@ BOOL LLImageDXT::decode(LLImageRaw* raw_image, F32 time)
 	
 	if (mFileFormat >= FORMAT_DXT1 && mFileFormat <= FORMAT_DXR5)
 	{
-		llwarns << "Attempt to decode compressed LLImageDXT to Raw (unsupported)" << llendl;
+		LL_WARNS() << "Attempt to decode compressed LLImageDXT to Raw (unsupported)" << LL_ENDL;
 		return FALSE;
 	}
 	
@@ -303,7 +303,7 @@ BOOL LLImageDXT::getMipData(LLPointer<LLImageRaw>& raw, S32 discard)
 	}
 	else if (discard < mDiscardLevel)
 	{
-		llerrs << "Request for invalid discard level" << llendl;
+		LL_ERRS() << "Request for invalid discard level" << LL_ENDL;
 	}
 	U8* data = getData() + getMipOffset(discard);
 	S32 width = 0;
@@ -331,7 +331,7 @@ BOOL LLImageDXT::encodeDXT(const LLImageRaw* raw_image, F32 time, bool explicit_
 		format = FORMAT_RGBA8;
 		break;
 	  default:
-		llerrs << "LLImageDXT::encode: Unhandled channel number: " << ncomponents << llendl;
+		LL_ERRS() << "LLImageDXT::encode: Unhandled channel number: " << ncomponents << LL_ENDL;
 		return 0;
 	}
 
@@ -422,7 +422,7 @@ bool LLImageDXT::convertToDXR()
 	  case FORMAT_DXT4: newformat = FORMAT_DXR4; break;
 	  case FORMAT_DXT5: newformat = FORMAT_DXR5; break;
 	  default:
-		llwarns << "convertToDXR: can not convert format: " << llformat("0x%08x",getFourCC(mFileFormat)) << llendl;
+		LL_WARNS() << "convertToDXR: can not convert format: " << llformat("0x%08x",getFourCC(mFileFormat)) << LL_ENDL;
 		return false;
 	}
 	mFileFormat = newformat;
@@ -433,7 +433,7 @@ bool LLImageDXT::convertToDXR()
 	U8* newdata = (U8*)ALLOCATE_MEM(LLImageBase::getPrivatePool(), total_bytes);
 	if (!newdata)
 	{
-		llerrs << "Out of memory in LLImageDXT::convertToDXR()" << llendl;
+		LL_ERRS() << "Out of memory in LLImageDXT::convertToDXR()" << LL_ENDL;
 		return false;
 	}
 	llassert(total_bytes > 0);
@@ -466,7 +466,7 @@ S32 LLImageDXT::calcDataSize(S32 discard_level)
 {
 	if (mFileFormat == FORMAT_UNKNOWN)
 	{
-		llerrs << "calcDataSize called with unloaded LLImageDXT" << llendl;
+		LL_ERRS() << "calcDataSize called with unloaded LLImageDXT" << LL_ENDL;
 		return 0;
 	}
 	if (discard_level < 0)
diff --git a/indra/llimage/llimagefilter.h b/indra/llimage/llimagefilter.h
index 0f1cbc3fb8..16ec395f76 100755
--- a/indra/llimage/llimagefilter.h
+++ b/indra/llimage/llimagefilter.h
@@ -27,6 +27,7 @@
 #ifndef LL_LLIMAGEFILTER_H
 #define LL_LLIMAGEFILTER_H
 
+#include "llsd.h"
 #include "llimage.h"
 
 class LLImageRaw;
diff --git a/indra/llimage/llimagej2c.cpp b/indra/llimage/llimagej2c.cpp
index 5412f98ee5..7cd59a2983 100755
--- a/indra/llimage/llimagej2c.cpp
+++ b/indra/llimage/llimagej2c.cpp
@@ -24,11 +24,13 @@
  */
 #include "linden_common.h"
 
+#include "llapr.h"
 #include "lldir.h"
 #include "llimagej2c.h"
 #include "lltimer.h"
 #include "llmath.h"
 #include "llmemory.h"
+#include "llsd.h"
 
 typedef LLImageJ2CImpl* (*CreateLLImageJ2CFunction)();
 typedef void (*DestroyLLImageJ2CFunction)(LLImageJ2CImpl*);
@@ -60,6 +62,7 @@ LLImageJ2C::LLImageJ2C() : 	LLImageFormatted(IMG_CODEC_J2C),
 							mAreaUsedForDataSizeCalcs(0)
 {
 	mImpl = fallbackCreateLLImageJ2CImpl();
+	claimMem(mImpl);
 
 	// Clear data size table
 	for( S32 i = 0; i <= MAX_DISCARD_LEVEL; i++)
diff --git a/indra/llimage/llimagejpeg.cpp b/indra/llimage/llimagejpeg.cpp
index b70f84efc8..e419c77ff2 100755
--- a/indra/llimage/llimagejpeg.cpp
+++ b/indra/llimage/llimagejpeg.cpp
@@ -32,8 +32,7 @@
 
 jmp_buf	LLImageJPEG::sSetjmpBuffer ;
 LLImageJPEG::LLImageJPEG(S32 quality) 
-	:
-	LLImageFormatted(IMG_CODEC_JPEG),
+:	LLImageFormatted(IMG_CODEC_JPEG),
 	mOutputBuffer( NULL ),
 	mOutputBufferSize( 0 ),
 	mEncodeQuality( quality ) // on a scale from 1 to 100
@@ -374,7 +373,7 @@ boolean LLImageJPEG::encodeEmptyOutputBuffer( j_compress_ptr cinfo )
   U8* new_buffer = new U8[ new_buffer_size ];
   if (!new_buffer)
   {
-  	llerrs << "Out of memory in LLImageJPEG::encodeEmptyOutputBuffer( j_compress_ptr cinfo )" << llendl;
+  	LL_ERRS() << "Out of memory in LLImageJPEG::encodeEmptyOutputBuffer( j_compress_ptr cinfo )" << LL_ENDL;
   	return FALSE;
   }
   memcpy( new_buffer, self->mOutputBuffer, self->mOutputBufferSize );	/* Flawfinder: ignore */
@@ -383,7 +382,9 @@ boolean LLImageJPEG::encodeEmptyOutputBuffer( j_compress_ptr cinfo )
 
   cinfo->dest->next_output_byte = self->mOutputBuffer + self->mOutputBufferSize;
   cinfo->dest->free_in_buffer = self->mOutputBufferSize;
+  self->disclaimMem(self->mOutputBufferSize);
   self->mOutputBufferSize = new_buffer_size;
+  self->claimMem(new_buffer_size);
 
   return TRUE;
 }
@@ -465,7 +466,7 @@ void LLImageJPEG::errorOutputMessage( j_common_ptr cinfo )
 	LLImage::setLastError(error);
 
 	BOOL is_decode = (cinfo->is_decompressor != 0);
-	llwarns << "LLImageJPEG " << (is_decode ? "decode " : "encode ") << " failed: " << buffer << llendl;
+	LL_WARNS() << "LLImageJPEG " << (is_decode ? "decode " : "encode ") << " failed: " << buffer << LL_ENDL;
 }
 
 BOOL LLImageJPEG::encode( const LLImageRaw* raw_image, F32 encode_time )
@@ -489,7 +490,9 @@ BOOL LLImageJPEG::encode( const LLImageRaw* raw_image, F32 encode_time )
 	// Allocate a temporary buffer big enough to hold the entire compressed image (and then some)
 	// (Note: we make it bigger in emptyOutputBuffer() if we need to)
 	delete[] mOutputBuffer;
+	disclaimMem(mOutputBufferSize);
 	mOutputBufferSize = getWidth() * getHeight() * getComponents() + 1024;
+	claimMem(mOutputBufferSize);
 	mOutputBuffer = new U8[ mOutputBufferSize ];
 
 	const U8* raw_image_data = NULL;
@@ -526,6 +529,7 @@ BOOL LLImageJPEG::encode( const LLImageRaw* raw_image, F32 encode_time )
 		jpeg_destroy_compress(&cinfo);
 		delete[] mOutputBuffer;
 		mOutputBuffer = NULL;
+		disclaimMem(mOutputBufferSize);
 		mOutputBufferSize = 0;
 		return FALSE;
 	}
@@ -628,6 +632,7 @@ BOOL LLImageJPEG::encode( const LLImageRaw* raw_image, F32 encode_time )
 		// After finish_compress, we can release the temp output buffer. 
 		delete[] mOutputBuffer;
 		mOutputBuffer = NULL;
+		disclaimMem(mOutputBufferSize);
 		mOutputBufferSize = 0;
 
 		////////////////////////////////////////
@@ -640,6 +645,7 @@ BOOL LLImageJPEG::encode( const LLImageRaw* raw_image, F32 encode_time )
 		jpeg_destroy_compress(&cinfo);
 		delete[] mOutputBuffer;
 		mOutputBuffer = NULL;
+		disclaimMem(mOutputBufferSize);
 		mOutputBufferSize = 0;
 		return FALSE;
 	}
diff --git a/indra/llimage/llimagejpeg.h b/indra/llimage/llimagejpeg.h
index 7ac7f5d2e0..5b596d9fa4 100755
--- a/indra/llimage/llimagejpeg.h
+++ b/indra/llimage/llimagejpeg.h
@@ -31,6 +31,7 @@
 
 #include "llimage.h"
 
+#include "llwin32headerslean.h"
 extern "C" {
 #ifdef LL_STANDALONE
 # include <jpeglib.h>
diff --git a/indra/llimage/llimagetga.cpp b/indra/llimage/llimagetga.cpp
index 920ae2891f..4eb8dc7440 100755
--- a/indra/llimage/llimagetga.cpp
+++ b/indra/llimage/llimagetga.cpp
@@ -266,7 +266,7 @@ BOOL LLImageTGA::updateData()
 			mColorMap = new U8[ color_map_bytes ];  
 			if (!mColorMap)
 			{
-				llerrs << "Out of Memory in BOOL LLImageTGA::updateData()" << llendl;
+				LL_ERRS() << "Out of Memory in BOOL LLImageTGA::updateData()" << LL_ENDL;
 				return FALSE;
 			}
 			memcpy( mColorMap, getData() + mDataOffset, color_map_bytes );	/* Flawfinder: ignore */
@@ -1043,7 +1043,7 @@ BOOL LLImageTGA::decodeAndProcess( LLImageRaw* raw_image, F32 domain, F32 weight
 	// Only works for unflipped monochrome RLE images
 	if( (getComponents() != 1) || (mImageType != 11) || mOriginTopBit || mOriginRightBit ) 
 	{
-		llerrs << "LLImageTGA trying to alpha-gradient process an image that's not a standard RLE, one component image" << llendl;
+		LL_ERRS() << "LLImageTGA trying to alpha-gradient process an image that's not a standard RLE, one component image" << LL_ENDL;
 		return FALSE;
 	}
 
@@ -1151,7 +1151,7 @@ bool LLImageTGA::loadFile( const std::string& path )
 	LLFILE* file = LLFile::fopen(path, "rb");	/* Flawfinder: ignore */
 	if( !file )
 	{
-		llwarns << "Couldn't open file " << path << llendl;
+		LL_WARNS() << "Couldn't open file " << path << LL_ENDL;
 		return false;
 	}
 
@@ -1167,7 +1167,7 @@ bool LLImageTGA::loadFile( const std::string& path )
 	if( bytes_read != file_size )
 	{
 		deleteData();
-		llwarns << "Couldn't read file " << path << llendl;
+		LL_WARNS() << "Couldn't read file " << path << LL_ENDL;
 		return false;
 	}
 
@@ -1175,7 +1175,7 @@ bool LLImageTGA::loadFile( const std::string& path )
 
 	if( !updateData() )
 	{
-		llwarns << "Couldn't decode file " << path << llendl;
+		LL_WARNS() << "Couldn't decode file " << path << LL_ENDL;
 		deleteData();
 		return false;
 	}
diff --git a/indra/llimage/llimageworker.cpp b/indra/llimage/llimageworker.cpp
index ad2eb0f69c..c8b0e872f6 100755
--- a/indra/llimage/llimageworker.cpp
+++ b/indra/llimage/llimageworker.cpp
@@ -60,7 +60,7 @@ S32 LLImageDecodeThread::update(F32 max_time_ms)
 		bool res = addRequest(req);
 		if (!res)
 		{
-			llerrs << "request added after LLLFSThread::cleanupClass()" << llendl;
+			LL_ERRS() << "request added after LLLFSThread::cleanupClass()" << LL_ENDL;
 		}
 	}
 	mCreationList.clear();
diff --git a/indra/llimage/tests/llimageworker_test.cpp b/indra/llimage/tests/llimageworker_test.cpp
index e255d65b43..c030b105fb 100755
--- a/indra/llimage/tests/llimageworker_test.cpp
+++ b/indra/llimage/tests/llimageworker_test.cpp
@@ -31,6 +31,8 @@
 #include "../llimageworker.h"
 // For timer class
 #include "../llcommon/lltimer.h"
+// for lltrace class
+#include "../llcommon/lltrace.h"
 // Tut header
 #include "../test/lltut.h"
 
@@ -43,7 +45,8 @@
 // * A simulator for a class can be implemented here. Please comment and document thoroughly.
 
 LLImageBase::LLImageBase() 
-: mData(NULL),
+: LLTrace::MemTrackable<LLImageBase>("LLImageBase"),
+mData(NULL),
 mDataSize(0),
 mWidth(0),
 mHeight(0),
@@ -110,7 +113,6 @@ namespace tut
 	{
 		// Instance to be tested
 		LLImageDecodeThread* mThread;
-
 		// Constructor and destructor of the test wrapper
 		imagedecodethread_test()
 		{
@@ -136,6 +138,7 @@ namespace tut
 		imagerequest_test()
 		{
 			done = false;
+
 			mRequest = new LLImageDecodeThread::ImageRequest(0, 0,
 											 LLQueuedThread::PRIORITY_NORMAL, 0, FALSE,
 											 new responder_test(&done));