14 files changed, 528 insertions, 544 deletions

diff --git a/indra/integration_tests/llimage_libtest/llimage_libtest.cpp b/indra/integration_tests/llimage_libtest/llimage_libtest.cpp
index 365f5f758c..0151016862 100644
--- a/indra/integration_tests/llimage_libtest/llimage_libtest.cpp
+++ b/indra/integration_tests/llimage_libtest/llimage_libtest.cpp
@@ -53,12 +53,29 @@ 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"
+" -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"
+" -d, --discard_level <n>\n"
+"        Discard level max used on input. 0 is highest resolution. Max discard level is 5.\n"
+"        This allows the input image to be clamped in resolution when loading.\n"
+"        Only valid for j2c images. Default is no discard.\n"
+" -p, --precincts <n>\n"
+"        Dimension of precincts in pixels. Precincts are assumed square and identical for\n"
+"        all levels. Note that this option also add PLT and tile markers to the codestream, \n"
+"        and uses RPCL order. Power of 2 must be used.\n"
+"        Only valid for output j2c images. Default is no precincts used.\n"
+" -b, --blocks <n>\n"
+"        Dimension of coding blocks in pixels. Blocks are assumed square. Power of 2 must\n"
+"        be used. Blocks must be smaller than precincts. Like precincts, this option adds\n"
+"        PLT, tile markers and uses RPCL.\n"
+"        Only valid for output j2c images. Default is 64.\n"
 " -log, --logmetrics <metric>\n"
 "        Log performance data for <metric>. Results in <metric>.slp\n"
 "        Note: so far, only ImageCompressionTester has been tested.\n"
-" -r, --analyzeperformance\n"
+" -a, --analyzeperformance\n"
 "        Create a report comparing <metric>_baseline.slp with current <metric>.slp\n"
-"        Results in <metric>_report.csv"
+"        Results in <metric>_report.csv\n"
 " -s, --image-stats\n"
 "        Output stats for each input and output image.\n"
 "\n";
@@ -69,31 +86,8 @@ static bool sAllDone = false;
 // Create an empty formatted image instance of the correct type from the filename
 LLPointer<LLImageFormatted> create_image(const std::string &filename)
 {
-	std::string exten = gDirUtilp->getExtension(filename);
-	U32 codec = LLImageBase::getCodecFromExtension(exten);
-	
-	LLPointer<LLImageFormatted> image;
-	switch (codec)
-	{
-		case IMG_CODEC_BMP:
-			image = new LLImageBMP();
-			break;
-		case IMG_CODEC_TGA:
-			image = new LLImageTGA();
-			break;
-		case IMG_CODEC_JPEG:
-			image = new LLImageJPEG();
-			break;
-		case IMG_CODEC_J2C:
-			image = new LLImageJ2C();
-			break;
-		case IMG_CODEC_PNG:
-			image = new LLImagePNG();
-			break;
-		default:
-			return NULL;
-	}
-	
+	std::string exten = gDirUtilp->getExtension(filename);	
+	LLPointer<LLImageFormatted> image = LLImageFormatted::createFromExtension(exten);
 	return image;
 }
 
@@ -110,10 +104,11 @@ 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, bool output_stats)
+LLPointer<LLImageRaw> load_image(const std::string &src_filename, int discard_level, int* region, 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))
 	{
 		return NULL;
@@ -131,6 +126,15 @@ LLPointer<LLImageRaw> load_image(const std::string &src_filename, bool output_st
 	}
 	
 	LLPointer<LLImageRaw> raw_image = new LLImageRaw;
+	
+	// Set the image restriction on load in the case of a j2c image
+	if ((image->getCodec() == IMG_CODEC_J2C) && ((discard_level != -1) || (region != NULL)))
+	{
+		// That method doesn't exist (and likely, doesn't make sense) for any other image file format
+		// hence the required cryptic cast.
+		((LLImageJ2C*)(image.get()))->initDecode(*raw_image, discard_level, region);
+	}
+	
 	if (!image->decode(raw_image, 0.0f))
 	{
 		return NULL;
@@ -140,10 +144,18 @@ LLPointer<LLImageRaw> load_image(const std::string &src_filename, bool output_st
 }
 
 // Save a raw image instance into a file
-bool save_image(const std::string &dest_filename, LLPointer<LLImageRaw> raw_image, bool output_stats)
+bool save_image(const std::string &dest_filename, LLPointer<LLImageRaw> raw_image, int blocks_size, int precincts_size, bool output_stats)
 {
 	LLPointer<LLImageFormatted> image = create_image(dest_filename);
 	
+	// Set the image codestream parameters on output in the case of a j2c image
+	if ((image->getCodec() == IMG_CODEC_J2C) && ((blocks_size != -1) || (precincts_size != -1)))
+	{
+		// That method doesn't exist (and likely, doesn't make sense) for any other image file format
+		// hence the required cryptic cast.
+		((LLImageJ2C*)(image.get()))->initEncode(*raw_image, blocks_size, precincts_size);
+	}
+	
 	if (!image->encode(raw_image, 0.0f))
 	{
 		return false;
@@ -280,8 +292,13 @@ int main(int argc, char** argv)
 	// List of input and output files
 	std::list<std::string> input_filenames;
 	std::list<std::string> output_filenames;
+	// Other optional parsed arguments
 	bool analyze_performance = false;
 	bool image_stats = false;
+	int* region = NULL;
+	int discard_level = -1;
+	int precincts_size = -1;
+	int blocks_size = -1;
 
 	// Init whatever is necessary
 	ll_init_apr();
@@ -323,6 +340,81 @@ int main(int argc, char** argv)
 				file_name = argv[arg+1];	// Next argument and loop over
 			}
 		}
+		else if ((!strcmp(argv[arg], "--region") || !strcmp(argv[arg], "-r")) && arg < argc-1)
+		{
+			std::string value_str = argv[arg+1];
+			int index = 0;
+			region = new int[4];
+			while (value_str[0] != '-')		// if arg starts with '-', it's the next option
+			{
+				int value = atoi(value_str.c_str());
+				region[index++] = value;
+				arg += 1;					// Definitely skip that arg now we know it's a number
+				if ((arg + 1) == argc)		// Break out of the loop if we reach the end of the arg list
+					break;
+				if (index == 4)				// Break out of the loop if we captured 4 values already
+					break;
+				value_str = argv[arg+1];	// Next argument and loop over
+			}
+			if (index != 4)
+			{
+				std::cout << "--region arguments invalid" << std::endl;
+				delete [] region;
+				region = NULL;
+			}
+		}
+		else if (!strcmp(argv[arg], "--discard_level") || !strcmp(argv[arg], "-d"))
+		{
+			std::string value_str;
+			if ((arg + 1) < argc)
+			{
+				value_str = argv[arg+1];
+			}
+			if (((arg + 1) >= argc) || (value_str[0] == '-'))
+			{
+				std::cout << "No valid --discard_level argument given, discard_level ignored" << std::endl;
+			}
+			else
+			{
+				discard_level = atoi(value_str.c_str());
+				// Clamp to the values accepted by the viewer
+				discard_level = llclamp(discard_level,0,5);
+			}
+		}
+		else if (!strcmp(argv[arg], "--precincts") || !strcmp(argv[arg], "-p"))
+		{
+			std::string value_str;
+			if ((arg + 1) < argc)
+			{
+				value_str = argv[arg+1];
+			}
+			if (((arg + 1) >= argc) || (value_str[0] == '-'))
+			{
+				std::cout << "No valid --precincts argument given, precincts ignored" << std::endl;
+			}
+			else
+			{
+				precincts_size = atoi(value_str.c_str());
+				// *TODO: make sure precincts_size is a power of 2
+			}
+		}
+		else if (!strcmp(argv[arg], "--blocks") || !strcmp(argv[arg], "-b"))
+		{
+			std::string value_str;
+			if ((arg + 1) < argc)
+			{
+				value_str = argv[arg+1];
+			}
+			if (((arg + 1) >= argc) || (value_str[0] == '-'))
+			{
+				std::cout << "No valid --blocks argument given, blocks ignored" << std::endl;
+			}
+			else
+			{
+				blocks_size = atoi(value_str.c_str());
+				// *TODO: make sure blocks_size is a power of 2
+			}
+		}
 		else if (!strcmp(argv[arg], "--logmetrics") || !strcmp(argv[arg], "-log"))
 		{
 			// '--logmetrics' needs to be specified with a named test metric argument
@@ -346,7 +438,7 @@ int main(int argc, char** argv)
 					break;
 			}
 		}
-		else if (!strcmp(argv[arg], "--analyzeperformance") || !strcmp(argv[arg], "-r"))
+		else if (!strcmp(argv[arg], "--analyzeperformance") || !strcmp(argv[arg], "-a"))
 		{
 			analyze_performance = true;
 		}
@@ -364,7 +456,7 @@ int main(int argc, char** argv)
 	}
 	if (analyze_performance && !LLFastTimer::sMetricLog)
 	{
-		std::cout << "Cannot create perf report if no perf gathered (i.e. use argument -log <perf> with -r) -> exit" << std::endl;
+		std::cout << "Cannot create perf report if no perf gathered (i.e. use argument -log <perf> with -a) -> exit" << std::endl;
 		return 0;
 	}
 	
@@ -385,7 +477,7 @@ int main(int argc, char** argv)
 	for (; in_file != in_end; ++in_file)
 	{
 		// Load file
-		LLPointer<LLImageRaw> raw_image = load_image(*in_file, image_stats);
+		LLPointer<LLImageRaw> raw_image = load_image(*in_file, discard_level, region, image_stats);
 		if (!raw_image)
 		{
 			std::cout << "Error: Image " << *in_file << " could not be loaded" << std::endl;
@@ -395,7 +487,7 @@ int main(int argc, char** argv)
 		// Save file
 		if (out_file != out_end)
 		{
-			if (!save_image(*out_file, raw_image, image_stats))
+			if (!save_image(*out_file, raw_image, blocks_size, precincts_size, image_stats))
 			{
 				std::cout << "Error: Image " << *out_file << " could not be saved" << std::endl;
 			}
@@ -407,25 +499,25 @@ int main(int argc, char** argv)
 		}
 	}
 
-	// Stop the perf gathering system if needed
-	if (LLFastTimer::sMetricLog)
-	{
-		LLMetricPerformanceTesterBasic::deleteTester(LLFastTimer::sLogName);
-		sAllDone = true;
-	}
-	
 	// Output perf data if requested by user
 	if (analyze_performance)
 	{
-		std::cout << "Analyzing performance" << std::endl;
-		
 		std::string baseline_name = LLFastTimer::sLogName + "_baseline.slp";
 		std::string current_name  = LLFastTimer::sLogName + ".slp"; 
 		std::string report_name   = LLFastTimer::sLogName + "_report.csv";
 		
+		std::cout << "Analyzing performance, check report in : " << report_name << std::endl;
+
 		LLMetricPerformanceTesterBasic::doAnalysisMetrics(baseline_name, current_name, report_name);
 	}
 	
+	// Stop the perf gathering system if needed
+	if (LLFastTimer::sMetricLog)
+	{
+		LLMetricPerformanceTesterBasic::deleteTester(LLFastTimer::sLogName);
+		sAllDone = true;
+	}
+	
 	// Cleanup and exit
 	LLImage::cleanupClass();
 	if (fast_timer_log_thread)
diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp
index 39211bf7fa..f0d15d9607 100644
--- a/indra/llimage/llimage.cpp
+++ b/indra/llimage/llimage.cpp
@@ -1254,28 +1254,7 @@ bool LLImageRaw::createFromFile(const std::string &filename, bool j2c_lowest_mip
 		return false;
 	}
 	
-	LLPointer<LLImageFormatted> image;
-	switch(codec)
-	{
-	  //case IMG_CODEC_RGB:
-	  case IMG_CODEC_BMP:
-		image = new LLImageBMP();
-		break;
-	  case IMG_CODEC_TGA:
-		image = new LLImageTGA();
-		break;
-	  case IMG_CODEC_JPEG:
-		image = new LLImageJPEG();
-		break;
-	  case IMG_CODEC_J2C:
-		image = new LLImageJ2C();
-		break;
-	  case IMG_CODEC_DXT:
-		image = new LLImageDXT();
-		break;
-	  default:
-		return false;
-	}
+	LLPointer<LLImageFormatted> image = LLImageFormatted::createFromType(codec);
 	llassert(image.notNull());
 
 	U8 *buffer = image->allocateData(length);
diff --git a/indra/llimage/llimagej2c.cpp b/indra/llimage/llimagej2c.cpp
index 80fec7f8a0..a90df0f1c1 100644
--- a/indra/llimage/llimagej2c.cpp
+++ b/indra/llimage/llimagej2c.cpp
@@ -139,6 +139,15 @@ BOOL LLImageJ2C::updateData()
 	return res;
 }
 
+BOOL LLImageJ2C::initDecode(LLImageRaw &raw_image, int discard_level, int* region)
+{
+	return mImpl->initDecode(*this,raw_image,discard_level,region);
+}
+
+BOOL LLImageJ2C::initEncode(LLImageRaw &raw_image, int blocks_size, int precincts_size)
+{
+	return mImpl->initEncode(*this,raw_image,blocks_size,precincts_size);
+}
 
 BOOL LLImageJ2C::decode(LLImageRaw *raw_imagep, F32 decode_time)
 {
@@ -251,6 +260,9 @@ 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;
 	while (discard_level > 0)
 	{
diff --git a/indra/llimage/llimagej2c.h b/indra/llimage/llimagej2c.h
index dd5bec8b2e..6bba81aab5 100644
--- a/indra/llimage/llimagej2c.h
+++ b/indra/llimage/llimagej2c.h
@@ -56,6 +56,8 @@ public:
 	/*virtual*/ void resetLastError();
 	/*virtual*/ void setLastError(const std::string& message, const std::string& filename = std::string());
 	
+	BOOL initDecode(LLImageRaw &raw_image, int discard_level, int* region);
+	BOOL initEncode(LLImageRaw &raw_image, int blocks_size, int precincts_size);
 	
 	// Encode with comment text 
 	BOOL encode(const LLImageRaw *raw_imagep, const char* comment_text, F32 encode_time=0.0);
@@ -117,6 +119,8 @@ protected:
 	virtual BOOL decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count) = 0;
 	virtual BOOL encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text, F32 encode_time=0.0,
 							BOOL reversible=FALSE) = 0;
+	virtual BOOL initDecode(LLImageJ2C &base, LLImageRaw &raw_image, int discard_level = -1, int* region = NULL) = 0;
+	virtual BOOL initEncode(LLImageJ2C &base, LLImageRaw &raw_image, int blocks_size = -1, int precincts_size = -1) = 0;
 
 	friend class LLImageJ2C;
 };
diff --git a/indra/llimagej2coj/llimagej2coj.cpp b/indra/llimagej2coj/llimagej2coj.cpp
index 13b12c0928..8288fa1f5c 100644
--- a/indra/llimagej2coj/llimagej2coj.cpp
+++ b/indra/llimagej2coj/llimagej2coj.cpp
@@ -107,6 +107,17 @@ LLImageJ2COJ::~LLImageJ2COJ()
 {
 }
 
+BOOL LLImageJ2COJ::initDecode(LLImageJ2C &base, LLImageRaw &raw_image, int discard_level, int* region)
+{
+	// No specific implementation for this method in the OpenJpeg case
+	return FALSE;
+}
+
+BOOL LLImageJ2COJ::initEncode(LLImageJ2C &base, LLImageRaw &raw_image, int blocks_size, int precincts_size)
+{
+	// No specific implementation for this method in the OpenJpeg case
+	return FALSE;
+}
 
 BOOL LLImageJ2COJ::decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count)
 {
diff --git a/indra/llimagej2coj/llimagej2coj.h b/indra/llimagej2coj/llimagej2coj.h
index 9476665ccb..9c7cc09fcb 100644
--- a/indra/llimagej2coj/llimagej2coj.h
+++ b/indra/llimagej2coj/llimagej2coj.h
@@ -39,6 +39,8 @@ protected:
 	/*virtual*/ BOOL decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count);
 	/*virtual*/ BOOL encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text, F32 encode_time=0.0,
 								BOOL reversible = FALSE);
+	/*virtual*/ BOOL initDecode(LLImageJ2C &base, LLImageRaw &raw_image, int discard_level = -1, int* region = NULL);
+	/*virtual*/ BOOL initEncode(LLImageJ2C &base, LLImageRaw &raw_image, int blocks_size = -1, int precincts_size = -1);
 };
 
 #endif
diff --git a/indra/llkdu/llimagej2ckdu.cpp b/indra/llkdu/llimagej2ckdu.cpp
index 10ea5685e8..5b2c045841 100644
--- a/indra/llkdu/llimagej2ckdu.cpp
+++ b/indra/llkdu/llimagej2ckdu.cpp
@@ -34,35 +34,35 @@
 
 class kdc_flow_control {
 	
-public: // Member functions
-    kdc_flow_control(kdu_image_in_base *img_in, kdu_codestream codestream);
-    ~kdc_flow_control();
-    bool advance_components();
-    void process_components();
+public:
+	kdc_flow_control(kdu_image_in_base *img_in, kdu_codestream codestream);
+	~kdc_flow_control();
+	bool advance_components();
+	void process_components();
+	
+private:
 	
-private: // Data
-    
-    struct kdc_component_flow_control {
-    public: // Data
-        kdu_image_in_base *reader;
-        int vert_subsampling;
-        int ratio_counter;  /*  Initialized to 0, decremented by `count_delta';
+	struct kdc_component_flow_control {
+	public:
+		kdu_image_in_base *reader;
+		int vert_subsampling;
+		int ratio_counter;  /*  Initialized to 0, decremented by `count_delta';
                                 when < 0, a new line must be processed, after
                                 which it is incremented by `vert_subsampling'.  */
-        int initial_lines;
-        int remaining_lines;
-        kdu_line_buf *line;
-    };
-    
-    kdu_codestream codestream;
-    kdu_dims valid_tile_indices;
-    kdu_coords tile_idx;
-    kdu_tile tile;
-    int num_components;
-    kdc_component_flow_control *components;
-    int count_delta; // Holds the minimum of the `vert_subsampling' fields
-    kdu_multi_analysis engine;
-    kdu_long max_buffer_memory;
+		int initial_lines;
+		int remaining_lines;
+		kdu_line_buf *line;
+	};
+	
+	kdu_codestream codestream;
+	kdu_dims valid_tile_indices;
+	kdu_coords tile_idx;
+	kdu_tile tile;
+	int num_components;
+	kdc_component_flow_control *components;
+	int count_delta; // Holds the minimum of the `vert_subsampling' fields
+	kdu_multi_analysis engine;
+	kdu_long max_buffer_memory;
 };
 
 //
@@ -72,7 +72,8 @@ void set_default_colour_weights(kdu_params *siz);
 
 const char* engineInfoLLImageJ2CKDU()
 {
-	return "KDU v6.4.1";
+	std::string version = llformat("KDU %s", KDU_CORE_VERSION);
+	return version.c_str();
 }
 
 LLImageJ2CKDU* createLLImageJ2CKDU()
@@ -105,7 +106,11 @@ const char* fallbackEngineInfoLLImageJ2CImpl()
 class LLKDUDecodeState
 {
 public:
+	LLKDUDecodeState(kdu_tile tile, kdu_byte *buf, S32 row_gap);
+	~LLKDUDecodeState();
+	BOOL processTileDecode(F32 decode_time, BOOL limit_time = TRUE);
 
+private:
 	S32 mNumComponents;
 	BOOL mUseYCC;
 	kdu_dims mDims;
@@ -113,22 +118,12 @@ public:
 	kdu_tile_comp mComps[4];
 	kdu_line_buf mLines[4];
 	kdu_pull_ifc mEngines[4];
-	bool mReversible[4]; // Some components may be reversible and others not.
-	int mBitDepths[4]; // Original bit-depth may be quite different from 8.
-
+	bool mReversible[4]; // Some components may be reversible and others not
+	int mBitDepths[4];   // Original bit-depth may be quite different from 8
+	
 	kdu_tile mTile;
 	kdu_byte *mBuf;
 	S32 mRowGap;
-
-	LLKDUDecodeState(kdu_tile tile, kdu_byte *buf, S32 row_gap);
-	~LLKDUDecodeState();
-	BOOL processTileDecode(F32 decode_time, BOOL limit_time = TRUE);
-
-public:
-	int *AssignLayerBytes(siz_params *siz, int &num_specs);
-
-	void setupCodeStream(BOOL keep_codestream, LLImageJ2CKDU::ECodeStreamMode mode);
-	BOOL initDecode(LLImageRaw &raw_image, F32 decode_time, LLImageJ2CKDU::ECodeStreamMode mode, S32 first_channel, S32 max_channel_count );
 };
 
 void ll_kdu_error( void )
@@ -153,7 +148,7 @@ class LLKDUMessageError : public kdu_message
 public:
 	/*virtual*/ void put_text(const char *s);
 	/*virtual*/ void put_text(const kdu_uint16 *s);
-	/*virtual*/ void flush(bool end_of_message=false);
+	/*virtual*/ void flush(bool end_of_message = false);
 	static LLKDUMessageError sDefaultMessage;
 };
 
@@ -179,7 +174,7 @@ void LLKDUMessageError::put_text(const kdu_uint16 *s)
 
 void LLKDUMessageError::flush(bool end_of_message)
 {
-	if( end_of_message ) 
+	if (end_of_message) 
 	{
 		throw "KDU throwing an exception";
 	}
@@ -195,7 +190,9 @@ mCodeStreamp(NULL),
 mTPosp(NULL),
 mTileIndicesp(NULL),
 mRawImagep(NULL),
-mDecodeState(NULL)
+mDecodeState(NULL),
+mBlocksSize(-1),
+mPrecinctsSize(-1)
 {
 }
 
@@ -210,7 +207,7 @@ void transfer_bytes(kdu_byte *dest, kdu_line_buf &src, int gap, int precision);
 void LLImageJ2CKDU::setupCodeStream(LLImageJ2C &base, BOOL keep_codestream, ECodeStreamMode mode)
 {
 	S32 data_size = base.getDataSize();
-	S32 max_bytes = base.getMaxBytes() ? base.getMaxBytes() : data_size;
+	S32 max_bytes = (base.getMaxBytes() ? base.getMaxBytes() : data_size);
 
 	//
 	//  Initialization
@@ -247,21 +244,21 @@ void LLImageJ2CKDU::setupCodeStream(LLImageJ2C &base, BOOL keep_codestream, ECod
 	// Set the maximum number of bytes to use from the codestream
 	mCodeStreamp->set_max_bytes(max_bytes);
 
-	//    If you want to flip or rotate the image for some reason, change
+	//	If you want to flip or rotate the image for some reason, change
 	// the resolution, or identify a restricted region of interest, this is
 	// the place to do it.  You may use "kdu_codestream::change_appearance"
 	// and "kdu_codestream::apply_input_restrictions" for this purpose.
-	//    If you wish to truncate the code-stream prior to decompression, you
+	//	If you wish to truncate the code-stream prior to decompression, you
 	// may use "kdu_codestream::set_max_bytes".
-	//    If you wish to retain all compressed data so that the material
+	//	If you wish to retain all compressed data so that the material
 	// can be decompressed multiple times, possibly with different appearance
 	// parameters, you should call "kdu_codestream::set_persistent" here.
-	//    There are a variety of other features which must be enabled at
+	//	There are a variety of other features which must be enabled at
 	// this point if you want to take advantage of them.  See the
 	// descriptions appearing with the "kdu_codestream" interface functions
 	// in "kdu_compressed.h" for an itemized account of these capabilities.
 
-	switch( mode )
+	switch (mode)
 	{
 	case MODE_FAST:
 		mCodeStreamp->set_fast();
@@ -326,7 +323,19 @@ void LLImageJ2CKDU::cleanupCodeStream()
 	mTileIndicesp = NULL;
 }
 
-BOOL LLImageJ2CKDU::initDecode(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, ECodeStreamMode mode, S32 first_channel, S32 max_channel_count )
+BOOL LLImageJ2CKDU::initDecode(LLImageJ2C &base, LLImageRaw &raw_image, int discard_level, int* region)
+{
+	return initDecode(base,raw_image,0.0f,MODE_FAST,0,4,discard_level,region);
+}
+
+BOOL LLImageJ2CKDU::initEncode(LLImageJ2C &base, LLImageRaw &raw_image, int blocks_size, int precincts_size)
+{
+	mBlocksSize = blocks_size;
+	mPrecinctsSize = precincts_size;
+	return TRUE;
+}
+
+BOOL LLImageJ2CKDU::initDecode(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, ECodeStreamMode mode, S32 first_channel, S32 max_channel_count, int discard_level, int* region)
 {
 	base.resetLastError();
 
@@ -339,17 +348,36 @@ BOOL LLImageJ2CKDU::initDecode(LLImageJ2C &base, LLImageRaw &raw_image, F32 deco
 
 		mRawImagep = &raw_image;
 		mCodeStreamp->change_appearance(false, true, false);
-		mCodeStreamp->apply_input_restrictions(first_channel,max_channel_count,base.getRawDiscardLevel(),0,NULL);
 
-		kdu_dims dims; mCodeStreamp->get_dims(0,dims);
-		S32 channels = base.getComponents() - first_channel;
-		if( channels > max_channel_count )
+		// Apply loading discard level and cropping if required
+		kdu_dims* region_kdu = NULL;
+		if (region != NULL)
+		{
+			region_kdu = new kdu_dims;
+			region_kdu->pos.x  = region[0];
+			region_kdu->pos.y  = region[1];
+			region_kdu->size.x = region[2] - region[0];
+			region_kdu->size.y = region[3] - region[1];
+		}
+		int discard = (discard_level != -1 ? discard_level : base.getRawDiscardLevel());
+		
+		// Apply loading restrictions
+		mCodeStreamp->apply_input_restrictions( first_channel, max_channel_count, discard, 0, region_kdu);
+		
+		// Clean-up
+		if (region_kdu)
 		{
-			channels = max_channel_count;
+			delete region_kdu;
+			region_kdu = NULL;
 		}
+
+		// Resize raw_image according to the image to be decoded
+		kdu_dims dims; mCodeStreamp->get_dims(0,dims);
+		S32 channels = base.getComponents() - first_channel;
+		channels = llmin(channels,max_channel_count);
 		raw_image.resize(dims.size.x, dims.size.y, channels);
+		//	llinfos << "Resizing raw_image to " << dims.size.x << ":" << dims.size.y << llendl;
 
-		//	llinfos << "Resizing to " << dims.size.x << ":" << dims.size.y << llendl;
 		if (!mTileIndicesp)
 		{
 			mTileIndicesp = new kdu_dims;
@@ -426,7 +454,7 @@ BOOL LLImageJ2CKDU::decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 deco
 					// canvas coordinate system.  Comparing the two tells
 					// us where the current tile is in the buffer.
 					S32 channels = base.getComponents() - first_channel;
-					if( channels > max_channel_count )
+					if (channels > max_channel_count)
 					{
 						channels = max_channel_count;
 					}
@@ -452,14 +480,14 @@ BOOL LLImageJ2CKDU::decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 deco
 					return FALSE;
 				}
 			}
-			catch( const char* msg )
+			catch (const char* msg)
 			{
 				base.setLastError(ll_safe_string(msg));
 				base.decodeFailed();
 				cleanupCodeStream();
 				return TRUE; // done
 			}
-			catch( ... )
+			catch (...)
 			{
 				base.setLastError( "Unknown J2C error" );
 				base.decodeFailed();
@@ -482,28 +510,17 @@ BOOL LLImageJ2CKDU::decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 deco
 
 BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text, F32 encode_time, BOOL reversible)
 {
-	// Collect simple arguments.
-	bool transpose, vflip, hflip;
-	bool allow_rate_prediction, mem, quiet, no_weights;
-	int cpu_iterations;
-	std::ostream *record_stream;
-
-	transpose = false;
-	record_stream = NULL;
-	allow_rate_prediction = true;
-	no_weights = false;
-	cpu_iterations = -1;
-	mem = false;
-	quiet = false;
-	vflip = true;
-	hflip = false;
+	// Declare and set simple arguments
+	bool transpose = false;
+	bool vflip = true;
+	bool hflip = false;
 
 	try
 	{
-		// Set up input image files.
+		// Set up input image files
 		siz_params siz;
 		
-		// Should set rate someplace here.
+		// Should set rate someplace here
 		LLKDUMemIn mem_in(raw_image.getData(),
 			raw_image.getDataSize(),
 			raw_image.getWidth(),
@@ -521,12 +538,12 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 		siz.set(Sprecision,0,0,8);  // Image samples have original bit-depth of 8
 		siz.set(Ssigned,0,0,false); // Image samples are originally unsigned
 
-		kdu_params *siz_ref = &siz; siz_ref->finalize();
-		siz_params transformed_siz; // Use this one to construct code-strea
+		kdu_params *siz_ref = &siz; 
+		siz_ref->finalize();
+		siz_params transformed_siz; // Use this one to construct code-stream
 		transformed_siz.copy_from(&siz,-1,-1,-1,0,transpose,false,false);
 
-		// Construct the `kdu_codestream' object and parse all remaining arguments.
-
+		// Construct the `kdu_codestream' object and parse all remaining arguments
 		U32 max_output_size = base.getWidth()*base.getHeight()*base.getComponents();
 		if (max_output_size < 1000)
 		{
@@ -538,8 +555,7 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 		LLKDUMemTarget output(output_buffer, output_size, base.getWidth()*base.getHeight()*base.getComponents());
 		if (output_size > max_output_size)
 		{
-			llerrs << llformat("LLImageJ2C::encode output_size(%d) > max_output_size(%d)",
-				output_size,max_output_size) << llendl;
+			llerrs << llformat("LLImageJ2C::encode output_size(%d) > max_output_size(%d)", output_size,max_output_size) << llendl;
 		}
 
 		kdu_codestream codestream;
@@ -558,15 +574,18 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 		kdu_long layer_bytes[64];
 		U32 max_bytes = 0;
 
-		if ((num_components >= 3) && !no_weights)
+		if (num_components >= 3)
 		{
+			// Note that we always use YCC and not YUV
+			// *TODO: Verify this doesn't screws up reversible textures (like sculpties) as YCC is not reversible but YUV is...
 			set_default_colour_weights(codestream.access_siz());
 		}
 
 		if (reversible)
 		{
-			// If we're doing reversible, assume we're not using quality layers.
+			// If we're doing reversible (i.e. lossless compression), assumes we're not using quality layers.
 			// Yes, I know this is incorrect!
+			// *TODO: Indeed, this is incorrect and unecessary... Try using the regular layer setting...
 			codestream.access_siz()->parse_string("Creversible=yes");
 			codestream.access_siz()->parse_string("Clayers=1");
 			num_layer_specs = 1;
@@ -577,6 +596,7 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 			// 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());
@@ -617,42 +637,56 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 				codestream.access_siz()->parse_string(layer_string.c_str());
 			}
 		}
-		codestream.access_siz()->finalize_all();
-		if (cpu_iterations >= 0)
+		
+		// Set up data ordering, markers, etc... if precincts or blocks specified
+		if ((mBlocksSize != -1) || (mPrecinctsSize != -1))
 		{
-			codestream.collect_timing_stats(cpu_iterations);
+			if (mPrecinctsSize != -1)
+			{
+				std::string precincts_string = llformat("Cprecincts={%d,%d}",mPrecinctsSize,mPrecinctsSize);
+				codestream.access_siz()->parse_string(precincts_string.c_str());
+			}
+			if (mBlocksSize != -1)
+			{
+				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");
+			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());
+			std::string Parts_string = llformat("ORGtparts=R");
+			codestream.access_siz()->parse_string(Parts_string.c_str());
 		}
+		
+		codestream.access_siz()->finalize_all();
 		codestream.change_appearance(transpose,vflip,hflip);
 
 		// Now we are ready for sample data processing.
-        kdc_flow_control *tile = new kdc_flow_control(&mem_in,codestream);
-        bool done = false;
-        while (!done)
-        { 
-            // Process line by line
-            done = true;
-            if (tile->advance_components())
-            {
-                done = false;
-                tile->process_components();
-            }
-        }
+		kdc_flow_control *tile = new kdc_flow_control(&mem_in,codestream);
+		bool done = false;
+		while (!done)
+		{ 
+			// Process line by line
+			if (tile->advance_components())
+			{
+				tile->process_components();
+			}
+			else
+			{
+				done = true;
+			}
+		}
 
 		// Produce the compressed output
-        codestream.flush(layer_bytes,num_layer_specs);
+		codestream.flush(layer_bytes,num_layer_specs);
 
 		// Cleanup
-        delete tile;
-
+		delete tile;
 		codestream.destroy();
-		if (record_stream != NULL)
-		{
-			delete record_stream;
-		}
 
 		// Now that we're done encoding, create the new data buffer for the compressed
 		// image and stick it there.
-
 		base.copyData(output_buffer, output_size);
 		base.updateData(); // set width, height
 		delete[] output_buffer;
@@ -674,19 +708,19 @@ BOOL LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, co
 BOOL LLImageJ2CKDU::getMetadata(LLImageJ2C &base)
 {
 	// *FIX: kdu calls our callback function if there's an error, and
-	// then bombs.  To regain control, we throw an exception, and
+	// then bombs. To regain control, we throw an exception, and
 	// catch it here.
 	try
 	{
 		setupCodeStream(base, FALSE, MODE_FAST);
 		return TRUE;
 	}
-	catch( const char* msg )
+	catch (const char* msg)
 	{
 		base.setLastError(ll_safe_string(msg));
 		return FALSE;
 	}
-	catch( ... )
+	catch (...)
 	{
 		base.setLastError( "Unknown J2C error" );
 		return FALSE;
@@ -699,37 +733,49 @@ void set_default_colour_weights(kdu_params *siz)
 	assert(cod != NULL);
 
 	bool can_use_ycc = true;
-	bool rev0=false;
-	int depth0=0, sub_x0=1, sub_y0=1;
-	for (int c=0; c < 3; c++)
+	bool rev0 = false;
+	int depth0 = 0, sub_x0 = 1, sub_y0 = 1;
+	for (int c = 0; c < 3; c++)
 	{
-		int depth=0; siz->get(Sprecision,c,0,depth);
-		int sub_y=1; siz->get(Ssampling,c,0,sub_y);
-		int sub_x=1; siz->get(Ssampling,c,1,sub_x);
+		int depth = 0; siz->get(Sprecision,c,0,depth);
+		int sub_y = 1; siz->get(Ssampling,c,0,sub_y);
+		int sub_x = 1; siz->get(Ssampling,c,1,sub_x);
 		kdu_params *coc = cod->access_relation(-1,c);
-		bool rev=false; coc->get(Creversible,0,0,rev);
+		bool rev = false; coc->get(Creversible,0,0,rev);
 		if (c == 0)
-		{ rev0=rev; depth0=depth; sub_x0=sub_x; sub_y0=sub_y; }
-		else if ((rev != rev0) || (depth != depth0) ||
-			(sub_x != sub_x0) || (sub_y != sub_y0))
+		{
+			rev0 = rev; depth0 = depth; sub_x0 = sub_x; sub_y0 = sub_y;
+		}
+		else if ((rev != rev0) || (depth != depth0) || 
+				 (sub_x != sub_x0) || (sub_y != sub_y0))
+		{
 			can_use_ycc = false;
+		}
 	}
 	if (!can_use_ycc)
+	{
 		return;
+	}
 
 	bool use_ycc;
 	if (!cod->get(Cycc,0,0,use_ycc))
+	{
 		cod->set(Cycc,0,0,use_ycc=true);
+	}
 	if (!use_ycc)
+	{
 		return;
+	}
 	float weight;
-	if (cod->get(Clev_weights,0,0,weight) ||
-		cod->get(Cband_weights,0,0,weight))
-		return; // Weights already specified explicitly.
+	if (cod->get(Clev_weights,0,0,weight) || cod->get(Cband_weights,0,0,weight))
+	{
+		// Weights already specified explicitly -> nothing to do
+		return; 
+	}
 
-	/* These example weights are adapted from numbers generated by Marcus Nadenau
-	at EPFL, for a viewing distance of 15 cm and a display resolution of
-	300 DPI. */
+	// These example weights are adapted from numbers generated by Marcus Nadenau
+	// at EPFL, for a viewing distance of 15 cm and a display resolution of
+	// 300 DPI.
 
 	cod->parse_string("Cband_weights:C0="
 		"{0.0901},{0.2758},{0.2758},"
@@ -775,7 +821,7 @@ all necessary level shifting, type conversion, rounding and truncation. */
 				val += 128;
 				if (val & ((-1)<<8))
 				{
-					val = (val<0)?0:255;
+					val = (val < 0 ? 0 : 255);
 				}
 				*dest = (kdu_byte) val;
 			}
@@ -793,7 +839,7 @@ all necessary level shifting, type conversion, rounding and truncation. */
 				val += 128;
 				if (val & ((-1)<<8))
 				{
-					val = (val<0)?0:255;
+					val = (val < 0 ? 0 : 255);
 				}
 				*dest = (kdu_byte) val;
 			}
@@ -816,7 +862,7 @@ all necessary level shifting, type conversion, rounding and truncation. */
 					val += 128;
 					if (val & ((-1)<<8))
 					{
-						val = (val<0)?0:255;
+						val = (val < 0 ? 0 : 255);
 					}
 					*dest = (kdu_byte) val;
 				}
@@ -835,7 +881,7 @@ all necessary level shifting, type conversion, rounding and truncation. */
 					val += 128;
 					if (val & ((-1)<<8))
 					{
-						val = (val<0)?0:(256-(1<<upshift));
+						val = (val < 0 ? 0 : 256 - (1<<upshift));
 					}
 					*dest = (kdu_byte) val;
 				}
@@ -857,7 +903,7 @@ all necessary level shifting, type conversion, rounding and truncation. */
 					val += 128;
 					if (val & ((-1)<<8))
 					{
-						val = (val<0)?0:255;
+						val = (val < 0 ? 0 : 255);
 					}
 					*dest = (kdu_byte) val;
 				}
@@ -873,7 +919,7 @@ all necessary level shifting, type conversion, rounding and truncation. */
 					val += 128;
 					if (val & ((-1)<<8))
 					{
-						val = (val<0)?0:(256-(1<<upshift));
+						val = (val < 0 ? 0 : 256 - (1<<upshift));
 					}
 					*dest = (kdu_byte) val;
 				}
@@ -892,17 +938,17 @@ LLKDUDecodeState::LLKDUDecodeState(kdu_tile tile, kdu_byte *buf, S32 row_gap)
 
 	mNumComponents = tile.get_num_components();
 
-	llassert(mNumComponents<=4);
+	llassert(mNumComponents <= 4);
 	mUseYCC = tile.get_ycc();
 
-	for (c=0; c<4; ++c)
+	for (c = 0; c < 4; ++c)
 	{
 		mReversible[c] = false;
 		mBitDepths[c] = 0;
 	}
 
 	// Open tile-components and create processing engines and resources
-	for (c=0; c < mNumComponents; c++)
+	for (c = 0; c < mNumComponents; c++)
 	{
 		mComps[c] = mTile.access_component(c);
 		mReversible[c] = mComps[c].get_reversible();
@@ -929,7 +975,7 @@ LLKDUDecodeState::LLKDUDecodeState(kdu_tile tile, kdu_byte *buf, S32 row_gap)
 		}
 	}
 	mAllocator.finalize(); // Actually creates buffering resources
-	for (c=0; c < mNumComponents; c++)
+	for (c = 0; c < mNumComponents; c++)
 	{
 		mLines[c].create(); // Grabs resources from the allocator.
 	}
@@ -937,13 +983,11 @@ LLKDUDecodeState::LLKDUDecodeState(kdu_tile tile, kdu_byte *buf, S32 row_gap)
 
 LLKDUDecodeState::~LLKDUDecodeState()
 {
-	S32 c;
 	// Cleanup
-	for (c=0; c < mNumComponents; c++)
+	for (S32 c = 0; c < mNumComponents; c++)
 	{
 		mEngines[c].destroy(); // engines are interfaces; no default destructors
 	}
-
 	mTile.close();
 }
 
@@ -962,7 +1006,7 @@ separation between consecutive rows in the real buffer. */
 	LLTimer decode_timer;
 	while (mDims.size.y--)
 	{
-		for (c=0; c < mNumComponents; c++)
+		for (c = 0; c < mNumComponents; c++)
 		{
 			mEngines[c].pull(mLines[c],true);
 		}
@@ -970,7 +1014,7 @@ separation between consecutive rows in the real buffer. */
 		{
 			kdu_convert_ycc_to_rgb(mLines[0],mLines[1],mLines[2]);
 		}
-		for (c=0; c < mNumComponents; c++)
+		for (c = 0; c < mNumComponents; c++)
 		{
 			transfer_bytes(mBuf+c,mLines[c],mNumComponents,mBitDepths[c]);
 		}
@@ -990,96 +1034,100 @@ separation between consecutive rows in the real buffer. */
 
 kdc_flow_control::kdc_flow_control (kdu_image_in_base *img_in, kdu_codestream codestream)
 {
-    int n;
-    
-    this->codestream = codestream;
-    codestream.get_valid_tiles(valid_tile_indices);
-    tile_idx = valid_tile_indices.pos;
-    tile = codestream.open_tile(tile_idx,NULL);
-    
-    // Set up the individual components
-    num_components = codestream.get_num_components(true);
-    components = new kdc_component_flow_control[num_components];
-    count_delta = 0;
-    kdc_component_flow_control *comp = components;
-    for (n = 0; n < num_components; n++, comp++)
-    {
-        comp->line = NULL;
-        comp->reader = img_in;
-        kdu_coords subsampling;  
-        codestream.get_subsampling(n,subsampling,true);
-        kdu_dims dims;  
-        codestream.get_tile_dims(tile_idx,n,dims,true);
-        comp->vert_subsampling = subsampling.y;
-        if ((n == 0) || (comp->vert_subsampling < count_delta))
-        {
-            count_delta = comp->vert_subsampling;
-        }
-        comp->ratio_counter = 0;
-        comp->remaining_lines = comp->initial_lines = dims.size.y;
-    }
-    assert(num_components >= 0);
-    
-    tile.set_components_of_interest(num_components);
-    max_buffer_memory = engine.create(codestream,tile,false,NULL,false,1,NULL,NULL,false);
+	int n;
+	
+	this->codestream = codestream;
+	codestream.get_valid_tiles(valid_tile_indices);
+	tile_idx = valid_tile_indices.pos;
+	tile = codestream.open_tile(tile_idx,NULL);
+	
+	// Set up the individual components
+	num_components = codestream.get_num_components(true);
+	components = new kdc_component_flow_control[num_components];
+	count_delta = 0;
+	kdc_component_flow_control *comp = components;
+	for (n = 0; n < num_components; n++, comp++)
+	{
+		comp->line = NULL;
+		comp->reader = img_in;
+		kdu_coords subsampling;  
+		codestream.get_subsampling(n,subsampling,true);
+		kdu_dims dims;  
+		codestream.get_tile_dims(tile_idx,n,dims,true);
+		comp->vert_subsampling = subsampling.y;
+		if ((n == 0) || (comp->vert_subsampling < count_delta))
+		{
+			count_delta = comp->vert_subsampling;
+		}
+		comp->ratio_counter = 0;
+		comp->remaining_lines = comp->initial_lines = dims.size.y;
+	}
+	assert(num_components >= 0);
+	
+	tile.set_components_of_interest(num_components);
+	max_buffer_memory = engine.create(codestream,tile,false,NULL,false,1,NULL,NULL,false);
 }
 
 kdc_flow_control::~kdc_flow_control()
 {
-    if (components != NULL)
-        delete[] components;
-    if (engine.exists())
-        engine.destroy();
+	if (components != NULL)
+	{
+		delete[] components;
+	}
+	if (engine.exists())
+	{
+		engine.destroy();
+	}
 }
 
 bool kdc_flow_control::advance_components()
 {
-    bool found_line = false;
-    while (!found_line)
-    {
-        bool all_done = true;
-        kdc_component_flow_control *comp = components;
-        for (int n = 0; n < num_components; n++, comp++)
-        {
-            assert(comp->ratio_counter >= 0);
-            if (comp->remaining_lines > 0)
-            {
-                all_done = false;
-                comp->ratio_counter -= count_delta;
-                if (comp->ratio_counter < 0)
-                {
-                    found_line = true;
-                    comp->line = engine.exchange_line(n,NULL,NULL);
-                    assert(comp->line != NULL);
+	bool found_line = false;
+	while (!found_line)
+	{
+		bool all_done = true;
+		kdc_component_flow_control *comp = components;
+		for (int n = 0; n < num_components; n++, comp++)
+		{
+			assert(comp->ratio_counter >= 0);
+			if (comp->remaining_lines > 0)
+			{
+				all_done = false;
+				comp->ratio_counter -= count_delta;
+				if (comp->ratio_counter < 0)
+				{
+					found_line = true;
+					comp->line = engine.exchange_line(n,NULL,NULL);
+					assert(comp->line != NULL);
 					if (comp->line->get_width())
 					{
 						comp->reader->get(n,*(comp->line),0);
 					}
-                }
-            }
-        }
-        if (all_done)
-        {
-            return false;
-        }
-    }
-    return true;
+				}
+			}
+		}
+		if (all_done)
+		{
+			return false;
+		}
+	}
+	return true;
 }
 
 void kdc_flow_control::process_components()
 {
-    kdc_component_flow_control *comp = components;
-    for (int n = 0; n < num_components; n++, comp++)
-    {
-        if (comp->ratio_counter < 0)
-        {
-            comp->ratio_counter += comp->vert_subsampling;
-            assert(comp->ratio_counter >= 0);
-            assert(comp->remaining_lines > 0);
-            comp->remaining_lines--;
-            assert(comp->line != NULL);
-            engine.exchange_line(n,comp->line,NULL);
-            comp->line = NULL;
-        }
-    }
+	kdc_component_flow_control *comp = components;
+	for (int n = 0; n < num_components; n++, comp++)
+	{
+		if (comp->ratio_counter < 0)
+		{
+			comp->ratio_counter += comp->vert_subsampling;
+			assert(comp->ratio_counter >= 0);
+			assert(comp->remaining_lines > 0);
+			comp->remaining_lines--;
+			assert(comp->line != NULL);
+			engine.exchange_line(n,comp->line,NULL);
+			comp->line = NULL;
+		}
+	}
 }
diff --git a/indra/llkdu/llimagej2ckdu.h b/indra/llkdu/llimagej2ckdu.h
index 5628f69eeb..9fce58b762 100644
--- a/indra/llkdu/llimagej2ckdu.h
+++ b/indra/llkdu/llimagej2ckdu.h
@@ -58,17 +58,21 @@ protected:
 	/*virtual*/ BOOL decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count);
 	/*virtual*/ BOOL encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text, F32 encode_time=0.0,
 								BOOL reversible=FALSE);
+	/*virtual*/ BOOL initDecode(LLImageJ2C &base, LLImageRaw &raw_image, int discard_level = -1, int* region = NULL);
+	/*virtual*/ BOOL initEncode(LLImageJ2C &base, LLImageRaw &raw_image, int blocks_size = -1, int precincts_size = -1);
 
 private:
+	BOOL initDecode(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, ECodeStreamMode mode, S32 first_channel, S32 max_channel_count, int discard_level = -1, int* region = NULL);
 	void setupCodeStream(LLImageJ2C &base, BOOL keep_codestream, ECodeStreamMode mode);
 	void cleanupCodeStream();
-	BOOL initDecode(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, ECodeStreamMode mode, S32 first_channel, S32 max_channel_count );
 
 	// Encode variable
 	LLKDUMemSource *mInputp;
 	kdu_codestream *mCodeStreamp;
 	kdu_coords *mTPosp; // tile position
 	kdu_dims *mTileIndicesp;
+	int mBlocksSize;
+	int mPrecinctsSize;
 
 	// Temporary variables for in-progress decodes...
 	LLImageRaw *mRawImagep;
diff --git a/indra/llkdu/llkdumem.cpp b/indra/llkdu/llkdumem.cpp
index 1f549cbbe0..0347475559 100644
--- a/indra/llkdu/llkdumem.cpp
+++ b/indra/llkdu/llkdumem.cpp
@@ -47,12 +47,12 @@ LLKDUMemIn::LLKDUMemIn(const U8 *data,
 	num_components = in_num_components;
 	alignment_bytes = 0;
 
-	for (n=0; n<3; ++n)
+	for (n = 0; n < 3; ++n)
 	{
 		precision[n] = 0;
 	}
 
-	for (n=0; n < num_components; ++n)
+	for (n = 0; n < num_components; ++n)
 	{
 		siz->set(Sdims,n,0,rows);
 		siz->set(Sdims,n,1,cols);
@@ -80,12 +80,12 @@ LLKDUMemIn::~LLKDUMemIn()
 	}
 	image_line_buf *tmp;
 	while ((tmp=incomplete_lines) != NULL)
-    {
+	{
 		incomplete_lines = tmp->next;
 		delete tmp; 
 	}
 	while ((tmp=free_lines) != NULL)
-    {
+	{
 		free_lines = tmp->next;
 		delete tmp;
 	}
@@ -98,16 +98,16 @@ bool LLKDUMemIn::get(int comp_idx, kdu_line_buf &line, int x_tnum)
 	assert((idx >= 0) && (idx < num_components));
 	x_tnum = x_tnum*num_components+idx;
 	image_line_buf *scan, *prev=NULL;
-	for (scan=incomplete_lines; scan != NULL; prev=scan, scan=scan->next)
-    {
+	for (scan = incomplete_lines; scan != NULL; prev = scan, scan = scan->next)
+	{
 		assert(scan->next_x_tnum >= x_tnum);
 		if (scan->next_x_tnum == x_tnum)
 		{
 			break;
 		}
-    }
+	}
 	if (scan == NULL)
-    { // Need to read a new image line.
+	{ // Need to read a new image line.
 		assert(x_tnum == 0); // Must consume in very specific order.
 		if (num_unread_rows == 0)
 		{
@@ -134,7 +134,7 @@ bool LLKDUMemIn::get(int comp_idx, kdu_line_buf &line, int x_tnum)
 		num_unread_rows--;
 		scan->accessed_samples = 0;
 		scan->next_x_tnum = 0;
-    }
+	}
 
 	assert((cols-scan->accessed_samples) >= line.get_width());
 
@@ -161,7 +161,7 @@ bool LLKDUMemIn::get(int comp_idx, kdu_line_buf &line, int x_tnum)
 		}
 	}
 	else
-    {
+	{
 		kdu_sample16 *dp = line.get_buf16();
 		if (line.is_absolute())
 		{ // 16-bit absolute integers
@@ -177,7 +177,7 @@ bool LLKDUMemIn::get(int comp_idx, kdu_line_buf &line, int x_tnum)
 				dp->ival = (((kdu_int16)(*sp)) - 128) << (KDU_FIX_POINT-8);
 			}
 		}
-    }
+	}
 
 	scan->next_x_tnum++;
 	if (idx == (num_components-1))
diff --git a/indra/llkdu/llkdumem.h b/indra/llkdu/llkdumem.h
index 7064de4408..9d923fc367 100644
--- a/indra/llkdu/llkdumem.h
+++ b/indra/llkdu/llkdumem.h
@@ -39,7 +39,7 @@
 
 class LLKDUMemSource: public kdu_compressed_source
 {
-public: // Member functions
+public:
 	LLKDUMemSource(U8 *input_buffer, U32 size)
 	{
 		mData = input_buffer;
@@ -47,11 +47,11 @@ public: // Member functions
 		mCurPos = 0;
 	}
 
-    ~LLKDUMemSource()
+	~LLKDUMemSource()
 	{
 	}
 
-    int read(kdu_byte *buf, int num_bytes)
+	int read(kdu_byte *buf, int num_bytes)
 	{
 		U32 num_out;
 		num_out = num_bytes;
@@ -70,7 +70,7 @@ public: // Member functions
 		mCurPos = 0;
 	}
 
-private: // Data
+private:
 	U8 *mData;
 	U32 mSize;
 	U32 mCurPos;
@@ -78,7 +78,7 @@ private: // Data
 
 class LLKDUMemTarget: public kdu_compressed_target
 {
-public: // Member functions
+public:
 	LLKDUMemTarget(U8 *output_buffer, U32 &output_size, const U32 buffer_size)
 	{
 		mData = output_buffer;
@@ -87,11 +87,11 @@ public: // Member functions
 		mOutputSize = &output_size;
 	}
 
-    ~LLKDUMemTarget()
-    {
+	~LLKDUMemTarget()
+	{
 	}
 
-    bool write(const kdu_byte *buf, int num_bytes)
+	bool write(const kdu_byte *buf, int num_bytes)
 	{
 		U32 num_out;
 		num_out = num_bytes;
@@ -108,7 +108,7 @@ public: // Member functions
 		return true;
 	}
 	
-private: // Data
+private:
 	U8 *mData;
 	U32 mSize;
 	U32 mCurPos;
@@ -117,27 +117,27 @@ private: // Data
 
 class LLKDUMemIn : public kdu_image_in_base
 {
-public: // Member functions
-    LLKDUMemIn(const U8 *data,
+public:
+	LLKDUMemIn(const U8 *data,
 				const U32 size,
 				const U16 rows,
 				const U16 cols,
 				U8 in_num_components,
 				siz_params *siz);
-    ~LLKDUMemIn();
+	~LLKDUMemIn();
 
-    bool get(int comp_idx, kdu_line_buf &line, int x_tnum);
+	bool get(int comp_idx, kdu_line_buf &line, int x_tnum);
 
-private: // Data
+private:
 	const U8 *mData;
-    int first_comp_idx;
-    int num_components;
-    int rows, cols;
-    int alignment_bytes; // Number of 0's at end of each line.
-    int precision[3];
-    image_line_buf *incomplete_lines; // Each "sample" represents a full pixel
-    image_line_buf *free_lines;
-    int num_unread_rows;
+	int first_comp_idx;
+	int num_components;
+	int rows, cols;
+	int alignment_bytes; // Number of 0's at end of each line.
+	int precision[3];
+	image_line_buf *incomplete_lines; // Each "sample" represents a full pixel
+	image_line_buf *free_lines;
+	int num_unread_rows;
 
 	U32 mCurPos;
 	U32 mDataSize;
diff --git a/indra/newview/llfloaterimagepreview.cpp b/indra/newview/llfloaterimagepreview.cpp
index c7fbdd5745..d76e7885bc 100644
--- a/indra/newview/llfloaterimagepreview.cpp
+++ b/indra/newview/llfloaterimagepreview.cpp
@@ -325,122 +325,51 @@ void LLFloaterImagePreview::draw()
 bool LLFloaterImagePreview::loadImage(const std::string& src_filename)
 {
 	std::string exten = gDirUtilp->getExtension(src_filename);
-	
-	U32 codec = IMG_CODEC_INVALID;
-	std::string temp_str;
-	if( exten == "bmp")
-	{
-		codec = IMG_CODEC_BMP;
-	}
-	else if( exten == "tga")
-	{
-		codec = IMG_CODEC_TGA;
-	}
-	else if( exten == "jpg" || exten == "jpeg")
-	{
-		codec = IMG_CODEC_JPEG;
-	}
-	else if( exten == "png" )
-	{
-		codec = IMG_CODEC_PNG;
-	}
+	U32 codec = LLImageBase::getCodecFromExtension(exten);
 
 	LLImageDimensionsInfo image_info;
-	if(!image_info.load(src_filename,codec))
+	if (!image_info.load(src_filename,codec))
 	{
 		mImageLoadError = image_info.getLastError();
 		return false;
 	}
 
 	S32 max_width = gSavedSettings.getS32("max_texture_dimension_X");
-	S32 max_heigh = gSavedSettings.getS32("max_texture_dimension_Y");
+	S32 max_height = gSavedSettings.getS32("max_texture_dimension_Y");
 
-	if(image_info.getWidth() > max_width|| image_info.getHeight() > max_heigh)
+	if ((image_info.getWidth() > max_width) || (image_info.getHeight() > max_height))
 	{
 		LLStringUtil::format_map_t args;
 		args["WIDTH"] = llformat("%d", max_width);
-		args["HEIGHT"] = llformat("%d", max_heigh);
+		args["HEIGHT"] = llformat("%d", max_height);
 
 		mImageLoadError = LLTrans::getString("texture_load_dimensions_error", args);
 		return false;
 	}
 	
-
+	// Load the image
+	LLPointer<LLImageFormatted> image = LLImageFormatted::createFromType(codec);
+	if (image.isNull())
+	{
+		return false;
+	}
+	if (!image->load(src_filename))
+	{
+		return false;
+	}
+	// Decompress or expand it in a raw image structure
 	LLPointer<LLImageRaw> raw_image = new LLImageRaw;
-
-	switch (codec)
+	if (!image->decode(raw_image, 0.0f))
 	{
-	case IMG_CODEC_BMP:
-		{
-			LLPointer<LLImageBMP> bmp_image = new LLImageBMP;
-
-			if (!bmp_image->load(src_filename))
-			{
-				return false;
-			}
-			
-			if (!bmp_image->decode(raw_image, 0.0f))
-			{
-				return false;
-			}
-		}
-		break;
-	case IMG_CODEC_TGA:
-		{
-			LLPointer<LLImageTGA> tga_image = new LLImageTGA;
-
-			if (!tga_image->load(src_filename))
-			{
-				return false;
-			}
-			
-			if (!tga_image->decode(raw_image))
-			{
-				return false;
-			}
-
-			if(	(tga_image->getComponents() != 3) &&
-				(tga_image->getComponents() != 4) )
-			{
-				tga_image->setLastError( "Image files with less than 3 or more than 4 components are not supported." );
-				return false;
-			}
-		}
-		break;
-	case IMG_CODEC_JPEG:
-		{
-			LLPointer<LLImageJPEG> jpeg_image = new LLImageJPEG;
-
-			if (!jpeg_image->load(src_filename))
-			{
-				return false;
-			}
-			
-			if (!jpeg_image->decode(raw_image, 0.0f))
-			{
-				return false;
-			}
-		}
-		break;
-	case IMG_CODEC_PNG:
-		{
-			LLPointer<LLImagePNG> png_image = new LLImagePNG;
-
-			if (!png_image->load(src_filename))
-			{
-				return false;
-			}
-			
-			if (!png_image->decode(raw_image, 0.0f))
-			{
-				return false;
-			}
-		}
-		break;
-	default:
 		return false;
 	}
-
+	// Check the image constraints
+	if ((image->getComponents() != 3) && (image->getComponents() != 4))
+	{
+		image->setLastError("Image files with less than 3 or more than 4 components are not supported.");
+		return false;
+	}
+	
 	raw_image->biasedScaleToPowerOfTwo(1024);
 	mRawImagep = raw_image;
 	
diff --git a/indra/newview/llviewermenufile.cpp b/indra/newview/llviewermenufile.cpp
index fda291f3c1..2cf8dbec89 100644
--- a/indra/newview/llviewermenufile.cpp
+++ b/indra/newview/llviewermenufile.cpp
@@ -493,6 +493,7 @@ void upload_new_resource(const std::string& src_filename, std::string name,
 	LLSD args;
 
 	std::string exten = gDirUtilp->getExtension(src_filename);
+	U32 codec = LLImageBase::getCodecFromExtension(exten);
 	LLAssetType::EType asset_type = LLAssetType::AT_NONE;
 	std::string error_message;
 
@@ -510,66 +511,20 @@ void upload_new_resource(const std::string& src_filename, std::string name,
  		upload_error(error_message, "NoFileExtension", filename, args);
 		return;
 	}
-	else if( exten == "bmp")
+	else if (codec != IMG_CODEC_INVALID)
 	{
+		// It's an image file, the upload procedure is the same for all
 		asset_type = LLAssetType::AT_TEXTURE;
-		if (!LLViewerTextureList::createUploadFile(src_filename,
-												 filename,
-												 IMG_CODEC_BMP ))
+		if (!LLViewerTextureList::createUploadFile(src_filename, filename, codec ))
 		{
 			error_message = llformat( "Problem with file %s:\n\n%s\n",
-					src_filename.c_str(), LLImage::getLastError().c_str());
+									 src_filename.c_str(), LLImage::getLastError().c_str());
 			args["FILE"] = src_filename;
 			args["ERROR"] = LLImage::getLastError();
 			upload_error(error_message, "ProblemWithFile", filename, args);
 			return;
 		}
 	}
-	else if( exten == "tga")
-	{
-		asset_type = LLAssetType::AT_TEXTURE;
-		if (!LLViewerTextureList::createUploadFile(src_filename,
-												 filename,
-												 IMG_CODEC_TGA ))
-		{
-			error_message = llformat("Problem with file %s:\n\n%s\n",
-					src_filename.c_str(), LLImage::getLastError().c_str());
-			args["FILE"] = src_filename;
-			args["ERROR"] = LLImage::getLastError();
-			upload_error(error_message, "ProblemWithFile", filename, args);
-			return;
-		}
-	}
-	else if( exten == "jpg" || exten == "jpeg")
-	{
-		asset_type = LLAssetType::AT_TEXTURE;
-		if (!LLViewerTextureList::createUploadFile(src_filename,
-												 filename,
-												 IMG_CODEC_JPEG ))
-		{
-			error_message = llformat("Problem with file %s:\n\n%s\n",
-					src_filename.c_str(), LLImage::getLastError().c_str());
-			args["FILE"] = src_filename;
-			args["ERROR"] = LLImage::getLastError();
-			upload_error(error_message, "ProblemWithFile", filename, args);
-			return;
-		}
-	}
- 	else if( exten == "png")
- 	{
- 		asset_type = LLAssetType::AT_TEXTURE;
- 		if (!LLViewerTextureList::createUploadFile(src_filename,
- 												 filename,
- 												 IMG_CODEC_PNG ))
- 		{
- 			error_message = llformat("Problem with file %s:\n\n%s\n",
- 					src_filename.c_str(), LLImage::getLastError().c_str());
- 			args["FILE"] = src_filename;
- 			args["ERROR"] = LLImage::getLastError();
- 			upload_error(error_message, "ProblemWithFile", filename, args);
- 			return;
- 		}
- 	}
 	else if(exten == "wav")
 	{
 		asset_type = LLAssetType::AT_SOUND;  // tag it as audio
diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp
index 06f6ff23c2..5afed721ac 100644
--- a/indra/newview/llviewertexturelist.cpp
+++ b/indra/newview/llviewertexturelist.cpp
@@ -927,99 +927,43 @@ void LLViewerTextureList::decodeAllImages(F32 max_time)
 BOOL LLViewerTextureList::createUploadFile(const std::string& filename,
 										 const std::string& out_filename,
 										 const U8 codec)
-{
-	// First, load the image.
+{	
+	// Load the image
+	LLPointer<LLImageFormatted> image = LLImageFormatted::createFromType(codec);
+	if (image.isNull())
+	{
+		return FALSE;
+	}	
+	if (!image->load(filename))
+	{
+		return FALSE;
+	}
+	// Decompress or expand it in a raw image structure
 	LLPointer<LLImageRaw> raw_image = new LLImageRaw;
-	
-	switch (codec)
+	if (!image->decode(raw_image, 0.0f))
 	{
-		case IMG_CODEC_BMP:
-		{
-			LLPointer<LLImageBMP> bmp_image = new LLImageBMP;
-			
-			if (!bmp_image->load(filename))
-			{
-				return FALSE;
-			}
-			
-			if (!bmp_image->decode(raw_image, 0.0f))
-			{
-				return FALSE;
-			}
-		}
-			break;
-		case IMG_CODEC_TGA:
-		{
-			LLPointer<LLImageTGA> tga_image = new LLImageTGA;
-			
-			if (!tga_image->load(filename))
-			{
-				return FALSE;
-			}
-			
-			if (!tga_image->decode(raw_image))
-			{
-				return FALSE;
-			}
-			
-			if(	(tga_image->getComponents() != 3) &&
-			   (tga_image->getComponents() != 4) )
-			{
-				tga_image->setLastError( "Image files with less than 3 or more than 4 components are not supported." );
-				return FALSE;
-			}
-		}
-			break;
-		case IMG_CODEC_JPEG:
-		{
-			LLPointer<LLImageJPEG> jpeg_image = new LLImageJPEG;
-			
-			if (!jpeg_image->load(filename))
-			{
-				return FALSE;
-			}
-			
-			if (!jpeg_image->decode(raw_image, 0.0f))
-			{
-				return FALSE;
-			}
-		}
-			break;
-		case IMG_CODEC_PNG:
-		{
-			LLPointer<LLImagePNG> png_image = new LLImagePNG;
-			
-			if (!png_image->load(filename))
-			{
-				return FALSE;
-			}
-			
-			if (!png_image->decode(raw_image, 0.0f))
-			{
-				return FALSE;
-			}
-		}
-			break;
-		default:
-			return FALSE;
+		return FALSE;
 	}
-	
-	LLPointer<LLImageJ2C> compressedImage = convertToUploadFile(raw_image);
-	
-	if( !compressedImage->save(out_filename) )
+	// Check the image constraints
+	if ((image->getComponents() != 3) && (image->getComponents() != 4))
 	{
-		llinfos << "Couldn't create output file " << out_filename << llendl;
+		image->setLastError("Image files with less than 3 or more than 4 components are not supported.");
 		return FALSE;
 	}
-	
-	// test to see if the encode and save worked.
+	// Convert to j2c (JPEG2000) and save the file locally
+	LLPointer<LLImageJ2C> compressedImage = convertToUploadFile(raw_image);	
+	if (!compressedImage->save(out_filename))
+	{
+		llinfos << "Couldn't create output file : " << out_filename << llendl;
+		return FALSE;
+	}
+	// Test to see if the encode and save worked
 	LLPointer<LLImageJ2C> integrity_test = new LLImageJ2C;
-	if( !integrity_test->loadAndValidate( out_filename ) )
+	if (!integrity_test->loadAndValidate( out_filename ))
 	{
-		llinfos << "Image: " << out_filename << " is corrupt." << llendl;
+		llinfos << "Image file : " << out_filename << " is corrupt" << llendl;
 		return FALSE;
 	}
-	
 	return TRUE;
 }
 
diff --git a/indra/test_apps/llplugintest/llmediaplugintest.cpp b/indra/test_apps/llplugintest/llmediaplugintest.cpp
index e9d4d99753..ee65e0aa87 100644
--- a/indra/test_apps/llplugintest/llmediaplugintest.cpp
+++ b/indra/test_apps/llplugintest/llmediaplugintest.cpp
@@ -2154,6 +2154,10 @@ void LLMediaPluginTest::handleMediaEvent(LLPluginClassMedia* self, EMediaEvent e
 		}
 		break;
 
+		case MEDIA_EVENT_NAVIGATE_ERROR_PAGE:
+			std::cerr <<  "Media event:  MEDIA_EVENT_NAVIGATE_ERROR_PAGE, uri is: " << self->getClickURL() << std::endl;
+		break;
+			
 		case MEDIA_EVENT_CLICK_LINK_HREF:
 		{
 			std::cerr <<  "Media event:  MEDIA_EVENT_CLICK_LINK_HREF, uri is " << self->getClickURL() << ", target is " << self->getClickTarget() << std::endl;