summaryrefslogtreecommitdiff
path: root/indra/llimage/llimagej2c.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llimage/llimagej2c.cpp')
-rw-r--r--indra/llimage/llimagej2c.cpp1186
1 files changed, 593 insertions, 593 deletions
diff --git a/indra/llimage/llimagej2c.cpp b/indra/llimage/llimagej2c.cpp
index 382da40dcf..9593c6b972 100644
--- a/indra/llimage/llimagej2c.cpp
+++ b/indra/llimage/llimagej2c.cpp
@@ -1,593 +1,593 @@
-/**
- * @file llimagej2c.cpp
- *
- * $LicenseInfo:firstyear=2001&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"
-
-#include "llapr.h"
-#include "lldir.h"
-#include "llimagej2c.h"
-#include "lltimer.h"
-#include "llmath.h"
-#include "llmemory.h"
-#include "llsd.h"
-#include <boost/scoped_ptr.hpp>
-
-// Declare the prototype for this factory function here. It is implemented in
-// other files which define a LLImageJ2CImpl subclass, but only ONE static
-// library which has the implementation for this function should ever be
-// linked.
-LLImageJ2CImpl* fallbackCreateLLImageJ2CImpl();
-
-// Test data gathering handle
-LLImageCompressionTester* LLImageJ2C::sTesterp = NULL ;
-const std::string sTesterName("ImageCompressionTester");
-
-//static
-std::string LLImageJ2C::getEngineInfo()
-{
- // All known LLImageJ2CImpl implementation subclasses are cheap to
- // construct.
- std::unique_ptr<LLImageJ2CImpl> impl(fallbackCreateLLImageJ2CImpl());
- return impl->getEngineInfo();
-}
-
-LLImageJ2C::LLImageJ2C() : LLImageFormatted(IMG_CODEC_J2C),
- mMaxBytes(0),
- mRawDiscardLevel(-1),
- mRate(DEFAULT_COMPRESSION_RATE),
- mReversible(false),
- mAreaUsedForDataSizeCalcs(0)
-{
- mImpl.reset(fallbackCreateLLImageJ2CImpl());
-
- // Clear data size table
- for( S32 i = 0; i <= MAX_DISCARD_LEVEL; i++)
- { // Array size is MAX_DISCARD_LEVEL+1
- mDataSizes[i] = 0;
- }
-
- // If that test log has ben requested but not yet created, create it
- if (LLMetricPerformanceTesterBasic::isMetricLogRequested(sTesterName) && !LLMetricPerformanceTesterBasic::getTester(sTesterName))
- {
- sTesterp = new LLImageCompressionTester() ;
- if (!sTesterp->isValid())
- {
- delete sTesterp;
- sTesterp = NULL;
- }
- }
-}
-
-// virtual
-LLImageJ2C::~LLImageJ2C() {}
-
-// virtual
-void LLImageJ2C::resetLastError()
-{
- mLastError.clear();
-}
-
-//virtual
-void LLImageJ2C::setLastError(const std::string& message, const std::string& filename)
-{
- mLastError = message;
- if (!filename.empty())
- mLastError += std::string(" FILE: ") + filename;
-}
-
-// virtual
-S8 LLImageJ2C::getRawDiscardLevel()
-{
- return mRawDiscardLevel;
-}
-
-bool LLImageJ2C::updateData()
-{
- bool res = true;
- resetLastError();
-
- LLImageDataLock lock(this);
-
- // Check to make sure that this instance has been initialized with data
- if (!getData() || (getDataSize() < 16))
- {
- setLastError("LLImageJ2C uninitialized");
- res = false;
- }
- else
- {
- res = mImpl->getMetadata(*this);
- }
-
- if (res)
- {
- // SJB: override discard based on mMaxBytes elsewhere
- S32 max_bytes = getDataSize(); // mMaxBytes ? mMaxBytes : getDataSize();
- S32 discard = calcDiscardLevelBytes(max_bytes);
- setDiscardLevel(discard);
- }
-
- if (!mLastError.empty())
- {
- LLImage::setLastError(mLastError);
- }
- return res;
-}
-
-bool LLImageJ2C::initDecode(LLImageRaw &raw_image, int discard_level, int* region)
-{
- setDiscardLevel(discard_level != -1 ? discard_level : 0);
- return mImpl->initDecode(*this,raw_image,discard_level,region);
-}
-
-bool LLImageJ2C::initEncode(LLImageRaw &raw_image, int blocks_size, int precincts_size, int levels)
-{
- return mImpl->initEncode(*this,raw_image,blocks_size,precincts_size,levels);
-}
-
-bool LLImageJ2C::decode(LLImageRaw *raw_imagep, F32 decode_time)
-{
- LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
- return decodeChannels(raw_imagep, decode_time, 0, 4);
-}
-
-
-// Returns true to mean done, whether successful or not.
-bool LLImageJ2C::decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 first_channel, S32 max_channel_count )
-{
- LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
- LLTimer elapsed;
-
- resetLastError();
-
- bool res;
- {
- LLImageDataLock lock(this);
-
- mDecoding = true;
- // Check to make sure that this instance has been initialized with data
- if (!getData() || (getDataSize() < 16))
- {
- setLastError("LLImageJ2C uninitialized");
- res = true; // done
- }
- else
- {
- // Update the raw discard level
- updateRawDiscardLevel();
- res = mImpl->decodeImpl(*this, *raw_imagep, decode_time, first_channel, max_channel_count);
- }
- }
-
- if (res)
- {
- if (!mDecoding)
- {
- // Failed
- raw_imagep->deleteData();
- res = false;
- }
- else
- {
- mDecoding = false;
- }
- }
- else
- {
- if (mDecoding)
- {
- LL_WARNS() << "decodeImpl failed but mDecoding is true" << LL_ENDL;
- mDecoding = false;
- }
- }
-
- if (!mLastError.empty())
- {
- LLImage::setLastError(mLastError);
- }
-
- LLImageCompressionTester* tester = (LLImageCompressionTester*)LLMetricPerformanceTesterBasic::getTester(sTesterName);
- if (tester)
- {
- // Decompression stat gathering
- // Note that we *do not* take into account the decompression failures data so we might overestimate the time spent processing
-
- // Always add the decompression time to the stat
- tester->updateDecompressionStats(elapsed.getElapsedTimeF32()) ;
- if (res)
- {
- // The whole data stream is finally decompressed when res is returned as true
- tester->updateDecompressionStats(this->getDataSize(), raw_imagep->getDataSize()) ;
- }
- }
-
- return res;
-}
-
-
-bool LLImageJ2C::encode(const LLImageRaw *raw_imagep, F32 encode_time)
-{
- return encode(raw_imagep, NULL, encode_time);
-}
-
-
-bool LLImageJ2C::encode(const LLImageRaw *raw_imagep, const char* comment_text, F32 encode_time)
-{
- LLTimer elapsed;
- resetLastError();
- bool res = mImpl->encodeImpl(*this, *raw_imagep, comment_text, encode_time, mReversible);
- if (!mLastError.empty())
- {
- LLImage::setLastError(mLastError);
- }
-
- LLImageCompressionTester* tester = (LLImageCompressionTester*)LLMetricPerformanceTesterBasic::getTester(sTesterName);
- if (tester)
- {
- // Compression stat gathering
- // Note that we *do not* take into account the compression failures cases so we night overestimate the time spent processing
-
- // Always add the compression time to the stat
- tester->updateCompressionStats(elapsed.getElapsedTimeF32()) ;
- if (res)
- {
- // The whole data stream is finally compressed when res is returned as true
- tester->updateCompressionStats(this->getDataSize(), raw_imagep->getDataSize()) ;
- }
- }
-
- return res;
-}
-
-//static
-S32 LLImageJ2C::calcHeaderSizeJ2C()
-{
- return FIRST_PACKET_SIZE; // Hack. just needs to be >= actual header size...
-}
-
-//static
-S32 LLImageJ2C::calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, F32 rate)
-{
- // Note: This provides an estimation for the first to last quality layer of a given discard level
- // This is however an efficient approximation, as the true discard level boundary would be
- // in general too big for fast fetching.
- // For details about the equation used here, see https://wiki.lindenlab.com/wiki/THX1138_KDU_Improvements#Byte_Range_Study
-
- // Estimate the number of layers. This is consistent with what's done for j2c encoding in LLImageJ2CKDU::encodeImpl().
- S32 nb_layers = 1;
- S32 surface = w*h;
- S32 s = 64*64;
- while (surface > s)
- {
- nb_layers++;
- s *= 4;
- }
- F32 layer_factor = 3.0f * (7 - llclamp(nb_layers,1,6));
-
- // Compute w/pow(2,discard_level) and h/pow(2,discard_level)
- w >>= discard_level;
- h >>= discard_level;
- w = llmax(w, 1);
- h = llmax(h, 1);
-
- // Temporary: compute both new and old range and pick one according to the settings TextureNewByteRange
- // *TODO: Take the old code out once we have enough tests done
- S32 bytes;
- S32 new_bytes = (S32) (sqrt((F32)(w*h))*(F32)(comp)*rate*1000.f/layer_factor);
- S32 old_bytes = (S32)((F32)(w*h*comp)*rate);
- bytes = (LLImage::useNewByteRange() && (new_bytes < old_bytes) ? new_bytes : old_bytes);
- bytes = llmax(bytes, calcHeaderSizeJ2C());
- return bytes;
-}
-
-S32 LLImageJ2C::calcHeaderSize()
-{
- return calcHeaderSizeJ2C();
-}
-
-// calcDataSize() returns how many bytes to read to load discard_level (including header)
-S32 LLImageJ2C::calcDataSize(S32 discard_level)
-{
- discard_level = llclamp(discard_level, 0, MAX_DISCARD_LEVEL);
- if ( mAreaUsedForDataSizeCalcs != (getHeight() * getWidth())
- || (mDataSizes[0] == 0))
- {
- mAreaUsedForDataSizeCalcs = getHeight() * getWidth();
-
- S32 level = MAX_DISCARD_LEVEL; // Start at the highest discard
- while ( level >= 0 )
- {
- mDataSizes[level] = calcDataSizeJ2C(getWidth(), getHeight(), getComponents(), level, mRate);
- level--;
- }
- }
- return mDataSizes[discard_level];
-}
-
-S32 LLImageJ2C::calcDiscardLevelBytes(S32 bytes)
-{
- llassert(bytes >= 0);
- S32 discard_level = 0;
- if (bytes == 0)
- {
- return MAX_DISCARD_LEVEL;
- }
- while (1)
- {
- S32 bytes_needed = calcDataSize(discard_level);
- // Use TextureReverseByteRange percent (see settings.xml) of the optimal size to qualify as correct rendering for the given discard level
- if (bytes >= (bytes_needed*LLImage::getReverseByteRangePercent()/100))
- {
- break;
- }
- discard_level++;
- if (discard_level >= MAX_DISCARD_LEVEL)
- {
- break;
- }
- }
- return discard_level;
-}
-
-void LLImageJ2C::setMaxBytes(S32 max_bytes)
-{
- mMaxBytes = max_bytes;
-}
-
-void LLImageJ2C::setReversible(const bool reversible)
-{
- mReversible = reversible;
-}
-
-
-bool LLImageJ2C::loadAndValidate(const std::string &filename)
-{
- bool res = true;
-
- resetLastError();
-
- S32 file_size = 0;
- LLAPRFile infile ;
- infile.open(filename, LL_APR_RB, NULL, &file_size);
- apr_file_t* apr_file = infile.getFileHandle() ;
- if (!apr_file)
- {
- setLastError("Unable to open file for reading", filename);
- res = false;
- }
- else if (file_size == 0)
- {
- setLastError("File is empty",filename);
- res = false;
- }
- else
- {
- U8 *data = (U8*)ll_aligned_malloc_16(file_size);
- if (!data)
- {
- infile.close();
- setLastError("Out of memory", filename);
- res = false;
- }
- else
- {
- apr_size_t bytes_read = file_size;
- apr_status_t s = apr_file_read(apr_file, data, &bytes_read); // modifies bytes_read
- infile.close();
-
- if (s != APR_SUCCESS || (S32)bytes_read != file_size)
- {
- ll_aligned_free_16(data);
- setLastError("Unable to read entire file");
- res = false;
- }
- else
- {
- res = validate(data, file_size);
- }
- }
- }
-
- if (!mLastError.empty())
- {
- LLImage::setLastError(mLastError);
- }
-
- return res;
-}
-
-
-bool LLImageJ2C::validate(U8 *data, U32 file_size)
-{
- resetLastError();
-
- LLImageDataLock lock(this);
-
- setData(data, file_size);
-
- bool res = updateData();
- if ( res )
- {
- // Check to make sure that this instance has been initialized with data
- if (!getData() || (0 == getDataSize()))
- {
- setLastError("LLImageJ2C uninitialized");
- res = false;
- }
- else
- {
- res = mImpl->getMetadata(*this);
- }
- }
-
- if (!mLastError.empty())
- {
- LLImage::setLastError(mLastError);
- }
- return res;
-}
-
-void LLImageJ2C::decodeFailed()
-{
- mDecoding = false;
-}
-
-void LLImageJ2C::updateRawDiscardLevel()
-{
- mRawDiscardLevel = mMaxBytes ? calcDiscardLevelBytes(mMaxBytes) : mDiscardLevel;
-}
-
-LLImageJ2CImpl::~LLImageJ2CImpl()
-{
-}
-
-//----------------------------------------------------------------------------------------------
-// Start of LLImageCompressionTester
-//----------------------------------------------------------------------------------------------
-LLImageCompressionTester::LLImageCompressionTester() : LLMetricPerformanceTesterBasic(sTesterName)
-{
- addMetric("Time Decompression (s)");
- addMetric("Volume In Decompression (kB)");
- addMetric("Volume Out Decompression (kB)");
- addMetric("Decompression Ratio (x:1)");
- addMetric("Perf Decompression (kB/s)");
-
- addMetric("Time Compression (s)");
- addMetric("Volume In Compression (kB)");
- addMetric("Volume Out Compression (kB)");
- addMetric("Compression Ratio (x:1)");
- addMetric("Perf Compression (kB/s)");
-
- mRunBytesInDecompression = 0;
- mRunBytesOutDecompression = 0;
- mRunBytesInCompression = 0;
-
- mTotalBytesInDecompression = 0;
- mTotalBytesOutDecompression = 0;
- mTotalBytesInCompression = 0;
- mTotalBytesOutCompression = 0;
-
- mTotalTimeDecompression = 0.0f;
- mTotalTimeCompression = 0.0f;
- mRunTimeDecompression = 0.0f;
-}
-
-LLImageCompressionTester::~LLImageCompressionTester()
-{
- outputTestResults();
- LLImageJ2C::sTesterp = NULL;
-}
-
-//virtual
-void LLImageCompressionTester::outputTestRecord(LLSD *sd)
-{
- std::string currentLabel = getCurrentLabelName();
-
- F32 decompressionPerf = 0.0f;
- F32 compressionPerf = 0.0f;
- F32 decompressionRate = 0.0f;
- F32 compressionRate = 0.0f;
-
- F32 totalkBInDecompression = (F32)(mTotalBytesInDecompression) / 1000.f;
- F32 totalkBOutDecompression = (F32)(mTotalBytesOutDecompression) / 1000.f;
- F32 totalkBInCompression = (F32)(mTotalBytesInCompression) / 1000.f;
- F32 totalkBOutCompression = (F32)(mTotalBytesOutCompression) / 1000.f;
-
- if (!is_approx_zero(mTotalTimeDecompression))
- {
- decompressionPerf = totalkBInDecompression / mTotalTimeDecompression;
- }
- if (!is_approx_zero(totalkBInDecompression))
- {
- decompressionRate = totalkBOutDecompression / totalkBInDecompression;
- }
- if (!is_approx_zero(mTotalTimeCompression))
- {
- compressionPerf = totalkBInCompression / mTotalTimeCompression;
- }
- if (!is_approx_zero(totalkBOutCompression))
- {
- compressionRate = totalkBInCompression / totalkBOutCompression;
- }
-
- (*sd)[currentLabel]["Time Decompression (s)"] = (LLSD::Real)mTotalTimeDecompression;
- (*sd)[currentLabel]["Volume In Decompression (kB)"] = (LLSD::Real)totalkBInDecompression;
- (*sd)[currentLabel]["Volume Out Decompression (kB)"]= (LLSD::Real)totalkBOutDecompression;
- (*sd)[currentLabel]["Decompression Ratio (x:1)"] = (LLSD::Real)decompressionRate;
- (*sd)[currentLabel]["Perf Decompression (kB/s)"] = (LLSD::Real)decompressionPerf;
-
- (*sd)[currentLabel]["Time Compression (s)"] = (LLSD::Real)mTotalTimeCompression;
- (*sd)[currentLabel]["Volume In Compression (kB)"] = (LLSD::Real)totalkBInCompression;
- (*sd)[currentLabel]["Volume Out Compression (kB)"] = (LLSD::Real)totalkBOutCompression;
- (*sd)[currentLabel]["Compression Ratio (x:1)"] = (LLSD::Real)compressionRate;
- (*sd)[currentLabel]["Perf Compression (kB/s)"] = (LLSD::Real)compressionPerf;
-}
-
-void LLImageCompressionTester::updateCompressionStats(const F32 deltaTime)
-{
- mTotalTimeCompression += deltaTime;
-}
-
-void LLImageCompressionTester::updateCompressionStats(const S32 bytesCompress, const S32 bytesRaw)
-{
- mTotalBytesInCompression += bytesRaw;
- mRunBytesInCompression += bytesRaw;
- mTotalBytesOutCompression += bytesCompress;
- if (mRunBytesInCompression > (1000000))
- {
- // Output everything
- outputTestResults();
- // Reset the compression data of the run
- mRunBytesInCompression = 0;
- }
-}
-
-void LLImageCompressionTester::updateDecompressionStats(const F32 deltaTime)
-{
- mTotalTimeDecompression += deltaTime;
-}
-
-void LLImageCompressionTester::updateDecompressionStats(const S32 bytesIn, const S32 bytesOut)
-{
- mTotalBytesInDecompression += bytesIn;
- mRunBytesInDecompression += bytesIn;
- mTotalBytesOutDecompression += bytesOut;
- mRunBytesOutDecompression += bytesOut;
- //if (mRunBytesInDecompression > (1000000))
- if (mRunBytesOutDecompression > (10000000))
- //if ((mTotalTimeDecompression - mRunTimeDecompression) >= (5.0f))
- {
- // Output everything
- outputTestResults();
- // Reset the decompression data of the run
- mRunBytesInDecompression = 0;
- mRunBytesOutDecompression = 0;
- mRunTimeDecompression = mTotalTimeDecompression;
- }
-}
-
-//----------------------------------------------------------------------------------------------
-// End of LLTexturePipelineTester
-//----------------------------------------------------------------------------------------------
-
+/**
+ * @file llimagej2c.cpp
+ *
+ * $LicenseInfo:firstyear=2001&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"
+
+#include "llapr.h"
+#include "lldir.h"
+#include "llimagej2c.h"
+#include "lltimer.h"
+#include "llmath.h"
+#include "llmemory.h"
+#include "llsd.h"
+#include <boost/scoped_ptr.hpp>
+
+// Declare the prototype for this factory function here. It is implemented in
+// other files which define a LLImageJ2CImpl subclass, but only ONE static
+// library which has the implementation for this function should ever be
+// linked.
+LLImageJ2CImpl* fallbackCreateLLImageJ2CImpl();
+
+// Test data gathering handle
+LLImageCompressionTester* LLImageJ2C::sTesterp = NULL ;
+const std::string sTesterName("ImageCompressionTester");
+
+//static
+std::string LLImageJ2C::getEngineInfo()
+{
+ // All known LLImageJ2CImpl implementation subclasses are cheap to
+ // construct.
+ std::unique_ptr<LLImageJ2CImpl> impl(fallbackCreateLLImageJ2CImpl());
+ return impl->getEngineInfo();
+}
+
+LLImageJ2C::LLImageJ2C() : LLImageFormatted(IMG_CODEC_J2C),
+ mMaxBytes(0),
+ mRawDiscardLevel(-1),
+ mRate(DEFAULT_COMPRESSION_RATE),
+ mReversible(false),
+ mAreaUsedForDataSizeCalcs(0)
+{
+ mImpl.reset(fallbackCreateLLImageJ2CImpl());
+
+ // Clear data size table
+ for( S32 i = 0; i <= MAX_DISCARD_LEVEL; i++)
+ { // Array size is MAX_DISCARD_LEVEL+1
+ mDataSizes[i] = 0;
+ }
+
+ // If that test log has ben requested but not yet created, create it
+ if (LLMetricPerformanceTesterBasic::isMetricLogRequested(sTesterName) && !LLMetricPerformanceTesterBasic::getTester(sTesterName))
+ {
+ sTesterp = new LLImageCompressionTester() ;
+ if (!sTesterp->isValid())
+ {
+ delete sTesterp;
+ sTesterp = NULL;
+ }
+ }
+}
+
+// virtual
+LLImageJ2C::~LLImageJ2C() {}
+
+// virtual
+void LLImageJ2C::resetLastError()
+{
+ mLastError.clear();
+}
+
+//virtual
+void LLImageJ2C::setLastError(const std::string& message, const std::string& filename)
+{
+ mLastError = message;
+ if (!filename.empty())
+ mLastError += std::string(" FILE: ") + filename;
+}
+
+// virtual
+S8 LLImageJ2C::getRawDiscardLevel()
+{
+ return mRawDiscardLevel;
+}
+
+bool LLImageJ2C::updateData()
+{
+ bool res = true;
+ resetLastError();
+
+ LLImageDataLock lock(this);
+
+ // Check to make sure that this instance has been initialized with data
+ if (!getData() || (getDataSize() < 16))
+ {
+ setLastError("LLImageJ2C uninitialized");
+ res = false;
+ }
+ else
+ {
+ res = mImpl->getMetadata(*this);
+ }
+
+ if (res)
+ {
+ // SJB: override discard based on mMaxBytes elsewhere
+ S32 max_bytes = getDataSize(); // mMaxBytes ? mMaxBytes : getDataSize();
+ S32 discard = calcDiscardLevelBytes(max_bytes);
+ setDiscardLevel(discard);
+ }
+
+ if (!mLastError.empty())
+ {
+ LLImage::setLastError(mLastError);
+ }
+ return res;
+}
+
+bool LLImageJ2C::initDecode(LLImageRaw &raw_image, int discard_level, int* region)
+{
+ setDiscardLevel(discard_level != -1 ? discard_level : 0);
+ return mImpl->initDecode(*this,raw_image,discard_level,region);
+}
+
+bool LLImageJ2C::initEncode(LLImageRaw &raw_image, int blocks_size, int precincts_size, int levels)
+{
+ return mImpl->initEncode(*this,raw_image,blocks_size,precincts_size,levels);
+}
+
+bool LLImageJ2C::decode(LLImageRaw *raw_imagep, F32 decode_time)
+{
+ LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
+ return decodeChannels(raw_imagep, decode_time, 0, 4);
+}
+
+
+// Returns true to mean done, whether successful or not.
+bool LLImageJ2C::decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 first_channel, S32 max_channel_count )
+{
+ LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
+ LLTimer elapsed;
+
+ resetLastError();
+
+ bool res;
+ {
+ LLImageDataLock lock(this);
+
+ mDecoding = true;
+ // Check to make sure that this instance has been initialized with data
+ if (!getData() || (getDataSize() < 16))
+ {
+ setLastError("LLImageJ2C uninitialized");
+ res = true; // done
+ }
+ else
+ {
+ // Update the raw discard level
+ updateRawDiscardLevel();
+ res = mImpl->decodeImpl(*this, *raw_imagep, decode_time, first_channel, max_channel_count);
+ }
+ }
+
+ if (res)
+ {
+ if (!mDecoding)
+ {
+ // Failed
+ raw_imagep->deleteData();
+ res = false;
+ }
+ else
+ {
+ mDecoding = false;
+ }
+ }
+ else
+ {
+ if (mDecoding)
+ {
+ LL_WARNS() << "decodeImpl failed but mDecoding is true" << LL_ENDL;
+ mDecoding = false;
+ }
+ }
+
+ if (!mLastError.empty())
+ {
+ LLImage::setLastError(mLastError);
+ }
+
+ LLImageCompressionTester* tester = (LLImageCompressionTester*)LLMetricPerformanceTesterBasic::getTester(sTesterName);
+ if (tester)
+ {
+ // Decompression stat gathering
+ // Note that we *do not* take into account the decompression failures data so we might overestimate the time spent processing
+
+ // Always add the decompression time to the stat
+ tester->updateDecompressionStats(elapsed.getElapsedTimeF32()) ;
+ if (res)
+ {
+ // The whole data stream is finally decompressed when res is returned as true
+ tester->updateDecompressionStats(this->getDataSize(), raw_imagep->getDataSize()) ;
+ }
+ }
+
+ return res;
+}
+
+
+bool LLImageJ2C::encode(const LLImageRaw *raw_imagep, F32 encode_time)
+{
+ return encode(raw_imagep, NULL, encode_time);
+}
+
+
+bool LLImageJ2C::encode(const LLImageRaw *raw_imagep, const char* comment_text, F32 encode_time)
+{
+ LLTimer elapsed;
+ resetLastError();
+ bool res = mImpl->encodeImpl(*this, *raw_imagep, comment_text, encode_time, mReversible);
+ if (!mLastError.empty())
+ {
+ LLImage::setLastError(mLastError);
+ }
+
+ LLImageCompressionTester* tester = (LLImageCompressionTester*)LLMetricPerformanceTesterBasic::getTester(sTesterName);
+ if (tester)
+ {
+ // Compression stat gathering
+ // Note that we *do not* take into account the compression failures cases so we night overestimate the time spent processing
+
+ // Always add the compression time to the stat
+ tester->updateCompressionStats(elapsed.getElapsedTimeF32()) ;
+ if (res)
+ {
+ // The whole data stream is finally compressed when res is returned as true
+ tester->updateCompressionStats(this->getDataSize(), raw_imagep->getDataSize()) ;
+ }
+ }
+
+ return res;
+}
+
+//static
+S32 LLImageJ2C::calcHeaderSizeJ2C()
+{
+ return FIRST_PACKET_SIZE; // Hack. just needs to be >= actual header size...
+}
+
+//static
+S32 LLImageJ2C::calcDataSizeJ2C(S32 w, S32 h, S32 comp, S32 discard_level, F32 rate)
+{
+ // Note: This provides an estimation for the first to last quality layer of a given discard level
+ // This is however an efficient approximation, as the true discard level boundary would be
+ // in general too big for fast fetching.
+ // For details about the equation used here, see https://wiki.lindenlab.com/wiki/THX1138_KDU_Improvements#Byte_Range_Study
+
+ // Estimate the number of layers. This is consistent with what's done for j2c encoding in LLImageJ2CKDU::encodeImpl().
+ S32 nb_layers = 1;
+ S32 surface = w*h;
+ S32 s = 64*64;
+ while (surface > s)
+ {
+ nb_layers++;
+ s *= 4;
+ }
+ F32 layer_factor = 3.0f * (7 - llclamp(nb_layers,1,6));
+
+ // Compute w/pow(2,discard_level) and h/pow(2,discard_level)
+ w >>= discard_level;
+ h >>= discard_level;
+ w = llmax(w, 1);
+ h = llmax(h, 1);
+
+ // Temporary: compute both new and old range and pick one according to the settings TextureNewByteRange
+ // *TODO: Take the old code out once we have enough tests done
+ S32 bytes;
+ S32 new_bytes = (S32) (sqrt((F32)(w*h))*(F32)(comp)*rate*1000.f/layer_factor);
+ S32 old_bytes = (S32)((F32)(w*h*comp)*rate);
+ bytes = (LLImage::useNewByteRange() && (new_bytes < old_bytes) ? new_bytes : old_bytes);
+ bytes = llmax(bytes, calcHeaderSizeJ2C());
+ return bytes;
+}
+
+S32 LLImageJ2C::calcHeaderSize()
+{
+ return calcHeaderSizeJ2C();
+}
+
+// calcDataSize() returns how many bytes to read to load discard_level (including header)
+S32 LLImageJ2C::calcDataSize(S32 discard_level)
+{
+ discard_level = llclamp(discard_level, 0, MAX_DISCARD_LEVEL);
+ if ( mAreaUsedForDataSizeCalcs != (getHeight() * getWidth())
+ || (mDataSizes[0] == 0))
+ {
+ mAreaUsedForDataSizeCalcs = getHeight() * getWidth();
+
+ S32 level = MAX_DISCARD_LEVEL; // Start at the highest discard
+ while ( level >= 0 )
+ {
+ mDataSizes[level] = calcDataSizeJ2C(getWidth(), getHeight(), getComponents(), level, mRate);
+ level--;
+ }
+ }
+ return mDataSizes[discard_level];
+}
+
+S32 LLImageJ2C::calcDiscardLevelBytes(S32 bytes)
+{
+ llassert(bytes >= 0);
+ S32 discard_level = 0;
+ if (bytes == 0)
+ {
+ return MAX_DISCARD_LEVEL;
+ }
+ while (1)
+ {
+ S32 bytes_needed = calcDataSize(discard_level);
+ // Use TextureReverseByteRange percent (see settings.xml) of the optimal size to qualify as correct rendering for the given discard level
+ if (bytes >= (bytes_needed*LLImage::getReverseByteRangePercent()/100))
+ {
+ break;
+ }
+ discard_level++;
+ if (discard_level >= MAX_DISCARD_LEVEL)
+ {
+ break;
+ }
+ }
+ return discard_level;
+}
+
+void LLImageJ2C::setMaxBytes(S32 max_bytes)
+{
+ mMaxBytes = max_bytes;
+}
+
+void LLImageJ2C::setReversible(const bool reversible)
+{
+ mReversible = reversible;
+}
+
+
+bool LLImageJ2C::loadAndValidate(const std::string &filename)
+{
+ bool res = true;
+
+ resetLastError();
+
+ S32 file_size = 0;
+ LLAPRFile infile ;
+ infile.open(filename, LL_APR_RB, NULL, &file_size);
+ apr_file_t* apr_file = infile.getFileHandle() ;
+ if (!apr_file)
+ {
+ setLastError("Unable to open file for reading", filename);
+ res = false;
+ }
+ else if (file_size == 0)
+ {
+ setLastError("File is empty",filename);
+ res = false;
+ }
+ else
+ {
+ U8 *data = (U8*)ll_aligned_malloc_16(file_size);
+ if (!data)
+ {
+ infile.close();
+ setLastError("Out of memory", filename);
+ res = false;
+ }
+ else
+ {
+ apr_size_t bytes_read = file_size;
+ apr_status_t s = apr_file_read(apr_file, data, &bytes_read); // modifies bytes_read
+ infile.close();
+
+ if (s != APR_SUCCESS || (S32)bytes_read != file_size)
+ {
+ ll_aligned_free_16(data);
+ setLastError("Unable to read entire file");
+ res = false;
+ }
+ else
+ {
+ res = validate(data, file_size);
+ }
+ }
+ }
+
+ if (!mLastError.empty())
+ {
+ LLImage::setLastError(mLastError);
+ }
+
+ return res;
+}
+
+
+bool LLImageJ2C::validate(U8 *data, U32 file_size)
+{
+ resetLastError();
+
+ LLImageDataLock lock(this);
+
+ setData(data, file_size);
+
+ bool res = updateData();
+ if ( res )
+ {
+ // Check to make sure that this instance has been initialized with data
+ if (!getData() || (0 == getDataSize()))
+ {
+ setLastError("LLImageJ2C uninitialized");
+ res = false;
+ }
+ else
+ {
+ res = mImpl->getMetadata(*this);
+ }
+ }
+
+ if (!mLastError.empty())
+ {
+ LLImage::setLastError(mLastError);
+ }
+ return res;
+}
+
+void LLImageJ2C::decodeFailed()
+{
+ mDecoding = false;
+}
+
+void LLImageJ2C::updateRawDiscardLevel()
+{
+ mRawDiscardLevel = mMaxBytes ? calcDiscardLevelBytes(mMaxBytes) : mDiscardLevel;
+}
+
+LLImageJ2CImpl::~LLImageJ2CImpl()
+{
+}
+
+//----------------------------------------------------------------------------------------------
+// Start of LLImageCompressionTester
+//----------------------------------------------------------------------------------------------
+LLImageCompressionTester::LLImageCompressionTester() : LLMetricPerformanceTesterBasic(sTesterName)
+{
+ addMetric("Time Decompression (s)");
+ addMetric("Volume In Decompression (kB)");
+ addMetric("Volume Out Decompression (kB)");
+ addMetric("Decompression Ratio (x:1)");
+ addMetric("Perf Decompression (kB/s)");
+
+ addMetric("Time Compression (s)");
+ addMetric("Volume In Compression (kB)");
+ addMetric("Volume Out Compression (kB)");
+ addMetric("Compression Ratio (x:1)");
+ addMetric("Perf Compression (kB/s)");
+
+ mRunBytesInDecompression = 0;
+ mRunBytesOutDecompression = 0;
+ mRunBytesInCompression = 0;
+
+ mTotalBytesInDecompression = 0;
+ mTotalBytesOutDecompression = 0;
+ mTotalBytesInCompression = 0;
+ mTotalBytesOutCompression = 0;
+
+ mTotalTimeDecompression = 0.0f;
+ mTotalTimeCompression = 0.0f;
+ mRunTimeDecompression = 0.0f;
+}
+
+LLImageCompressionTester::~LLImageCompressionTester()
+{
+ outputTestResults();
+ LLImageJ2C::sTesterp = NULL;
+}
+
+//virtual
+void LLImageCompressionTester::outputTestRecord(LLSD *sd)
+{
+ std::string currentLabel = getCurrentLabelName();
+
+ F32 decompressionPerf = 0.0f;
+ F32 compressionPerf = 0.0f;
+ F32 decompressionRate = 0.0f;
+ F32 compressionRate = 0.0f;
+
+ F32 totalkBInDecompression = (F32)(mTotalBytesInDecompression) / 1000.f;
+ F32 totalkBOutDecompression = (F32)(mTotalBytesOutDecompression) / 1000.f;
+ F32 totalkBInCompression = (F32)(mTotalBytesInCompression) / 1000.f;
+ F32 totalkBOutCompression = (F32)(mTotalBytesOutCompression) / 1000.f;
+
+ if (!is_approx_zero(mTotalTimeDecompression))
+ {
+ decompressionPerf = totalkBInDecompression / mTotalTimeDecompression;
+ }
+ if (!is_approx_zero(totalkBInDecompression))
+ {
+ decompressionRate = totalkBOutDecompression / totalkBInDecompression;
+ }
+ if (!is_approx_zero(mTotalTimeCompression))
+ {
+ compressionPerf = totalkBInCompression / mTotalTimeCompression;
+ }
+ if (!is_approx_zero(totalkBOutCompression))
+ {
+ compressionRate = totalkBInCompression / totalkBOutCompression;
+ }
+
+ (*sd)[currentLabel]["Time Decompression (s)"] = (LLSD::Real)mTotalTimeDecompression;
+ (*sd)[currentLabel]["Volume In Decompression (kB)"] = (LLSD::Real)totalkBInDecompression;
+ (*sd)[currentLabel]["Volume Out Decompression (kB)"]= (LLSD::Real)totalkBOutDecompression;
+ (*sd)[currentLabel]["Decompression Ratio (x:1)"] = (LLSD::Real)decompressionRate;
+ (*sd)[currentLabel]["Perf Decompression (kB/s)"] = (LLSD::Real)decompressionPerf;
+
+ (*sd)[currentLabel]["Time Compression (s)"] = (LLSD::Real)mTotalTimeCompression;
+ (*sd)[currentLabel]["Volume In Compression (kB)"] = (LLSD::Real)totalkBInCompression;
+ (*sd)[currentLabel]["Volume Out Compression (kB)"] = (LLSD::Real)totalkBOutCompression;
+ (*sd)[currentLabel]["Compression Ratio (x:1)"] = (LLSD::Real)compressionRate;
+ (*sd)[currentLabel]["Perf Compression (kB/s)"] = (LLSD::Real)compressionPerf;
+}
+
+void LLImageCompressionTester::updateCompressionStats(const F32 deltaTime)
+{
+ mTotalTimeCompression += deltaTime;
+}
+
+void LLImageCompressionTester::updateCompressionStats(const S32 bytesCompress, const S32 bytesRaw)
+{
+ mTotalBytesInCompression += bytesRaw;
+ mRunBytesInCompression += bytesRaw;
+ mTotalBytesOutCompression += bytesCompress;
+ if (mRunBytesInCompression > (1000000))
+ {
+ // Output everything
+ outputTestResults();
+ // Reset the compression data of the run
+ mRunBytesInCompression = 0;
+ }
+}
+
+void LLImageCompressionTester::updateDecompressionStats(const F32 deltaTime)
+{
+ mTotalTimeDecompression += deltaTime;
+}
+
+void LLImageCompressionTester::updateDecompressionStats(const S32 bytesIn, const S32 bytesOut)
+{
+ mTotalBytesInDecompression += bytesIn;
+ mRunBytesInDecompression += bytesIn;
+ mTotalBytesOutDecompression += bytesOut;
+ mRunBytesOutDecompression += bytesOut;
+ //if (mRunBytesInDecompression > (1000000))
+ if (mRunBytesOutDecompression > (10000000))
+ //if ((mTotalTimeDecompression - mRunTimeDecompression) >= (5.0f))
+ {
+ // Output everything
+ outputTestResults();
+ // Reset the decompression data of the run
+ mRunBytesInDecompression = 0;
+ mRunBytesOutDecompression = 0;
+ mRunTimeDecompression = mTotalTimeDecompression;
+ }
+}
+
+//----------------------------------------------------------------------------------------------
+// End of LLTexturePipelineTester
+//----------------------------------------------------------------------------------------------
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 00:23:50 +0000