From bc6f669ff41db304723428746868d79d3f3b48da Mon Sep 17 00:00:00 2001
From: Merov Linden <merov@lindenlab.com>
Date: Thu, 15 Mar 2012 13:01:14 -0700
Subject: SH-3047 : Read the number of levels from the j2c image header instead
 of relying on hacked computation based on width / height.

---
 indra/llimage/llimage.cpp    | 3 ++-
 indra/llimage/llimage.h      | 5 ++++-
 indra/llimage/llimagej2c.cpp | 3 +++
 3 files changed, 9 insertions(+), 2 deletions(-)

(limited to 'indra/llimage')

diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp
index 56e01ac851..091e78e358 100644
--- a/indra/llimage/llimage.cpp
+++ b/indra/llimage/llimage.cpp
@@ -1334,7 +1334,8 @@ LLImageFormatted::LLImageFormatted(S8 codec)
 	  mCodec(codec),
 	  mDecoding(0),
 	  mDecoded(0),
-	  mDiscardLevel(-1)
+	  mDiscardLevel(-1),
+	  mLevels(0)
 {
 	mMemType = LLMemType::MTYPE_IMAGEFORMATTED;
 }
diff --git a/indra/llimage/llimage.h b/indra/llimage/llimage.h
index 4469c9e860..847ba8c11c 100644
--- a/indra/llimage/llimage.h
+++ b/indra/llimage/llimage.h
@@ -313,6 +313,8 @@ public:
 	BOOL isDecoded()  const { return mDecoded ? TRUE : FALSE; }
 	void setDiscardLevel(S8 discard_level) { mDiscardLevel = discard_level; }
 	S8 getDiscardLevel() const { return mDiscardLevel; }
+	S8 getLevels() const { return mLevels; }
+	void setLevels(S8 nlevels) { mLevels = nlevels; }
 
 	// setLastError needs to be deferred for J2C images since it may be called from a DLL
 	virtual void resetLastError();
@@ -325,7 +327,8 @@ protected:
 	S8 mCodec;
 	S8 mDecoding;
 	S8 mDecoded;  // unused, but changing LLImage layout requires recompiling static Mac/Linux libs. 2009-01-30 JC
-	S8 mDiscardLevel;
+	S8 mDiscardLevel;	// Current resolution level worked on. 0 = full res, 1 = half res, 2 = quarter res, etc...
+	S8 mLevels;			// Number of resolution levels in that image. Min is 1. 0 means unknown.
 	
 public:
 	static S32 sGlobalFormattedMemory;
diff --git a/indra/llimage/llimagej2c.cpp b/indra/llimage/llimagej2c.cpp
index cc8cb66d73..fbf4b769e1 100644
--- a/indra/llimage/llimagej2c.cpp
+++ b/indra/llimage/llimagej2c.cpp
@@ -142,6 +142,7 @@ BOOL LLImageJ2C::updateData()
 
 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);
 }
 
@@ -286,6 +287,8 @@ S32 LLImageJ2C::calcHeaderSize()
 
 // calcDataSize() returns how many bytes to read 
 // to load discard_level (including header and higher discard levels)
+// *TODO: This is deeply wrong. That size should be taken from the image file header or other 
+// relevant infos. In any case, this is only an approximation.
 S32 LLImageJ2C::calcDataSize(S32 discard_level)
 {
 	discard_level = llclamp(discard_level, 0, MAX_DISCARD_LEVEL);
-- 
cgit v1.3


From fe7a4d0183bfb19784b61124ef4c377c9a5d42d2 Mon Sep 17 00:00:00 2001
From: Merov Linden <merov@lindenlab.com>
Date: Thu, 15 Mar 2012 14:07:54 -0700
Subject: SH-3047 : Add a load_size argument to llimage_libtest and allow
 partial image file to be loaded.

---
 .../llimage_libtest/llimage_libtest.cpp            | 28 +++++++++++++++++++---
 indra/llimage/llimage.cpp                          | 15 ++++++++----
 indra/llimage/llimage.h                            |  2 +-
 3 files changed, 36 insertions(+), 9 deletions(-)

(limited to 'indra/llimage')

diff --git a/indra/integration_tests/llimage_libtest/llimage_libtest.cpp b/indra/integration_tests/llimage_libtest/llimage_libtest.cpp
index 9d524367ed..50dde971af 100644
--- a/indra/integration_tests/llimage_libtest/llimage_libtest.cpp
+++ b/indra/integration_tests/llimage_libtest/llimage_libtest.cpp
@@ -54,6 +54,11 @@ static const char USAGE[] = "\n"
 " -o, --output <file1 .. file2> OR <type>\n"
 "        List of image files to create (assumes same order as for input files)\n"
 "        OR 3 letters file type extension to convert each input file into.\n"
+" -load, --load_size <n>\n"
+"        Portion of the input image to load, in bytes."
+"        Will load the whole image if 0 or if the size requested is more than the file size."
+"        This parameter will be applied to any input image type but really makes sense only"
+"        for j2c images."
 " -r, --region <x0, y0, x1, y1>\n"
 "        Crop region applied to the input files in pixels.\n"
 "        Only used for j2c images. Default is no region cropping.\n"
@@ -112,12 +117,12 @@ void output_image_stats(LLPointer<LLImageFormatted> image, const std::string &fi
 }
 
 // Load an image from file and return a raw (decompressed) instance of its data
-LLPointer<LLImageRaw> load_image(const std::string &src_filename, int discard_level, int* region, bool output_stats)
+LLPointer<LLImageRaw> load_image(const std::string &src_filename, int discard_level, int* region, int load_size, bool output_stats)
 {
 	LLPointer<LLImageFormatted> image = create_image(src_filename);
 	
 	// This just loads the image file stream into a buffer. No decoding done.
-	if (!image->load(src_filename))
+	if (!image->load(src_filename, load_size))
 	{
 		return NULL;
 	}
@@ -310,6 +315,7 @@ int main(int argc, char** argv)
 	bool image_stats = false;
 	int* region = NULL;
 	int discard_level = -1;
+	int load_size = 0;
 	int precincts_size = -1;
 	int blocks_size = -1;
 	int levels = 0;
@@ -396,6 +402,22 @@ int main(int argc, char** argv)
 				discard_level = llclamp(discard_level,0,5);
 			}
 		}
+		else if (!strcmp(argv[arg], "--load_size") || !strcmp(argv[arg], "-load"))
+		{
+			std::string value_str;
+			if ((arg + 1) < argc)
+			{
+				value_str = argv[arg+1];
+			}
+			if (((arg + 1) >= argc) || (value_str[0] == '-'))
+			{
+				std::cout << "No valid --load_size argument given, load_size ignored" << std::endl;
+			}
+			else
+			{
+				load_size = atoi(value_str.c_str());
+			}
+		}
 		else if (!strcmp(argv[arg], "--precincts") || !strcmp(argv[arg], "-p"))
 		{
 			std::string value_str;
@@ -510,7 +532,7 @@ int main(int argc, char** argv)
 	for (; in_file != in_end; ++in_file, ++out_file)
 	{
 		// Load file
-		LLPointer<LLImageRaw> raw_image = load_image(*in_file, discard_level, region, image_stats);
+		LLPointer<LLImageRaw> raw_image = load_image(*in_file, discard_level, region, load_size, image_stats);
 		if (!raw_image)
 		{
 			std::cout << "Error: Image " << *in_file << " could not be loaded" << std::endl;
diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp
index 091e78e358..937655a22d 100644
--- a/indra/llimage/llimage.cpp
+++ b/indra/llimage/llimage.cpp
@@ -1562,7 +1562,7 @@ void LLImageFormatted::appendData(U8 *data, S32 size)
 
 //----------------------------------------------------------------------------
 
-BOOL LLImageFormatted::load(const std::string &filename)
+BOOL LLImageFormatted::load(const std::string &filename, int load_size)
 {
 	resetLastError();
 
@@ -1581,14 +1581,19 @@ BOOL LLImageFormatted::load(const std::string &filename)
 		return FALSE;
 	}
 
+	// Constrain the load size to acceptable values
+	if ((load_size == 0) || (load_size > file_size))
+	{
+		load_size = file_size;
+	}
 	BOOL res;
-	U8 *data = allocateData(file_size);
-	apr_size_t bytes_read = file_size;
+	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
-	if (s != APR_SUCCESS || (S32) bytes_read != file_size)
+	if (s != APR_SUCCESS || (S32) bytes_read != load_size)
 	{
 		deleteData();
-		setLastError("Unable to read entire file",filename);
+		setLastError("Unable to read file",filename);
 		res = FALSE;
 	}
 	else
diff --git a/indra/llimage/llimage.h b/indra/llimage/llimage.h
index 847ba8c11c..eba8362f1c 100644
--- a/indra/llimage/llimage.h
+++ b/indra/llimage/llimage.h
@@ -294,7 +294,7 @@ public:
 	// getRawDiscardLevel() by default returns mDiscardLevel, but may be overridden (LLImageJ2C)
 	virtual S8  getRawDiscardLevel() { return mDiscardLevel; }
 	
-	BOOL load(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
-- 
cgit v1.3


From df09fd8e8b5b73330e4942c2cb218a216d7aca99 Mon Sep 17 00:00:00 2001
From: Merov Linden <merov@lindenlab.com>
Date: Mon, 2 Apr 2012 19:05:32 -0700
Subject: SH-3060 : Preliminary implementation of the new byte range
 computation, implement setting to turn it on or off

---
 indra/llimage/llimage.cpp               |  4 ++-
 indra/llimage/llimage.h                 |  5 +++-
 indra/llimage/llimagej2c.cpp            | 47 +++++++++++----------------------
 indra/llkdu/llimagej2ckdu.cpp           | 14 ++++++++--
 indra/newview/app_settings/settings.xml | 11 ++++++++
 indra/newview/llappviewer.cpp           |  2 +-
 6 files changed, 47 insertions(+), 36 deletions(-)

(limited to 'indra/llimage')

diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp
index 937655a22d..7f95441075 100644
--- a/indra/llimage/llimage.cpp
+++ b/indra/llimage/llimage.cpp
@@ -48,11 +48,13 @@
 //static
 std::string LLImage::sLastErrorMessage;
 LLMutex* LLImage::sMutex = NULL;
+bool LLImage::sUseNewByteRange = false;
 LLPrivateMemoryPool* LLImageBase::sPrivatePoolp = NULL ;
 
 //static
-void LLImage::initClass()
+void LLImage::initClass(bool use_new_byte_range)
 {
+	sUseNewByteRange = use_new_byte_range;
 	sMutex = new LLMutex(NULL);
 
 	LLImageBase::createPrivatePool() ;
diff --git a/indra/llimage/llimage.h b/indra/llimage/llimage.h
index eba8362f1c..b757547ab8 100644
--- a/indra/llimage/llimage.h
+++ b/indra/llimage/llimage.h
@@ -89,15 +89,18 @@ typedef enum e_image_codec
 class LLImage
 {
 public:
-	static void initClass();
+	static void initClass(bool use_new_byte_range = false);
 	static void cleanupClass();
 
 	static const std::string& getLastError();
 	static void setLastError(const std::string& message);
 	
+	static bool useNewByteRange() { return sUseNewByteRange; }
+	
 protected:
 	static LLMutex* sMutex;
 	static std::string sLastErrorMessage;
+	static bool sUseNewByteRange;
 };
 
 //============================================================================
diff --git a/indra/llimage/llimagej2c.cpp b/indra/llimage/llimagej2c.cpp
index fbf4b769e1..cbb6f75b43 100644
--- a/indra/llimage/llimagej2c.cpp
+++ b/indra/llimage/llimagej2c.cpp
@@ -262,10 +262,12 @@ S32 LLImageJ2C::calcHeaderSizeJ2C()
 //static
 S32 LLImageJ2C::calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, F32 rate)
 {
-	// Note: this only provides an *estimate* of the size in bytes of an image level
-	// *TODO: find a way to read the true size (when available) and convey the fact
-	// that the result is an estimate in the other cases
-	if (rate <= 0.f) rate = .125f;
+	// Note: This provides an estimation for the first quality layer of a given discard level
+	// This is however an efficient approximation, as the true discard level boundary would be
+	// in general too big for fast fetching.
+	// For details about the equation used here, see https://wiki.lindenlab.com/wiki/THX1138_KDU_Improvements#Byte_Range_Study
+	if (rate <= 0.f) rate = 1.f/8.f;
+	// Compute w/pow(2,discard_level) and h/pow(2,discard_level)
 	while (discard_level > 0)
 	{
 		if (w < 1 || h < 1)
@@ -274,7 +276,13 @@ S32 LLImageJ2C::calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, F32 r
 		h >>= 1;
 		discard_level--;
 	}
-	S32 bytes = (S32)((F32)(w*h*comp)*rate);
+	// Temporary: compute both new and old range and pick one according to the settings TextureNewByteRange 
+	// *TODO: Take the old code out once we have enough tests done
+	// *TODO: Replace the magic "7" by the number of quality layers in the j2c image
+	S32 bytes;
+	S32 new_bytes = sqrt((F32)(w*h))*(F32)(comp)*rate*1000.f/7.f;
+	S32 old_bytes = (S32)((F32)(w*h*comp)*rate);
+	bytes = (LLImage::useNewByteRange() ? new_bytes : old_bytes);
 	bytes = llmax(bytes, calcHeaderSizeJ2C());
 	return bytes;
 }
@@ -284,11 +292,7 @@ S32 LLImageJ2C::calcHeaderSize()
 	return calcHeaderSizeJ2C();
 }
 
-
-// calcDataSize() returns how many bytes to read 
-// to load discard_level (including header and higher discard levels)
-// *TODO: This is deeply wrong. That size should be taken from the image file header or other 
-// relevant infos. In any case, this is only an approximation.
+// calcDataSize() returns how many bytes to read to load discard_level (including header)
 S32 LLImageJ2C::calcDataSize(S32 discard_level)
 {
 	discard_level = llclamp(discard_level, 0, MAX_DISCARD_LEVEL);
@@ -304,25 +308,6 @@ S32 LLImageJ2C::calcDataSize(S32 discard_level)
 			mDataSizes[level] = calcDataSizeJ2C(getWidth(), getHeight(), getComponents(), level, mRate);
 			level--;
 		}
-
-		/* This is technically a more correct way to calculate the size required
-		   for each discard level, since they should include the size needed for
-		   lower levels.   Unfortunately, this doesn't work well and will lead to 
-		   download stalls.  The true correct way is to parse the header.  This will
-		   all go away with http textures at some point.
-
-		// Calculate the size for each discard level.   Lower levels (higher quality)
-		// contain the cumulative size of higher levels		
-		S32 total_size = calcHeaderSizeJ2C();
-
-		S32 level = MAX_DISCARD_LEVEL;	// Start at the highest discard
-		while ( level >= 0 )
-		{	// Add in this discard level and all before it
-			total_size += calcDataSizeJ2C(getWidth(), getHeight(), getComponents(), level, mRate);
-			mDataSizes[level] = total_size;
-			level--;
-		}
-		*/
 	}
 	return mDataSizes[discard_level];
 }
@@ -337,8 +322,8 @@ S32 LLImageJ2C::calcDiscardLevelBytes(S32 bytes)
 	}
 	while (1)
 	{
-		S32 bytes_needed = calcDataSize(discard_level); // virtual
-		if (bytes >= bytes_needed - (bytes_needed>>2)) // For J2c, up the res at 75% of the optimal number of bytes
+		S32 bytes_needed = calcDataSize(discard_level);
+		if (bytes >= bytes_needed)
 		{
 			break;
 		}
diff --git a/indra/llkdu/llimagej2ckdu.cpp b/indra/llkdu/llimagej2ckdu.cpp
index fdfab5506a..4468b8563b 100644
--- a/indra/llkdu/llimagej2ckdu.cpp
+++ b/indra/llkdu/llimagej2ckdu.cpp
@@ -294,6 +294,13 @@ void LLImageJ2CKDU::setupCodeStream(LLImageJ2C &base, BOOL keep_codestream, ECod
 
 	// Get the number of resolution levels in that image
 	mLevels = mCodeStreamp->get_min_dwt_levels();
+	
+	//kdu_coords idx; idx.x = 0; idx.y = 0;
+	//kdu_dims tile_indices_in;  
+	//mCodeStreamp->get_valid_tiles(tile_indices_in);
+	//mCodeStreamp->create_tile(idx+tile_indices_in.pos);
+	//int layers = mCodeStreamp->get_max_tile_layers();
+	//llinfos << "Merov debug : setupCodeStream, levels = " << mLevels << ", layers = " << layers << llendl;
 
 	// Set the base dimensions
 	base.setSize(dims.size.x, dims.size.y, components);
@@ -390,7 +397,7 @@ BOOL LLImageJ2CKDU::initDecode(LLImageJ2C &base, LLImageRaw &raw_image, F32 deco
 			region_kdu->size.y = region[3] - region[1];
 		}
 		int discard = (discard_level != -1 ? discard_level : base.getRawDiscardLevel());
-		
+		llinfos << "Merov debug : initDecode, discard used = " << discard << ", asked = " << discard_level << llendl;
 		// Apply loading restrictions
 		mCodeStreamp->apply_input_restrictions( first_channel, max_channel_count, discard, 0, region_kdu);
 		
@@ -468,6 +475,9 @@ BOOL LLImageJ2CKDU::decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 deco
 				{
 					kdu_tile tile = mCodeStreamp->open_tile(*(mTPosp)+mTileIndicesp->pos);
 
+					int layers = mCodeStreamp->get_max_tile_layers();
+					llinfos << "Merov debug : decodeImpl, levels = " << mLevels << ", layers = " << layers << llendl;
+
 					// Find the region of the buffer occupied by this
 					// tile.  Note that we have no control over
 					// sub-sampling factors which might have been used
@@ -675,7 +685,7 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 				std::string blocks_string = llformat("Cblk={%d,%d}",mBlocksSize,mBlocksSize);
 				codestream.access_siz()->parse_string(blocks_string.c_str());
 			}
-			std::string ordering_string = llformat("Corder=RPCL");
+			std::string ordering_string = llformat("Corder=LRCP");
 			codestream.access_siz()->parse_string(ordering_string.c_str());
 			std::string PLT_string = llformat("ORGgen_plt=yes");
 			codestream.access_siz()->parse_string(PLT_string.c_str());
diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index 9fff543b13..5fc9c5d863 100755
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -10686,6 +10686,17 @@
       <key>Value</key>
       <integer>0</integer>
     </map>
+    <key>TextureNewByteRange</key>
+    <map>
+      <key>Comment</key>
+      <string>Use the new more accurate byte range computation for j2c discard levels</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>1</integer>
+    </map>
     <key>TexturePickerShowFolders</key>
     <map>
       <key>Comment</key>
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index bea8303d69..1a68d0317e 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -1947,7 +1947,7 @@ bool LLAppViewer::initThreads()
 	static const bool enable_threads = true;
 #endif
 
-	LLImage::initClass();
+	LLImage::initClass(gSavedSettings.getBOOL("TextureNewByteRange"));
 
 	LLVFSThread::initClass(enable_threads && false);
 	LLLFSThread::initClass(enable_threads && false);
-- 
cgit v1.3


From c6511d9c857c079e0360f88c05328feb70a8bc0d Mon Sep 17 00:00:00 2001
From: Merov Linden <merov@lindenlab.com>
Date: Wed, 4 Apr 2012 15:59:52 -0700
Subject: SH-3075 : Fix encoding for reversible images and small textures

---
 indra/llimage/llimage.h       |   2 +
 indra/llkdu/llimagej2ckdu.cpp | 112 +++++++++++++++++++++---------------------
 2 files changed, 58 insertions(+), 56 deletions(-)

(limited to 'indra/llimage')

diff --git a/indra/llimage/llimage.h b/indra/llimage/llimage.h
index b757547ab8..18f8ae2fbb 100644
--- a/indra/llimage/llimage.h
+++ b/indra/llimage/llimage.h
@@ -48,6 +48,8 @@ const S32 MAX_PRECINCT_SIZE = 2048;			// No reason to be bigger than MAX_IMAGE_S
 const S32 MIN_PRECINCT_SIZE = 4;			// Can't be smaller than MIN_BLOCK_SIZE
 const S32 MAX_BLOCK_SIZE = 64;				// Max total block size is 4096, hence 64x64 when using square blocks
 const S32 MIN_BLOCK_SIZE = 4;				// Min block dim is 4 according to jpeg2000 spec
+const S32 MIN_LAYER_SIZE = 2000;			// Size of the first quality layer (after header). Must be > to FIRST_PACKET_SIZE!!
+const S32 MAX_NB_LAYERS = 64;				// Max number of layers we'll entertain in SL (practical limit)
 
 const S32 MIN_IMAGE_SIZE = (1<<MIN_IMAGE_MIP); // 4, only used for expand/contract power of 2
 const S32 MAX_IMAGE_SIZE = (1<<MAX_IMAGE_MIP); // 2048
diff --git a/indra/llkdu/llimagej2ckdu.cpp b/indra/llkdu/llimagej2ckdu.cpp
index 4468b8563b..78c9be7bfd 100644
--- a/indra/llkdu/llimagej2ckdu.cpp
+++ b/indra/llkdu/llimagej2ckdu.cpp
@@ -599,12 +599,6 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 			comment.put_text(comment_text);
 		}
 
-		// Set codestream options
-		int num_layer_specs = 0;
-
-		kdu_long layer_bytes[64];
-		U32 max_bytes = 0;
-
 		if (num_components >= 3)
 		{
 			// Note that we always use YCC and not YUV
@@ -612,67 +606,70 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 			set_default_colour_weights(codestream.access_siz());
 		}
 
+		// Set codestream options
+		int num_layer_specs = 0;
+		kdu_long layer_bytes[MAX_NB_LAYERS];
+		U32 max_bytes = (U32)(base.getWidth() * base.getHeight() * base.getComponents());
+
+		// Rate is the argument passed into the LLImageJ2C which
+		// specifies the target compression rate.  The default is 8:1.
+		// *TODO: mRate is actually always 8:1 in the viewer. Test different values. Also force to reversible for small (< 500 bytes) textures.
+		if (base.mRate != 0.f)
+		{
+			max_bytes = (U32)((F32)(max_bytes) * base.mRate);
+		}
+		else
+		{
+			max_bytes = (U32)((F32)(max_bytes) / 8.0f);
+		}
+		
+		// If the image is very small, code it in a lossless way.
+		// Note: it'll also have only 1 layer which is fine as there's no point reordering blocks in that case.
+		if (max_bytes < FIRST_PACKET_SIZE)
+		{
+			reversible = true;
+		}
+		
+		// This code is where we specify the target number of bytes for each quality layer.
+		// We're using a logarithmic spacing rule that fits with our way of fetching texture data.
+		// Note: For more info on this layers business, read kdu_codestream::flush() doc in kdu_compressed.h
+		U32 i = FIRST_PACKET_SIZE;
+		while ((i < max_bytes) && (num_layer_specs < (MAX_NB_LAYERS-1)))
+		{
+			if (i == FIRST_PACKET_SIZE * 4)
+			{
+				// That really just means that the first layer is FIRST_PACKET_SIZE and the second is MIN_LAYER_SIZE
+				i = MIN_LAYER_SIZE;
+			}
+			layer_bytes[num_layer_specs] = i;
+			num_layer_specs++;
+			i *= 4;
+		}
+
 		if (reversible)
 		{
 			codestream.access_siz()->parse_string("Creversible=yes");
-			// *TODO: we should use yuv in reversible mode and one level since those images are small. 
+			// *TODO: we should use yuv in reversible mode and one res level since those images are small. 
 			// Don't turn this on now though as both create problems on decoding for the moment
 			//codestream.access_siz()->parse_string("Clevels=1");
 			//codestream.access_siz()->parse_string("Cycc=no");
-			// If we're doing reversible (i.e. lossless compression), assumes we're not using quality layers.
-			// *TODO: this is incorrect and unecessary. Try using the regular layer setting.
-			codestream.access_siz()->parse_string("Clayers=1");
-			num_layer_specs = 1;
-			layer_bytes[0] = 0;
+			// In the reversible case, set the last entry of that table to 0 so that all generated bits will
+			// indeed be output by the time the last quality layer is encountered.
+			layer_bytes[num_layer_specs] = 0;
 		}
 		else
 		{
-			// Rate is the argument passed into the LLImageJ2C which
-			// specifies the target compression rate.  The default is 8:1.
-			// Possibly if max_bytes < 500, we should just use the default setting?
-			// *TODO: mRate is actually always 8:1 in the viewer. Test different values. Also force to reversible for small (< 500 bytes) textures.
-			if (base.mRate != 0.f)
-			{
-				max_bytes = (U32)(base.mRate*base.getWidth()*base.getHeight()*base.getComponents());
-			}
-			else
-			{
-				max_bytes = (U32)(base.getWidth()*base.getHeight()*base.getComponents()*0.125);
-			}
-
-			const U32 min_bytes = FIRST_PACKET_SIZE;
-			if (max_bytes > min_bytes)
-			{
-				U32 i;
-				// This code is where we specify the target number of bytes for
-				// each layer.  Not sure if we should do this for small images
-				// or not.  The goal is to have this roughly align with
-				// different quality levels that we decode at.
-				for (i = min_bytes; i < max_bytes; i*=4)
-				{
-					if (i == min_bytes * 4)
-					{
-						i = 2000;
-					}
-					layer_bytes[num_layer_specs] = i;
-					num_layer_specs++;
-				}
-				layer_bytes[num_layer_specs] = max_bytes;
-				num_layer_specs++;
-
-				std::string layer_string = llformat("Clayers=%d",num_layer_specs);
-				codestream.access_siz()->parse_string(layer_string.c_str());
-			}
-			else
-			{
-				layer_bytes[0] = min_bytes;
-				num_layer_specs = 1;
-				std::string layer_string = llformat("Clayers=%d",num_layer_specs);
-				codestream.access_siz()->parse_string(layer_string.c_str());
-			}
+			// Truncate the last quality layer if necessary so to fit the set compression ratio
+			layer_bytes[num_layer_specs] = max_bytes;
 		}
+		num_layer_specs++;
+
+		std::string layer_string = llformat("Clayers=%d",num_layer_specs);
+		codestream.access_siz()->parse_string(layer_string.c_str());
 		
 		// Set up data ordering, markers, etc... if precincts or blocks specified
+		// Note: This code is *not* used in the encoding made by the viewer. It is currently used only
+		// by llimage_libtest to create various j2c and test alternative compression schemes.
 		if ((mBlocksSize != -1) || (mPrecinctsSize != -1))
 		{
 			if (mPrecinctsSize != -1)
@@ -692,16 +689,19 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 			std::string Parts_string = llformat("ORGtparts=R");
 			codestream.access_siz()->parse_string(Parts_string.c_str());
 		}
+		
+		// Set the number of wavelets subresolutions (aka levels) 
 		if (mLevels != 0)
 		{
 			std::string levels_string = llformat("Clevels=%d",mLevels);
 			codestream.access_siz()->parse_string(levels_string.c_str());
 		}
 		
+		// Complete the encode settings
 		codestream.access_siz()->finalize_all();
 		codestream.change_appearance(transpose,vflip,hflip);
 
-		// Now we are ready for sample data processing.
+		// Now we are ready for sample data processing
 		kdc_flow_control *tile = new kdc_flow_control(&mem_in,codestream);
 		bool done = false;
 		while (!done)
-- 
cgit v1.3


From 782981866a70f4a33a298c93ee80aaf138fdf459 Mon Sep 17 00:00:00 2001
From: Merov Linden <merov@lindenlab.com>
Date: Wed, 4 Apr 2012 18:58:34 -0700
Subject: SH-3060 : New byte range implementation. Intermediate (not working)
 state.

---
 indra/llimage/llimage.cpp                |  3 ++-
 indra/llimage/llimage.h                  |  3 +++
 indra/llimage/llimagej2c.cpp             | 20 +++++++++++-----
 indra/llimage/llimagej2c.h               |  3 ++-
 indra/llkdu/llimagej2ckdu.cpp            | 40 +++++++++++++++++---------------
 indra/llkdu/llimagej2ckdu.h              |  1 +
 indra/llkdu/tests/llimagej2ckdu_test.cpp |  1 +
 7 files changed, 44 insertions(+), 27 deletions(-)

(limited to 'indra/llimage')

diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp
index 7f95441075..cce03ff6e6 100644
--- a/indra/llimage/llimage.cpp
+++ b/indra/llimage/llimage.cpp
@@ -1337,7 +1337,8 @@ LLImageFormatted::LLImageFormatted(S8 codec)
 	  mDecoding(0),
 	  mDecoded(0),
 	  mDiscardLevel(-1),
-	  mLevels(0)
+	  mLevels(0),
+      mLayers(0)
 {
 	mMemType = LLMemType::MTYPE_IMAGEFORMATTED;
 }
diff --git a/indra/llimage/llimage.h b/indra/llimage/llimage.h
index 18f8ae2fbb..c5a7d6262e 100644
--- a/indra/llimage/llimage.h
+++ b/indra/llimage/llimage.h
@@ -320,6 +320,8 @@ public:
 	S8 getDiscardLevel() const { return mDiscardLevel; }
 	S8 getLevels() const { return mLevels; }
 	void setLevels(S8 nlevels) { mLevels = nlevels; }
+	S32 getLayers() const { return mLayers; }
+	void setLayers(S32 nlayers) { mLayers = nlayers; }
 
 	// setLastError needs to be deferred for J2C images since it may be called from a DLL
 	virtual void resetLastError();
@@ -334,6 +336,7 @@ protected:
 	S8 mDecoded;  // unused, but changing LLImage layout requires recompiling static Mac/Linux libs. 2009-01-30 JC
 	S8 mDiscardLevel;	// Current resolution level worked on. 0 = full res, 1 = half res, 2 = quarter res, etc...
 	S8 mLevels;			// Number of resolution levels in that image. Min is 1. 0 means unknown.
+	S32 mLayers;		// Number of quality layers in that image. Min is 1. 0 means unknown.
 	
 public:
 	static S32 sGlobalFormattedMemory;
diff --git a/indra/llimage/llimagej2c.cpp b/indra/llimage/llimagej2c.cpp
index cbb6f75b43..dc5bd8b5d5 100644
--- a/indra/llimage/llimagej2c.cpp
+++ b/indra/llimage/llimagej2c.cpp
@@ -58,7 +58,8 @@ LLImageJ2C::LLImageJ2C() : 	LLImageFormatted(IMG_CODEC_J2C),
 							mRawDiscardLevel(-1),
 							mRate(0.0f),
 							mReversible(FALSE),
-							mAreaUsedForDataSizeCalcs(0)
+							mAreaUsedForDataSizeCalcs(0),
+							mLayersUsedForDataSizeCalcs(0)
 {
 	mImpl = fallbackCreateLLImageJ2CImpl();
 
@@ -260,7 +261,7 @@ S32 LLImageJ2C::calcHeaderSizeJ2C()
 }
 
 //static
-S32 LLImageJ2C::calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, F32 rate)
+S32 LLImageJ2C::calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, S32 nb_layers, F32 rate)
 {
 	// Note: This provides an estimation for the first quality layer of a given discard level
 	// This is however an efficient approximation, as the true discard level boundary would be
@@ -278,10 +279,11 @@ S32 LLImageJ2C::calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, F32 r
 	}
 	// Temporary: compute both new and old range and pick one according to the settings TextureNewByteRange 
 	// *TODO: Take the old code out once we have enough tests done
-	// *TODO: Replace the magic "7" by the number of quality layers in the j2c image
 	S32 bytes;
-	S32 new_bytes = sqrt((F32)(w*h))*(F32)(comp)*rate*1000.f/7.f;
+	F32 layer_factor = ((nb_layers > 0) && (nb_layers < 7) ? 3.0f * (7 - nb_layers): 3.0f);
+	S32 new_bytes = sqrt((F32)(w*h))*(F32)(comp)*rate*1000.f/layer_factor;
 	S32 old_bytes = (S32)((F32)(w*h*comp)*rate);
+	llinfos << "Merov debug : calcDataSizeJ2C, layers = " << nb_layers << ", old = " << old_bytes << ", new = " << new_bytes << llendl;
 	bytes = (LLImage::useNewByteRange() ? new_bytes : old_bytes);
 	bytes = llmax(bytes, calcHeaderSizeJ2C());
 	return bytes;
@@ -298,14 +300,20 @@ S32 LLImageJ2C::calcDataSize(S32 discard_level)
 	discard_level = llclamp(discard_level, 0, MAX_DISCARD_LEVEL);
 
 	if ( mAreaUsedForDataSizeCalcs != (getHeight() * getWidth()) 
-		|| mDataSizes[0] == 0)
+		|| (mLayersUsedForDataSizeCalcs != getLayers())
+		|| (mDataSizes[0] == 0))
 	{
+		if (mLayersUsedForDataSizeCalcs != getLayers())
+		{
+			llinfos << "Merov debug : recomputing data size because " << mLayersUsedForDataSizeCalcs << " != " << getLayers() << llendl;
+		}
 		mAreaUsedForDataSizeCalcs = getHeight() * getWidth();
+		mLayersUsedForDataSizeCalcs = getLayers();
 		
 		S32 level = MAX_DISCARD_LEVEL;	// Start at the highest discard
 		while ( level >= 0 )
 		{
-			mDataSizes[level] = calcDataSizeJ2C(getWidth(), getHeight(), getComponents(), level, mRate);
+			mDataSizes[level] = calcDataSizeJ2C(getWidth(), getHeight(), getComponents(), level, getLayers(), mRate);
 			level--;
 		}
 	}
diff --git a/indra/llimage/llimagej2c.h b/indra/llimage/llimagej2c.h
index 914174fc57..28e3026aac 100644
--- a/indra/llimage/llimagej2c.h
+++ b/indra/llimage/llimagej2c.h
@@ -72,7 +72,7 @@ public:
 	S32 getMaxBytes() const { return mMaxBytes; }
 
 	static S32 calcHeaderSizeJ2C();
-	static S32 calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, F32 rate = 0.f);
+	static S32 calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, S32 nb_layers = 0, F32 rate = 0.f);
 
 	static std::string getEngineInfo();
 
@@ -88,6 +88,7 @@ protected:
 	
 	S32 mDataSizes[MAX_DISCARD_LEVEL+1];		// Size of data required to reach a given level
 	U32 mAreaUsedForDataSizeCalcs;				// Height * width used to calculate mDataSizes
+	S32 mLayersUsedForDataSizeCalcs;			// Numbers of layers used to calculate mDataSizes
 
 	S8  mRawDiscardLevel;
 	F32 mRate;
diff --git a/indra/llkdu/llimagej2ckdu.cpp b/indra/llkdu/llimagej2ckdu.cpp
index 78c9be7bfd..08d840917d 100644
--- a/indra/llkdu/llimagej2ckdu.cpp
+++ b/indra/llkdu/llimagej2ckdu.cpp
@@ -195,7 +195,8 @@ mRawImagep(NULL),
 mDecodeState(NULL),
 mBlocksSize(-1),
 mPrecinctsSize(-1),
-mLevels(0)
+mLevels(0),
+mLayers(0)
 {
 }
 
@@ -245,6 +246,8 @@ void LLImageJ2CKDU::setupCodeStream(LLImageJ2C &base, BOOL keep_codestream, ECod
 	mCodeStreamp->create(mInputp);
 
 	// Set the maximum number of bytes to use from the codestream
+	// *TODO: This seems to be wrong. The base class should have no idea of how j2c compression works so no
+	// good way of computing what's the byte range to be used.
 	mCodeStreamp->set_max_bytes(max_bytes,true);
 
 	//	If you want to flip or rotate the image for some reason, change
@@ -295,13 +298,6 @@ void LLImageJ2CKDU::setupCodeStream(LLImageJ2C &base, BOOL keep_codestream, ECod
 	// Get the number of resolution levels in that image
 	mLevels = mCodeStreamp->get_min_dwt_levels();
 	
-	//kdu_coords idx; idx.x = 0; idx.y = 0;
-	//kdu_dims tile_indices_in;  
-	//mCodeStreamp->get_valid_tiles(tile_indices_in);
-	//mCodeStreamp->create_tile(idx+tile_indices_in.pos);
-	//int layers = mCodeStreamp->get_max_tile_layers();
-	//llinfos << "Merov debug : setupCodeStream, levels = " << mLevels << ", layers = " << layers << llendl;
-
 	// Set the base dimensions
 	base.setSize(dims.size.x, dims.size.y, components);
 	base.setLevels(mLevels);
@@ -364,7 +360,8 @@ BOOL LLImageJ2CKDU::initEncode(LLImageJ2C &base, LLImageRaw &raw_image, int bloc
 	mLevels = levels;
 	if (mLevels != 0)
 	{
-		mLevels = llclamp(mLevels,MIN_DECOMPOSITION_LEVELS,MIN_DECOMPOSITION_LEVELS);		
+		mLevels = llclamp(mLevels,MIN_DECOMPOSITION_LEVELS,MAX_DECOMPOSITION_LEVELS);
+		base.setLevels(mLevels);
 	}
 	return TRUE;
 }
@@ -476,7 +473,11 @@ BOOL LLImageJ2CKDU::decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 deco
 					kdu_tile tile = mCodeStreamp->open_tile(*(mTPosp)+mTileIndicesp->pos);
 
 					int layers = mCodeStreamp->get_max_tile_layers();
-					llinfos << "Merov debug : decodeImpl, levels = " << mLevels << ", layers = " << layers << llendl;
+					if (layers > mLayers)
+					{
+						mLayers = layers;
+						base.setLayers(mLayers);
+					}
 
 					// Find the region of the buffer occupied by this
 					// tile.  Note that we have no control over
@@ -607,7 +608,7 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 		}
 
 		// Set codestream options
-		int num_layer_specs = 0;
+		mLayers = 0;
 		kdu_long layer_bytes[MAX_NB_LAYERS];
 		U32 max_bytes = (U32)(base.getWidth() * base.getHeight() * base.getComponents());
 
@@ -634,15 +635,15 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 		// We're using a logarithmic spacing rule that fits with our way of fetching texture data.
 		// Note: For more info on this layers business, read kdu_codestream::flush() doc in kdu_compressed.h
 		U32 i = FIRST_PACKET_SIZE;
-		while ((i < max_bytes) && (num_layer_specs < (MAX_NB_LAYERS-1)))
+		while ((i < max_bytes) && (mLayers < (MAX_NB_LAYERS-1)))
 		{
 			if (i == FIRST_PACKET_SIZE * 4)
 			{
 				// That really just means that the first layer is FIRST_PACKET_SIZE and the second is MIN_LAYER_SIZE
 				i = MIN_LAYER_SIZE;
 			}
-			layer_bytes[num_layer_specs] = i;
-			num_layer_specs++;
+			layer_bytes[mLayers] = i;
+			mLayers++;
 			i *= 4;
 		}
 
@@ -655,17 +656,18 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 			//codestream.access_siz()->parse_string("Cycc=no");
 			// In the reversible case, set the last entry of that table to 0 so that all generated bits will
 			// indeed be output by the time the last quality layer is encountered.
-			layer_bytes[num_layer_specs] = 0;
+			layer_bytes[mLayers] = 0;
 		}
 		else
 		{
 			// Truncate the last quality layer if necessary so to fit the set compression ratio
-			layer_bytes[num_layer_specs] = max_bytes;
+			layer_bytes[mLayers] = max_bytes;
 		}
-		num_layer_specs++;
+		mLayers++;
 
-		std::string layer_string = llformat("Clayers=%d",num_layer_specs);
+		std::string layer_string = llformat("Clayers=%d",mLayers);
 		codestream.access_siz()->parse_string(layer_string.c_str());
+		base.setLayers(mLayers);
 		
 		// Set up data ordering, markers, etc... if precincts or blocks specified
 		// Note: This code is *not* used in the encoding made by the viewer. It is currently used only
@@ -718,7 +720,7 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 		}
 
 		// Produce the compressed output
-		codestream.flush(layer_bytes,num_layer_specs);
+		codestream.flush(layer_bytes,mLayers);
 
 		// Cleanup
 		delete tile;
diff --git a/indra/llkdu/llimagej2ckdu.h b/indra/llkdu/llimagej2ckdu.h
index 9ab0b9e4a7..fab97326d4 100644
--- a/indra/llkdu/llimagej2ckdu.h
+++ b/indra/llkdu/llimagej2ckdu.h
@@ -75,6 +75,7 @@ private:
 	int mBlocksSize;
 	int mPrecinctsSize;
 	int mLevels;
+	int mLayers;
 
 	// Temporary variables for in-progress decodes...
 	LLImageRaw *mRawImagep;
diff --git a/indra/llkdu/tests/llimagej2ckdu_test.cpp b/indra/llkdu/tests/llimagej2ckdu_test.cpp
index feb6671e40..405f7c9388 100644
--- a/indra/llkdu/tests/llimagej2ckdu_test.cpp
+++ b/indra/llkdu/tests/llimagej2ckdu_test.cpp
@@ -146,6 +146,7 @@ void kdu_codestream::set_fast() { }
 void kdu_codestream::set_fussy() { }
 void kdu_codestream::get_dims(int, kdu_dims&, bool ) { }
 int kdu_codestream::get_min_dwt_levels() { return 5; }
+int kdu_codestream::get_max_tile_layers() { return 1; }
 void kdu_codestream::change_appearance(bool, bool, bool) { }
 void kdu_codestream::get_tile_dims(kdu_coords, int, kdu_dims&, bool ) { }
 void kdu_codestream::destroy() { }
-- 
cgit v1.3


From 91094d92a75b3900be15bfb8be4b9f7cc072487b Mon Sep 17 00:00:00 2001
From: Merov Linden <merov@lindenlab.com>
Date: Thu, 5 Apr 2012 22:05:00 -0700
Subject: SH-3060 : Implement new byte range computation, cleaned up use of
 compression rate as well.

---
 indra/llimage/llimage.cpp             |  3 +-
 indra/llimage/llimage.h               |  4 +--
 indra/llimage/llimagej2c.cpp          | 55 +++++++++++++++++------------------
 indra/llimage/llimagej2c.h            |  7 +++--
 indra/llkdu/llimagej2ckdu.cpp         | 44 +++++++++-------------------
 indra/llkdu/llimagej2ckdu.h           |  1 -
 indra/newview/lltexlayer.cpp          |  1 -
 indra/newview/llviewertexturelist.cpp |  1 -
 8 files changed, 46 insertions(+), 70 deletions(-)

(limited to 'indra/llimage')

diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp
index cce03ff6e6..7f95441075 100644
--- a/indra/llimage/llimage.cpp
+++ b/indra/llimage/llimage.cpp
@@ -1337,8 +1337,7 @@ LLImageFormatted::LLImageFormatted(S8 codec)
 	  mDecoding(0),
 	  mDecoded(0),
 	  mDiscardLevel(-1),
-	  mLevels(0),
-      mLayers(0)
+	  mLevels(0)
 {
 	mMemType = LLMemType::MTYPE_IMAGEFORMATTED;
 }
diff --git a/indra/llimage/llimage.h b/indra/llimage/llimage.h
index c5a7d6262e..a643e4d9f5 100644
--- a/indra/llimage/llimage.h
+++ b/indra/llimage/llimage.h
@@ -62,6 +62,7 @@ const S32 MAX_IMAGE_DATA_SIZE = MAX_IMAGE_AREA * MAX_IMAGE_COMPONENTS; //2048 *
 // *TODO: change both to 1024 when SIM texture fetching is deprecated
 const S32 FIRST_PACKET_SIZE = 600;
 const S32 MAX_IMG_PACKET_SIZE = 1000;
+const S32 HTTP_PACKET_SIZE = 1496;
 
 // Base classes for images.
 // There are two major parts for the image:
@@ -320,8 +321,6 @@ public:
 	S8 getDiscardLevel() const { return mDiscardLevel; }
 	S8 getLevels() const { return mLevels; }
 	void setLevels(S8 nlevels) { mLevels = nlevels; }
-	S32 getLayers() const { return mLayers; }
-	void setLayers(S32 nlayers) { mLayers = nlayers; }
 
 	// setLastError needs to be deferred for J2C images since it may be called from a DLL
 	virtual void resetLastError();
@@ -336,7 +335,6 @@ protected:
 	S8 mDecoded;  // unused, but changing LLImage layout requires recompiling static Mac/Linux libs. 2009-01-30 JC
 	S8 mDiscardLevel;	// Current resolution level worked on. 0 = full res, 1 = half res, 2 = quarter res, etc...
 	S8 mLevels;			// Number of resolution levels in that image. Min is 1. 0 means unknown.
-	S32 mLayers;		// Number of quality layers in that image. Min is 1. 0 means unknown.
 	
 public:
 	static S32 sGlobalFormattedMemory;
diff --git a/indra/llimage/llimagej2c.cpp b/indra/llimage/llimagej2c.cpp
index dc5bd8b5d5..7894de0de5 100644
--- a/indra/llimage/llimagej2c.cpp
+++ b/indra/llimage/llimagej2c.cpp
@@ -56,10 +56,9 @@ std::string LLImageJ2C::getEngineInfo()
 LLImageJ2C::LLImageJ2C() : 	LLImageFormatted(IMG_CODEC_J2C),
 							mMaxBytes(0),
 							mRawDiscardLevel(-1),
-							mRate(0.0f),
+							mRate(DEFAULT_COMPRESSION_RATE),
 							mReversible(FALSE),
-							mAreaUsedForDataSizeCalcs(0),
-							mLayersUsedForDataSizeCalcs(0)
+							mAreaUsedForDataSizeCalcs(0)
 {
 	mImpl = fallbackCreateLLImageJ2CImpl();
 
@@ -257,33 +256,40 @@ BOOL LLImageJ2C::encode(const LLImageRaw *raw_imagep, const char* comment_text,
 //static
 S32 LLImageJ2C::calcHeaderSizeJ2C()
 {
-	return FIRST_PACKET_SIZE; // Hack. just needs to be >= actual header size...
+	return HTTP_PACKET_SIZE; // Hack. just needs to be >= actual header size...
 }
 
 //static
-S32 LLImageJ2C::calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, S32 nb_layers, F32 rate)
+S32 LLImageJ2C::calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, F32 rate)
 {
-	// Note: This provides an estimation for the first quality layer of a given discard level
+	// Note: This provides an estimation for the first to last quality layer of a given discard level
 	// This is however an efficient approximation, as the true discard level boundary would be
 	// in general too big for fast fetching.
 	// For details about the equation used here, see https://wiki.lindenlab.com/wiki/THX1138_KDU_Improvements#Byte_Range_Study
-	if (rate <= 0.f) rate = 1.f/8.f;
-	// Compute w/pow(2,discard_level) and h/pow(2,discard_level)
-	while (discard_level > 0)
+
+	// Estimate the number of layers. This is consistent with what's done in j2c encoding
+	S32 nb_layers = 1;
+	S32 surface = w*h;
+	S32 s = 64*64;
+	while (surface > s)
 	{
-		if (w < 1 || h < 1)
-			break;
-		w >>= 1;
-		h >>= 1;
-		discard_level--;
+		nb_layers++;
+		s *= 4;
 	}
+	F32 layer_factor =  3.0f * (7 - llclamp(nb_layers,1,6));
+	
+	// Compute w/pow(2,discard_level) and h/pow(2,discard_level)
+	w >>= discard_level;
+	h >>= discard_level;
+	w = llmax(w, 1);
+	h = llmax(h, 1);
+
 	// Temporary: compute both new and old range and pick one according to the settings TextureNewByteRange 
 	// *TODO: Take the old code out once we have enough tests done
 	S32 bytes;
-	F32 layer_factor = ((nb_layers > 0) && (nb_layers < 7) ? 3.0f * (7 - nb_layers): 3.0f);
 	S32 new_bytes = sqrt((F32)(w*h))*(F32)(comp)*rate*1000.f/layer_factor;
 	S32 old_bytes = (S32)((F32)(w*h*comp)*rate);
-	llinfos << "Merov debug : calcDataSizeJ2C, layers = " << nb_layers << ", old = " << old_bytes << ", new = " << new_bytes << llendl;
+	//llinfos << "Merov debug : w = " << w << ", h = " << h << ", c = " << comp << ", r = " << rate << ", d = " << discard_level << ", l = " << nb_layers << ", old = " << old_bytes << ", new = " << new_bytes << llendl;
 	bytes = (LLImage::useNewByteRange() ? new_bytes : old_bytes);
 	bytes = llmax(bytes, calcHeaderSizeJ2C());
 	return bytes;
@@ -298,26 +304,22 @@ S32 LLImageJ2C::calcHeaderSize()
 S32 LLImageJ2C::calcDataSize(S32 discard_level)
 {
 	discard_level = llclamp(discard_level, 0, MAX_DISCARD_LEVEL);
-
+	return calcDataSizeJ2C(getWidth(), getHeight(), getComponents(), discard_level, mRate);
+	/*
 	if ( mAreaUsedForDataSizeCalcs != (getHeight() * getWidth()) 
-		|| (mLayersUsedForDataSizeCalcs != getLayers())
 		|| (mDataSizes[0] == 0))
 	{
-		if (mLayersUsedForDataSizeCalcs != getLayers())
-		{
-			llinfos << "Merov debug : recomputing data size because " << mLayersUsedForDataSizeCalcs << " != " << getLayers() << llendl;
-		}
 		mAreaUsedForDataSizeCalcs = getHeight() * getWidth();
-		mLayersUsedForDataSizeCalcs = getLayers();
 		
 		S32 level = MAX_DISCARD_LEVEL;	// Start at the highest discard
 		while ( level >= 0 )
 		{
-			mDataSizes[level] = calcDataSizeJ2C(getWidth(), getHeight(), getComponents(), level, getLayers(), mRate);
+			mDataSizes[level] = calcDataSizeJ2C(getWidth(), getHeight(), getComponents(), level, mRate);
 			level--;
 		}
 	}
 	return mDataSizes[discard_level];
+	*/
 }
 
 S32 LLImageJ2C::calcDiscardLevelBytes(S32 bytes)
@@ -344,11 +346,6 @@ S32 LLImageJ2C::calcDiscardLevelBytes(S32 bytes)
 	return discard_level;
 }
 
-void LLImageJ2C::setRate(F32 rate)
-{
-	mRate = rate;
-}
-
 void LLImageJ2C::setMaxBytes(S32 max_bytes)
 {
 	mMaxBytes = max_bytes;
diff --git a/indra/llimage/llimagej2c.h b/indra/llimage/llimagej2c.h
index 28e3026aac..91c344d12f 100644
--- a/indra/llimage/llimagej2c.h
+++ b/indra/llimage/llimagej2c.h
@@ -31,6 +31,9 @@
 #include "llassettype.h"
 #include "llmetricperformancetester.h"
 
+// JPEG2000 : compression rate used in j2c conversion.
+const F32 DEFAULT_COMPRESSION_RATE = 1.f/8.f;
+
 class LLImageJ2CImpl;
 class LLImageCompressionTester ;
 
@@ -67,12 +70,11 @@ public:
 
 	// Encode accessors
 	void setReversible(const BOOL reversible); // Use non-lossy?
-	void setRate(F32 rate);
 	void setMaxBytes(S32 max_bytes);
 	S32 getMaxBytes() const { return mMaxBytes; }
 
 	static S32 calcHeaderSizeJ2C();
-	static S32 calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, S32 nb_layers = 0, F32 rate = 0.f);
+	static S32 calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, F32 rate = DEFAULT_COMPRESSION_RATE);
 
 	static std::string getEngineInfo();
 
@@ -88,7 +90,6 @@ protected:
 	
 	S32 mDataSizes[MAX_DISCARD_LEVEL+1];		// Size of data required to reach a given level
 	U32 mAreaUsedForDataSizeCalcs;				// Height * width used to calculate mDataSizes
-	S32 mLayersUsedForDataSizeCalcs;			// Numbers of layers used to calculate mDataSizes
 
 	S8  mRawDiscardLevel;
 	F32 mRate;
diff --git a/indra/llkdu/llimagej2ckdu.cpp b/indra/llkdu/llimagej2ckdu.cpp
index 08d840917d..31db9d48e3 100644
--- a/indra/llkdu/llimagej2ckdu.cpp
+++ b/indra/llkdu/llimagej2ckdu.cpp
@@ -195,8 +195,7 @@ mRawImagep(NULL),
 mDecodeState(NULL),
 mBlocksSize(-1),
 mPrecinctsSize(-1),
-mLevels(0),
-mLayers(0)
+mLevels(0)
 {
 }
 
@@ -472,13 +471,6 @@ BOOL LLImageJ2CKDU::decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 deco
 				{
 					kdu_tile tile = mCodeStreamp->open_tile(*(mTPosp)+mTileIndicesp->pos);
 
-					int layers = mCodeStreamp->get_max_tile_layers();
-					if (layers > mLayers)
-					{
-						mLayers = layers;
-						base.setLayers(mLayers);
-					}
-
 					// Find the region of the buffer occupied by this
 					// tile.  Note that we have no control over
 					// sub-sampling factors which might have been used
@@ -608,21 +600,14 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 		}
 
 		// Set codestream options
-		mLayers = 0;
+		int nb_layers = 0;
 		kdu_long layer_bytes[MAX_NB_LAYERS];
 		U32 max_bytes = (U32)(base.getWidth() * base.getHeight() * base.getComponents());
 
-		// Rate is the argument passed into the LLImageJ2C which
-		// specifies the target compression rate.  The default is 8:1.
-		// *TODO: mRate is actually always 8:1 in the viewer. Test different values. Also force to reversible for small (< 500 bytes) textures.
-		if (base.mRate != 0.f)
-		{
-			max_bytes = (U32)((F32)(max_bytes) * base.mRate);
-		}
-		else
-		{
-			max_bytes = (U32)((F32)(max_bytes) / 8.0f);
-		}
+		// Rate is the argument passed into the LLImageJ2C which specifies the target compression rate. The default is 8:1.
+		// *TODO: mRate is actually always 8:1 in the viewer. Test different values.
+		llassert (base.mRate > 0.f);
+		max_bytes = (U32)((F32)(max_bytes) * base.mRate);
 		
 		// If the image is very small, code it in a lossless way.
 		// Note: it'll also have only 1 layer which is fine as there's no point reordering blocks in that case.
@@ -635,15 +620,15 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 		// We're using a logarithmic spacing rule that fits with our way of fetching texture data.
 		// Note: For more info on this layers business, read kdu_codestream::flush() doc in kdu_compressed.h
 		U32 i = FIRST_PACKET_SIZE;
-		while ((i < max_bytes) && (mLayers < (MAX_NB_LAYERS-1)))
+		while ((i < max_bytes) && (nb_layers < (MAX_NB_LAYERS-1)))
 		{
 			if (i == FIRST_PACKET_SIZE * 4)
 			{
 				// That really just means that the first layer is FIRST_PACKET_SIZE and the second is MIN_LAYER_SIZE
 				i = MIN_LAYER_SIZE;
 			}
-			layer_bytes[mLayers] = i;
-			mLayers++;
+			layer_bytes[nb_layers] = i;
+			nb_layers++;
 			i *= 4;
 		}
 
@@ -656,18 +641,17 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 			//codestream.access_siz()->parse_string("Cycc=no");
 			// In the reversible case, set the last entry of that table to 0 so that all generated bits will
 			// indeed be output by the time the last quality layer is encountered.
-			layer_bytes[mLayers] = 0;
+			layer_bytes[nb_layers] = 0;
 		}
 		else
 		{
 			// Truncate the last quality layer if necessary so to fit the set compression ratio
-			layer_bytes[mLayers] = max_bytes;
+			layer_bytes[nb_layers] = max_bytes;
 		}
-		mLayers++;
+		nb_layers++;
 
-		std::string layer_string = llformat("Clayers=%d",mLayers);
+		std::string layer_string = llformat("Clayers=%d",nb_layers);
 		codestream.access_siz()->parse_string(layer_string.c_str());
-		base.setLayers(mLayers);
 		
 		// Set up data ordering, markers, etc... if precincts or blocks specified
 		// Note: This code is *not* used in the encoding made by the viewer. It is currently used only
@@ -720,7 +704,7 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 		}
 
 		// Produce the compressed output
-		codestream.flush(layer_bytes,mLayers);
+		codestream.flush(layer_bytes,nb_layers);
 
 		// Cleanup
 		delete tile;
diff --git a/indra/llkdu/llimagej2ckdu.h b/indra/llkdu/llimagej2ckdu.h
index fab97326d4..9ab0b9e4a7 100644
--- a/indra/llkdu/llimagej2ckdu.h
+++ b/indra/llkdu/llimagej2ckdu.h
@@ -75,7 +75,6 @@ private:
 	int mBlocksSize;
 	int mPrecinctsSize;
 	int mLevels;
-	int mLayers;
 
 	// Temporary variables for in-progress decodes...
 	LLImageRaw *mRawImagep;
diff --git a/indra/newview/lltexlayer.cpp b/indra/newview/lltexlayer.cpp
index 1693cfc9e2..467115c928 100644
--- a/indra/newview/lltexlayer.cpp
+++ b/indra/newview/lltexlayer.cpp
@@ -497,7 +497,6 @@ void LLTexLayerSetBuffer::doUpload()
 	}
 	
 	LLPointer<LLImageJ2C> compressedImage = new LLImageJ2C;
-	compressedImage->setRate(0.f);
 	const char* comment_text = LINDEN_J2C_COMMENT_PREFIX "RGBHM"; // writes into baked_color_data. 5 channels (rgb, heightfield/alpha, mask)
 	if (compressedImage->encode(baked_image, comment_text))
 	{
diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp
index 089f45ca89..54ae519422 100644
--- a/indra/newview/llviewertexturelist.cpp
+++ b/indra/newview/llviewertexturelist.cpp
@@ -1030,7 +1030,6 @@ LLPointer<LLImageJ2C> LLViewerTextureList::convertToUploadFile(LLPointer<LLImage
 {
 	raw_image->biasedScaleToPowerOfTwo(LLViewerFetchedTexture::MAX_IMAGE_SIZE_DEFAULT);
 	LLPointer<LLImageJ2C> compressedImage = new LLImageJ2C();
-	compressedImage->setRate(0.f);
 	
 	if (gSavedSettings.getBOOL("LosslessJ2CUpload") &&
 		(raw_image->getWidth() * raw_image->getHeight() <= LL_IMAGE_REZ_LOSSLESS_CUTOFF * LL_IMAGE_REZ_LOSSLESS_CUTOFF))
-- 
cgit v1.3


From 0539de909951e94c9c22aac9ac94835793c7bf49 Mon Sep 17 00:00:00 2001
From: Oz Linden <oz@lindenlab.com>
Date: Fri, 6 Apr 2012 14:36:58 -0400
Subject: STORM-1837: check for valid png header before attempting to decode

---
 indra/llimage/llimagepng.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'indra/llimage')

diff --git a/indra/llimage/llimagepng.cpp b/indra/llimage/llimagepng.cpp
index 8d493ecde0..294f68b122 100644
--- a/indra/llimage/llimagepng.cpp
+++ b/indra/llimage/llimagepng.cpp
@@ -60,6 +60,12 @@ BOOL LLImagePNG::updateData()
 
 	// Decode the PNG data and extract sizing information
 	LLPngWrapper pngWrapper;
+	if (!pngWrapper.isValidPng(getData()))
+	{
+		setLastError("LLImagePNG data does not have a valid PNG header!");
+		return FALSE;
+	}
+
 	LLPngWrapper::ImageInfo infop;
 	if (! pngWrapper.readPng(getData(), NULL, &infop))
 	{
@@ -90,6 +96,12 @@ BOOL LLImagePNG::decode(LLImageRaw* raw_image, F32 decode_time)
 
 	// Decode the PNG data into the raw image
 	LLPngWrapper pngWrapper;
+	if (!pngWrapper.isValidPng(getData()))
+	{
+		setLastError("LLImagePNG data does not have a valid PNG header!");
+		return FALSE;
+	}
+
 	if (! pngWrapper.readPng(getData(), raw_image))
 	{
 		setLastError(pngWrapper.getErrorMessage());
-- 
cgit v1.3


From 172b45d5a217c7cdb922f49706b310edc412fc28 Mon Sep 17 00:00:00 2001
From: Merov Linden <merov@lindenlab.com>
Date: Fri, 6 Apr 2012 18:28:47 -0700
Subject: SH-3060 : Complete new byte range computation, clean up and back
 pedal on some changes that didn't pay of.

---
 indra/llimage/llimagej2c.cpp  | 11 ++++-------
 indra/llkdu/llimagej2ckdu.cpp |  2 +-
 2 files changed, 5 insertions(+), 8 deletions(-)

(limited to 'indra/llimage')

diff --git a/indra/llimage/llimagej2c.cpp b/indra/llimage/llimagej2c.cpp
index 7894de0de5..69d261c9a6 100644
--- a/indra/llimage/llimagej2c.cpp
+++ b/indra/llimage/llimagej2c.cpp
@@ -256,7 +256,7 @@ BOOL LLImageJ2C::encode(const LLImageRaw *raw_imagep, const char* comment_text,
 //static
 S32 LLImageJ2C::calcHeaderSizeJ2C()
 {
-	return HTTP_PACKET_SIZE; // Hack. just needs to be >= actual header size...
+	return FIRST_PACKET_SIZE; // Hack. just needs to be >= actual header size...
 }
 
 //static
@@ -267,7 +267,7 @@ S32 LLImageJ2C::calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, F32 r
 	// in general too big for fast fetching.
 	// For details about the equation used here, see https://wiki.lindenlab.com/wiki/THX1138_KDU_Improvements#Byte_Range_Study
 
-	// Estimate the number of layers. This is consistent with what's done in j2c encoding
+	// Estimate the number of layers. This is consistent with what's done for j2c encoding in LLImageJ2CKDU::encodeImpl().
 	S32 nb_layers = 1;
 	S32 surface = w*h;
 	S32 s = 64*64;
@@ -304,8 +304,6 @@ S32 LLImageJ2C::calcHeaderSize()
 S32 LLImageJ2C::calcDataSize(S32 discard_level)
 {
 	discard_level = llclamp(discard_level, 0, MAX_DISCARD_LEVEL);
-	return calcDataSizeJ2C(getWidth(), getHeight(), getComponents(), discard_level, mRate);
-	/*
 	if ( mAreaUsedForDataSizeCalcs != (getHeight() * getWidth()) 
 		|| (mDataSizes[0] == 0))
 	{
@@ -319,7 +317,6 @@ S32 LLImageJ2C::calcDataSize(S32 discard_level)
 		}
 	}
 	return mDataSizes[discard_level];
-	*/
 }
 
 S32 LLImageJ2C::calcDiscardLevelBytes(S32 bytes)
@@ -332,8 +329,8 @@ S32 LLImageJ2C::calcDiscardLevelBytes(S32 bytes)
 	}
 	while (1)
 	{
-		S32 bytes_needed = calcDataSize(discard_level);
-		if (bytes >= bytes_needed)
+		S32 bytes_needed = calcDataSize(discard_level); // virtual
+		if (bytes >= bytes_needed - (bytes_needed>>2)) // For J2c, up the res at 75% of the optimal number of bytes
 		{
 			break;
 		}
diff --git a/indra/llkdu/llimagej2ckdu.cpp b/indra/llkdu/llimagej2ckdu.cpp
index 31db9d48e3..cbfc34ebb8 100644
--- a/indra/llkdu/llimagej2ckdu.cpp
+++ b/indra/llkdu/llimagej2ckdu.cpp
@@ -393,7 +393,7 @@ BOOL LLImageJ2CKDU::initDecode(LLImageJ2C &base, LLImageRaw &raw_image, F32 deco
 			region_kdu->size.y = region[3] - region[1];
 		}
 		int discard = (discard_level != -1 ? discard_level : base.getRawDiscardLevel());
-		llinfos << "Merov debug : initDecode, discard used = " << discard << ", asked = " << discard_level << llendl;
+		//llinfos << "Merov debug : initDecode, discard used = " << discard << ", asked = " << discard_level << llendl;
 		// Apply loading restrictions
 		mCodeStreamp->apply_input_restrictions( first_channel, max_channel_count, discard, 0, region_kdu);
 		
-- 
cgit v1.3


From c410a4e3325350e3d9a72b867dcef44df9136f54 Mon Sep 17 00:00:00 2001
From: Merov Linden <merov@lindenlab.com>
Date: Thu, 12 Apr 2012 20:19:56 -0700
Subject: SH-3080 : Implement the TextureReverseByteRange setting so we can
 play with that parameter

---
 indra/llimage/llimage.cpp               |  4 +++-
 indra/llimage/llimage.h                 |  4 +++-
 indra/llimage/llimagej2c.cpp            |  6 +++---
 indra/newview/app_settings/settings.xml | 11 +++++++++++
 indra/newview/llappviewer.cpp           |  2 +-
 5 files changed, 21 insertions(+), 6 deletions(-)

(limited to 'indra/llimage')

diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp
index 7f95441075..6775b005f4 100644
--- a/indra/llimage/llimage.cpp
+++ b/indra/llimage/llimage.cpp
@@ -49,12 +49,14 @@
 std::string LLImage::sLastErrorMessage;
 LLMutex* LLImage::sMutex = NULL;
 bool LLImage::sUseNewByteRange = false;
+S32  LLImage::sMinimalReverseByteRangePercent = 75;
 LLPrivateMemoryPool* LLImageBase::sPrivatePoolp = NULL ;
 
 //static
-void LLImage::initClass(bool use_new_byte_range)
+void LLImage::initClass(bool use_new_byte_range, S32 minimal_reverse_byte_range_percent)
 {
 	sUseNewByteRange = use_new_byte_range;
+    sMinimalReverseByteRangePercent = minimal_reverse_byte_range_percent;
 	sMutex = new LLMutex(NULL);
 
 	LLImageBase::createPrivatePool() ;
diff --git a/indra/llimage/llimage.h b/indra/llimage/llimage.h
index a643e4d9f5..46e6d1a901 100644
--- a/indra/llimage/llimage.h
+++ b/indra/llimage/llimage.h
@@ -92,18 +92,20 @@ typedef enum e_image_codec
 class LLImage
 {
 public:
-	static void initClass(bool use_new_byte_range = false);
+	static void initClass(bool use_new_byte_range = false, S32 minimal_reverse_byte_range_percent = 75);
 	static void cleanupClass();
 
 	static const std::string& getLastError();
 	static void setLastError(const std::string& message);
 	
 	static bool useNewByteRange() { return sUseNewByteRange; }
+    static S32  getReverseByteRangePercent() { return sMinimalReverseByteRangePercent; }
 	
 protected:
 	static LLMutex* sMutex;
 	static std::string sLastErrorMessage;
 	static bool sUseNewByteRange;
+    static S32  sMinimalReverseByteRangePercent;
 };
 
 //============================================================================
diff --git a/indra/llimage/llimagej2c.cpp b/indra/llimage/llimagej2c.cpp
index 69d261c9a6..4c5c8a9c52 100644
--- a/indra/llimage/llimagej2c.cpp
+++ b/indra/llimage/llimagej2c.cpp
@@ -289,7 +289,6 @@ S32 LLImageJ2C::calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, F32 r
 	S32 bytes;
 	S32 new_bytes = sqrt((F32)(w*h))*(F32)(comp)*rate*1000.f/layer_factor;
 	S32 old_bytes = (S32)((F32)(w*h*comp)*rate);
-	//llinfos << "Merov debug : w = " << w << ", h = " << h << ", c = " << comp << ", r = " << rate << ", d = " << discard_level << ", l = " << nb_layers << ", old = " << old_bytes << ", new = " << new_bytes << llendl;
 	bytes = (LLImage::useNewByteRange() ? new_bytes : old_bytes);
 	bytes = llmax(bytes, calcHeaderSizeJ2C());
 	return bytes;
@@ -329,8 +328,9 @@ S32 LLImageJ2C::calcDiscardLevelBytes(S32 bytes)
 	}
 	while (1)
 	{
-		S32 bytes_needed = calcDataSize(discard_level); // virtual
-		if (bytes >= bytes_needed - (bytes_needed>>2)) // For J2c, up the res at 75% of the optimal number of bytes
+		S32 bytes_needed = calcDataSize(discard_level);
+		// Use TextureReverseByteRange percent (see settings.xml) of the optimal size to qualify as correct rendering for the given discard level
+		if (bytes >= (bytes_needed*LLImage::getReverseByteRangePercent()/100))
 		{
 			break;
 		}
diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index 5fc9c5d863..eff00b257c 100755
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -10719,6 +10719,17 @@
       <key>Value</key>
       <integer>2</integer>
     </map>
+    <key>TextureReverseByteRange</key>
+    <map>
+      <key>Comment</key>
+      <string>Minimal percent of the optimal byte range allowed to render a given discard level</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>S32</string>
+      <key>Value</key>
+      <integer>50</integer>
+    </map>
     <key>ThrottleBandwidthKBPS</key>
     <map>
       <key>Comment</key>
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 1a68d0317e..37119f4451 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -1947,7 +1947,7 @@ bool LLAppViewer::initThreads()
 	static const bool enable_threads = true;
 #endif
 
-	LLImage::initClass(gSavedSettings.getBOOL("TextureNewByteRange"));
+	LLImage::initClass(gSavedSettings.getBOOL("TextureNewByteRange"),gSavedSettings.getBOOL("TextureReverseByteRange"));
 
 	LLVFSThread::initClass(enable_threads && false);
 	LLLFSThread::initClass(enable_threads && false);
-- 
cgit v1.3


From 8778010feec5193c5ffc88d70e4a303aebaaaee4 Mon Sep 17 00:00:00 2001
From: "Brad Payne (Vir Linden)" <vir@lindenlab.com>
Date: Fri, 13 Apr 2012 17:03:29 -0400
Subject: fix for linux build failure

---
 indra/llimage/llimagej2c.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 mode change 100644 => 100755 indra/llimage/llimagej2c.cpp

(limited to 'indra/llimage')

diff --git a/indra/llimage/llimagej2c.cpp b/indra/llimage/llimagej2c.cpp
old mode 100644
new mode 100755
index 69d261c9a6..4e08f09b4e
--- a/indra/llimage/llimagej2c.cpp
+++ b/indra/llimage/llimagej2c.cpp
@@ -287,7 +287,7 @@ S32 LLImageJ2C::calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, F32 r
 	// Temporary: compute both new and old range and pick one according to the settings TextureNewByteRange 
 	// *TODO: Take the old code out once we have enough tests done
 	S32 bytes;
-	S32 new_bytes = sqrt((F32)(w*h))*(F32)(comp)*rate*1000.f/layer_factor;
+	S32 new_bytes = (S32) (sqrt((F32)(w*h))*(F32)(comp)*rate*1000.f/layer_factor);
 	S32 old_bytes = (S32)((F32)(w*h*comp)*rate);
 	//llinfos << "Merov debug : w = " << w << ", h = " << h << ", c = " << comp << ", r = " << rate << ", d = " << discard_level << ", l = " << nb_layers << ", old = " << old_bytes << ", new = " << new_bytes << llendl;
 	bytes = (LLImage::useNewByteRange() ? new_bytes : old_bytes);
-- 
cgit v1.3


From 8b3703bd03487e6d70a793427ed1587b1cd86808 Mon Sep 17 00:00:00 2001
From: Merov Linden <merov@lindenlab.com>
Date: Fri, 13 Apr 2012 15:42:54 -0700
Subject: SH-3060 : Always use old byte range on low res (faster), reserve new
 byte range for high res.

---
 indra/llimage/llimagej2c.cpp | 7 +++++--
 indra/llimage/llimagej2c.h   | 1 +
 2 files changed, 6 insertions(+), 2 deletions(-)

(limited to 'indra/llimage')

diff --git a/indra/llimage/llimagej2c.cpp b/indra/llimage/llimagej2c.cpp
index 4c5c8a9c52..a76734e550 100644
--- a/indra/llimage/llimagej2c.cpp
+++ b/indra/llimage/llimagej2c.cpp
@@ -289,7 +289,7 @@ S32 LLImageJ2C::calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, F32 r
 	S32 bytes;
 	S32 new_bytes = sqrt((F32)(w*h))*(F32)(comp)*rate*1000.f/layer_factor;
 	S32 old_bytes = (S32)((F32)(w*h*comp)*rate);
-	bytes = (LLImage::useNewByteRange() ? new_bytes : old_bytes);
+	bytes = (LLImage::useNewByteRange() && (new_bytes < old_bytes) ? new_bytes : old_bytes);
 	bytes = llmax(bytes, calcHeaderSizeJ2C());
 	return bytes;
 }
@@ -473,6 +473,7 @@ LLImageCompressionTester::LLImageCompressionTester() : LLMetricPerformanceTester
 
 	mTotalTimeDecompression = 0.0f;
 	mTotalTimeCompression = 0.0f;
+	mRunTimeDecompression = 0.0f;
 }
 
 LLImageCompressionTester::~LLImageCompressionTester()
@@ -555,12 +556,14 @@ void LLImageCompressionTester::updateDecompressionStats(const S32 bytesIn, const
 	mTotalBytesInDecompression += bytesIn;
 	mRunBytesInDecompression += bytesIn;
 	mTotalBytesOutDecompression += bytesOut;
-	if (mRunBytesInDecompression > (1000000))
+	//if (mRunBytesInDecompression > (1000000))
+	if ((mTotalTimeDecompression - mRunTimeDecompression) >= (5.0f))
 	{
 		// Output everything
 		outputTestResults();
 		// Reset the decompression data of the run
 		mRunBytesInDecompression = 0;
+		mRunTimeDecompression = mTotalTimeDecompression;
 	}
 }
 
diff --git a/indra/llimage/llimagej2c.h b/indra/llimage/llimagej2c.h
index 91c344d12f..42093e0e64 100644
--- a/indra/llimage/llimagej2c.h
+++ b/indra/llimage/llimagej2c.h
@@ -163,6 +163,7 @@ class LLImageCompressionTester : public LLMetricPerformanceTesterBasic
         //
         F32 mTotalTimeDecompression;        // Total time spent in computing decompression
         F32 mTotalTimeCompression;          // Total time spent in computing compression
+        F32 mRunTimeDecompression;          // Time in this run (we output every 5 sec in decompress)
     };
 
 #endif
-- 
cgit v1.3


From 5c11b6b2e59ea8042d8dac6071b8be4c81293889 Mon Sep 17 00:00:00 2001
From: Merov Linden <merov@lindenlab.com>
Date: Tue, 8 May 2012 10:16:14 -0700
Subject: SH-3047 : Tweak of the performance compression data gathering code

---
 indra/llimage/llimagej2c.cpp | 6 +++++-
 indra/llimage/llimagej2c.h   | 3 ++-
 2 files changed, 7 insertions(+), 2 deletions(-)

(limited to 'indra/llimage')

diff --git a/indra/llimage/llimagej2c.cpp b/indra/llimage/llimagej2c.cpp
index 4435e0d2a4..452aad25cb 100755
--- a/indra/llimage/llimagej2c.cpp
+++ b/indra/llimage/llimagej2c.cpp
@@ -464,6 +464,7 @@ LLImageCompressionTester::LLImageCompressionTester() : LLMetricPerformanceTester
 	addMetric("Perf Compression (kB/s)");
 
 	mRunBytesInDecompression = 0;
+	mRunBytesOutDecompression = 0;
 	mRunBytesInCompression = 0;
 
 	mTotalBytesInDecompression = 0;
@@ -556,13 +557,16 @@ void LLImageCompressionTester::updateDecompressionStats(const S32 bytesIn, const
 	mTotalBytesInDecompression += bytesIn;
 	mRunBytesInDecompression += bytesIn;
 	mTotalBytesOutDecompression += bytesOut;
+	mRunBytesOutDecompression += bytesOut;
 	//if (mRunBytesInDecompression > (1000000))
-	if ((mTotalTimeDecompression - mRunTimeDecompression) >= (5.0f))
+	if (mRunBytesOutDecompression > (10000000))
+	//if ((mTotalTimeDecompression - mRunTimeDecompression) >= (5.0f))
 	{
 		// Output everything
 		outputTestResults();
 		// Reset the decompression data of the run
 		mRunBytesInDecompression = 0;
+		mRunBytesOutDecompression = 0;
 		mRunTimeDecompression = mTotalTimeDecompression;
 	}
 }
diff --git a/indra/llimage/llimagej2c.h b/indra/llimage/llimagej2c.h
index 42093e0e64..ce8195940d 100644
--- a/indra/llimage/llimagej2c.h
+++ b/indra/llimage/llimagej2c.h
@@ -156,7 +156,8 @@ class LLImageCompressionTester : public LLMetricPerformanceTesterBasic
         U32 mTotalBytesOutDecompression;    // Total bytes produced by decompressor
         U32 mTotalBytesInCompression;       // Total bytes fed to compressor
         U32 mTotalBytesOutCompression;      // Total bytes produced by compressor
-		U32 mRunBytesInDecompression;		// Bytes fed to decompressor in this run
+        U32 mRunBytesInDecompression;		// Bytes fed to decompressor in this run
+        U32 mRunBytesOutDecompression;		// Bytes produced by the decompressor in this run
 		U32 mRunBytesInCompression;			// Bytes fed to compressor in this run
         //
         // Time
-- 
cgit v1.3