/indra/llimage/llimagej2c.cpp
https://bitbucket.org/lindenlab/viewer-beta/ · C++ · 580 lines · 411 code · 82 blank · 87 comment · 55 complexity · 3ff587831171bf98d6c3b91017b2db26 MD5 · raw file
- /**
- * @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 "lldir.h"
- #include "llimagej2c.h"
- #include "llmemtype.h"
- #include "lltimer.h"
- #include "llmath.h"
- #include "llmemory.h"
- typedef LLImageJ2CImpl* (*CreateLLImageJ2CFunction)();
- typedef void (*DestroyLLImageJ2CFunction)(LLImageJ2CImpl*);
- typedef const char* (*EngineInfoLLImageJ2CFunction)();
- // Declare the prototype for theses functions here. Their functionality
- // will be implemented in other files which define a derived LLImageJ2CImpl
- // but only ONE static library which has the implementation for these
- // functions should ever be included.
- LLImageJ2CImpl* fallbackCreateLLImageJ2CImpl();
- void fallbackDestroyLLImageJ2CImpl(LLImageJ2CImpl* impl);
- const char* fallbackEngineInfoLLImageJ2CImpl();
- // Test data gathering handle
- LLImageCompressionTester* LLImageJ2C::sTesterp = NULL ;
- const std::string sTesterName("ImageCompressionTester");
- //static
- std::string LLImageJ2C::getEngineInfo()
- {
- return fallbackEngineInfoLLImageJ2CImpl();
- }
- LLImageJ2C::LLImageJ2C() : LLImageFormatted(IMG_CODEC_J2C),
- mMaxBytes(0),
- mRawDiscardLevel(-1),
- mRate(0.0f),
- mReversible(FALSE),
- mAreaUsedForDataSizeCalcs(0)
- {
- mImpl = 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()
- {
- if ( mImpl )
- {
- fallbackDestroyLLImageJ2CImpl(mImpl);
- }
- }
- // 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();
- // 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)
- {
- 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)
- {
- 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 )
- {
- LLTimer elapsed;
- LLMemType mt1(mMemType);
- BOOL res = TRUE;
-
- resetLastError();
- // 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();
- mDecoding = TRUE;
- res = mImpl->decodeImpl(*this, *raw_imagep, decode_time, first_channel, max_channel_count);
- }
-
- if (res)
- {
- if (!mDecoding)
- {
- // Failed
- raw_imagep->deleteData();
- }
- else
- {
- 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;
- LLMemType mt1(mMemType);
- 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 only provides an *estimate* of the size in bytes of an image level
- // *TODO: find a way to read the true size (when available) and convey the fact
- // that the result is an estimate in the other cases
- if (rate <= 0.f) rate = .125f;
- while (discard_level > 0)
- {
- if (w < 1 || h < 1)
- break;
- w >>= 1;
- h >>= 1;
- discard_level--;
- }
- S32 bytes = (S32)((F32)(w*h*comp)*rate);
- bytes = llmax(bytes, calcHeaderSizeJ2C());
- return bytes;
- }
- S32 LLImageJ2C::calcHeaderSize()
- {
- return calcHeaderSizeJ2C();
- }
- // calcDataSize() returns how many bytes to read
- // to load discard_level (including header and higher discard levels)
- 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--;
- }
- /* This is technically a more correct way to calculate the size required
- for each discard level, since they should include the size needed for
- lower levels. Unfortunately, this doesn't work well and will lead to
- download stalls. The true correct way is to parse the header. This will
- all go away with http textures at some point.
- // Calculate the size for each discard level. Lower levels (higher quality)
- // contain the cumulative size of higher levels
- S32 total_size = calcHeaderSizeJ2C();
- S32 level = MAX_DISCARD_LEVEL; // Start at the highest discard
- while ( level >= 0 )
- { // Add in this discard level and all before it
- total_size += calcDataSizeJ2C(getWidth(), getHeight(), getComponents(), level, mRate);
- mDataSizes[level] = total_size;
- level--;
- }
- */
- }
- return mDataSizes[discard_level];
- }
- 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); // virtual
- if (bytes >= bytes_needed - (bytes_needed>>2)) // For J2c, up the res at 75% of the optimal number of bytes
- {
- break;
- }
- discard_level++;
- if (discard_level >= MAX_DISCARD_LEVEL)
- {
- break;
- }
- }
- return discard_level;
- }
- void LLImageJ2C::setRate(F32 rate)
- {
- mRate = rate;
- }
- 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*)ALLOCATE_MEM(LLImageBase::getPrivatePool(), file_size);
- 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)
- {
- FREE_MEM(LLImageBase::getPrivatePool(), 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)
- {
- LLMemType mt1(mMemType);
- resetLastError();
-
- 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;
- mRunBytesInCompression = 0;
- mTotalBytesInDecompression = 0;
- mTotalBytesOutDecompression = 0;
- mTotalBytesInCompression = 0;
- mTotalBytesOutCompression = 0;
- mTotalTimeDecompression = 0.0f;
- mTotalTimeCompression = 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.0;
- F32 totalkBOutDecompression = (F32)(mTotalBytesOutDecompression) / 1000.0;
- F32 totalkBInCompression = (F32)(mTotalBytesInCompression) / 1000.0;
- F32 totalkBOutCompression = (F32)(mTotalBytesOutCompression) / 1000.0;
-
- 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;
- if (mRunBytesInDecompression > (1000000))
- {
- // Output everything
- outputTestResults();
- // Reset the decompression data of the run
- mRunBytesInDecompression = 0;
- }
- }
- //----------------------------------------------------------------------------------------------
- // End of LLTexturePipelineTester
- //----------------------------------------------------------------------------------------------