Merge pull request #1476 from secondlife/marchcat/x-b-merge

Maint X -> Maint B merge

6 files changed, 1568 insertions, 1568 deletions

diff --git a/indra/llkdu/include_kdu_xxxx.h b/indra/llkdu/include_kdu_xxxx.h
index 61204b5689..3db417a6cb 100644
--- a/indra/llkdu/include_kdu_xxxx.h
+++ b/indra/llkdu/include_kdu_xxxx.h
@@ -2,8 +2,8 @@
  * @file   include_kdu_xxxx.h
  * @author Nat Goodspeed
  * @date   2016-04-25
- * @brief  
- * 
+ * @brief
+ *
  * $LicenseInfo:firstyear=2016&license=viewerlgpl$
  * Copyright (c) 2016, Linden Research, Inc.
  * $/LicenseInfo$
diff --git a/indra/llkdu/llimagej2ckdu.cpp b/indra/llkdu/llimagej2ckdu.cpp
index 2ad42d6b87..c51650a470 100644
--- a/indra/llkdu/llimagej2ckdu.cpp
+++ b/indra/llkdu/llimagej2ckdu.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llimagej2ckdu.cpp
  * @brief This is an implementation of JPEG2000 encode/decode using Kakadu
  *
  * $LicenseInfo:firstyear=2010&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -51,8 +51,8 @@ namespace kdu_core
 inline
 std::ostream& operator<<(std::ostream& out, const kdu_dims& dims)
 {
-	return out << "(" << dims.pos.x << "," << dims.pos.y << "),"
-				  "[" << dims.size.x << "x" << dims.size.y << "]";
+    return out << "(" << dims.pos.x << "," << dims.pos.y << "),"
+                  "[" << dims.size.x << "x" << dims.size.y << "]";
 }
 } // namespace kdu_core
 
@@ -103,36 +103,36 @@ std::string report_kdu_exception(kdu_exception mb)
 
 
 class kdc_flow_control {
-	
+
 public:
-	kdc_flow_control(kdu_supp::kdu_image_in_base *img_in, kdu_codestream codestream);
-	~kdc_flow_control();
-	bool advance_components();
-	void process_components();
-	
+    kdc_flow_control(kdu_supp::kdu_image_in_base *img_in, kdu_codestream codestream);
+    ~kdc_flow_control();
+    bool advance_components();
+    void process_components();
+
 private:
-	
-	struct kdc_component_flow_control {
-	public:
-		kdu_supp::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_supp::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;
 };
 
 //
@@ -143,73 +143,73 @@ void set_default_colour_weights(kdu_params *siz);
 // Factory function: see declaration in llimagej2c.cpp
 LLImageJ2CImpl* fallbackCreateLLImageJ2CImpl()
 {
-	return new LLImageJ2CKDU();
+    return new LLImageJ2CKDU();
 }
 
 std::string LLImageJ2CKDU::getEngineInfo() const
 {
-	return llformat("KDU %s", KDU_CORE_VERSION);
+    return llformat("KDU %s", KDU_CORE_VERSION);
 }
 
 class LLKDUDecodeState
 {
 public:
-	LLKDUDecodeState(kdu_tile tile, kdu_byte *buf, S32 row_gap,
-					 kdu_codestream* codestreamp);
-	~LLKDUDecodeState();
-	bool processTileDecode(F32 decode_time, bool limit_time = true);
+    LLKDUDecodeState(kdu_tile tile, kdu_byte *buf, S32 row_gap,
+                     kdu_codestream* codestreamp);
+    ~LLKDUDecodeState();
+    bool processTileDecode(F32 decode_time, bool limit_time = true);
 
 private:
-	S32 mNumComponents;
-	bool mUseYCC;
-	kdu_dims mDims;
-	kdu_sample_allocator mAllocator;
-	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
-	
-	kdu_tile mTile;
-	kdu_byte *mBuf;
-	S32 mRowGap;
+    S32 mNumComponents;
+    bool mUseYCC;
+    kdu_dims mDims;
+    kdu_sample_allocator mAllocator;
+    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
+
+    kdu_tile mTile;
+    kdu_byte *mBuf;
+    S32 mRowGap;
 };
 
 // Stuff for new kdu error handling
 class LLKDUMessage: public kdu_message
 {
 public:
-	LLKDUMessage(const std::string& type):
-		mType(type)
-	{}
-
-	virtual void put_text(const char *s)
-	{
-		LL_INFOS() << "KDU " << mType << ": " << s << LL_ENDL;
-	}
-
-	virtual void put_text(const kdu_uint16 *s)
-	{
-		// The previous implementation simply streamed 's' to the log. So
-		// either this put_text() override was never called -- or it produced
-		// some baffling log messages -- because I assert that streaming a
-		// const kdu_uint16* to a std::ostream will display only the hex value
-		// of the pointer.
-		LL_INFOS() << "KDU " << mType << ": "
-				   << utf16str_to_utf8str(llutf16string(s)) << LL_ENDL;
-	}
+    LLKDUMessage(const std::string& type):
+        mType(type)
+    {}
+
+    virtual void put_text(const char *s)
+    {
+        LL_INFOS() << "KDU " << mType << ": " << s << LL_ENDL;
+    }
+
+    virtual void put_text(const kdu_uint16 *s)
+    {
+        // The previous implementation simply streamed 's' to the log. So
+        // either this put_text() override was never called -- or it produced
+        // some baffling log messages -- because I assert that streaming a
+        // const kdu_uint16* to a std::ostream will display only the hex value
+        // of the pointer.
+        LL_INFOS() << "KDU " << mType << ": "
+                   << utf16str_to_utf8str(llutf16string(s)) << LL_ENDL;
+    }
 
 private:
-	std::string mType;
+    std::string mType;
 };
 
 struct LLKDUMessageWarning : public LLKDUMessage
 {
-	LLKDUMessageWarning():
-		LLKDUMessage("Warning")
-	{
-		kdu_customize_warnings(this);
-	}
+    LLKDUMessageWarning():
+        LLKDUMessage("Warning")
+    {
+        kdu_customize_warnings(this);
+    }
 };
 // Instantiating LLKDUMessageWarning calls kdu_customize_warnings() with the
 // new instance. Make it static so this only happens once.
@@ -217,55 +217,55 @@ static LLKDUMessageWarning sWarningHandler;
 
 struct LLKDUMessageError : public LLKDUMessage
 {
-	LLKDUMessageError():
-		LLKDUMessage("Error")
-	{
-		kdu_customize_errors(this);
-	}
-
-	virtual void flush(bool end_of_message = false)
-	{
-		// According to the documentation nat found:
-		// http://pirlwww.lpl.arizona.edu/resources/guide/software/Kakadu/html_pages/globals__kdu$mize_errors.html
-		// "If a kdu_error object is destroyed, handler→flush will be called with
-		// an end_of_message argument equal to true and the process will
-		// subsequently be terminated through exit. The termination may be
-		// avoided, however, by throwing an exception from within the message
-		// terminating handler→flush call."
-		// So throwing an exception here isn't arbitrary: we MUST throw an
-		// exception if we want to recover from a KDU error.
-		// Because this confused me: the above quote specifically refers to
-		// the kdu_error class, which is constructed internally within KDU at
-		// the point where a fatal error is discovered and reported. It is NOT
-		// talking about the kdu_message subclass passed to
-		// kdu_customize_errors(). Destroying this static object at program
-		// shutdown will NOT engage the behavior described above.
-		if (end_of_message) 
-		{
-			LLTHROW(KDUError("LLKDUMessageError::flush()"));
-		}
-	}
+    LLKDUMessageError():
+        LLKDUMessage("Error")
+    {
+        kdu_customize_errors(this);
+    }
+
+    virtual void flush(bool end_of_message = false)
+    {
+        // According to the documentation nat found:
+        // http://pirlwww.lpl.arizona.edu/resources/guide/software/Kakadu/html_pages/globals__kdu$mize_errors.html
+        // "If a kdu_error object is destroyed, handler→flush will be called with
+        // an end_of_message argument equal to true and the process will
+        // subsequently be terminated through exit. The termination may be
+        // avoided, however, by throwing an exception from within the message
+        // terminating handler→flush call."
+        // So throwing an exception here isn't arbitrary: we MUST throw an
+        // exception if we want to recover from a KDU error.
+        // Because this confused me: the above quote specifically refers to
+        // the kdu_error class, which is constructed internally within KDU at
+        // the point where a fatal error is discovered and reported. It is NOT
+        // talking about the kdu_message subclass passed to
+        // kdu_customize_errors(). Destroying this static object at program
+        // shutdown will NOT engage the behavior described above.
+        if (end_of_message)
+        {
+            LLTHROW(KDUError("LLKDUMessageError::flush()"));
+        }
+    }
 };
 // Instantiating LLKDUMessageError calls kdu_customize_errors() with the new
 // instance. Make it static so this only happens once.
 static LLKDUMessageError sErrorHandler;
 
 LLImageJ2CKDU::LLImageJ2CKDU() : LLImageJ2CImpl(),
-	mInputp(),
-	mCodeStreamp(),
-	mTPosp(),
-	mTileIndicesp(),
-	mRawImagep(NULL),
-	mDecodeState(),
-	mBlocksSize(-1),
-	mPrecinctsSize(-1),
-	mLevels(0)
+    mInputp(),
+    mCodeStreamp(),
+    mTPosp(),
+    mTileIndicesp(),
+    mRawImagep(NULL),
+    mDecodeState(),
+    mBlocksSize(-1),
+    mPrecinctsSize(-1),
+    mLevels(0)
 {
 }
 
 LLImageJ2CKDU::~LLImageJ2CKDU()
 {
-	cleanupCodeStream(); // in case destroyed before decode completed
+    cleanupCodeStream(); // in case destroyed before decode completed
 }
 
 // Stuff for new simple decode
@@ -277,114 +277,114 @@ void transfer_bytes(kdu_byte *dest, kdu_line_buf &src, int gap, int precision);
 // as well, when that still existed, with keep_codestream true and MODE_FAST.
 void LLImageJ2CKDU::setupCodeStream(LLImageJ2C &base, bool keep_codestream, ECodeStreamMode mode)
 {
-	S32 data_size = base.getDataSize();
-	S32 max_bytes = (base.getMaxBytes() ? base.getMaxBytes() : data_size);
-
-	//
-	//  Initialization
-	//
-	mCodeStreamp.reset();
-
-	// It's not clear to nat under what circumstances we would reuse a
-	// pre-existing LLKDUMemSource instance. As of 2016-08-05, it consists of
-	// two U32s and a pointer, so it's not as if it would be a huge overhead
-	// to allocate a new one every time.
-	// Also -- why is base.getData() tested specifically here? If that returns
-	// NULL, shouldn't we bail out of the whole method?
-	if (!mInputp && base.getData())
-	{
-		// The compressed data has been loaded
-		// Setup the source for the codestream
-		mInputp.reset(new LLKDUMemSource(base.getData(), data_size));
-	}
-
-	if (mInputp)
-	{
-		// This is LLKDUMemSource::reset(), not boost::scoped_ptr::reset().
-		mInputp->reset();
-	}
-
-	mCodeStreamp->create(mInputp.get());
-
-	// 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
-	// 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
-	// may use "kdu_codestream::set_max_bytes".
-	//	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
-	// 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)
-	{
-	case MODE_FAST:
-		mCodeStreamp->set_fast();
-		break;
-	case MODE_RESILIENT:
-		mCodeStreamp->set_resilient();
-		break;
-	case MODE_FUSSY:
-		mCodeStreamp->set_fussy();
-		break;
-	default:
-		llassert(0);
-		mCodeStreamp->set_fast();
-	}
-
-	kdu_dims dims;
-	mCodeStreamp->get_dims(0,dims);
-
-	S32 components = mCodeStreamp->get_num_components();
-
-	// Check that components have consistent dimensions (for PPM file)
-	for (int idx = 1; idx < components; ++idx)
-	{
-		kdu_dims other_dims;
-		mCodeStreamp->get_dims(idx, other_dims);
-		if (other_dims != dims)
-		{
-			// This method is only called from methods that catch KDUError.
-			// We want to fail the image load, not crash the viewer.
-			LLTHROW(KDUError(STRINGIZE("Component " << idx << " dimensions "
-									   << stringize(other_dims)
-									   << " do not match component 0 dimensions "
-									   << stringize(dims) << "!")));
-		}
-	}
-
-	// Get the number of resolution levels in that image
-	mLevels = mCodeStreamp->get_min_dwt_levels();
-	
-	// Set the base dimensions
-	base.setSize(dims.size.x, dims.size.y, components);
-	base.setLevels(mLevels);
-	
-	if (!keep_codestream)
-	{
-		mCodeStreamp.reset();
-		mInputp.reset();
-	}
+    S32 data_size = base.getDataSize();
+    S32 max_bytes = (base.getMaxBytes() ? base.getMaxBytes() : data_size);
+
+    //
+    //  Initialization
+    //
+    mCodeStreamp.reset();
+
+    // It's not clear to nat under what circumstances we would reuse a
+    // pre-existing LLKDUMemSource instance. As of 2016-08-05, it consists of
+    // two U32s and a pointer, so it's not as if it would be a huge overhead
+    // to allocate a new one every time.
+    // Also -- why is base.getData() tested specifically here? If that returns
+    // NULL, shouldn't we bail out of the whole method?
+    if (!mInputp && base.getData())
+    {
+        // The compressed data has been loaded
+        // Setup the source for the codestream
+        mInputp.reset(new LLKDUMemSource(base.getData(), data_size));
+    }
+
+    if (mInputp)
+    {
+        // This is LLKDUMemSource::reset(), not boost::scoped_ptr::reset().
+        mInputp->reset();
+    }
+
+    mCodeStreamp->create(mInputp.get());
+
+    // 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
+    // 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
+    // may use "kdu_codestream::set_max_bytes".
+    //  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
+    // 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)
+    {
+    case MODE_FAST:
+        mCodeStreamp->set_fast();
+        break;
+    case MODE_RESILIENT:
+        mCodeStreamp->set_resilient();
+        break;
+    case MODE_FUSSY:
+        mCodeStreamp->set_fussy();
+        break;
+    default:
+        llassert(0);
+        mCodeStreamp->set_fast();
+    }
+
+    kdu_dims dims;
+    mCodeStreamp->get_dims(0,dims);
+
+    S32 components = mCodeStreamp->get_num_components();
+
+    // Check that components have consistent dimensions (for PPM file)
+    for (int idx = 1; idx < components; ++idx)
+    {
+        kdu_dims other_dims;
+        mCodeStreamp->get_dims(idx, other_dims);
+        if (other_dims != dims)
+        {
+            // This method is only called from methods that catch KDUError.
+            // We want to fail the image load, not crash the viewer.
+            LLTHROW(KDUError(STRINGIZE("Component " << idx << " dimensions "
+                                       << stringize(other_dims)
+                                       << " do not match component 0 dimensions "
+                                       << stringize(dims) << "!")));
+        }
+    }
+
+    // Get the number of resolution levels in that image
+    mLevels = mCodeStreamp->get_min_dwt_levels();
+
+    // Set the base dimensions
+    base.setSize(dims.size.x, dims.size.y, components);
+    base.setLevels(mLevels);
+
+    if (!keep_codestream)
+    {
+        mCodeStreamp.reset();
+        mInputp.reset();
+    }
 }
 
 void LLImageJ2CKDU::cleanupCodeStream()
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
-	mInputp.reset();
-	mDecodeState.reset();
-	mCodeStreamp.reset();
-	mTPosp.reset();
-	mTileIndicesp.reset();
+    mInputp.reset();
+    mDecodeState.reset();
+    mCodeStreamp.reset();
+    mTPosp.reset();
+    mTileIndicesp.reset();
 }
 
 // This is the protected virtual method called by LLImageJ2C::initDecode().
@@ -392,34 +392,34 @@ void LLImageJ2CKDU::cleanupCodeStream()
 // llimage_libtest.cpp's load_image() function. No detectable production use.
 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);
+    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, int levels)
 {
-	mPrecinctsSize = precincts_size;
-	if (mPrecinctsSize != -1)
-	{
-		mPrecinctsSize = get_lower_power_two(mPrecinctsSize,MAX_PRECINCT_SIZE);
-		mPrecinctsSize = llmax(mPrecinctsSize,MIN_PRECINCT_SIZE);
-	}
-	mBlocksSize = blocks_size;
-	if (mBlocksSize != -1)
-	{
-		mBlocksSize = get_lower_power_two(mBlocksSize,MAX_BLOCK_SIZE);
-		mBlocksSize = llmax(mBlocksSize,MIN_BLOCK_SIZE);
-		if (mPrecinctsSize != -1)
-		{
-			mBlocksSize = llmin(mBlocksSize,mPrecinctsSize);	// blocks *must* be smaller than precincts
-		}
-	}
-	mLevels = levels;
-	if (mLevels != 0)
-	{
-		mLevels = llclamp(mLevels,MIN_DECOMPOSITION_LEVELS,MAX_DECOMPOSITION_LEVELS);
-		base.setLevels(mLevels);
-	}
-	return true;
+    mPrecinctsSize = precincts_size;
+    if (mPrecinctsSize != -1)
+    {
+        mPrecinctsSize = get_lower_power_two(mPrecinctsSize,MAX_PRECINCT_SIZE);
+        mPrecinctsSize = llmax(mPrecinctsSize,MIN_PRECINCT_SIZE);
+    }
+    mBlocksSize = blocks_size;
+    if (mBlocksSize != -1)
+    {
+        mBlocksSize = get_lower_power_two(mBlocksSize,MAX_BLOCK_SIZE);
+        mBlocksSize = llmax(mBlocksSize,MIN_BLOCK_SIZE);
+        if (mPrecinctsSize != -1)
+        {
+            mBlocksSize = llmin(mBlocksSize,mPrecinctsSize);    // blocks *must* be smaller than precincts
+        }
+    }
+    mLevels = levels;
+    if (mLevels != 0)
+    {
+        mLevels = llclamp(mLevels,MIN_DECOMPOSITION_LEVELS,MAX_DECOMPOSITION_LEVELS);
+        base.setLevels(mLevels);
+    }
+    return true;
 }
 
 // This is the real (private) initDecode() called both by the protected
@@ -428,83 +428,83 @@ bool LLImageJ2CKDU::initEncode(LLImageJ2C &base, LLImageRaw &raw_image, int bloc
 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)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
-	base.resetLastError();
-
-	// *FIX: kdu calls our callback function if there's an error, and then bombs.
-	// To regain control, we throw an exception, and catch it here.
-	try
-	{
-		// Merov : Test!! DO NOT COMMIT!!
-		//findDiscardLevelsBoundaries(base);
-
-		base.updateRawDiscardLevel();
-		setupCodeStream(base, true, mode);
-
-		mRawImagep = &raw_image;
-		mCodeStreamp->change_appearance(false, true, false);
-
-		// 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());
-		//LL_INFOS() << "Merov debug : initDecode, discard used = " << discard << ", asked = " << discard_level << LL_ENDL;
-		// Apply loading restrictions
-		mCodeStreamp->apply_input_restrictions( first_channel, max_channel_count, discard, 0, region_kdu);
-		
-		// Clean-up
-		if (region_kdu)
-		{
-			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);
-
-		if (!mTileIndicesp)
-		{
-			mTileIndicesp.reset(new kdu_dims);
-		}
-		mCodeStreamp->get_valid_tiles(*mTileIndicesp);
-		if (!mTPosp)
-		{
-			mTPosp.reset(new kdu_coords);
-			mTPosp->y = 0;
-			mTPosp->x = 0;
-		}
-	}
-	catch (const KDUError& msg)
-	{
-		base.setLastError(msg.what());
-		return false;
-	}
-	catch (kdu_exception kdu_value)
-	{
-		// KDU internally throws kdu_exception. It's possible that such an
-		// exception might leak out into our code. Catch kdu_exception
-		// specially because boost::current_exception_diagnostic_information()
-		// could do nothing with it.
-		base.setLastError(report_kdu_exception(kdu_value));
-		return false;
-	}
-	catch (...)
-	{
-		base.setLastError("Unknown J2C error: " +
-						  boost::current_exception_diagnostic_information());
-		return false;
-	}
-
-	return true;
+    base.resetLastError();
+
+    // *FIX: kdu calls our callback function if there's an error, and then bombs.
+    // To regain control, we throw an exception, and catch it here.
+    try
+    {
+        // Merov : Test!! DO NOT COMMIT!!
+        //findDiscardLevelsBoundaries(base);
+
+        base.updateRawDiscardLevel();
+        setupCodeStream(base, true, mode);
+
+        mRawImagep = &raw_image;
+        mCodeStreamp->change_appearance(false, true, false);
+
+        // 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());
+        //LL_INFOS() << "Merov debug : initDecode, discard used = " << discard << ", asked = " << discard_level << LL_ENDL;
+        // Apply loading restrictions
+        mCodeStreamp->apply_input_restrictions( first_channel, max_channel_count, discard, 0, region_kdu);
+
+        // Clean-up
+        if (region_kdu)
+        {
+            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);
+
+        if (!mTileIndicesp)
+        {
+            mTileIndicesp.reset(new kdu_dims);
+        }
+        mCodeStreamp->get_valid_tiles(*mTileIndicesp);
+        if (!mTPosp)
+        {
+            mTPosp.reset(new kdu_coords);
+            mTPosp->y = 0;
+            mTPosp->x = 0;
+        }
+    }
+    catch (const KDUError& msg)
+    {
+        base.setLastError(msg.what());
+        return false;
+    }
+    catch (kdu_exception kdu_value)
+    {
+        // KDU internally throws kdu_exception. It's possible that such an
+        // exception might leak out into our code. Catch kdu_exception
+        // specially because boost::current_exception_diagnostic_information()
+        // could do nothing with it.
+        base.setLastError(report_kdu_exception(kdu_value));
+        return false;
+    }
+    catch (...)
+    {
+        base.setLastError("Unknown J2C error: " +
+                          boost::current_exception_diagnostic_information());
+        return false;
+    }
+
+    return true;
 }
 
 
@@ -512,344 +512,344 @@ bool LLImageJ2CKDU::initDecode(LLImageJ2C &base, LLImageRaw &raw_image, F32 deco
 bool LLImageJ2CKDU::decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
-	ECodeStreamMode mode = MODE_FAST;
-
-	LLTimer decode_timer;
-
-	if (!mCodeStreamp->exists())
-	{
-		if (!initDecode(base, raw_image, decode_time, mode, first_channel, max_channel_count))
-		{
-			// Initializing the J2C decode failed, bail out.
-			cleanupCodeStream();
-			return true; // done
-		}
-	}
-
-	// These can probably be grabbed from what's saved in the class.
-	kdu_dims dims;
-	mCodeStreamp->get_dims(0,dims);
-
-	// Now we are ready to walk through the tiles processing them one-by-one.
-	kdu_byte *buffer = raw_image.getData();
-	if (!buffer)
-	{
-		base.setLastError("Memory error");
-		base.decodeFailed();
-		cleanupCodeStream();
-		return true; // done
-	}
-
-	while (mTPosp->y < mTileIndicesp->size.y)
-	{
-		while (mTPosp->x < mTileIndicesp->size.x)
-		{
-			try
-			{
-				if (!mDecodeState)
-				{
-					kdu_tile tile = mCodeStreamp->open_tile(*(mTPosp)+mTileIndicesp->pos);
-
-					// 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
-					// during compression and so it can happen that tiles
-					// (at the image component level) actually have
-					// different dimensions.  For this reason, we cannot
-					// figure out the buffer region occupied by a tile
-					// directly from the tile indices.  Instead, we query
-					// the highest resolution of the first tile-component
-					// concerning its location and size on the canvas --
-					// the `dims' object already holds the location and
-					// size of the entire image component on the same
-					// 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)
-					{
-						channels = max_channel_count;
-					}
-					kdu_resolution res = tile.access_component(0).access_resolution();
-					kdu_dims tile_dims; res.get_dims(tile_dims);
-					kdu_coords offset = tile_dims.pos - dims.pos;
-					int row_gap = channels*dims.size.x; // inter-row separation
-					kdu_byte *buf = buffer + offset.y*row_gap + offset.x*channels;
-					mDecodeState.reset(new LLKDUDecodeState(tile, buf, row_gap,
-															mCodeStreamp.get()));
-				}
-				// Do the actual processing
-				F32 remaining_time = decode_time - decode_timer.getElapsedTimeF32();
-				// This is where we do the actual decode.  If we run out of time, return false.
-				if (mDecodeState->processTileDecode(remaining_time, (decode_time > 0.0f)))
-				{
-					mDecodeState.reset();
-				}
-				else
-				{
-					// Not finished decoding yet.
-					//					setLastError("Ran out of time while decoding");
-					return false;
-				}
-			}
-			catch (const KDUError& msg)
-			{
-				base.setLastError(msg.what());
-				base.decodeFailed();
-				cleanupCodeStream();
-				return true; // done
-			}
-			catch (kdu_exception kdu_value)
-			{
-				// KDU internally throws kdu_exception. It's possible that such an
-				// exception might leak out into our code. Catch kdu_exception
-				// specially because boost::current_exception_diagnostic_information()
-				// could do nothing with it.
-				base.setLastError(report_kdu_exception(kdu_value));
-				base.decodeFailed();
-				cleanupCodeStream();
-				return true; // done
-			}
-			catch (...)
-			{
-				base.setLastError("Unknown J2C error: " +
-								  boost::current_exception_diagnostic_information());
-				base.decodeFailed();
-				cleanupCodeStream();
-				return true; // done
-			}
-
-
-			mTPosp->x++;
-		}
-		mTPosp->y++;
-		mTPosp->x = 0;
-	}
-
-	cleanupCodeStream();
-
-	return true;
+    ECodeStreamMode mode = MODE_FAST;
+
+    LLTimer decode_timer;
+
+    if (!mCodeStreamp->exists())
+    {
+        if (!initDecode(base, raw_image, decode_time, mode, first_channel, max_channel_count))
+        {
+            // Initializing the J2C decode failed, bail out.
+            cleanupCodeStream();
+            return true; // done
+        }
+    }
+
+    // These can probably be grabbed from what's saved in the class.
+    kdu_dims dims;
+    mCodeStreamp->get_dims(0,dims);
+
+    // Now we are ready to walk through the tiles processing them one-by-one.
+    kdu_byte *buffer = raw_image.getData();
+    if (!buffer)
+    {
+        base.setLastError("Memory error");
+        base.decodeFailed();
+        cleanupCodeStream();
+        return true; // done
+    }
+
+    while (mTPosp->y < mTileIndicesp->size.y)
+    {
+        while (mTPosp->x < mTileIndicesp->size.x)
+        {
+            try
+            {
+                if (!mDecodeState)
+                {
+                    kdu_tile tile = mCodeStreamp->open_tile(*(mTPosp)+mTileIndicesp->pos);
+
+                    // 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
+                    // during compression and so it can happen that tiles
+                    // (at the image component level) actually have
+                    // different dimensions.  For this reason, we cannot
+                    // figure out the buffer region occupied by a tile
+                    // directly from the tile indices.  Instead, we query
+                    // the highest resolution of the first tile-component
+                    // concerning its location and size on the canvas --
+                    // the `dims' object already holds the location and
+                    // size of the entire image component on the same
+                    // 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)
+                    {
+                        channels = max_channel_count;
+                    }
+                    kdu_resolution res = tile.access_component(0).access_resolution();
+                    kdu_dims tile_dims; res.get_dims(tile_dims);
+                    kdu_coords offset = tile_dims.pos - dims.pos;
+                    int row_gap = channels*dims.size.x; // inter-row separation
+                    kdu_byte *buf = buffer + offset.y*row_gap + offset.x*channels;
+                    mDecodeState.reset(new LLKDUDecodeState(tile, buf, row_gap,
+                                                            mCodeStreamp.get()));
+                }
+                // Do the actual processing
+                F32 remaining_time = decode_time - decode_timer.getElapsedTimeF32();
+                // This is where we do the actual decode.  If we run out of time, return false.
+                if (mDecodeState->processTileDecode(remaining_time, (decode_time > 0.0f)))
+                {
+                    mDecodeState.reset();
+                }
+                else
+                {
+                    // Not finished decoding yet.
+                    //                  setLastError("Ran out of time while decoding");
+                    return false;
+                }
+            }
+            catch (const KDUError& msg)
+            {
+                base.setLastError(msg.what());
+                base.decodeFailed();
+                cleanupCodeStream();
+                return true; // done
+            }
+            catch (kdu_exception kdu_value)
+            {
+                // KDU internally throws kdu_exception. It's possible that such an
+                // exception might leak out into our code. Catch kdu_exception
+                // specially because boost::current_exception_diagnostic_information()
+                // could do nothing with it.
+                base.setLastError(report_kdu_exception(kdu_value));
+                base.decodeFailed();
+                cleanupCodeStream();
+                return true; // done
+            }
+            catch (...)
+            {
+                base.setLastError("Unknown J2C error: " +
+                                  boost::current_exception_diagnostic_information());
+                base.decodeFailed();
+                cleanupCodeStream();
+                return true; // done
+            }
+
+
+            mTPosp->x++;
+        }
+        mTPosp->y++;
+        mTPosp->x = 0;
+    }
+
+    cleanupCodeStream();
+
+    return true;
 }
 
 
 bool LLImageJ2CKDU::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text, F32 encode_time, bool reversible)
 {
-	// Declare and set simple arguments
-	bool transpose = false;
-	bool vflip = true;
-	bool hflip = false;
-
-	try
-	{
-		// Set up input image files
-		siz_params siz;
-		
-		// Should set rate someplace here
-		LLKDUMemIn mem_in(raw_image.getData(),
-			raw_image.getDataSize(),
-			raw_image.getWidth(),
-			raw_image.getHeight(),
-			raw_image.getComponents(),
-			&siz);
-
-		base.setSize(raw_image.getWidth(), raw_image.getHeight(), raw_image.getComponents());
-
-		int num_components = raw_image.getComponents();
-
-		siz.set(Scomponents,0,0,num_components);
-		siz.set(Sdims,0,0,base.getHeight());  // Height of first image component
-		siz.set(Sdims,0,1,base.getWidth());   // Width of first image component
-		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-stream
-		transformed_siz.copy_from(&siz,-1,-1,-1,0,transpose,false,false);
-
-		// Construct the `kdu_codestream' object and parse all remaining arguments
-		U32 max_output_size = base.getWidth()*base.getHeight()*base.getComponents();
-		max_output_size = (max_output_size < 1000 ? 1000 : max_output_size);
-		U8 *output_buffer = new U8[max_output_size];
-		U32 output_size = 0; // Address updated by LLKDUMemTarget to give the final compressed buffer size
-		LLKDUMemTarget output(output_buffer, output_size, max_output_size);
-
-		kdu_codestream codestream;
-		codestream.create(&transformed_siz,&output);
-
-		if (comment_text)
-		{
-			// Set the comments for the codestream
-			kdu_codestream_comment comment = codestream.add_comment();
-			comment.put_text(comment_text);
-		}
-
-		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());
-		}
-
-		// Set codestream options
-		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.
-		llassert (base.mRate > 0.f);
-		max_bytes = (U32)((F32)(max_bytes) * base.mRate);
-		
-		// 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
-		layer_bytes[nb_layers++] = FIRST_PACKET_SIZE;
-		U32 i = MIN_LAYER_SIZE;
-		while ((i < max_bytes) && (nb_layers < (MAX_NB_LAYERS-1)))
-		{
-			layer_bytes[nb_layers++] = i;
-			i *= 4;
-		}
-		// Note: for small images, we can have (max_bytes < FIRST_PACKET_SIZE), hence the test
-		if (layer_bytes[nb_layers-1] < max_bytes)
-		{
-			// Set the last quality layer so to fit the preset compression ratio
-			layer_bytes[nb_layers++] = max_bytes;
-		}
-
-		if (reversible)
-		{
-			// Use 0 for a last quality layer for reversible images so all remaining code blocks will be flushed
-			// Hack: KDU encoding for reversible images has a bug for small images that leads to j2c images that 
-			// cannot be open or are very blurry. Avoiding that last layer prevents the problem to happen.
-			if ((base.getWidth() >= 32) || (base.getHeight() >= 32))
-			{
-				layer_bytes[nb_layers++] = 0;
-			}
-			codestream.access_siz()->parse_string("Creversible=yes");
-			// *TODO: we should use yuv in reversible mode
-			// Don't turn this on now though as it creates problems on decoding for the moment
-			//codestream.access_siz()->parse_string("Cycc=no");
-		}
-		
-		std::string layer_string = llformat("Clayers=%d",nb_layers);
-		codestream.access_siz()->parse_string(layer_string.c_str());
-		
-		// Set up data ordering, markers, etc... if precincts or blocks specified
-		if ((mBlocksSize != -1) || (mPrecinctsSize != -1))
-		{
-			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=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());
-			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
-		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,nb_layers);
-
-		// Cleanup
-		delete tile;
-		codestream.destroy();
-
-		// 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;
-	}
-	catch(const KDUError& msg)
-	{
-		base.setLastError(msg.what());
-		return false;
-	}
-	catch (kdu_exception kdu_value)
-	{
-		// KDU internally throws kdu_exception. It's possible that such an
-		// exception might leak out into our code. Catch kdu_exception
-		// specially because boost::current_exception_diagnostic_information()
-		// could do nothing with it.
-		base.setLastError(report_kdu_exception(kdu_value));
-		return false;
-	}
-	catch( ... )
-	{
-		base.setLastError("Unknown J2C error: " +
-						  boost::current_exception_diagnostic_information());
-		return false;
-	}
-
-	return true;
+    // Declare and set simple arguments
+    bool transpose = false;
+    bool vflip = true;
+    bool hflip = false;
+
+    try
+    {
+        // Set up input image files
+        siz_params siz;
+
+        // Should set rate someplace here
+        LLKDUMemIn mem_in(raw_image.getData(),
+            raw_image.getDataSize(),
+            raw_image.getWidth(),
+            raw_image.getHeight(),
+            raw_image.getComponents(),
+            &siz);
+
+        base.setSize(raw_image.getWidth(), raw_image.getHeight(), raw_image.getComponents());
+
+        int num_components = raw_image.getComponents();
+
+        siz.set(Scomponents,0,0,num_components);
+        siz.set(Sdims,0,0,base.getHeight());  // Height of first image component
+        siz.set(Sdims,0,1,base.getWidth());   // Width of first image component
+        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-stream
+        transformed_siz.copy_from(&siz,-1,-1,-1,0,transpose,false,false);
+
+        // Construct the `kdu_codestream' object and parse all remaining arguments
+        U32 max_output_size = base.getWidth()*base.getHeight()*base.getComponents();
+        max_output_size = (max_output_size < 1000 ? 1000 : max_output_size);
+        U8 *output_buffer = new U8[max_output_size];
+        U32 output_size = 0; // Address updated by LLKDUMemTarget to give the final compressed buffer size
+        LLKDUMemTarget output(output_buffer, output_size, max_output_size);
+
+        kdu_codestream codestream;
+        codestream.create(&transformed_siz,&output);
+
+        if (comment_text)
+        {
+            // Set the comments for the codestream
+            kdu_codestream_comment comment = codestream.add_comment();
+            comment.put_text(comment_text);
+        }
+
+        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());
+        }
+
+        // Set codestream options
+        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.
+        llassert (base.mRate > 0.f);
+        max_bytes = (U32)((F32)(max_bytes) * base.mRate);
+
+        // 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
+        layer_bytes[nb_layers++] = FIRST_PACKET_SIZE;
+        U32 i = MIN_LAYER_SIZE;
+        while ((i < max_bytes) && (nb_layers < (MAX_NB_LAYERS-1)))
+        {
+            layer_bytes[nb_layers++] = i;
+            i *= 4;
+        }
+        // Note: for small images, we can have (max_bytes < FIRST_PACKET_SIZE), hence the test
+        if (layer_bytes[nb_layers-1] < max_bytes)
+        {
+            // Set the last quality layer so to fit the preset compression ratio
+            layer_bytes[nb_layers++] = max_bytes;
+        }
+
+        if (reversible)
+        {
+            // Use 0 for a last quality layer for reversible images so all remaining code blocks will be flushed
+            // Hack: KDU encoding for reversible images has a bug for small images that leads to j2c images that
+            // cannot be open or are very blurry. Avoiding that last layer prevents the problem to happen.
+            if ((base.getWidth() >= 32) || (base.getHeight() >= 32))
+            {
+                layer_bytes[nb_layers++] = 0;
+            }
+            codestream.access_siz()->parse_string("Creversible=yes");
+            // *TODO: we should use yuv in reversible mode
+            // Don't turn this on now though as it creates problems on decoding for the moment
+            //codestream.access_siz()->parse_string("Cycc=no");
+        }
+
+        std::string layer_string = llformat("Clayers=%d",nb_layers);
+        codestream.access_siz()->parse_string(layer_string.c_str());
+
+        // Set up data ordering, markers, etc... if precincts or blocks specified
+        if ((mBlocksSize != -1) || (mPrecinctsSize != -1))
+        {
+            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=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());
+            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
+        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,nb_layers);
+
+        // Cleanup
+        delete tile;
+        codestream.destroy();
+
+        // 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;
+    }
+    catch(const KDUError& msg)
+    {
+        base.setLastError(msg.what());
+        return false;
+    }
+    catch (kdu_exception kdu_value)
+    {
+        // KDU internally throws kdu_exception. It's possible that such an
+        // exception might leak out into our code. Catch kdu_exception
+        // specially because boost::current_exception_diagnostic_information()
+        // could do nothing with it.
+        base.setLastError(report_kdu_exception(kdu_value));
+        return false;
+    }
+    catch( ... )
+    {
+        base.setLastError("Unknown J2C error: " +
+                          boost::current_exception_diagnostic_information());
+        return false;
+    }
+
+    return true;
 }
 
 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
-	// catch it here.
-	try
-	{
-		setupCodeStream(base, false, MODE_FAST);
-		return true;
-	}
-	catch (const KDUError& msg)
-	{
-		base.setLastError(msg.what());
-		return false;
-	}
-	catch (kdu_exception kdu_value)
-	{
-		// KDU internally throws kdu_exception. It's possible that such an
-		// exception might leak out into our code. Catch kdu_exception
-		// specially because boost::current_exception_diagnostic_information()
-		// could do nothing with it.
-		base.setLastError(report_kdu_exception(kdu_value));
-		return false;
-	}
-	catch (...)
-	{
-		base.setLastError("Unknown J2C error: " +
-						  boost::current_exception_diagnostic_information());
-		return false;
-	}
+    // *FIX: kdu calls our callback function if there's an error, and
+    // then bombs. To regain control, we throw an exception, and
+    // catch it here.
+    try
+    {
+        setupCodeStream(base, false, MODE_FAST);
+        return true;
+    }
+    catch (const KDUError& msg)
+    {
+        base.setLastError(msg.what());
+        return false;
+    }
+    catch (kdu_exception kdu_value)
+    {
+        // KDU internally throws kdu_exception. It's possible that such an
+        // exception might leak out into our code. Catch kdu_exception
+        // specially because boost::current_exception_diagnostic_information()
+        // could do nothing with it.
+        base.setLastError(report_kdu_exception(kdu_value));
+        return false;
+    }
+    catch (...)
+    {
+        base.setLastError("Unknown J2C error: " +
+                          boost::current_exception_diagnostic_information());
+        return false;
+    }
 }
 
 /*****************************************************************************/
@@ -860,31 +860,31 @@ bool LLImageJ2CKDU::getMetadata(LLImageJ2C &base)
 // Only called by copy_tile(), which is itself commented out
 static void copy_block(kdu_block *in, kdu_block *out)
 {
-	if (in->K_max_prime != out->K_max_prime)
-    { 
-		std::cout << "Cannot copy blocks belonging to subbands with different quantization parameters." << std::endl; 
-		return;
-	}
-	if ((in->size.x != out->size.x) || (in->size.y != out->size.y))  
-    { 
-		std::cout << "Cannot copy code-blocks with different dimensions." << std::endl; 
-		return;
-	}
-	out->missing_msbs = in->missing_msbs;
-	if (out->max_passes < (in->num_passes+2))        // Gives us enough to round up
-		out->set_max_passes(in->num_passes+2,false); // to the next whole bit-plane
-	out->num_passes = in->num_passes;
-	int num_bytes = 0;
-	for (int z=0; z < in->num_passes; z++)
+    if (in->K_max_prime != out->K_max_prime)
+    {
+        std::cout << "Cannot copy blocks belonging to subbands with different quantization parameters." << std::endl;
+        return;
+    }
+    if ((in->size.x != out->size.x) || (in->size.y != out->size.y))
+    {
+        std::cout << "Cannot copy code-blocks with different dimensions." << std::endl;
+        return;
+    }
+    out->missing_msbs = in->missing_msbs;
+    if (out->max_passes < (in->num_passes+2))        // Gives us enough to round up
+        out->set_max_passes(in->num_passes+2,false); // to the next whole bit-plane
+    out->num_passes = in->num_passes;
+    int num_bytes = 0;
+    for (int z=0; z < in->num_passes; z++)
     {
-		num_bytes += (out->pass_lengths[z] = in->pass_lengths[z]);
-		out->pass_slopes[z] = in->pass_slopes[z];
+        num_bytes += (out->pass_lengths[z] = in->pass_lengths[z]);
+        out->pass_slopes[z] = in->pass_slopes[z];
     }
-	
+
     // Just copy compressed code-bytes. Block transcoding not supported.
-	if (out->max_bytes < num_bytes)
-		out->set_max_bytes(num_bytes,false);
-	memcpy(out->byte_buffer,in->byte_buffer,(size_t) num_bytes);
+    if (out->max_bytes < num_bytes)
+        out->set_max_bytes(num_bytes,false);
+    memcpy(out->byte_buffer,in->byte_buffer,(size_t) num_bytes);
 }
 |*==========================================================================*/
 
@@ -896,56 +896,56 @@ static void copy_block(kdu_block *in, kdu_block *out)
 // Only called by findDiscardLevelsBoundaries(), which is itself commented out
 static void
 copy_tile(kdu_tile tile_in, kdu_tile tile_out, int tnum_in, int tnum_out,
-		  kdu_params *siz_in, kdu_params *siz_out, int skip_components,
-		  int &num_blocks)
+          kdu_params *siz_in, kdu_params *siz_out, int skip_components,
+          int &num_blocks)
 {
-	int num_components = tile_out.get_num_components();
-	int new_tpart=0, next_tpart = 1;
-	
-	for (int c=0; c < num_components; c++)
+    int num_components = tile_out.get_num_components();
+    int new_tpart=0, next_tpart = 1;
+
+    for (int c=0; c < num_components; c++)
     {
-		kdu_tile_comp comp_in, comp_out;
-		comp_in = tile_in.access_component(c);
-		comp_out = tile_out.access_component(c);
-		int num_resolutions = comp_out.get_num_resolutions();
-		//std::cout << "    Copying tile : num_resolutions = " << num_resolutions << std::endl;
-		for (int r=0; r < num_resolutions; r++)
+        kdu_tile_comp comp_in, comp_out;
+        comp_in = tile_in.access_component(c);
+        comp_out = tile_out.access_component(c);
+        int num_resolutions = comp_out.get_num_resolutions();
+        //std::cout << "    Copying tile : num_resolutions = " << num_resolutions << std::endl;
+        for (int r=0; r < num_resolutions; r++)
         {
-			kdu_resolution res_in;  res_in = comp_in.access_resolution(r);
-			kdu_resolution res_out; res_out = comp_out.access_resolution(r);
-			int b, min_band;
-			int num_bands = res_in.get_valid_band_indices(min_band);
-			std::cout << "        Copying tile : num_bands = " << num_bands << std::endl;
-			for (b=min_band; num_bands > 0; num_bands--, b++)
+            kdu_resolution res_in;  res_in = comp_in.access_resolution(r);
+            kdu_resolution res_out; res_out = comp_out.access_resolution(r);
+            int b, min_band;
+            int num_bands = res_in.get_valid_band_indices(min_band);
+            std::cout << "        Copying tile : num_bands = " << num_bands << std::endl;
+            for (b=min_band; num_bands > 0; num_bands--, b++)
             {
-				kdu_subband band_in;  band_in = res_in.access_subband(b);
-				kdu_subband band_out; band_out = res_out.access_subband(b);
-				kdu_dims blocks_in;  band_in.get_valid_blocks(blocks_in);
-				kdu_dims blocks_out; band_out.get_valid_blocks(blocks_out);
-				if ((blocks_in.size.x != blocks_out.size.x) ||
-					(blocks_in.size.y != blocks_out.size.y))
-                { 
-					std::cout << "Transcoding operation cannot proceed: Code-block partitions for the input and output code-streams do not agree." << std::endl;
-					return;
-				}
-				kdu_coords idx;
-				//std::cout << "            Copying tile : block indices, x = " << blocks_out.size.x << " and y = " << blocks_out.size.y << std::endl;
-				for (idx.y=0; idx.y < blocks_out.size.y; idx.y++)
-				{
-					for (idx.x=0; idx.x < blocks_out.size.x; idx.x++)
-					{
-						kdu_block *in =
-						band_in.open_block(idx+blocks_in.pos,&new_tpart);
-						for (; next_tpart <= new_tpart; next_tpart++)
-							siz_out->copy_from(siz_in,tnum_in,tnum_out,next_tpart,
-											   skip_components);
-						kdu_block *out = band_out.open_block(idx+blocks_out.pos);
-						copy_block(in,out);
-						band_in.close_block(in);
-						band_out.close_block(out);
-						num_blocks++;
-					}
-				}
+                kdu_subband band_in;  band_in = res_in.access_subband(b);
+                kdu_subband band_out; band_out = res_out.access_subband(b);
+                kdu_dims blocks_in;  band_in.get_valid_blocks(blocks_in);
+                kdu_dims blocks_out; band_out.get_valid_blocks(blocks_out);
+                if ((blocks_in.size.x != blocks_out.size.x) ||
+                    (blocks_in.size.y != blocks_out.size.y))
+                {
+                    std::cout << "Transcoding operation cannot proceed: Code-block partitions for the input and output code-streams do not agree." << std::endl;
+                    return;
+                }
+                kdu_coords idx;
+                //std::cout << "            Copying tile : block indices, x = " << blocks_out.size.x << " and y = " << blocks_out.size.y << std::endl;
+                for (idx.y=0; idx.y < blocks_out.size.y; idx.y++)
+                {
+                    for (idx.x=0; idx.x < blocks_out.size.x; idx.x++)
+                    {
+                        kdu_block *in =
+                        band_in.open_block(idx+blocks_in.pos,&new_tpart);
+                        for (; next_tpart <= new_tpart; next_tpart++)
+                            siz_out->copy_from(siz_in,tnum_in,tnum_out,next_tpart,
+                                               skip_components);
+                        kdu_block *out = band_out.open_block(idx+blocks_out.pos);
+                        copy_block(in,out);
+                        band_in.close_block(in);
+                        band_out.close_block(out);
+                        num_blocks++;
+                    }
+                }
             }
         }
     }
@@ -959,174 +959,174 @@ copy_tile(kdu_tile tile_in, kdu_tile tile_out, int tnum_in, int tnum_out,
 // See comments in header file for why this is commented out.
 void LLImageJ2CKDU::findDiscardLevelsBoundaries(LLImageJ2C &base)
 {
-	// We need the number of levels in that image before starting.
-	getMetadata(base);
-	
-	for (int discard_level = 0; discard_level < mLevels; discard_level++)
-	{
-		//std::cout << "Parsing discard level = " << discard_level << std::endl;
-		// Create the input codestream object.
-		setupCodeStream(base, true, MODE_FAST);
-		mCodeStreamp->apply_input_restrictions(0, 4, discard_level, 0, NULL);
-		mCodeStreamp->set_max_bytes(KDU_LONG_MAX,true);
-		siz_params *siz_in = mCodeStreamp->access_siz();
-	
-		// Create the output codestream object.
-		siz_params siz;
-		siz.copy_from(siz_in,-1,-1,-1,0,discard_level,false,false,false);
-		siz.set(Scomponents,0,0,mCodeStreamp->get_num_components());
-	
-		U32 max_output_size = base.getWidth()*base.getHeight()*base.getComponents();
-		max_output_size = (max_output_size < 1000 ? 1000 : max_output_size);
-		U8 *output_buffer = new U8[max_output_size];
-		U32 output_size = 0; // Address updated by LLKDUMemTarget to give the final compressed buffer size
-		LLKDUMemTarget output(output_buffer, output_size, max_output_size);
-		kdu_codestream codestream_out; 
-		codestream_out.create(&siz,&output);
-		//codestream_out.share_buffering(*mCodeStreamp);
-		siz_params *siz_out = codestream_out.access_siz();
-		siz_out->copy_from(siz_in,-1,-1,-1,0,discard_level,false,false,false);
-		codestream_out.access_siz()->finalize_all(-1);
-	
-		// Set up rate control variables
-		kdu_long max_bytes = KDU_LONG_MAX;
-		kdu_params *cod = siz_out->access_cluster(COD_params);
-		int total_layers;  cod->get(Clayers,0,0,total_layers);
-		kdu_long *layer_bytes = new kdu_long[total_layers];
-		int nel, non_empty_layers = 0;
-	
-		// Now ready to perform the transfer of compressed data between streams
-		int flush_counter = INT_MAX;
-		kdu_dims tile_indices_in;  
-		mCodeStreamp->get_valid_tiles(tile_indices_in);
-		kdu_dims tile_indices_out; 
-		codestream_out.get_valid_tiles(tile_indices_out);
-		assert((tile_indices_in.size.x == tile_indices_out.size.x) &&
-			   (tile_indices_in.size.y == tile_indices_out.size.y));
-		int num_blocks=0;
-	
-		kdu_coords idx;
-		//std::cout << "Parsing tiles : x = " << tile_indices_out.size.x << " to y = " << tile_indices_out.size.y << std::endl;
-		for (idx.y=0; idx.y < tile_indices_out.size.y; idx.y++)
-		{
-			for (idx.x=0; idx.x < tile_indices_out.size.x; idx.x++)
-			{
-				kdu_tile tile_in = mCodeStreamp->open_tile(idx+tile_indices_in.pos);
-				int tnum_in = tile_in.get_tnum();
-				int tnum_out = idx.x + idx.y*tile_indices_out.size.x;
-				siz_out->copy_from(siz_in,tnum_in,tnum_out,0,0,discard_level,false,false,false);
-				siz_out->finalize_all(tnum_out);
-				// Note: do not open the output tile without first copying any tile-specific code-stream parameters
-				kdu_tile tile_out = codestream_out.open_tile(idx+tile_indices_out.pos);
-				assert(tnum_out == tile_out.get_tnum());
-				copy_tile(tile_in,tile_out,tnum_in,tnum_out,siz_in,siz_out,0,num_blocks);
-				tile_in.close();
-				tile_out.close();
-				flush_counter--;
-				if ((flush_counter <= 0) && codestream_out.ready_for_flush())
-				{
-					flush_counter = INT_MAX;
-					nel = codestream_out.trans_out(max_bytes,layer_bytes,total_layers);
-					non_empty_layers = (nel > non_empty_layers)?nel:non_empty_layers;
-				}
-			}
-		}
-	
-		// Generate the output code-stream
-		if (codestream_out.ready_for_flush())
-		{
-			nel = codestream_out.trans_out(max_bytes,layer_bytes,total_layers);
-			non_empty_layers = (nel > non_empty_layers)?nel:non_empty_layers;
-		}
-		if (non_empty_layers > total_layers)
-			non_empty_layers = total_layers; // Can happen if a tile has more layers
-	
-		// Print out stats
-		std::cout << "Code stream parsing for discard level = " << discard_level << std::endl;
-		std::cout << "    Total compressed memory in  = " << mCodeStreamp->get_compressed_data_memory() << " bytes" << std::endl;
-		std::cout << "    Total compressed memory out = " << codestream_out.get_compressed_data_memory() << " bytes" << std::endl;
-		//std::cout << "    Output contains " << total_layers << " quality layers" << std::endl;		
-		std::cout << "    Transferred " << num_blocks << " code-blocks from in to out" << std::endl;
-		//std::cout << "    Read " << mCodeStreamp->get_num_tparts() << " tile-part(s) from a total of " << (int) tile_indices_in.area() << " tile(s)" << std::endl;
-		std::cout << "    Total bytes read = " << mCodeStreamp->get_total_bytes() << std::endl;
-		//std::cout << "    Wrote " << codestream_out.get_num_tparts() << " tile-part(s) in a total of " << (int) tile_indices_out.area() << " tile(s)" << std::endl;
-		std::cout << "    Total bytes written = " << codestream_out.get_total_bytes() << std::endl;
-		std::cout << "-------------" << std::endl;
-	
-		// Clean-up
-		cleanupCodeStream();
-		codestream_out.destroy();
-		delete[] output_buffer;	
-	}
-	return;
+    // We need the number of levels in that image before starting.
+    getMetadata(base);
+
+    for (int discard_level = 0; discard_level < mLevels; discard_level++)
+    {
+        //std::cout << "Parsing discard level = " << discard_level << std::endl;
+        // Create the input codestream object.
+        setupCodeStream(base, true, MODE_FAST);
+        mCodeStreamp->apply_input_restrictions(0, 4, discard_level, 0, NULL);
+        mCodeStreamp->set_max_bytes(KDU_LONG_MAX,true);
+        siz_params *siz_in = mCodeStreamp->access_siz();
+
+        // Create the output codestream object.
+        siz_params siz;
+        siz.copy_from(siz_in,-1,-1,-1,0,discard_level,false,false,false);
+        siz.set(Scomponents,0,0,mCodeStreamp->get_num_components());
+
+        U32 max_output_size = base.getWidth()*base.getHeight()*base.getComponents();
+        max_output_size = (max_output_size < 1000 ? 1000 : max_output_size);
+        U8 *output_buffer = new U8[max_output_size];
+        U32 output_size = 0; // Address updated by LLKDUMemTarget to give the final compressed buffer size
+        LLKDUMemTarget output(output_buffer, output_size, max_output_size);
+        kdu_codestream codestream_out;
+        codestream_out.create(&siz,&output);
+        //codestream_out.share_buffering(*mCodeStreamp);
+        siz_params *siz_out = codestream_out.access_siz();
+        siz_out->copy_from(siz_in,-1,-1,-1,0,discard_level,false,false,false);
+        codestream_out.access_siz()->finalize_all(-1);
+
+        // Set up rate control variables
+        kdu_long max_bytes = KDU_LONG_MAX;
+        kdu_params *cod = siz_out->access_cluster(COD_params);
+        int total_layers;  cod->get(Clayers,0,0,total_layers);
+        kdu_long *layer_bytes = new kdu_long[total_layers];
+        int nel, non_empty_layers = 0;
+
+        // Now ready to perform the transfer of compressed data between streams
+        int flush_counter = INT_MAX;
+        kdu_dims tile_indices_in;
+        mCodeStreamp->get_valid_tiles(tile_indices_in);
+        kdu_dims tile_indices_out;
+        codestream_out.get_valid_tiles(tile_indices_out);
+        assert((tile_indices_in.size.x == tile_indices_out.size.x) &&
+               (tile_indices_in.size.y == tile_indices_out.size.y));
+        int num_blocks=0;
+
+        kdu_coords idx;
+        //std::cout << "Parsing tiles : x = " << tile_indices_out.size.x << " to y = " << tile_indices_out.size.y << std::endl;
+        for (idx.y=0; idx.y < tile_indices_out.size.y; idx.y++)
+        {
+            for (idx.x=0; idx.x < tile_indices_out.size.x; idx.x++)
+            {
+                kdu_tile tile_in = mCodeStreamp->open_tile(idx+tile_indices_in.pos);
+                int tnum_in = tile_in.get_tnum();
+                int tnum_out = idx.x + idx.y*tile_indices_out.size.x;
+                siz_out->copy_from(siz_in,tnum_in,tnum_out,0,0,discard_level,false,false,false);
+                siz_out->finalize_all(tnum_out);
+                // Note: do not open the output tile without first copying any tile-specific code-stream parameters
+                kdu_tile tile_out = codestream_out.open_tile(idx+tile_indices_out.pos);
+                assert(tnum_out == tile_out.get_tnum());
+                copy_tile(tile_in,tile_out,tnum_in,tnum_out,siz_in,siz_out,0,num_blocks);
+                tile_in.close();
+                tile_out.close();
+                flush_counter--;
+                if ((flush_counter <= 0) && codestream_out.ready_for_flush())
+                {
+                    flush_counter = INT_MAX;
+                    nel = codestream_out.trans_out(max_bytes,layer_bytes,total_layers);
+                    non_empty_layers = (nel > non_empty_layers)?nel:non_empty_layers;
+                }
+            }
+        }
+
+        // Generate the output code-stream
+        if (codestream_out.ready_for_flush())
+        {
+            nel = codestream_out.trans_out(max_bytes,layer_bytes,total_layers);
+            non_empty_layers = (nel > non_empty_layers)?nel:non_empty_layers;
+        }
+        if (non_empty_layers > total_layers)
+            non_empty_layers = total_layers; // Can happen if a tile has more layers
+
+        // Print out stats
+        std::cout << "Code stream parsing for discard level = " << discard_level << std::endl;
+        std::cout << "    Total compressed memory in  = " << mCodeStreamp->get_compressed_data_memory() << " bytes" << std::endl;
+        std::cout << "    Total compressed memory out = " << codestream_out.get_compressed_data_memory() << " bytes" << std::endl;
+        //std::cout << "    Output contains " << total_layers << " quality layers" << std::endl;
+        std::cout << "    Transferred " << num_blocks << " code-blocks from in to out" << std::endl;
+        //std::cout << "    Read " << mCodeStreamp->get_num_tparts() << " tile-part(s) from a total of " << (int) tile_indices_in.area() << " tile(s)" << std::endl;
+        std::cout << "    Total bytes read = " << mCodeStreamp->get_total_bytes() << std::endl;
+        //std::cout << "    Wrote " << codestream_out.get_num_tparts() << " tile-part(s) in a total of " << (int) tile_indices_out.area() << " tile(s)" << std::endl;
+        std::cout << "    Total bytes written = " << codestream_out.get_total_bytes() << std::endl;
+        std::cout << "-------------" << std::endl;
+
+        // Clean-up
+        cleanupCodeStream();
+        codestream_out.destroy();
+        delete[] output_buffer;
+    }
+    return;
 }
 |*==========================================================================*/
 
 void set_default_colour_weights(kdu_params *siz)
 {
-	kdu_params *cod = siz->access_cluster(COD_params);
-	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++)
-	{
-		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);
-		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))
-		{
-			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))
-	{
-		// 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.
-
-	cod->parse_string("Cband_weights:C0="
-		"{0.0901},{0.2758},{0.2758},"
-		"{0.7018},{0.8378},{0.8378},{1}");
-	cod->parse_string("Cband_weights:C1="
-		"{0.0263},{0.0863},{0.0863},"
-		"{0.1362},{0.2564},{0.2564},"
-		"{0.3346},{0.4691},{0.4691},"
-		"{0.5444},{0.6523},{0.6523},"
-		"{0.7078},{0.7797},{0.7797},{1}");
-	cod->parse_string("Cband_weights:C2="
-		"{0.0773},{0.1835},{0.1835},"
-		"{0.2598},{0.4130},{0.4130},"
-		"{0.5040},{0.6464},{0.6464},"
-		"{0.7220},{0.8254},{0.8254},"
-		"{0.8769},{0.9424},{0.9424},{1}");
+    kdu_params *cod = siz->access_cluster(COD_params);
+    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++)
+    {
+        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);
+        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))
+        {
+            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))
+    {
+        // 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.
+
+    cod->parse_string("Cband_weights:C0="
+        "{0.0901},{0.2758},{0.2758},"
+        "{0.7018},{0.8378},{0.8378},{1}");
+    cod->parse_string("Cband_weights:C1="
+        "{0.0263},{0.0863},{0.0863},"
+        "{0.1362},{0.2564},{0.2564},"
+        "{0.3346},{0.4691},{0.4691},"
+        "{0.5444},{0.6523},{0.6523},"
+        "{0.7078},{0.7797},{0.7797},{1}");
+    cod->parse_string("Cband_weights:C2="
+        "{0.0773},{0.1835},{0.1835},"
+        "{0.2598},{0.4130},{0.4130},"
+        "{0.5040},{0.6464},{0.6464},"
+        "{0.7220},{0.8254},{0.8254},"
+        "{0.8769},{0.9424},{0.9424},{1}");
 }
 
 /******************************************************************************/
@@ -1139,192 +1139,192 @@ byte buffer, spacing successive output samples apart by `gap' bytes
 (to allow for interleaving of colour components).  The function performs
 all necessary level shifting, type conversion, rounding and truncation. */
 {
-	int width = src.get_width();
-	if (src.get_buf32() != NULL)
-	{ // Decompressed samples have a 32-bit representation (integer or float)
-		assert(precision >= 8); // Else would have used 16 bit representation
-		kdu_sample32 *sp = src.get_buf32();
-		if (!src.is_absolute())
-		{ // Transferring normalized floating point data.
-			float scale16 = (float)(1<<16);
-			kdu_int32 val;
-
-			for (; width > 0; width--, sp++, dest+=gap)
-			{
-				val = (kdu_int32)(sp->fval*scale16);
-				val = (val+128)>>8; // May be faster than true rounding
-				val += 128;
-				if (val & ((0xffffffffU)<<8))
-				{
-					val = (val < 0 ? 0 : 255);
-				}
-				*dest = (kdu_byte) val;
-			}
-		}
-		else
-		{ // Transferring 32-bit absolute integers.
-			kdu_int32 val;
-			kdu_int32 downshift = precision-8;
-			kdu_int32 offset = (1<<downshift)>>1;
-
-			for (; width > 0; width--, sp++, dest+=gap)
-			{
-				val = sp->ival;
-				val = (val+offset)>>downshift;
-				val += 128;
-				if (val & ((0xffffffffU)<<8))
-				{
-					val = (val < 0 ? 0 : 255);
-				}
-				*dest = (kdu_byte) val;
-			}
-		}
-	}
-	else
-	{ // Source data is 16 bits.
-		kdu_sample16 *sp = src.get_buf16();
-		if (!src.is_absolute())
-		{ // Transferring 16-bit fixed point quantities
-			kdu_int16 val;
-
-			if (precision >= 8)
-			{ // Can essentially ignore the bit-depth.
-				for (; width > 0; width--, sp++, dest+=gap)
-				{
-					val = sp->ival;
-					val += (1<<(KDU_FIX_POINT-8))>>1;
-					val >>= (KDU_FIX_POINT-8);
-					val += 128;
-					if (val & ((0xffffffffU)<<8))
-					{
-						val = (val < 0 ? 0 : 255);
-					}
-					*dest = (kdu_byte) val;
-				}
-			}
-			else
-			{ // Need to force zeros into one or more least significant bits.
-				kdu_int16 downshift = KDU_FIX_POINT-precision;
-				kdu_int16 upshift = 8-precision;
-				kdu_int16 offset = 1<<(downshift-1);
-
-				for (; width > 0; width--, sp++, dest+=gap)
-				{
-					val = sp->ival;
-					val = (val+offset)>>downshift;
-					val <<= upshift;
-					val += 128;
-					if (val & ((0xffffffffU)<<8))
-					{
-						val = (val < 0 ? 0 : 256 - (1<<upshift));
-					}
-					*dest = (kdu_byte) val;
-				}
-			}
-		}
-		else
-		{ // Transferring 16-bit absolute integers.
-			kdu_int16 val;
-
-			if (precision >= 8)
-			{
-				kdu_int16 downshift = precision-8;
-				kdu_int16 offset = (1<<downshift)>>1;
-
-				for (; width > 0; width--, sp++, dest+=gap)
-				{
-					val = sp->ival;
-					val = (val+offset)>>downshift;
-					val += 128;
-					if (val & ((0xffffffffU)<<8))
-					{
-						val = (val < 0 ? 0 : 255);
-					}
-					*dest = (kdu_byte) val;
-				}
-			}
-			else
-			{
-				kdu_int16 upshift = 8-precision;
-
-				for (; width > 0; width--, sp++, dest+=gap)
-				{
-					val = sp->ival;
-					val <<= upshift;
-					val += 128;
-					if (val & ((0xffffffffU)<<8))
-					{
-						val = (val < 0 ? 0 : 256 - (1<<upshift));
-					}
-					*dest = (kdu_byte) val;
-				}
-			}
-		}
-	}
+    int width = src.get_width();
+    if (src.get_buf32() != NULL)
+    { // Decompressed samples have a 32-bit representation (integer or float)
+        assert(precision >= 8); // Else would have used 16 bit representation
+        kdu_sample32 *sp = src.get_buf32();
+        if (!src.is_absolute())
+        { // Transferring normalized floating point data.
+            float scale16 = (float)(1<<16);
+            kdu_int32 val;
+
+            for (; width > 0; width--, sp++, dest+=gap)
+            {
+                val = (kdu_int32)(sp->fval*scale16);
+                val = (val+128)>>8; // May be faster than true rounding
+                val += 128;
+                if (val & ((0xffffffffU)<<8))
+                {
+                    val = (val < 0 ? 0 : 255);
+                }
+                *dest = (kdu_byte) val;
+            }
+        }
+        else
+        { // Transferring 32-bit absolute integers.
+            kdu_int32 val;
+            kdu_int32 downshift = precision-8;
+            kdu_int32 offset = (1<<downshift)>>1;
+
+            for (; width > 0; width--, sp++, dest+=gap)
+            {
+                val = sp->ival;
+                val = (val+offset)>>downshift;
+                val += 128;
+                if (val & ((0xffffffffU)<<8))
+                {
+                    val = (val < 0 ? 0 : 255);
+                }
+                *dest = (kdu_byte) val;
+            }
+        }
+    }
+    else
+    { // Source data is 16 bits.
+        kdu_sample16 *sp = src.get_buf16();
+        if (!src.is_absolute())
+        { // Transferring 16-bit fixed point quantities
+            kdu_int16 val;
+
+            if (precision >= 8)
+            { // Can essentially ignore the bit-depth.
+                for (; width > 0; width--, sp++, dest+=gap)
+                {
+                    val = sp->ival;
+                    val += (1<<(KDU_FIX_POINT-8))>>1;
+                    val >>= (KDU_FIX_POINT-8);
+                    val += 128;
+                    if (val & ((0xffffffffU)<<8))
+                    {
+                        val = (val < 0 ? 0 : 255);
+                    }
+                    *dest = (kdu_byte) val;
+                }
+            }
+            else
+            { // Need to force zeros into one or more least significant bits.
+                kdu_int16 downshift = KDU_FIX_POINT-precision;
+                kdu_int16 upshift = 8-precision;
+                kdu_int16 offset = 1<<(downshift-1);
+
+                for (; width > 0; width--, sp++, dest+=gap)
+                {
+                    val = sp->ival;
+                    val = (val+offset)>>downshift;
+                    val <<= upshift;
+                    val += 128;
+                    if (val & ((0xffffffffU)<<8))
+                    {
+                        val = (val < 0 ? 0 : 256 - (1<<upshift));
+                    }
+                    *dest = (kdu_byte) val;
+                }
+            }
+        }
+        else
+        { // Transferring 16-bit absolute integers.
+            kdu_int16 val;
+
+            if (precision >= 8)
+            {
+                kdu_int16 downshift = precision-8;
+                kdu_int16 offset = (1<<downshift)>>1;
+
+                for (; width > 0; width--, sp++, dest+=gap)
+                {
+                    val = sp->ival;
+                    val = (val+offset)>>downshift;
+                    val += 128;
+                    if (val & ((0xffffffffU)<<8))
+                    {
+                        val = (val < 0 ? 0 : 255);
+                    }
+                    *dest = (kdu_byte) val;
+                }
+            }
+            else
+            {
+                kdu_int16 upshift = 8-precision;
+
+                for (; width > 0; width--, sp++, dest+=gap)
+                {
+                    val = sp->ival;
+                    val <<= upshift;
+                    val += 128;
+                    if (val & ((0xffffffffU)<<8))
+                    {
+                        val = (val < 0 ? 0 : 256 - (1<<upshift));
+                    }
+                    *dest = (kdu_byte) val;
+                }
+            }
+        }
+    }
 }
 
 LLKDUDecodeState::LLKDUDecodeState(kdu_tile tile, kdu_byte *buf, S32 row_gap,
-								   kdu_codestream* codestreamp)
+                                   kdu_codestream* codestreamp)
 {
-	S32 c;
-
-	mTile = tile;
-	mBuf = buf;
-	mRowGap = row_gap;
-
-	mNumComponents = tile.get_num_components();
-
-	llassert(mNumComponents <= 4);
-	mUseYCC = tile.get_ycc();
-
-	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++)
-	{
-		mComps[c] = mTile.access_component(c);
-		mReversible[c] = mComps[c].get_reversible();
-		mBitDepths[c] = mComps[c].get_bit_depth();
-		kdu_resolution res = mComps[c].access_resolution(); // Get top resolution
-		kdu_dims comp_dims; res.get_dims(comp_dims);
-		if (c == 0)
-		{
-			mDims = comp_dims;
-		}
-		else
-		{
-			llassert(mDims == comp_dims); // Safety check; the caller has ensured this
-		}
-		bool use_shorts = (mComps[c].get_bit_depth(true) <= 16);
-		mLines[c].pre_create(&mAllocator,mDims.size.x,mReversible[c],use_shorts,0,0);
-		if (res.which() == 0) // No DWT levels used
-		{
-			mEngines[c] = kdu_decoder(res.access_subband(LL_BAND),&mAllocator,use_shorts);
-		}
-		else
-		{
-			mEngines[c] = kdu_synthesis(res,&mAllocator,use_shorts);
-		}
-	}
-	mAllocator.finalize(*codestreamp); // Actually creates buffering resources
-	for (c = 0; c < mNumComponents; c++)
-	{
-		mLines[c].create(); // Grabs resources from the allocator.
-	}
+    S32 c;
+
+    mTile = tile;
+    mBuf = buf;
+    mRowGap = row_gap;
+
+    mNumComponents = tile.get_num_components();
+
+    llassert(mNumComponents <= 4);
+    mUseYCC = tile.get_ycc();
+
+    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++)
+    {
+        mComps[c] = mTile.access_component(c);
+        mReversible[c] = mComps[c].get_reversible();
+        mBitDepths[c] = mComps[c].get_bit_depth();
+        kdu_resolution res = mComps[c].access_resolution(); // Get top resolution
+        kdu_dims comp_dims; res.get_dims(comp_dims);
+        if (c == 0)
+        {
+            mDims = comp_dims;
+        }
+        else
+        {
+            llassert(mDims == comp_dims); // Safety check; the caller has ensured this
+        }
+        bool use_shorts = (mComps[c].get_bit_depth(true) <= 16);
+        mLines[c].pre_create(&mAllocator,mDims.size.x,mReversible[c],use_shorts,0,0);
+        if (res.which() == 0) // No DWT levels used
+        {
+            mEngines[c] = kdu_decoder(res.access_subband(LL_BAND),&mAllocator,use_shorts);
+        }
+        else
+        {
+            mEngines[c] = kdu_synthesis(res,&mAllocator,use_shorts);
+        }
+    }
+    mAllocator.finalize(*codestreamp); // Actually creates buffering resources
+    for (c = 0; c < mNumComponents; c++)
+    {
+        mLines[c].create(); // Grabs resources from the allocator.
+    }
 }
 
 LLKDUDecodeState::~LLKDUDecodeState()
 {
-	// Cleanup
-	for (S32 c = 0; c < mNumComponents; c++)
-	{
-		mEngines[c].destroy(); // engines are interfaces; no default destructors
-	}
-	mTile.close();
+    // Cleanup
+    for (S32 c = 0; c < mNumComponents; c++)
+    {
+        mEngines[c].destroy(); // engines are interfaces; no default destructors
+    }
+    mTile.close();
 }
 
 bool LLKDUDecodeState::processTileDecode(F32 decode_time, bool limit_time)
@@ -1336,13 +1336,13 @@ multiple tiles.  For this reason, `row_gap' is needed to identify the
 separation between consecutive rows in the real buffer. */
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
-	S32 c;
-	// Now walk through the lines of the buffer, recovering them from the
-	// relevant tile-component processing engines.
+    S32 c;
+    // Now walk through the lines of the buffer, recovering them from the
+    // relevant tile-component processing engines.
 
-	LLTimer decode_timer;
-	while (mDims.size.y--)
-	{
+    LLTimer decode_timer;
+    while (mDims.size.y--)
+    {
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("kduptc - pull");
             for (c = 0; c < mNumComponents; c++)
@@ -1351,11 +1351,11 @@ separation between consecutive rows in the real buffer. */
             }
         }
 
-		if ((mNumComponents >= 3) && mUseYCC)
-		{
+        if ((mNumComponents >= 3) && mUseYCC)
+        {
             LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("kduptc - convert");
-			kdu_convert_ycc_to_rgb(mLines[0],mLines[1],mLines[2]);
-		}
+            kdu_convert_ycc_to_rgb(mLines[0],mLines[1],mLines[2]);
+        }
 
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("kduptc - transfer");
@@ -1364,116 +1364,116 @@ separation between consecutive rows in the real buffer. */
                 transfer_bytes(mBuf + c, mLines[c], mNumComponents, mBitDepths[c]);
             }
         }
-		mBuf += mRowGap;
-		if (mDims.size.y % 10)
-		{
-			if (limit_time && decode_timer.getElapsedTimeF32() > decode_time)
-			{
-				return false;
-			}
-		}
-	}
-	return true;
+        mBuf += mRowGap;
+        if (mDims.size.y % 10)
+        {
+            if (limit_time && decode_timer.getElapsedTimeF32() > decode_time)
+            {
+                return false;
+            }
+        }
+    }
+    return true;
 }
 
-// kdc_flow_control 
+// kdc_flow_control
 
 kdc_flow_control::kdc_flow_control (kdu_supp::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);
-					if (comp->line->get_width())
-					{
-						comp->reader->get(n,*(comp->line),0);
-					}
-				}
-			}
-		}
-		if (all_done)
-		{
-			return false;
-		}
-	}
-	return true;
+    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;
 }
 
 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 fe3902380c..8037c81868 100644
--- a/indra/llkdu/llimagej2ckdu.h
+++ b/indra/llkdu/llimagej2ckdu.h
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llimagej2ckdu.h
  * @brief This is an implementation of JPEG2000 encode/decode using Kakadu
  *
  * $LicenseInfo:firstyear=2010&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -48,84 +48,84 @@ class LLKDUDecodeState;
 class LLKDUMemSource;
 
 class LLImageJ2CKDU : public LLImageJ2CImpl
-{	
+{
 public:
-	enum ECodeStreamMode 
-	{
-		MODE_FAST = 0,
-		MODE_RESILIENT = 1,
-		MODE_FUSSY = 2
-	};
-	LLImageJ2CKDU();
-	virtual ~LLImageJ2CKDU();
-	
+    enum ECodeStreamMode
+    {
+        MODE_FAST = 0,
+        MODE_RESILIENT = 1,
+        MODE_FUSSY = 2
+    };
+    LLImageJ2CKDU();
+    virtual ~LLImageJ2CKDU();
+
 protected:
-	virtual bool getMetadata(LLImageJ2C &base);
-	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, int levels = 0);
-	virtual std::string getEngineInfo() const;
+    virtual bool getMetadata(LLImageJ2C &base);
+    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, int levels = 0);
+    virtual std::string getEngineInfo() const;
 
 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();
-
-	// This method was public, but the only call to it is commented out in our
-	// own initDecode() method. I (nat 2016-08-04) don't know what it does or
-	// why. Even if it should be uncommented, it should probably still be
-	// private.
-//	void findDiscardLevelsBoundaries(LLImageJ2C &base);
-
-	// Helper class to hold a kdu_codestream, which is a handle to the
-	// underlying implementation object. When CodeStreamHolder is reset() or
-	// destroyed, it calls kdu_codestream::destroy() -- which kdu_codestream
-	// itself does not.
-	//
-	// Call through it like a smart pointer using operator->().
-	//
-	// Every RAII class must be noncopyable. For this we don't need move
-	// support.
-	class CodeStreamHolder: public boost::noncopyable
-	{
-	public:
-		~CodeStreamHolder()
-		{
-			reset();
-		}
-
-		void reset()
-		{
-			if (mCodeStream.exists())
-			{
-				mCodeStream.destroy();
-			}
-		}
-
-		// for those few times when you need a raw kdu_codestream*
-		kdu_core::kdu_codestream* get() { return &mCodeStream; }
-		kdu_core::kdu_codestream* operator->() { return &mCodeStream; }
-
-	private:
-		kdu_core::kdu_codestream mCodeStream;
-	};
-
-	// Encode variable
-	std::unique_ptr<LLKDUMemSource> mInputp;
-	CodeStreamHolder mCodeStreamp;
-	std::unique_ptr<kdu_core::kdu_coords> mTPosp; // tile position
-	std::unique_ptr<kdu_core::kdu_dims> mTileIndicesp;
-	int mBlocksSize;
-	int mPrecinctsSize;
-	int mLevels;
-
-	// Temporary variables for in-progress decodes...
-	// We don't own this LLImageRaw. We're simply pointing to an instance
-	// passed into initDecode().
-	LLImageRaw *mRawImagep;
-	std::unique_ptr<LLKDUDecodeState> mDecodeState;
+    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();
+
+    // This method was public, but the only call to it is commented out in our
+    // own initDecode() method. I (nat 2016-08-04) don't know what it does or
+    // why. Even if it should be uncommented, it should probably still be
+    // private.
+//  void findDiscardLevelsBoundaries(LLImageJ2C &base);
+
+    // Helper class to hold a kdu_codestream, which is a handle to the
+    // underlying implementation object. When CodeStreamHolder is reset() or
+    // destroyed, it calls kdu_codestream::destroy() -- which kdu_codestream
+    // itself does not.
+    //
+    // Call through it like a smart pointer using operator->().
+    //
+    // Every RAII class must be noncopyable. For this we don't need move
+    // support.
+    class CodeStreamHolder: public boost::noncopyable
+    {
+    public:
+        ~CodeStreamHolder()
+        {
+            reset();
+        }
+
+        void reset()
+        {
+            if (mCodeStream.exists())
+            {
+                mCodeStream.destroy();
+            }
+        }
+
+        // for those few times when you need a raw kdu_codestream*
+        kdu_core::kdu_codestream* get() { return &mCodeStream; }
+        kdu_core::kdu_codestream* operator->() { return &mCodeStream; }
+
+    private:
+        kdu_core::kdu_codestream mCodeStream;
+    };
+
+    // Encode variable
+    std::unique_ptr<LLKDUMemSource> mInputp;
+    CodeStreamHolder mCodeStreamp;
+    std::unique_ptr<kdu_core::kdu_coords> mTPosp; // tile position
+    std::unique_ptr<kdu_core::kdu_dims> mTileIndicesp;
+    int mBlocksSize;
+    int mPrecinctsSize;
+    int mLevels;
+
+    // Temporary variables for in-progress decodes...
+    // We don't own this LLImageRaw. We're simply pointing to an instance
+    // passed into initDecode().
+    LLImageRaw *mRawImagep;
+    std::unique_ptr<LLKDUDecodeState> mDecodeState;
 };
 
 #endif
diff --git a/indra/llkdu/llkdumem.cpp b/indra/llkdu/llkdumem.cpp
index 96e9da25d8..04ab033093 100644
--- a/indra/llkdu/llkdumem.cpp
+++ b/indra/llkdu/llkdumem.cpp
@@ -1,25 +1,25 @@
- /** 
+ /**
  * @file llkdumem.cpp
  * @brief Helper class for kdu memory management
  *
  * $LicenseInfo:firstyear=2010&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -36,164 +36,164 @@ using kd_supp_image_local::image_line_buf;
 #endif
 
 LLKDUMemIn::LLKDUMemIn(const U8 *data,
-					   const U32 size,
-					   const U16 width,
-					   const U16 height,
-					   const U8 in_num_components,
-					   siz_params *siz)
+                       const U32 size,
+                       const U16 width,
+                       const U16 height,
+                       const U8 in_num_components,
+                       siz_params *siz)
 {
-	U8 n;
-
-	first_comp_idx = 0;
-	rows = height;
-	cols = width;
-	num_components = in_num_components;
-	alignment_bytes = 0;
-
-	for (n = 0; n < 3; ++n)
-	{
-		precision[n] = 0;
-	}
-
-	for (n = 0; n < num_components; ++n)
-	{
-		siz->set(Sdims,n,0,rows);
-		siz->set(Sdims,n,1,cols);
-		siz->set(Ssigned,n,0,false);
-		siz->set(Sprecision,n,0,8);
-	}
-	incomplete_lines = NULL;
-	free_lines = NULL;
-	num_unread_rows = rows;
-
-	mData = data;
-	mDataSize = size;
-	mCurPos = 0;
+    U8 n;
+
+    first_comp_idx = 0;
+    rows = height;
+    cols = width;
+    num_components = in_num_components;
+    alignment_bytes = 0;
+
+    for (n = 0; n < 3; ++n)
+    {
+        precision[n] = 0;
+    }
+
+    for (n = 0; n < num_components; ++n)
+    {
+        siz->set(Sdims,n,0,rows);
+        siz->set(Sdims,n,1,cols);
+        siz->set(Ssigned,n,0,false);
+        siz->set(Sprecision,n,0,8);
+    }
+    incomplete_lines = NULL;
+    free_lines = NULL;
+    num_unread_rows = rows;
+
+    mData = data;
+    mDataSize = size;
+    mCurPos = 0;
 }
 
 LLKDUMemIn::~LLKDUMemIn()
 {
-	if ((num_unread_rows > 0) || (incomplete_lines != NULL))
-	{
-		kdu_warning w;
-		w << "Not all rows of image components "
-			<< first_comp_idx << " through "
-			<< first_comp_idx+num_components-1
-			<< " were consumed!";
-	}
-	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;
-	}
+    if ((num_unread_rows > 0) || (incomplete_lines != NULL))
+    {
+        kdu_warning w;
+        w << "Not all rows of image components "
+            << first_comp_idx << " through "
+            << first_comp_idx+num_components-1
+            << " were consumed!";
+    }
+    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;
+    }
 }
 
 
 bool LLKDUMemIn::get(int comp_idx, kdu_line_buf &line, int x_tnum)
 {
-	int idx = comp_idx - this->first_comp_idx;
-	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)
-	{
-		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.
-		assert(x_tnum == 0); // Must consume in very specific order.
-		if (num_unread_rows == 0)
-		{
-	        return false;
-		}
-		if ((scan = free_lines) == NULL)
-		{
-			scan = new image_line_buf(cols+3,num_components);
-		}
-		free_lines = scan->next;
-		if (prev == NULL)
-		{
-	        incomplete_lines = scan;
-		}
-		else
-		{
-			prev->next = scan;
-		}
-
-		// Copy from image buffer into scan.
-		memcpy(scan->buf, mData+mCurPos, cols*num_components);
-		mCurPos += cols*num_components;
-
-		num_unread_rows--;
-		scan->accessed_samples = 0;
-		scan->next_x_tnum = 0;
-	}
-
-	assert((cols-scan->accessed_samples) >= line.get_width());
-
-	int comp_offset = idx;
-	kdu_byte *sp = scan->buf+num_components*scan->accessed_samples + comp_offset;
-	int n=line.get_width();
-
-	if (line.get_buf32() != NULL)
-	{
-		kdu_sample32 *dp = line.get_buf32();
-		if (line.is_absolute())
-		{ // 32-bit absolute integers
-			for (; n > 0; n--, sp+=num_components, dp++)
-			{
-				dp->ival = ((kdu_int32)(*sp)) - 128;
-			}
-		}
-		else
-		{ // true 32-bit floats
-			for (; n > 0; n--, sp+=num_components, dp++)
-			{
-				dp->fval = (((float)(*sp)) / 256.0F) - 0.5F;
-			}
-		}
-	}
-	else
-	{
-		kdu_sample16 *dp = line.get_buf16();
-		if (line.is_absolute())
-		{ // 16-bit absolute integers
-			for (; n > 0; n--, sp+=num_components, dp++)
-			{
-				dp->ival = ((kdu_int16)(*sp)) - 128;
-			}
-		}
-		else
-		{ // 16-bit normalized representation.
-			for (; n > 0; n--, sp+=num_components, dp++)
-			{
-				dp->ival = (((kdu_int16)(*sp)) - 128) << (KDU_FIX_POINT-8);
-			}
-		}
-	}
-
-	scan->next_x_tnum++;
-	if (idx == (num_components-1))
-	{
-		scan->accessed_samples += line.get_width();
-	}
-	if (scan->accessed_samples == cols)
-	{ // Send empty line to free list.
-		assert(scan == incomplete_lines);
-		incomplete_lines = scan->next;
-		scan->next = free_lines;
-		free_lines = scan;
-	}
+    int idx = comp_idx - this->first_comp_idx;
+    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)
+    {
+        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.
+        assert(x_tnum == 0); // Must consume in very specific order.
+        if (num_unread_rows == 0)
+        {
+            return false;
+        }
+        if ((scan = free_lines) == NULL)
+        {
+            scan = new image_line_buf(cols+3,num_components);
+        }
+        free_lines = scan->next;
+        if (prev == NULL)
+        {
+            incomplete_lines = scan;
+        }
+        else
+        {
+            prev->next = scan;
+        }
+
+        // Copy from image buffer into scan.
+        memcpy(scan->buf, mData+mCurPos, cols*num_components);
+        mCurPos += cols*num_components;
+
+        num_unread_rows--;
+        scan->accessed_samples = 0;
+        scan->next_x_tnum = 0;
+    }
+
+    assert((cols-scan->accessed_samples) >= line.get_width());
+
+    int comp_offset = idx;
+    kdu_byte *sp = scan->buf+num_components*scan->accessed_samples + comp_offset;
+    int n=line.get_width();
+
+    if (line.get_buf32() != NULL)
+    {
+        kdu_sample32 *dp = line.get_buf32();
+        if (line.is_absolute())
+        { // 32-bit absolute integers
+            for (; n > 0; n--, sp+=num_components, dp++)
+            {
+                dp->ival = ((kdu_int32)(*sp)) - 128;
+            }
+        }
+        else
+        { // true 32-bit floats
+            for (; n > 0; n--, sp+=num_components, dp++)
+            {
+                dp->fval = (((float)(*sp)) / 256.0F) - 0.5F;
+            }
+        }
+    }
+    else
+    {
+        kdu_sample16 *dp = line.get_buf16();
+        if (line.is_absolute())
+        { // 16-bit absolute integers
+            for (; n > 0; n--, sp+=num_components, dp++)
+            {
+                dp->ival = ((kdu_int16)(*sp)) - 128;
+            }
+        }
+        else
+        { // 16-bit normalized representation.
+            for (; n > 0; n--, sp+=num_components, dp++)
+            {
+                dp->ival = (((kdu_int16)(*sp)) - 128) << (KDU_FIX_POINT-8);
+            }
+        }
+    }
+
+    scan->next_x_tnum++;
+    if (idx == (num_components-1))
+    {
+        scan->accessed_samples += line.get_width();
+    }
+    if (scan->accessed_samples == cols)
+    { // Send empty line to free list.
+        assert(scan == incomplete_lines);
+        incomplete_lines = scan->next;
+        scan->next = free_lines;
+        free_lines = scan;
+    }
 
   return true;
 }
diff --git a/indra/llkdu/llkdumem.h b/indra/llkdu/llkdumem.h
index 09d81f38de..177a8ea976 100644
--- a/indra/llkdu/llkdumem.h
+++ b/indra/llkdu/llkdumem.h
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llkdumem.h
  * @brief Helper class for kdu memory management
  *
  * $LicenseInfo:firstyear=2010&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -47,106 +47,106 @@
 class LLKDUMemSource: public kdu_core::kdu_compressed_source
 {
 public:
-	LLKDUMemSource(U8 *input_buffer, U32 size)
-	{
-		mData = input_buffer;
-		mSize = size;
-		mCurPos = 0;
-	}
-
-	~LLKDUMemSource()
-	{
-	}
-
-	int read(kdu_core::kdu_byte *buf, int num_bytes)
-	{
-		U32 num_out;
-		num_out = num_bytes;
-
-		if ((mSize - mCurPos) < (U32)num_bytes)
-		{
-			num_out = mSize -mCurPos;
-		}
-		memcpy(buf, mData + mCurPos, num_out);
-		mCurPos += num_out;
-		return num_out;
-	}
-
-	void reset()
-	{
-		mCurPos = 0;
-	}
+    LLKDUMemSource(U8 *input_buffer, U32 size)
+    {
+        mData = input_buffer;
+        mSize = size;
+        mCurPos = 0;
+    }
+
+    ~LLKDUMemSource()
+    {
+    }
+
+    int read(kdu_core::kdu_byte *buf, int num_bytes)
+    {
+        U32 num_out;
+        num_out = num_bytes;
+
+        if ((mSize - mCurPos) < (U32)num_bytes)
+        {
+            num_out = mSize -mCurPos;
+        }
+        memcpy(buf, mData + mCurPos, num_out);
+        mCurPos += num_out;
+        return num_out;
+    }
+
+    void reset()
+    {
+        mCurPos = 0;
+    }
 
 private:
-	U8 *mData;
-	U32 mSize;
-	U32 mCurPos;
+    U8 *mData;
+    U32 mSize;
+    U32 mCurPos;
 };
 
 class LLKDUMemTarget: public kdu_core::kdu_compressed_target
 {
 public:
-	LLKDUMemTarget(U8 *output_buffer, U32 &output_size, const U32 buffer_size)
-	{
-		mData = output_buffer;
-		mSize = buffer_size;
-		mCurPos = 0;
-		mOutputSize = &output_size;
-	}
-
-	~LLKDUMemTarget()
-	{
-	}
-
-	bool write(const kdu_core::kdu_byte *buf, int num_bytes)
-	{
-		U32 num_out;
-		num_out = num_bytes;
-
-		if ((mSize - mCurPos) < (U32)num_bytes)
-		{
-			num_out = mSize - mCurPos;
-			memcpy(mData + mCurPos, buf, num_out);
-			return false;
-		}
-		memcpy(mData + mCurPos, buf, num_out);
-		mCurPos += num_out;
-		*mOutputSize = mCurPos;
-		return true;
-	}
-	
+    LLKDUMemTarget(U8 *output_buffer, U32 &output_size, const U32 buffer_size)
+    {
+        mData = output_buffer;
+        mSize = buffer_size;
+        mCurPos = 0;
+        mOutputSize = &output_size;
+    }
+
+    ~LLKDUMemTarget()
+    {
+    }
+
+    bool write(const kdu_core::kdu_byte *buf, int num_bytes)
+    {
+        U32 num_out;
+        num_out = num_bytes;
+
+        if ((mSize - mCurPos) < (U32)num_bytes)
+        {
+            num_out = mSize - mCurPos;
+            memcpy(mData + mCurPos, buf, num_out);
+            return false;
+        }
+        memcpy(mData + mCurPos, buf, num_out);
+        mCurPos += num_out;
+        *mOutputSize = mCurPos;
+        return true;
+    }
+
 private:
-	U8 *mData;
-	U32 mSize;
-	U32 mCurPos;
-	U32 *mOutputSize;
+    U8 *mData;
+    U32 mSize;
+    U32 mCurPos;
+    U32 *mOutputSize;
 };
 
 class LLKDUMemIn : public kdu_supp::kdu_image_in_base
 {
 public:
-	LLKDUMemIn(const U8 *data,
-				const U32 size,
-				const U16 rows,
-				const U16 cols,
-				U8 in_num_components,
-				kdu_core::siz_params *siz);
-	~LLKDUMemIn();
+    LLKDUMemIn(const U8 *data,
+                const U32 size,
+                const U16 rows,
+                const U16 cols,
+                U8 in_num_components,
+                kdu_core::siz_params *siz);
+    ~LLKDUMemIn();
 
-	bool get(int comp_idx, kdu_core::kdu_line_buf &line, int x_tnum);
+    bool get(int comp_idx, kdu_core::kdu_line_buf &line, int x_tnum);
 
 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];
-	kd_supp_image_local::image_line_buf *incomplete_lines; // Each "sample" represents a full pixel
-	kd_supp_image_local::image_line_buf *free_lines;
-	int num_unread_rows;
-
-	U32 mCurPos;
-	U32 mDataSize;
+    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];
+    kd_supp_image_local::image_line_buf *incomplete_lines; // Each "sample" represents a full pixel
+    kd_supp_image_local::image_line_buf *free_lines;
+    int num_unread_rows;
+
+    U32 mCurPos;
+    U32 mDataSize;
 };
 #endif
diff --git a/indra/llkdu/tests/llimagej2ckdu_test.cpp b/indra/llkdu/tests/llimagej2ckdu_test.cpp
index 16213b7f45..db81d60d9e 100644
--- a/indra/llkdu/tests/llimagej2ckdu_test.cpp
+++ b/indra/llkdu/tests/llimagej2ckdu_test.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llimagej2ckdu_test.cpp
  * @author Merov Linden
  * @date 2010-12-17
@@ -6,27 +6,27 @@
  * $LicenseInfo:firstyear=2006&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
 
 #include "linden_common.h"
-// Class to test 
+// Class to test
 #include "llimagej2ckdu.h"
 
 #if __clang__
@@ -44,7 +44,7 @@
 
 // -------------------------------------------------------------------------------------------
 // Stubbing: Declarations required to link and run the class being tested
-// Notes: 
+// Notes:
 // * Add here stubbed implementation of the few classes and methods used in the class to be tested
 // * Add as little as possible (let the link errors guide you)
 // * Do not make any assumption as to how those classes or methods work (i.e. don't copy/paste code)
@@ -53,7 +53,7 @@
 // End Stubbing
 // -------------------------------------------------------------------------------------------
 // Stub the LL Image Classes
-//LLTrace::MemStatHandle	LLImageBase::sMemStat("LLImage");
+//LLTrace::MemStatHandle    LLImageBase::sMemStat("LLImage");
 
 LLImageRaw::LLImageRaw() { }
 LLImageRaw::~LLImageRaw() { }
@@ -241,81 +241,81 @@ void kdu_params::operator delete(void *) {}
 
 namespace tut
 {
-	// Test wrapper declarations
-	struct llimagej2ckdu_test
-	{
-		// Derived test class
-		class LLTestImageJ2CKDU : public LLImageJ2CKDU
-		{
-		public:
-			// Provides public access to some protected methods for testing
-			bool callGetMetadata(LLImageJ2C &base) { return getMetadata(base); }
-			bool callDecodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count)
-			{
-				return decodeImpl(base, raw_image, decode_time, first_channel, max_channel_count);
-			}
-			bool callEncodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text)
-			{
-				return encodeImpl(base, raw_image, comment_text);
-			}
-		};
-		// Instance to be tested
-		LLTestImageJ2CKDU* mImage;
-		
-		// Constructor and destructor of the test wrapper
-		llimagej2ckdu_test()
-		{
-			mImage = new LLTestImageJ2CKDU;
-		}
-		~llimagej2ckdu_test()
-		{
-			delete mImage;
-		}
-	};
-	
-	// Tut templating thingamagic: test group, object and test instance
-	typedef test_group<llimagej2ckdu_test> llimagej2ckdu_t;
-	typedef llimagej2ckdu_t::object llimagej2ckdu_object_t;
-	tut::llimagej2ckdu_t tut_llimagej2ckdu("LLImageJ2CKDU");
-	
-	// ---------------------------------------------------------------------------------------
-	// Test functions
-	// Notes:
-	// * Test as many as you possibly can without requiring a full blown simulation of everything
-	// * The tests are executed in sequence so the test instance state may change between calls
-	// * Remember that you cannot test private methods with tut
-	// ---------------------------------------------------------------------------------------
+    // Test wrapper declarations
+    struct llimagej2ckdu_test
+    {
+        // Derived test class
+        class LLTestImageJ2CKDU : public LLImageJ2CKDU
+        {
+        public:
+            // Provides public access to some protected methods for testing
+            bool callGetMetadata(LLImageJ2C &base) { return getMetadata(base); }
+            bool callDecodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count)
+            {
+                return decodeImpl(base, raw_image, decode_time, first_channel, max_channel_count);
+            }
+            bool callEncodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text)
+            {
+                return encodeImpl(base, raw_image, comment_text);
+            }
+        };
+        // Instance to be tested
+        LLTestImageJ2CKDU* mImage;
+
+        // Constructor and destructor of the test wrapper
+        llimagej2ckdu_test()
+        {
+            mImage = new LLTestImageJ2CKDU;
+        }
+        ~llimagej2ckdu_test()
+        {
+            delete mImage;
+        }
+    };
+
+    // Tut templating thingamagic: test group, object and test instance
+    typedef test_group<llimagej2ckdu_test> llimagej2ckdu_t;
+    typedef llimagej2ckdu_t::object llimagej2ckdu_object_t;
+    tut::llimagej2ckdu_t tut_llimagej2ckdu("LLImageJ2CKDU");
+
+    // ---------------------------------------------------------------------------------------
+    // Test functions
+    // Notes:
+    // * Test as many as you possibly can without requiring a full blown simulation of everything
+    // * The tests are executed in sequence so the test instance state may change between calls
+    // * Remember that you cannot test private methods with tut
+    // ---------------------------------------------------------------------------------------
 
-	// Test 1 : test getMetadata()
-	template<> template<>
-	void llimagej2ckdu_object_t::test<1>()
-	{
-		LLImageJ2C* image = new LLImageJ2C();
-		bool res = mImage->callGetMetadata(*image);
-		// Trying to set up a data stream with all NIL values and stubbed KDU will "work" and return true
-		// Note that is linking with KDU, that call will throw an exception and fail, returning false
-		ensure("getMetadata() test failed", res);
-	}
+    // Test 1 : test getMetadata()
+    template<> template<>
+    void llimagej2ckdu_object_t::test<1>()
+    {
+        LLImageJ2C* image = new LLImageJ2C();
+        bool res = mImage->callGetMetadata(*image);
+        // Trying to set up a data stream with all NIL values and stubbed KDU will "work" and return true
+        // Note that is linking with KDU, that call will throw an exception and fail, returning false
+        ensure("getMetadata() test failed", res);
+    }
 
-	// Test 2 : test decodeImpl()
-	template<> template<>
-	void llimagej2ckdu_object_t::test<2>()
-	{
-		LLImageJ2C* image = new LLImageJ2C();
-		LLImageRaw* raw = new LLImageRaw();
-		bool res = mImage->callDecodeImpl(*image, *raw, 0.0, 0, 0);
-		// Decoding returns true whenever there's nothing else to do, including if decoding failed, so we'll get true here
-		ensure("decodeImpl() test failed", res);
-	}
+    // Test 2 : test decodeImpl()
+    template<> template<>
+    void llimagej2ckdu_object_t::test<2>()
+    {
+        LLImageJ2C* image = new LLImageJ2C();
+        LLImageRaw* raw = new LLImageRaw();
+        bool res = mImage->callDecodeImpl(*image, *raw, 0.0, 0, 0);
+        // Decoding returns true whenever there's nothing else to do, including if decoding failed, so we'll get true here
+        ensure("decodeImpl() test failed", res);
+    }
 
-	// Test 3 : test encodeImpl()
-	template<> template<>
-	void llimagej2ckdu_object_t::test<3>()
-	{
-		LLImageJ2C* image = new LLImageJ2C();
-		LLImageRaw* raw = new LLImageRaw();
-		bool res = mImage->callEncodeImpl(*image, *raw, NULL);
-		// Encoding returns true unless an exception was raised, so we'll get true here though nothing really was done
-		ensure("encodeImpl() test failed", res);
-	}
+    // Test 3 : test encodeImpl()
+    template<> template<>
+    void llimagej2ckdu_object_t::test<3>()
+    {
+        LLImageJ2C* image = new LLImageJ2C();
+        LLImageRaw* raw = new LLImageRaw();
+        bool res = mImage->callEncodeImpl(*image, *raw, NULL);
+        // Encoding returns true unless an exception was raised, so we'll get true here though nothing really was done
+        ensure("encodeImpl() test failed", res);
+    }
 }