792 lines
20 KiB
C++
792 lines
20 KiB
C++
|
|
|
|
#include "tcodec.h"
|
|
#include "trastercm.h"
|
|
#include "tpixel.h"
|
|
#include "tbigmemorymanager.h"
|
|
#include "tsystem.h"
|
|
//#include "tstopwatch.h"
|
|
#include "timagecache.h"
|
|
#include "trasterimage.h"
|
|
|
|
//#include "snappy-c.h"
|
|
#if defined(LZ4_STATIC)
|
|
#include "lz4frame_static.h"
|
|
#else
|
|
#include "lz4frame.h"
|
|
#endif
|
|
|
|
#include <QDir>
|
|
#include <QProcess>
|
|
#include <QCoreApplication>
|
|
|
|
using namespace std;
|
|
|
|
namespace {
|
|
class Header {
|
|
enum RasType {
|
|
Raster32RGBM,
|
|
Raster64RGBM,
|
|
Raster32CM,
|
|
RasterGR8,
|
|
RasterGR16,
|
|
RasterUnknown
|
|
};
|
|
|
|
public:
|
|
Header(const TRasterP &ras);
|
|
~Header() {}
|
|
TRasterP createRaster() const;
|
|
int getRasterSize() const;
|
|
int m_lx;
|
|
int m_ly;
|
|
RasType m_rasType;
|
|
Header(void *mem) { memcpy(this, mem, sizeof(Header)); }
|
|
|
|
private:
|
|
Header(); // not implemented
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
Header::Header(const TRasterP &ras) {
|
|
assert(ras);
|
|
m_lx = ras->getLx();
|
|
m_ly = ras->getLy();
|
|
TRaster32P ras32(ras);
|
|
if (ras32)
|
|
m_rasType = Raster32RGBM;
|
|
else {
|
|
TRasterCM32P rasCM32(ras);
|
|
if (rasCM32)
|
|
m_rasType = Raster32CM;
|
|
else {
|
|
TRaster64P ras64(ras);
|
|
if (ras64)
|
|
m_rasType = Raster64RGBM;
|
|
else {
|
|
TRasterGR8P rasGR8(ras);
|
|
if (rasGR8)
|
|
m_rasType = RasterGR8;
|
|
else {
|
|
TRasterGR16P rasGR16(ras);
|
|
if (rasGR16)
|
|
m_rasType = RasterGR16;
|
|
else {
|
|
assert(!"Unknown RasterType");
|
|
m_rasType = RasterUnknown;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TRasterP Header::createRaster() const {
|
|
switch (m_rasType) {
|
|
case Raster32RGBM:
|
|
return TRaster32P(m_lx, m_ly);
|
|
break;
|
|
case Raster32CM:
|
|
return TRasterCM32P(m_lx, m_ly);
|
|
break;
|
|
case Raster64RGBM:
|
|
return TRaster64P(m_lx, m_ly);
|
|
break;
|
|
case RasterGR8:
|
|
return TRasterGR8P(m_lx, m_ly);
|
|
break;
|
|
case RasterGR16:
|
|
return TRasterGR16P(m_lx, m_ly);
|
|
break;
|
|
default:
|
|
assert(0);
|
|
return TRasterP();
|
|
break;
|
|
}
|
|
return TRasterP();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
int Header::getRasterSize() const {
|
|
switch (m_rasType) {
|
|
case Raster32RGBM:
|
|
return 4 * m_lx * m_ly;
|
|
break;
|
|
case Raster32CM:
|
|
return 4 * m_lx * m_ly;
|
|
break;
|
|
case Raster64RGBM:
|
|
return 8 * m_lx * m_ly;
|
|
break;
|
|
case RasterGR8:
|
|
return m_lx * m_ly;
|
|
break;
|
|
default:
|
|
assert(0);
|
|
return 0;
|
|
break;
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
} // anonymous namespace
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TRasterCodecSnappy
|
|
//------------------------------------------------------------------------------
|
|
|
|
/*TRasterCodecSnappy::TRasterCodecSnappy(const std::string &name, bool useCache)
|
|
: TRasterCodec(name)
|
|
, m_raster()
|
|
, m_useCache(useCache)
|
|
, m_cacheId("")
|
|
{
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TRasterCodecSnappy::~TRasterCodecSnappy()
|
|
{
|
|
if (m_useCache)
|
|
TImageCache::instance()->remove(m_cacheId);
|
|
else
|
|
m_raster = TRasterGR8P();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
UINT TRasterCodecSnappy::doCompress(const TRasterP &inRas, int allocUnit,
|
|
TRasterGR8P& outRas)
|
|
{
|
|
assert(inRas);
|
|
|
|
assert(inRas->getLx() == inRas->getWrap());
|
|
|
|
|
|
size_t inDataSize = inRas->getLx() * inRas->getLy() * inRas->getPixelSize();
|
|
size_t maxReqSize = snappy_max_compressed_length(inDataSize);
|
|
|
|
if (m_useCache)
|
|
{
|
|
if (m_cacheId=="")
|
|
m_cacheId = TImageCache::instance()->getUniqueId();
|
|
else
|
|
outRas = ((TRasterImageP)TImageCache::instance()->get(m_cacheId,
|
|
true))->getRaster();
|
|
}
|
|
else
|
|
outRas = m_raster;
|
|
|
|
if (!outRas || outRas->getLx()<(int)maxReqSize)
|
|
{
|
|
outRas = TRasterGR8P();
|
|
m_raster = TRasterGR8P();
|
|
if (m_useCache)
|
|
TImageCache::instance()->remove(m_cacheId);
|
|
outRas = TRasterGR8P(maxReqSize, 1);
|
|
if (m_useCache)
|
|
TImageCache::instance()->add(m_cacheId, TRasterImageP(outRas), true);
|
|
else
|
|
m_raster = outRas;
|
|
}
|
|
|
|
outRas->lock();
|
|
char* buffer = (char*) outRas->getRawData();
|
|
if (!buffer)
|
|
return 0;
|
|
|
|
inRas->lock();
|
|
char* inData = (char*) inRas->getRawData();
|
|
|
|
size_t outSize = maxReqSize;
|
|
snappy_status r = snappy_compress(inData, inDataSize, buffer, &outSize);
|
|
|
|
outRas->unlock();
|
|
inRas->unlock();
|
|
|
|
if(r != SNAPPY_OK)
|
|
throw TException("compress... something goes bad");
|
|
|
|
return outSize;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TRasterP TRasterCodecSnappy::compress(const TRasterP &inRas, int allocUnit,
|
|
TINT32 &outDataSize)
|
|
{
|
|
TRasterGR8P rasOut;
|
|
UINT outSize = doCompress(inRas, allocUnit, rasOut);
|
|
if (outSize==0)
|
|
return TRasterP();
|
|
|
|
UINT headerSize = sizeof(Header);
|
|
if (TBigMemoryManager::instance()->isActive() &&
|
|
TBigMemoryManager::instance()->getAvailableMemoryinKb()<((outSize +
|
|
headerSize)>>10))
|
|
return TRasterP();
|
|
|
|
TRasterGR8P r8(outSize + headerSize, 1);
|
|
r8->lock();
|
|
UCHAR *memoryChunk = r8->getRawData();
|
|
if (!memoryChunk)
|
|
return TRasterP();
|
|
Header head(inRas);
|
|
|
|
memcpy(memoryChunk, &head, headerSize);
|
|
UCHAR *tmp = memoryChunk + headerSize;
|
|
rasOut->lock();
|
|
memcpy(tmp, rasOut->getRawData(), outSize);
|
|
r8->unlock();
|
|
rasOut->unlock();
|
|
outDataSize = outSize + headerSize;
|
|
return r8;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TRasterCodecSnappy::decompress(const UCHAR* inData, TINT32 inDataSize,
|
|
TRasterP &outRas, bool safeMode)
|
|
{
|
|
int headerSize = sizeof(Header);
|
|
|
|
Header *header= (Header *)inData;
|
|
if (!outRas)
|
|
{
|
|
outRas = header->createRaster();
|
|
if (!outRas)
|
|
throw TException();
|
|
}
|
|
else
|
|
{
|
|
if (outRas->getLx() != outRas->getWrap())
|
|
throw TException();
|
|
}
|
|
|
|
int outDataSize = header->getRasterSize();
|
|
|
|
char* mc = (char*) inData + headerSize;
|
|
int ds = inDataSize - headerSize;
|
|
|
|
size_t outSize;
|
|
snappy_uncompressed_length(mc, ds, &outSize);
|
|
|
|
outRas->lock();
|
|
snappy_status rc = snappy_uncompress(mc, ds, (char*) outRas->getRawData(),
|
|
&outSize);
|
|
outRas->unlock();
|
|
|
|
if (rc != SNAPPY_OK)
|
|
{
|
|
if (safeMode)
|
|
return false;
|
|
else
|
|
{
|
|
throw TException("decompress... something goes bad");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
assert(outSize == (size_t)outDataSize);
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TRasterCodecSnappy::decompress(const TRasterP & compressedRas, TRasterP
|
|
&outRas)
|
|
{
|
|
int headerSize = sizeof(Header);
|
|
|
|
assert(compressedRas->getLy()==1 && compressedRas->getPixelSize()==1);
|
|
UINT inDataSize = compressedRas->getLx();
|
|
|
|
compressedRas->lock();
|
|
|
|
UCHAR* inData = compressedRas->getRawData();
|
|
Header header(inData);
|
|
|
|
if (!outRas)
|
|
{
|
|
outRas = header.createRaster();
|
|
if (!outRas)
|
|
throw TException();
|
|
}
|
|
else
|
|
{
|
|
if (outRas->getLx() != outRas->getWrap())
|
|
throw TException();
|
|
}
|
|
|
|
int outDataSize = header.getRasterSize();
|
|
|
|
char* mc = (char*) inData + headerSize;
|
|
int ds = inDataSize - headerSize;
|
|
|
|
size_t outSize;
|
|
snappy_uncompressed_length(mc, ds, &outSize);
|
|
|
|
char* outData = (char*) outRas->getRawData();
|
|
|
|
outRas->lock();
|
|
|
|
snappy_status rc = snappy_uncompress(mc, ds, outData, &outSize);
|
|
|
|
outRas->unlock();
|
|
compressedRas->unlock();
|
|
|
|
if (rc != SNAPPY_OK)
|
|
throw TException("decompress... something goes bad");
|
|
|
|
assert(outSize == (size_t)outDataSize);
|
|
}*/
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TRasterCodecLz4
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace {
|
|
bool lz4decompress(LZ4F_decompressionContext_t lz4dctx, char *out,
|
|
size_t *out_len_res, const char *in, size_t in_len) {
|
|
size_t out_len = *out_len_res, in_read, out_written;
|
|
|
|
*out_len_res = 0;
|
|
|
|
while (in_len) {
|
|
out_written = out_len;
|
|
in_read = in_len;
|
|
|
|
size_t res = LZ4F_decompress(lz4dctx, (void *)out, &out_written,
|
|
(const void *)in, &in_read, NULL);
|
|
|
|
if (LZ4F_isError(res)) return false;
|
|
|
|
*out_len_res += out_written;
|
|
|
|
out += out_written;
|
|
out_len -= out_written;
|
|
|
|
in += in_read;
|
|
in_len -= in_read;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
} // namespace
|
|
|
|
TRasterCodecLz4::TRasterCodecLz4(const std::string &name, bool useCache)
|
|
: TRasterCodec(name), m_raster(), m_useCache(useCache), m_cacheId("") {}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TRasterCodecLz4::~TRasterCodecLz4() {
|
|
if (m_useCache)
|
|
TImageCache::instance()->remove(m_cacheId);
|
|
else
|
|
m_raster = TRasterGR8P();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
UINT TRasterCodecLz4::doCompress(const TRasterP &inRas, int allocUnit,
|
|
TRasterGR8P &outRas) {
|
|
assert(inRas);
|
|
|
|
assert(inRas->getLx() == inRas->getWrap());
|
|
|
|
size_t inDataSize = inRas->getLx() * inRas->getLy() * inRas->getPixelSize();
|
|
size_t maxReqSize = LZ4F_compressFrameBound(inDataSize, NULL);
|
|
|
|
if (m_useCache) {
|
|
if (m_cacheId == "")
|
|
m_cacheId = TImageCache::instance()->getUniqueId();
|
|
else
|
|
outRas = ((TRasterImageP)TImageCache::instance()->get(m_cacheId, true))
|
|
->getRaster();
|
|
} else
|
|
outRas = m_raster;
|
|
|
|
if (!outRas || outRas->getLx() < (int)maxReqSize) {
|
|
outRas = TRasterGR8P();
|
|
m_raster = TRasterGR8P();
|
|
if (m_useCache) TImageCache::instance()->remove(m_cacheId);
|
|
outRas = TRasterGR8P(maxReqSize, 1);
|
|
if (m_useCache)
|
|
TImageCache::instance()->add(m_cacheId, TRasterImageP(outRas), true);
|
|
else
|
|
m_raster = outRas;
|
|
}
|
|
|
|
outRas->lock();
|
|
void *buffer = (void *)outRas->getRawData();
|
|
if (!buffer) return 0;
|
|
|
|
inRas->lock();
|
|
const void *inData = (const void *)inRas->getRawData();
|
|
|
|
size_t outSize =
|
|
LZ4F_compressFrame(buffer, maxReqSize, inData, inDataSize, NULL);
|
|
outRas->unlock();
|
|
inRas->unlock();
|
|
|
|
if (LZ4F_isError(outSize)) throw TException("compress... something goes bad");
|
|
|
|
return outSize;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TRasterP TRasterCodecLz4::compress(const TRasterP &inRas, int allocUnit,
|
|
TINT32 &outDataSize) {
|
|
TRasterGR8P rasOut;
|
|
UINT outSize = doCompress(inRas, allocUnit, rasOut);
|
|
if (outSize == 0) return TRasterP();
|
|
|
|
UINT headerSize = sizeof(Header);
|
|
if (TBigMemoryManager::instance()->isActive() &&
|
|
TBigMemoryManager::instance()->getAvailableMemoryinKb() <
|
|
((outSize + headerSize) >> 10))
|
|
return TRasterP();
|
|
|
|
TRasterGR8P r8(outSize + headerSize, 1);
|
|
r8->lock();
|
|
UCHAR *memoryChunk = r8->getRawData();
|
|
if (!memoryChunk) return TRasterP();
|
|
Header head(inRas);
|
|
|
|
memcpy(memoryChunk, &head, headerSize);
|
|
UCHAR *tmp = memoryChunk + headerSize;
|
|
rasOut->lock();
|
|
memcpy(tmp, rasOut->getRawData(), outSize);
|
|
r8->unlock();
|
|
rasOut->unlock();
|
|
outDataSize = outSize + headerSize;
|
|
return r8;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TRasterCodecLz4::decompress(const UCHAR *inData, TINT32 inDataSize,
|
|
TRasterP &outRas, bool safeMode) {
|
|
int headerSize = sizeof(Header);
|
|
|
|
Header *header = (Header *)inData;
|
|
if (!outRas) {
|
|
outRas = header->createRaster();
|
|
if (!outRas) throw TException();
|
|
} else {
|
|
if (outRas->getLx() != outRas->getWrap()) throw TException();
|
|
}
|
|
|
|
LZ4F_decompressionContext_t lz4dctx;
|
|
|
|
LZ4F_errorCode_t err =
|
|
LZ4F_createDecompressionContext(&lz4dctx, LZ4F_VERSION);
|
|
if (LZ4F_isError(err)) throw TException("compress... something goes bad");
|
|
|
|
int outDataSize = header->getRasterSize();
|
|
|
|
const char *mc = (const char *)(inData + headerSize);
|
|
size_t ds = inDataSize - headerSize;
|
|
|
|
size_t outSize = outDataSize;
|
|
char *outData = (char *)outRas->getRawData();
|
|
|
|
outRas->lock();
|
|
// err = LZ4F_decompress(lz4dctx, outData, &outSize, mc, &ds, NULL);
|
|
bool ok = lz4decompress(lz4dctx, outData, &outSize, mc, ds);
|
|
LZ4F_freeDecompressionContext(lz4dctx);
|
|
outRas->unlock();
|
|
|
|
if (!ok) {
|
|
if (safeMode)
|
|
return false;
|
|
else {
|
|
throw TException("decompress... something goes bad");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
assert(outSize == (size_t)outDataSize);
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TRasterCodecLz4::decompress(const TRasterP &compressedRas,
|
|
TRasterP &outRas) {
|
|
int headerSize = sizeof(Header);
|
|
|
|
assert(compressedRas->getLy() == 1 && compressedRas->getPixelSize() == 1);
|
|
UINT inDataSize = compressedRas->getLx();
|
|
|
|
compressedRas->lock();
|
|
|
|
UCHAR *inData = compressedRas->getRawData();
|
|
Header header(inData);
|
|
|
|
if (!outRas) {
|
|
outRas = header.createRaster();
|
|
if (!outRas) throw TException();
|
|
} else {
|
|
if (outRas->getLx() != outRas->getWrap()) throw TException();
|
|
}
|
|
|
|
LZ4F_decompressionContext_t lz4dctx;
|
|
|
|
LZ4F_errorCode_t err =
|
|
LZ4F_createDecompressionContext(&lz4dctx, LZ4F_VERSION);
|
|
if (LZ4F_isError(err)) throw TException("compress... something goes bad");
|
|
|
|
int outDataSize = header.getRasterSize();
|
|
|
|
const char *mc = (const char *)(inData + headerSize);
|
|
size_t ds = inDataSize - headerSize;
|
|
|
|
size_t outSize = outDataSize;
|
|
char *outData = (char *)outRas->getRawData();
|
|
|
|
outRas->lock();
|
|
|
|
// err = LZ4F_decompress(lz4dctx, outData, &outSize, mc, &ds, NULL);
|
|
bool ok = lz4decompress(lz4dctx, outData, &outSize, mc, ds);
|
|
LZ4F_freeDecompressionContext(lz4dctx);
|
|
|
|
outRas->unlock();
|
|
compressedRas->unlock();
|
|
|
|
if (!ok) throw TException("decompress... something goes bad");
|
|
|
|
assert(outSize == (size_t)outDataSize);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TRasterCodecLZO
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace {
|
|
|
|
bool lzoCompress(const QByteArray src, QByteArray &dst) {
|
|
QDir exeDir(QCoreApplication::applicationDirPath());
|
|
QString compressExe = exeDir.filePath("lzocompress");
|
|
QProcess process;
|
|
process.start(compressExe, QStringList() << QString::number(src.size()));
|
|
if (!process.waitForStarted()) return false;
|
|
process.write(src);
|
|
if (!process.waitForFinished()) return false;
|
|
dst = process.readAll();
|
|
return process.exitCode() == 0;
|
|
}
|
|
|
|
bool lzoDecompress(const QByteArray src, int dstSize, QByteArray &dst) {
|
|
QDir exeDir(QCoreApplication::applicationDirPath());
|
|
QString decompressExe = exeDir.filePath("lzodecompress");
|
|
QProcess process;
|
|
process.start(decompressExe, QStringList() << QString::number(dstSize)
|
|
<< QString::number(src.size()));
|
|
if (!process.waitForStarted()) return false;
|
|
process.write(src);
|
|
if (!process.waitForFinished()) return false;
|
|
dst = process.readAll();
|
|
return process.exitCode() == 0 && dst.size() == dstSize;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TRasterCodecLZO::TRasterCodecLZO(const std::string &name, bool useCache)
|
|
: TRasterCodec(name), m_raster(), m_useCache(useCache), m_cacheId("") {}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TRasterCodecLZO::~TRasterCodecLZO() {
|
|
if (m_useCache)
|
|
TImageCache::instance()->remove(m_cacheId);
|
|
else
|
|
m_raster = TRasterGR8P();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
UINT TRasterCodecLZO::doCompress(const TRasterP &inRas, int allocUnit,
|
|
TRasterGR8P &outRas) {
|
|
assert(inRas);
|
|
|
|
assert(inRas->getLx() == inRas->getWrap());
|
|
|
|
size_t inDataSize = inRas->getLx() * inRas->getLy() * inRas->getPixelSize();
|
|
|
|
// compress data
|
|
inRas->lock();
|
|
char *inData = (char *)inRas->getRawData();
|
|
QByteArray compressedBuffer;
|
|
if (!lzoCompress(QByteArray(inData, inDataSize), compressedBuffer))
|
|
throw TException("LZO compression failed");
|
|
|
|
inRas->unlock();
|
|
|
|
size_t maxReqSize = compressedBuffer.size(); // we have just done the
|
|
// compression: we know the
|
|
// actual size
|
|
|
|
if (m_useCache) {
|
|
if (m_cacheId == "")
|
|
m_cacheId = TImageCache::instance()->getUniqueId();
|
|
else
|
|
outRas = ((TRasterImageP)TImageCache::instance()->get(m_cacheId, true))
|
|
->getRaster();
|
|
} else
|
|
outRas = m_raster;
|
|
|
|
if (!outRas || outRas->getLx() < (int)maxReqSize) {
|
|
outRas = TRasterGR8P();
|
|
m_raster = TRasterGR8P();
|
|
if (m_useCache) TImageCache::instance()->remove(m_cacheId);
|
|
outRas = TRasterGR8P(maxReqSize, 1);
|
|
if (m_useCache)
|
|
TImageCache::instance()->add(m_cacheId, TRasterImageP(outRas), true);
|
|
else
|
|
m_raster = outRas;
|
|
}
|
|
|
|
size_t outSize = maxReqSize;
|
|
outRas->lock();
|
|
char *buffer = (char *)outRas->getRawData(); // Change cast types, if needed
|
|
if (!buffer) {
|
|
outRas->unlock();
|
|
return 0;
|
|
}
|
|
memcpy(buffer, compressedBuffer.data(), outSize);
|
|
outRas->unlock();
|
|
|
|
return outSize;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TRasterP TRasterCodecLZO::compress(const TRasterP &inRas, int allocUnit,
|
|
TINT32 &outDataSize) {
|
|
TRasterGR8P rasOut;
|
|
UINT outSize = doCompress(inRas, allocUnit, rasOut);
|
|
if (outSize == 0) return TRasterP();
|
|
|
|
UINT headerSize = sizeof(Header);
|
|
if (TBigMemoryManager::instance()->isActive() &&
|
|
TBigMemoryManager::instance()->getAvailableMemoryinKb() <
|
|
((outSize + headerSize) >> 10))
|
|
return TRasterP();
|
|
|
|
TRasterGR8P r8(outSize + headerSize, 1);
|
|
r8->lock();
|
|
UCHAR *memoryChunk = r8->getRawData();
|
|
if (!memoryChunk) return TRasterP();
|
|
Header head(inRas);
|
|
|
|
memcpy(memoryChunk, &head, headerSize);
|
|
UCHAR *tmp = memoryChunk + headerSize;
|
|
rasOut->lock();
|
|
memcpy(tmp, rasOut->getRawData(), outSize);
|
|
r8->unlock();
|
|
rasOut->unlock();
|
|
outDataSize = outSize + headerSize;
|
|
return r8;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TRasterCodecLZO::decompress(const UCHAR *inData, TINT32 inDataSize,
|
|
TRasterP &outRas, bool safeMode) {
|
|
int headerSize = sizeof(Header);
|
|
|
|
Header *header = (Header *)inData;
|
|
if (!outRas) {
|
|
outRas = header->createRaster();
|
|
if (!outRas) throw TException();
|
|
} else {
|
|
if (outRas->getLx() != outRas->getWrap()) throw TException();
|
|
}
|
|
|
|
int outDataSize = header->getRasterSize();
|
|
|
|
char *mc = (char *)inData + headerSize;
|
|
int ds = inDataSize - headerSize;
|
|
|
|
size_t outSize = outDataSize; // Calculate output buffer size
|
|
|
|
QByteArray decompressedBuffer;
|
|
if (!lzoDecompress(QByteArray(mc, ds), outSize, decompressedBuffer))
|
|
throw TException("LZO decompression failed");
|
|
|
|
outRas->lock();
|
|
memcpy(outRas->getRawData(), decompressedBuffer.data(),
|
|
decompressedBuffer.size());
|
|
bool rc = true;
|
|
|
|
outRas->unlock();
|
|
|
|
/*
|
|
if (rc != true) // Check success code here
|
|
{
|
|
if (safeMode)
|
|
return false;
|
|
else
|
|
{
|
|
throw TException("decompress... something goes bad");
|
|
return false;
|
|
}
|
|
}
|
|
*/
|
|
|
|
assert(outSize == (size_t)outDataSize);
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TRasterCodecLZO::decompress(const TRasterP &compressedRas,
|
|
TRasterP &outRas) {
|
|
int headerSize = sizeof(Header);
|
|
|
|
assert(compressedRas->getLy() == 1 && compressedRas->getPixelSize() == 1);
|
|
UINT inDataSize = compressedRas->getLx();
|
|
|
|
compressedRas->lock();
|
|
|
|
UCHAR *inData = compressedRas->getRawData();
|
|
Header header(inData);
|
|
|
|
if (!outRas) {
|
|
outRas = header.createRaster();
|
|
if (!outRas) throw TException();
|
|
} else {
|
|
if (outRas->getLx() != outRas->getWrap()) throw TException();
|
|
}
|
|
|
|
int outDataSize = header.getRasterSize();
|
|
|
|
char *mc = (char *)inData + headerSize;
|
|
int ds = inDataSize - headerSize;
|
|
|
|
size_t outSize = outDataSize; // Calculate output buffer size
|
|
|
|
char *outData = (char *)outRas->getRawData();
|
|
|
|
QByteArray decompressedBuffer;
|
|
if (!lzoDecompress(QByteArray(mc, ds), outSize, decompressedBuffer))
|
|
throw TException("LZO decompression failed");
|
|
outRas->lock();
|
|
memcpy(outRas->getRawData(), decompressedBuffer.data(),
|
|
decompressedBuffer.size());
|
|
bool rc = true;
|
|
|
|
outRas->unlock();
|
|
compressedRas->unlock();
|
|
|
|
if (rc != true) // Check success code here
|
|
throw TException("decompress... something goes bad");
|
|
|
|
assert(outSize == (size_t)outDataSize);
|
|
}
|