mirror of
https://github.com/team-charls/charls
synced 2025-03-28 21:03:13 +00:00
Error handling for small output buffers/damaged compressed data. Small performance improvements, and a litle refactoring.
This commit is contained in:
jdv_cp
parent
068d887135
commit
105136964c
@ -40,9 +40,6 @@ struct CContextRunMode
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void UpdateVariables(int Errval, UINT EMErrval)
|
||||
{
|
||||
if (Errval < 0)
|
||||
|
||||
@ -35,13 +35,28 @@ public:
|
||||
}
|
||||
|
||||
|
||||
|
||||
inlinehint void Skip(int length)
|
||||
{
|
||||
_cbitValid -= length;
|
||||
_valcurrent = _valcurrent << length;
|
||||
}
|
||||
|
||||
|
||||
void OnLineBegin(void* /*ptypeCur*/, void* /*ptypeLine*/, int /*cpixel*/) {}
|
||||
|
||||
template <class T>
|
||||
void OnLineEnd(T* ptypeCur, T* ptypeLine, int cpixel)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
for (int i = 0; i < cpixel; ++i)
|
||||
{
|
||||
//CheckedAssign(ptypeLine[i], ptypeCur[i]);
|
||||
ptypeLine[i] = ptypeCur[i];
|
||||
}
|
||||
#else
|
||||
memcpy(ptypeLine, ptypeCur, cpixel * sizeof(T));
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void MakeValid()
|
||||
|
||||
@ -24,6 +24,16 @@ public:
|
||||
virtual ~EncoderStrategy()
|
||||
{}
|
||||
|
||||
|
||||
|
||||
template <class T>
|
||||
void OnLineBegin(T* ptypeCur, T* ptypeLine, int cpixel)
|
||||
{
|
||||
memcpy(ptypeCur, ptypeLine, cpixel * sizeof(T));
|
||||
}
|
||||
|
||||
void OnLineEnd(void* /*ptypeCur*/, void* /*ptypeLine*/, int /*cpixel*/) {};
|
||||
|
||||
virtual void SetPresets(const JlsCustomParameters& presets) = 0;
|
||||
|
||||
virtual int EncodeScan(const void* pvoid, const Size& size, int ccomp, void* pvoidOut, int cbyte, void* pvoidCompare) = 0;
|
||||
|
||||
68
header.cpp
68
header.cpp
@ -110,11 +110,11 @@ JLSOutputStream::JLSOutputStream() :
|
||||
//
|
||||
JLSOutputStream::~JLSOutputStream()
|
||||
{
|
||||
for (UINT i = 0; i < _rgsegment.size(); ++i)
|
||||
for (UINT i = 0; i < _segments.size(); ++i)
|
||||
{
|
||||
delete _rgsegment[i];
|
||||
delete _segments[i];
|
||||
}
|
||||
_rgsegment.empty();
|
||||
_segments.empty();
|
||||
}
|
||||
|
||||
|
||||
@ -125,7 +125,7 @@ JLSOutputStream::~JLSOutputStream()
|
||||
//
|
||||
void JLSOutputStream::Init(Size size, int cbpp, int ccomp)
|
||||
{
|
||||
_rgsegment.push_back(CreateMarkerStartOfFrame(size, cbpp, ccomp));
|
||||
_segments.push_back(CreateMarkerStartOfFrame(size, cbpp, ccomp));
|
||||
}
|
||||
|
||||
|
||||
@ -142,9 +142,9 @@ int JLSOutputStream::Write(BYTE* pdata, int cbyteLength)
|
||||
WriteByte(JPEG_SOI);
|
||||
|
||||
|
||||
for (UINT i = 0; i < _rgsegment.size(); ++i)
|
||||
for (UINT i = 0; i < _segments.size(); ++i)
|
||||
{
|
||||
_rgsegment[i]->Write(this);
|
||||
_segments[i]->Write(this);
|
||||
}
|
||||
|
||||
//_bCompare = false;
|
||||
@ -161,7 +161,8 @@ JLSInputStream::JLSInputStream(const BYTE* pdata, int cbyteLength) :
|
||||
_pdata(pdata),
|
||||
_cbyteOffset(0),
|
||||
_cbyteLength(cbyteLength),
|
||||
_bCompare(false)
|
||||
_bCompare(false),
|
||||
_info()
|
||||
{
|
||||
}
|
||||
|
||||
@ -183,23 +184,24 @@ bool JLSInputStream::Read(void* pvoid, int cbyteAvailable)
|
||||
//
|
||||
bool JLSInputStream::ReadPixels(void* pvoid, int cbyteAvailable)
|
||||
{
|
||||
int cbytePlane = _info.size.cx * _info.size.cy * ((_info.cbit + 7)/8);
|
||||
int cbytePlane = _info.width * _info.height * ((_info.bitspersample + 7)/8);
|
||||
|
||||
if (cbyteAvailable < cbytePlane * _info.ccomp)
|
||||
return false;
|
||||
if (cbyteAvailable < cbytePlane * _info.components)
|
||||
throw JlsException(UncompressedBufferTooSmall);
|
||||
|
||||
if (_info.ilv == ILV_NONE)
|
||||
{
|
||||
BYTE* pbyte = (BYTE*)pvoid;
|
||||
for (int icomp = 0; icomp < _info.ccomp; ++icomp)
|
||||
for (int icomp = 0; icomp < _info.components; ++icomp)
|
||||
{
|
||||
ReadScan(pbyte);
|
||||
ReadScan(pbyte);
|
||||
|
||||
pbyte += cbytePlane;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ReadScan(pvoid);
|
||||
ReadScan(pvoid);
|
||||
}
|
||||
return true;
|
||||
|
||||
@ -306,11 +308,11 @@ void JLSInputStream::ReadPresetParameters()
|
||||
{
|
||||
case 1:
|
||||
{
|
||||
_presets.MAXVAL = ReadWord();
|
||||
_presets.T1 = ReadWord();
|
||||
_presets.T2 = ReadWord();
|
||||
_presets.T3 = ReadWord();
|
||||
_presets.RESET = ReadWord();
|
||||
_info.custom.MAXVAL = ReadWord();
|
||||
_info.custom.T1 = ReadWord();
|
||||
_info.custom.T2 = ReadWord();
|
||||
_info.custom.T3 = ReadWord();
|
||||
_info.custom.RESET = ReadWord();
|
||||
return;
|
||||
}
|
||||
}
|
||||
@ -330,7 +332,7 @@ void JLSInputStream::ReadStartOfScan()
|
||||
ReadByte();
|
||||
ReadByte();
|
||||
}
|
||||
_info.nnear = ReadByte();
|
||||
_info.allowedlossyerror = ReadByte();
|
||||
_info.ilv = interleavemode(ReadByte());
|
||||
}
|
||||
|
||||
@ -347,11 +349,12 @@ void JLSInputStream::ReadComment()
|
||||
//
|
||||
void JLSInputStream::ReadStartOfFrame()
|
||||
{
|
||||
_info.cbit = ReadByte();
|
||||
_info.bitspersample = ReadByte();
|
||||
int cline = ReadWord();
|
||||
int ccol = ReadWord();
|
||||
_info.size = Size(ccol, cline);
|
||||
_info.ccomp = ReadByte();
|
||||
_info.width = ccol;
|
||||
_info.height = cline;
|
||||
_info.components= ReadByte();
|
||||
|
||||
}
|
||||
|
||||
@ -375,9 +378,10 @@ int JLSInputStream::ReadWord()
|
||||
|
||||
void JLSInputStream::ReadScan(void* pvout)
|
||||
{
|
||||
std::auto_ptr<DecoderStrategy> qcodec(JlsCodecFactory<DecoderStrategy>().GetCodec(_info, _presets));
|
||||
int cline = _info.ilv == ILV_LINE ? _info.ccomp : 1;
|
||||
_cbyteOffset += qcodec->DecodeScan(pvout, _info.size, cline, _pdata + _cbyteOffset, _cbyteLength - _cbyteOffset, _bCompare);
|
||||
std::auto_ptr<DecoderStrategy> qcodec(JlsCodecFactory<DecoderStrategy>().GetCodec(_info, _info.custom));
|
||||
int cline = _info.ilv == ILV_LINE ? _info.components : 1;
|
||||
Size size = Size(_info.width,_info.height);
|
||||
_cbyteOffset += qcodec->DecodeScan(pvout, size, cline, _pdata + _cbyteOffset, _cbyteLength - _cbyteOffset, _bCompare);
|
||||
};
|
||||
|
||||
|
||||
@ -400,11 +404,11 @@ public:
|
||||
void Write(JLSOutputStream* pstream)
|
||||
{
|
||||
|
||||
ScanInfo info;
|
||||
info.cbit = _cbit;
|
||||
info.ccomp = _ccompScan;
|
||||
JlsParamaters info;
|
||||
info.bitspersample = _cbit;
|
||||
info.components = _ccompScan;
|
||||
info.ilv = _ilv;
|
||||
info.nnear = _nnear;
|
||||
info.allowedlossyerror = _nnear;
|
||||
|
||||
int ccompInterleaved = _ilv == ILV_LINE ? _ccompScan : 1;
|
||||
|
||||
@ -432,15 +436,15 @@ void JLSOutputStream::AddScan(const void* pbyteComp, const JlsParamaters* pparam
|
||||
{
|
||||
if (!IsDefault(&pparams->custom))
|
||||
{
|
||||
_rgsegment.push_back(CreateLSE(&pparams->custom));
|
||||
_segments.push_back(CreateLSE(&pparams->custom));
|
||||
}
|
||||
|
||||
_icompLast += 1;
|
||||
_rgsegment.push_back(EncodeStartOfScan(pparams,pparams->ilv == ILV_NONE ? _icompLast : -1));
|
||||
_segments.push_back(EncodeStartOfScan(pparams,pparams->ilv == ILV_NONE ? _icompLast : -1));
|
||||
|
||||
Size size = Size(pparams->width, pparams->height);
|
||||
int ccomp = pparams->ilv == ILV_NONE ? 1 : pparams->components;
|
||||
|
||||
|
||||
_rgsegment.push_back(new JpegImageDataSegment(pbyteComp, size, pparams->bitspersample, _icompLast, ccomp, pparams->ilv, pparams->allowedlossyerror, pparams->custom));
|
||||
_segments.push_back(new JpegImageDataSegment(pbyteComp, size, pparams->bitspersample, _icompLast, ccomp, pparams->ilv, pparams->allowedlossyerror, pparams->custom));
|
||||
}
|
||||
|
||||
4
header.h
4
header.h
@ -24,9 +24,9 @@ template<class STRATEGY>
|
||||
class JlsCodecFactory
|
||||
{
|
||||
public:
|
||||
STRATEGY* GetCodec(const ScanInfo& info, const JlsCustomParameters&);
|
||||
STRATEGY* GetCodec(const JlsParamaters& info, const JlsCustomParameters&);
|
||||
private:
|
||||
STRATEGY* GetCodecImpl(const ScanInfo& info);
|
||||
STRATEGY* GetCodecImpl(const JlsParamaters& info);
|
||||
};
|
||||
|
||||
|
||||
|
||||
@ -87,11 +87,19 @@ __declspec(dllexport) JLS_ERROR JpegLsDecode(void* pdataUncompressed, int cbyteU
|
||||
{
|
||||
JLSInputStream reader((BYTE*)pdataCompressed, cbyteCompressed);
|
||||
|
||||
if (!reader.Read(pdataUncompressed, cbyteUncompressed))
|
||||
return InvalidCompressedData;
|
||||
try
|
||||
{
|
||||
if (!reader.Read(pdataUncompressed, cbyteUncompressed))
|
||||
return InvalidCompressedData;
|
||||
|
||||
reader.GetBytesRead();
|
||||
return OK;
|
||||
reader.GetBytesRead();
|
||||
return OK;
|
||||
|
||||
}
|
||||
catch (JlsException e)
|
||||
{
|
||||
return e._error;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -145,14 +153,8 @@ __declspec(dllexport) JLS_ERROR JpegLsReadHeader(const void* pdataCompressed, in
|
||||
{
|
||||
JLSInputStream reader((BYTE*)pdataCompressed, cbyteCompressed);
|
||||
reader.ReadHeader();
|
||||
ScanInfo info = reader.GetMetadata();
|
||||
pparams->width = info.size.cx;
|
||||
pparams->height = info.size.cy;
|
||||
pparams->components= info.ccomp;
|
||||
pparams->bitspersample = info.cbit;
|
||||
pparams->allowedlossyerror = info.nnear;
|
||||
pparams->ilv = info.ilv;
|
||||
pparams->custom = reader.GetCustomPreset();
|
||||
JlsParamaters info = reader.GetMetadata();
|
||||
*pparams = info;
|
||||
return OK;
|
||||
}
|
||||
}
|
||||
@ -12,6 +12,15 @@ enum JLS_ERROR
|
||||
InvalidCompressedData
|
||||
};
|
||||
|
||||
class JlsException
|
||||
{
|
||||
public:
|
||||
JlsException(JLS_ERROR error) : _error(error)
|
||||
{ }
|
||||
|
||||
JLS_ERROR _error;
|
||||
};
|
||||
|
||||
enum interleavemode
|
||||
{
|
||||
ILV_NONE = 0,
|
||||
|
||||
27
jpegls.cpp
27
jpegls.cpp
@ -48,6 +48,7 @@ signed char QuantizeGratientOrg(const Presets& preset, int NEAR, int Di)
|
||||
}
|
||||
|
||||
|
||||
|
||||
std::vector<signed char> CreateQLutLossless(int cbit)
|
||||
{
|
||||
Presets preset = ComputeDefault((1 << cbit) - 1, 0);
|
||||
@ -75,12 +76,12 @@ std::vector<signed char> rgquant16Ll = CreateQLutLossless(16);
|
||||
|
||||
|
||||
template<class STRATEGY>
|
||||
STRATEGY* JlsCodecFactory<STRATEGY>::GetCodec(const ScanInfo& _info, const JlsCustomParameters& presets)
|
||||
STRATEGY* JlsCodecFactory<STRATEGY>::GetCodec(const JlsParamaters& _info, const JlsCustomParameters& presets)
|
||||
{
|
||||
STRATEGY* pstrategy = NULL;
|
||||
if (presets.RESET != 0 && presets.RESET != BASIC_RESET)
|
||||
{
|
||||
typename DefaultTraitsT<BYTE,BYTE> traits((1 << _info.cbit) - 1, _info.nnear);
|
||||
typename DefaultTraitsT<BYTE,BYTE> traits((1 << _info.bitspersample) - 1, _info.allowedlossyerror);
|
||||
traits.MAXVAL = presets.MAXVAL;
|
||||
traits.RESET = presets.RESET;
|
||||
pstrategy = new JlsCodec<DefaultTraitsT<BYTE, BYTE>, STRATEGY>(traits);
|
||||
@ -98,16 +99,16 @@ STRATEGY* JlsCodecFactory<STRATEGY>::GetCodec(const ScanInfo& _info, const JlsCu
|
||||
}
|
||||
|
||||
template<class STRATEGY>
|
||||
STRATEGY* JlsCodecFactory<STRATEGY>::GetCodecImpl(const ScanInfo& _info)
|
||||
STRATEGY* JlsCodecFactory<STRATEGY>::GetCodecImpl(const JlsParamaters& _info)
|
||||
{
|
||||
if (_info.ccomp != 1 && _info.ilv == ILV_SAMPLE)
|
||||
if (_info.components != 1 && _info.ilv == ILV_SAMPLE)
|
||||
{
|
||||
if (_info.ccomp == 3 && _info.cbit == 8)
|
||||
if (_info.components == 3 && _info.bitspersample == 8)
|
||||
{
|
||||
if (_info.nnear == 0)
|
||||
if (_info.allowedlossyerror == 0)
|
||||
return new JlsCodec<LosslessTraitsT<Triplet,8>, STRATEGY>();
|
||||
|
||||
typename DefaultTraitsT<BYTE,Triplet> traits((1 << _info.cbit) - 1, _info.nnear);
|
||||
typename DefaultTraitsT<BYTE,Triplet> traits((1 << _info.bitspersample) - 1, _info.allowedlossyerror);
|
||||
return new JlsCodec<DefaultTraitsT<BYTE,Triplet>, STRATEGY>(traits);
|
||||
}
|
||||
|
||||
@ -115,9 +116,9 @@ STRATEGY* JlsCodecFactory<STRATEGY>::GetCodecImpl(const ScanInfo& _info)
|
||||
}
|
||||
|
||||
// optimized lossless versions common monochrome formats (lossless)
|
||||
if (_info.nnear == 0)
|
||||
if (_info.allowedlossyerror == 0)
|
||||
{
|
||||
switch (_info.cbit)
|
||||
switch (_info.bitspersample)
|
||||
{
|
||||
case 8: return new JlsCodec<LosslessTraitsT<BYTE, 8>, STRATEGY>();
|
||||
case 10: return new JlsCodec<LosslessTraitsT<USHORT,10>, STRATEGY>();
|
||||
@ -127,15 +128,15 @@ STRATEGY* JlsCodecFactory<STRATEGY>::GetCodecImpl(const ScanInfo& _info)
|
||||
}
|
||||
|
||||
|
||||
if (_info.cbit <= 8)
|
||||
if (_info.bitspersample <= 8)
|
||||
{
|
||||
typename DefaultTraitsT<BYTE, BYTE> traits((1 << _info.cbit) - 1, _info.nnear);
|
||||
typename DefaultTraitsT<BYTE, BYTE> traits((1 << _info.bitspersample) - 1, _info.allowedlossyerror);
|
||||
return new JlsCodec<DefaultTraitsT<BYTE, BYTE>, STRATEGY>(traits);
|
||||
}
|
||||
|
||||
if (_info.cbit <= 16)
|
||||
if (_info.bitspersample <= 16)
|
||||
{
|
||||
typename DefaultTraitsT<USHORT, USHORT> traits((1 << _info.cbit) - 1, _info.nnear);
|
||||
typename DefaultTraitsT<USHORT, USHORT> traits((1 << _info.bitspersample) - 1, _info.allowedlossyerror);
|
||||
return new JlsCodec<DefaultTraitsT<USHORT, USHORT>, STRATEGY>(traits);
|
||||
}
|
||||
return NULL;
|
||||
|
||||
255
scan.h
255
scan.h
@ -8,6 +8,10 @@
|
||||
|
||||
#include "lookuptable.h"
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Apply
|
||||
//
|
||||
@ -124,7 +128,6 @@ public:
|
||||
_pquant(0),
|
||||
_size(0,0)
|
||||
{
|
||||
memset(_rghistogramK, 0, sizeof(_rghistogramK));
|
||||
}
|
||||
|
||||
JlsCodec(const TRAITS& inTraits) :
|
||||
@ -137,7 +140,6 @@ public:
|
||||
_pquant(0),
|
||||
_size(0,0)
|
||||
{
|
||||
memset(_rghistogramK, 0, sizeof(_rghistogramK));
|
||||
}
|
||||
|
||||
|
||||
@ -174,32 +176,20 @@ public:
|
||||
int DecodeRIError(CContextRunMode& ctx);
|
||||
Triplet DecodeRIPixel(Triplet Ra, Triplet Rb);
|
||||
PIXEL DecodeRIPixel(int Ra, int Rb);
|
||||
int DecodeRunPixels(PIXEL Ra, PIXEL* ptype, int ipixel, int cpixelMac);
|
||||
int DoRunMode(PIXEL* ptype, const PIXEL* ptypePrev, int ipixel, int cpixelMac, DecoderStrategy*);
|
||||
int DecodeRunPixels(PIXEL Ra, PIXEL* ptype, int cpixelMac);
|
||||
int DoRunMode(int ipixel, DecoderStrategy*);
|
||||
|
||||
void EncodeRIError(CContextRunMode& ctx, int Errval);
|
||||
SAMPLE EncodeRIPixel(int x, int Ra, int Rb);
|
||||
Triplet EncodeRIPixel(Triplet x, Triplet Ra, Triplet Rb);
|
||||
void EncodeRunPixels(int RUNcnt, bool bEndofline);
|
||||
int DoRunMode(PIXEL* ptype, const PIXEL* ptypePrev, int ipixel, int ctypeRem, EncoderStrategy*);
|
||||
void EncodeRunPixels(int runLength, bool bEndofline);
|
||||
int DoRunMode(int ipixel, EncoderStrategy*);
|
||||
|
||||
inlinehint SAMPLE DoRegular(int Qs, int, int pred, DecoderStrategy*);
|
||||
inlinehint SAMPLE DoRegular(int Qs, int x, int pred, EncoderStrategy*);
|
||||
|
||||
inlinehint void CheckedAssign(SAMPLE& typeDst, SAMPLE type)
|
||||
{
|
||||
ASSERT(!_bCompare || traits.IsNear(typeDst, type));
|
||||
typeDst = type;
|
||||
}
|
||||
|
||||
inlinehint void CheckedAssign(Triplet& typeDst, Triplet type)
|
||||
{
|
||||
ASSERT(!_bCompare || traits.IsNear(typeDst, type));
|
||||
typeDst = type;
|
||||
}
|
||||
|
||||
void DoLine(SAMPLE* ptype, const SAMPLE* ptypePrev);
|
||||
void DoLine(Triplet* ptype, const Triplet* ptypePrev);
|
||||
void DoLine(SAMPLE* pdummy);
|
||||
void DoLine(Triplet* pdummy);
|
||||
void DoScan(PIXEL* ptype, BYTE* pbyteCompressed, int cbyteCompressed);
|
||||
|
||||
public:
|
||||
@ -210,21 +200,26 @@ public:
|
||||
int DecodeScan(void* pvoidOut, const Size& size, int components, const void* pvoidIn, int cbyte, bool bCompare);
|
||||
|
||||
protected:
|
||||
TRAITS traits;
|
||||
signed char* _pquant;
|
||||
std::vector<signed char> _rgquant;
|
||||
JlsContext _rgcontext[365];
|
||||
// compression context
|
||||
JlsContext _contexts[365];
|
||||
CContextRunMode _contextRunmode[2];
|
||||
int RUNindex;
|
||||
Size _size;
|
||||
int _components; // for line interleaved mode
|
||||
PIXEL* ptypePrev; // previous line ptr
|
||||
PIXEL* ptypeCur; // current line ptr
|
||||
|
||||
// codec parameters
|
||||
TRAITS traits;
|
||||
Size _size;
|
||||
int _components; // only set for line interleaved mode
|
||||
int T3;
|
||||
int T2;
|
||||
int T1;
|
||||
|
||||
// quantization lookup table
|
||||
signed char* _pquant;
|
||||
std::vector<signed char> _rgquant;
|
||||
|
||||
// debugging
|
||||
int _rghistogramK[16];
|
||||
bool _bCompare;
|
||||
};
|
||||
|
||||
@ -234,7 +229,7 @@ template<class TRAITS, class STRATEGY>
|
||||
typename TRAITS::SAMPLE JlsCodec<TRAITS,STRATEGY>::DoRegular(int Qs, int, int pred, DecoderStrategy*)
|
||||
{
|
||||
int sign = BitWiseSign(Qs);
|
||||
JlsContext& ctx = _rgcontext[ApplySign(Qs, sign)];
|
||||
JlsContext& ctx = _contexts[ApplySign(Qs, sign)];
|
||||
int k = ctx.GetGolomb();
|
||||
int Px = traits.CorrectPrediction(pred + ApplySign(ctx.C, sign));
|
||||
|
||||
@ -249,7 +244,8 @@ typename TRAITS::SAMPLE JlsCodec<TRAITS,STRATEGY>::DoRegular(int Qs, int, int pr
|
||||
else
|
||||
{
|
||||
ErrVal = UnMapErrVal(DecodeValue(k, traits.LIMIT, traits.qbpp));
|
||||
ASSERT(abs(ErrVal) < 65535);
|
||||
if (abs(ErrVal) > 65535)
|
||||
throw JlsException(InvalidCompressedData);
|
||||
}
|
||||
ErrVal = ErrVal ^ ((traits.NEAR == 0) ? ctx.GetErrorCorrection(k) : 0);
|
||||
ctx.UpdateVariables(ErrVal, traits.NEAR, traits.RESET);
|
||||
@ -261,9 +257,10 @@ template<class TRAITS, class STRATEGY>
|
||||
typename TRAITS::SAMPLE JlsCodec<TRAITS,STRATEGY>::DoRegular(int Qs, int x, int pred, EncoderStrategy*)
|
||||
{
|
||||
int sign = BitWiseSign(Qs);
|
||||
JlsContext& ctx = _rgcontext[ApplySign(Qs, sign)];
|
||||
JlsContext& ctx = _contexts[ApplySign(Qs, sign)];
|
||||
int k = ctx.GetGolomb();
|
||||
int Px = traits.CorrectPrediction(pred + ApplySign(ctx.C, sign));
|
||||
|
||||
int ErrVal = traits.ComputeErrVal(ApplySign(x - Px, sign));
|
||||
|
||||
EncodeMappedValue(k, GetMappedErrVal(ctx.GetErrorCorrection(k | traits.NEAR) ^ ErrVal), traits.LIMIT);
|
||||
@ -366,6 +363,7 @@ inlinehint void JlsCodec<TRAITS,STRATEGY>::EncodeMappedValue(int k, UINT mappede
|
||||
template<class TRAITS, class STRATEGY>
|
||||
void JlsCodec<TRAITS,STRATEGY>::InitQuantizationLUT()
|
||||
{
|
||||
// for lossless mode with default paramaters, we have precomputed te luts for bitcounts 8,10,12 and 16
|
||||
if (traits.NEAR == 0 && traits.MAXVAL == (1 << traits.bpp) - 1)
|
||||
{
|
||||
Presets presets = ComputeDefault(traits.MAXVAL, traits.NEAR);
|
||||
@ -426,74 +424,39 @@ signed char JlsCodec<TRAITS,STRATEGY>::QuantizeGratientOrg(int Di)
|
||||
|
||||
|
||||
template<class TRAITS, class STRATEGY>
|
||||
void JlsCodec<TRAITS,STRATEGY>::EncodeRunPixels(int RUNcnt, bool bEndofline)
|
||||
void JlsCodec<TRAITS,STRATEGY>::EncodeRunPixels(int runLength, bool bEndofline)
|
||||
{
|
||||
while (RUNcnt >= (1 << J[RUNindex]))
|
||||
while (runLength >= (1 << J[RUNindex]))
|
||||
{
|
||||
AppendOnesToBitStream(1);
|
||||
RUNcnt = RUNcnt - (1 << J[RUNindex]);
|
||||
runLength = runLength - (1 << J[RUNindex]);
|
||||
IncrementRunIndex();
|
||||
}
|
||||
|
||||
if (bEndofline)
|
||||
{
|
||||
if (RUNcnt != 0)
|
||||
if (runLength != 0)
|
||||
{
|
||||
AppendOnesToBitStream(1);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
AppendToBitStream(RUNcnt, J[RUNindex] + 1); // leading 0 + actual remaining length
|
||||
AppendToBitStream(runLength, J[RUNindex] + 1); // leading 0 + actual remaining length
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
template<class TRAITS, class STRATEGY>
|
||||
int JlsCodec<TRAITS,STRATEGY>::DecodeRunPixels(PIXEL Ra, PIXEL* ptype, int ipixel, int cpixelMac)
|
||||
{
|
||||
int cpixelRun = 0;
|
||||
|
||||
while (ReadBit())
|
||||
{
|
||||
int cpixel = min(1 << J[RUNindex], cpixelMac - ipixel);
|
||||
|
||||
cpixelRun += cpixel;
|
||||
|
||||
if (cpixel == (1 << J[RUNindex]))
|
||||
{
|
||||
IncrementRunIndex();
|
||||
}
|
||||
|
||||
}
|
||||
if (ipixel + cpixelRun < cpixelMac)
|
||||
{
|
||||
// incomplete run
|
||||
cpixelRun += (J[RUNindex] > 0) ? ReadValue(J[RUNindex]) : 0;
|
||||
}
|
||||
|
||||
for (int i = 0; i < cpixelRun; ++i)
|
||||
{
|
||||
ptype[ipixel + i] = Ra;
|
||||
}
|
||||
|
||||
return ipixel + cpixelRun;
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
template<class TRAITS, class STRATEGY>
|
||||
int JlsCodec<TRAITS,STRATEGY>::DecodeRunPixels(PIXEL Ra, PIXEL* ptype, int ipixel, int cpixelMac)
|
||||
int JlsCodec<TRAITS,STRATEGY>::DecodeRunPixels(PIXEL Ra, PIXEL* ptype, int cpixelMac)
|
||||
{
|
||||
int ipixel = 0;
|
||||
while (ReadBit())
|
||||
{
|
||||
int cpixel = min(1 << J[RUNindex], cpixelMac - ipixel);
|
||||
for (int i = 0; i < cpixel; ++i)
|
||||
{
|
||||
ptype[ipixel] = Ra;
|
||||
ipixel++;
|
||||
ASSERT(ipixel <= cpixelMac);
|
||||
}
|
||||
ipixel += cpixel;
|
||||
ASSERT(ipixel <= cpixelMac);
|
||||
|
||||
if (cpixel == (1 << J[RUNindex]))
|
||||
{
|
||||
@ -501,18 +464,21 @@ int JlsCodec<TRAITS,STRATEGY>::DecodeRunPixels(PIXEL Ra, PIXEL* ptype, int ipixe
|
||||
}
|
||||
|
||||
if (ipixel == cpixelMac)
|
||||
return ipixel;
|
||||
break;
|
||||
}
|
||||
|
||||
// incomplete run
|
||||
UINT cpixelRun = (J[RUNindex] > 0) ? ReadValue(J[RUNindex]) : 0;
|
||||
|
||||
for (UINT i = 0; i < cpixelRun; ++i)
|
||||
|
||||
|
||||
if (ipixel != cpixelMac)
|
||||
{
|
||||
ptype[ipixel] = Ra;
|
||||
ipixel++;
|
||||
// incomplete run
|
||||
ipixel += (J[RUNindex] > 0) ? ReadValue(J[RUNindex]) : 0;
|
||||
}
|
||||
|
||||
for (int i = 0; i < ipixel; ++i)
|
||||
{
|
||||
ptype[i] = Ra;
|
||||
}
|
||||
|
||||
return ipixel;
|
||||
}
|
||||
|
||||
@ -550,17 +516,9 @@ Triplet JlsCodec<TRAITS,STRATEGY>::DecodeRIPixel(Triplet Ra, Triplet Rb)
|
||||
int Errval2 = DecodeRIError(_contextRunmode[0]);
|
||||
int Errval3 = DecodeRIError(_contextRunmode[0]);
|
||||
|
||||
//*
|
||||
|
||||
return Triplet(traits.ComputeReconstructedSample(Rb.v1, Errval1 * Sign(Rb.v1 - Ra.v1)),
|
||||
traits.ComputeReconstructedSample(Rb.v2, Errval2 * Sign(Rb.v2 - Ra.v2)),
|
||||
traits.ComputeReconstructedSample(Rb.v3, Errval3 * Sign(Rb.v3 - Ra.v3)));
|
||||
|
||||
/*/
|
||||
return Triplet(Rb.v1 + Errval1 * Sign(Rb.v1 - Ra.v1),
|
||||
Rb.v2 + Errval2 * Sign(Rb.v2 - Ra.v2),
|
||||
Rb.v3 + Errval3 * Sign(Rb.v3 - Ra.v3));
|
||||
//*/
|
||||
}
|
||||
|
||||
|
||||
@ -625,60 +583,61 @@ typename TRAITS::SAMPLE JlsCodec<TRAITS,STRATEGY>::EncodeRIPixel(int x, int Ra,
|
||||
|
||||
|
||||
template<class TRAITS, class STRATEGY>
|
||||
int JlsCodec<TRAITS,STRATEGY>::DoRunMode(PIXEL* ptype, const PIXEL* ptypePrev, int ipixel, int ctypeRem, EncoderStrategy*)
|
||||
int JlsCodec<TRAITS,STRATEGY>::DoRunMode(int ipixel, EncoderStrategy*)
|
||||
{
|
||||
ptype += ipixel;
|
||||
ptypePrev += ipixel;
|
||||
ctypeRem -= ipixel;
|
||||
int ctypeRem = _size.cx - ipixel;
|
||||
PIXEL* ptypeCurX = ptypeCur + ipixel;
|
||||
PIXEL* ptypePrevX = ptypePrev + ipixel;
|
||||
|
||||
PIXEL Ra = ptype[-1];
|
||||
PIXEL Ra = ptypeCurX[-1];
|
||||
|
||||
int RUNcnt = 0;
|
||||
int runLength = 0;
|
||||
|
||||
while (traits.IsNear(ptype[RUNcnt],Ra))
|
||||
while (traits.IsNear(ptypeCurX[runLength],Ra))
|
||||
{
|
||||
ptype[RUNcnt] = Ra;
|
||||
RUNcnt++;
|
||||
ptypeCurX[runLength] = Ra;
|
||||
runLength++;
|
||||
|
||||
if (RUNcnt == ctypeRem)
|
||||
if (runLength == ctypeRem)
|
||||
break;
|
||||
}
|
||||
|
||||
EncodeRunPixels(RUNcnt, RUNcnt == ctypeRem);
|
||||
EncodeRunPixels(runLength, runLength == ctypeRem);
|
||||
|
||||
if (RUNcnt == ctypeRem)
|
||||
return RUNcnt;
|
||||
if (runLength == ctypeRem)
|
||||
return runLength;
|
||||
|
||||
ptype[RUNcnt] = EncodeRIPixel(ptype[RUNcnt], Ra, ptypePrev[RUNcnt]);
|
||||
ptypeCurX[runLength] = EncodeRIPixel(ptypeCurX[runLength], Ra, ptypePrevX[runLength]);
|
||||
DecrementRunIndex();
|
||||
return RUNcnt + 1;
|
||||
return runLength + 1;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<class TRAITS, class STRATEGY>
|
||||
int JlsCodec<TRAITS,STRATEGY>::DoRunMode(PIXEL* ptype, const PIXEL* ptypePrev, int ipixel, int cpixelMac, DecoderStrategy*)
|
||||
int JlsCodec<TRAITS,STRATEGY>::DoRunMode(int ipixelStart, DecoderStrategy*)
|
||||
{
|
||||
PIXEL Ra = ptype[ipixel-1];
|
||||
int ipixelStart = ipixel;
|
||||
PIXEL Ra = ptypeCur[ipixelStart-1];
|
||||
|
||||
int cpixelRun = DecodeRunPixels(Ra, ptypeCur + ipixelStart, _size.cx - ipixelStart);
|
||||
|
||||
int ipixelEnd = ipixelStart + cpixelRun;
|
||||
|
||||
ipixel = DecodeRunPixels(Ra, ptype, ipixel, cpixelMac);
|
||||
|
||||
if (ipixel == cpixelMac)
|
||||
return ipixel - ipixelStart;
|
||||
if (ipixelEnd == _size.cx)
|
||||
return ipixelEnd - ipixelStart;
|
||||
|
||||
// run interruption
|
||||
PIXEL Rb = ptypePrev[ipixel];
|
||||
ptype[ipixel] = DecodeRIPixel(Ra, Rb);
|
||||
PIXEL Rb = ptypePrev[ipixelEnd];
|
||||
ptypeCur[ipixelEnd] = DecodeRIPixel(Ra, Rb);
|
||||
DecrementRunIndex();
|
||||
return ipixel - ipixelStart + 1 ;
|
||||
return ipixelEnd - ipixelStart + 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<class TRAITS, class STRATEGY>
|
||||
void JlsCodec<TRAITS,STRATEGY>::DoLine(typename TRAITS::SAMPLE* ptype, const typename TRAITS::SAMPLE* ptypePrev)
|
||||
void JlsCodec<TRAITS,STRATEGY>::DoLine(SAMPLE*)
|
||||
{
|
||||
int ipixel = 0;
|
||||
int Rb = ptypePrev[ipixel-1];
|
||||
@ -686,7 +645,7 @@ void JlsCodec<TRAITS,STRATEGY>::DoLine(typename TRAITS::SAMPLE* ptype, const typ
|
||||
|
||||
while(ipixel < _size.cx)
|
||||
{
|
||||
int Ra = ptype[ipixel -1];
|
||||
int Ra = ptypeCur[ipixel -1];
|
||||
int Rc = Rb;
|
||||
Rb = Rd;
|
||||
Rd = ptypePrev[ipixel + 1];
|
||||
@ -695,13 +654,13 @@ void JlsCodec<TRAITS,STRATEGY>::DoLine(typename TRAITS::SAMPLE* ptype, const typ
|
||||
|
||||
if (Qs == 0)
|
||||
{
|
||||
ipixel += DoRunMode(ptype, ptypePrev, ipixel, _size.cx, (STRATEGY*)(NULL));
|
||||
ipixel += DoRunMode(ipixel, (STRATEGY*)(NULL));
|
||||
Rb = ptypePrev[ipixel-1];
|
||||
Rd = ptypePrev[ipixel];
|
||||
}
|
||||
else
|
||||
{
|
||||
ptype[ipixel] = DoRegular(Qs, ptype[ipixel], GetPredictedValue(Ra, Rb, Rc), (STRATEGY*)(NULL));
|
||||
ptypeCur[ipixel] = DoRegular(Qs, ptypeCur[ipixel], GetPredictedValue(Ra, Rb, Rc), (STRATEGY*)(NULL));
|
||||
ipixel++;
|
||||
}
|
||||
}
|
||||
@ -710,12 +669,12 @@ void JlsCodec<TRAITS,STRATEGY>::DoLine(typename TRAITS::SAMPLE* ptype, const typ
|
||||
|
||||
|
||||
template<class TRAITS, class STRATEGY>
|
||||
void JlsCodec<TRAITS,STRATEGY>::DoLine(Triplet* ptype, const Triplet* ptypePrev)
|
||||
void JlsCodec<TRAITS,STRATEGY>::DoLine(Triplet*)
|
||||
{
|
||||
int ipixel = 0;
|
||||
while(ipixel < _size.cx)
|
||||
{
|
||||
Triplet Ra = ptype[ipixel -1];
|
||||
Triplet Ra = ptypeCur[ipixel -1];
|
||||
Triplet Rc = ptypePrev[ipixel-1];
|
||||
Triplet Rb = ptypePrev[ipixel];
|
||||
Triplet Rd = ptypePrev[ipixel + 1];
|
||||
@ -726,15 +685,15 @@ void JlsCodec<TRAITS,STRATEGY>::DoLine(Triplet* ptype, const Triplet* ptypePrev)
|
||||
|
||||
if (Qs1 == 0 && Qs2 == 0 && Qs3 == 0)
|
||||
{
|
||||
ipixel += DoRunMode(ptype, ptypePrev, ipixel, _size.cx, (STRATEGY*)(NULL));
|
||||
ipixel += DoRunMode(ipixel, (STRATEGY*)(NULL));
|
||||
}
|
||||
else
|
||||
{
|
||||
Triplet Rx;
|
||||
Rx.v1 = DoRegular(Qs1, ptype[ipixel].v1, GetPredictedValue(Ra.v1, Rb.v1, Rc.v1), (STRATEGY*)(NULL));
|
||||
Rx.v2 = DoRegular(Qs2, ptype[ipixel].v2, GetPredictedValue(Ra.v2, Rb.v2, Rc.v2), (STRATEGY*)(NULL));
|
||||
Rx.v3 = DoRegular(Qs3, ptype[ipixel].v3, GetPredictedValue(Ra.v3, Rb.v3, Rc.v3), (STRATEGY*)(NULL));
|
||||
ptype[ipixel] = Rx;
|
||||
Rx.v1 = DoRegular(Qs1, ptypeCur[ipixel].v1, GetPredictedValue(Ra.v1, Rb.v1, Rc.v1), (STRATEGY*)(NULL));
|
||||
Rx.v2 = DoRegular(Qs2, ptypeCur[ipixel].v2, GetPredictedValue(Ra.v2, Rb.v2, Rc.v2), (STRATEGY*)(NULL));
|
||||
Rx.v3 = DoRegular(Qs3, ptypeCur[ipixel].v3, GetPredictedValue(Ra.v3, Rb.v3, Rc.v3), (STRATEGY*)(NULL));
|
||||
ptypeCur[ipixel] = Rx;
|
||||
ipixel++;
|
||||
}
|
||||
|
||||
@ -743,8 +702,6 @@ void JlsCodec<TRAITS,STRATEGY>::DoLine(Triplet* ptype, const Triplet* ptypePrev)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<class TRAITS, class STRATEGY>
|
||||
void JlsCodec<TRAITS,STRATEGY>::DoScan(PIXEL* ptype, BYTE* pbyteCompressed, int cbyteCompressed)
|
||||
{
|
||||
@ -756,7 +713,7 @@ void JlsCodec<TRAITS,STRATEGY>::DoScan(PIXEL* ptype, BYTE* pbyteCompressed, int
|
||||
vectmp.resize((1 + _components) * pixelstride);
|
||||
|
||||
std::vector<int> rgRUNindex;
|
||||
rgRUNindex.resize(3);
|
||||
rgRUNindex.resize(_components);
|
||||
|
||||
for (int iline = 0; iline < _size.cy * _components; ++iline)
|
||||
{
|
||||
@ -764,29 +721,19 @@ void JlsCodec<TRAITS,STRATEGY>::DoScan(PIXEL* ptype, BYTE* pbyteCompressed, int
|
||||
RUNindex = rgRUNindex[icomponent];
|
||||
|
||||
int indexPrev = iline % (_components + 1);
|
||||
int indexCur = (iline + 3) % (_components + 1);
|
||||
int indexCur = (iline + _components) % (_components + 1);
|
||||
|
||||
PIXEL* ptypePrev = &vectmp[1 + indexPrev * pixelstride];
|
||||
PIXEL* ptypeCur = &vectmp[1 + indexCur * pixelstride];
|
||||
|
||||
ptypePrev[_size.cx] = ptypePrev[_size.cx - 1];
|
||||
ptypeCur[-1] = ptypePrev[0];
|
||||
PIXEL* ptypeLine = ptype + iline * _size.cx;
|
||||
if (!STRATEGY::IsDecoding)
|
||||
{
|
||||
for (int i = 0; i < _size.cx; ++i)
|
||||
{
|
||||
ptypeCur[i] = ptypeLine[i];
|
||||
}
|
||||
}
|
||||
DoLine(ptypeCur, ptypePrev);
|
||||
if (STRATEGY::IsDecoding)
|
||||
{
|
||||
for (int i = 0; i < _size.cx; ++i)
|
||||
{
|
||||
CheckedAssign(ptypeLine[i], ptypeCur[i]);
|
||||
}
|
||||
}
|
||||
ptypePrev = &vectmp[1 + indexPrev * pixelstride];
|
||||
ptypeCur = &vectmp[1 + indexCur * pixelstride];
|
||||
PIXEL* ptypeLine = ptype + iline * _size.cx;
|
||||
|
||||
// initialize edge pixels used for prediction
|
||||
ptypePrev[_size.cx] = ptypePrev[_size.cx - 1];
|
||||
ptypeCur[-1] = ptypePrev[0];
|
||||
|
||||
OnLineBegin(ptypeCur, ptypeLine, _size.cx);
|
||||
DoLine((PIXEL*) NULL); // dummy arg for overload resolution
|
||||
OnLineEnd(ptypeCur, ptypeLine, _size.cx);
|
||||
|
||||
rgRUNindex[icomponent] = RUNindex;
|
||||
}
|
||||
@ -861,10 +808,10 @@ void JlsCodec<TRAITS,STRATEGY>::InitParams(int t1, int t2, int t3, int nReset)
|
||||
|
||||
InitQuantizationLUT();
|
||||
|
||||
JlsContext ctxDefault = JlsContext(max(2, (traits.RANGE + 32)/64));
|
||||
for (UINT Q = 0; Q < sizeof(_rgcontext) / sizeof(_rgcontext[0]); ++Q)
|
||||
int A = max(2, (traits.RANGE + 32)/64);
|
||||
for (UINT Q = 0; Q < sizeof(_contexts) / sizeof(_contexts[0]); ++Q)
|
||||
{
|
||||
_rgcontext[Q] = ctxDefault;
|
||||
_contexts[Q] = JlsContext(A);
|
||||
}
|
||||
|
||||
_contextRunmode[0] = CContextRunMode(max(2, (traits.RANGE + 32)/64), 0, nReset);
|
||||
|
||||
27
streams.h
27
streams.h
@ -8,22 +8,6 @@
|
||||
#include <vector>
|
||||
#include "util.h"
|
||||
|
||||
struct ScanInfo
|
||||
{
|
||||
ScanInfo() :
|
||||
cbit(0),
|
||||
nnear(0),
|
||||
ccomp(0),
|
||||
ilv(ILV_NONE),
|
||||
size(0,0)
|
||||
{
|
||||
}
|
||||
int cbit;
|
||||
int nnear;
|
||||
int ccomp;
|
||||
interleavemode ilv;
|
||||
Size size;
|
||||
};
|
||||
|
||||
class JpegSegment;
|
||||
|
||||
@ -89,7 +73,7 @@ private:
|
||||
int _cbyteOffset;
|
||||
int _cbyteLength;
|
||||
int _icompLast;
|
||||
std::vector<JpegSegment*> _rgsegment;
|
||||
std::vector<JpegSegment*> _segments;
|
||||
};
|
||||
|
||||
|
||||
@ -119,11 +103,11 @@ public:
|
||||
int GetBytesRead()
|
||||
{ return _cbyteOffset; }
|
||||
|
||||
const ScanInfo& GetMetadata() const
|
||||
const JlsParamaters& GetMetadata() const
|
||||
{ return _info; }
|
||||
|
||||
const Presets& GetCustomPreset() const
|
||||
{ return _presets; }
|
||||
const JlsCustomParameters& GetCustomPreset() const
|
||||
{ return _info.custom; }
|
||||
|
||||
bool Read(void* pvoid, int cbyteAvailable);
|
||||
int ReadHeader();
|
||||
@ -145,8 +129,7 @@ private:
|
||||
int _cbyteOffset;
|
||||
int _cbyteLength;
|
||||
bool _bCompare;
|
||||
Presets _presets;
|
||||
ScanInfo _info;
|
||||
JlsParamaters _info;
|
||||
};
|
||||
|
||||
|
||||
|
||||
@ -111,12 +111,6 @@ void TestRoundTrip(const char* strName, const BYTE* rgbyteRaw, Size size, int cb
|
||||
int cbyteCompressed;
|
||||
JpegLsEncode(&rgbyteCompressed[0], rgbyteCompressed.size(), &cbyteCompressed, rgbyteRaw, rgbyteOut.size(), ¶ms);
|
||||
|
||||
//size_t cbyteCompressed = JpegLsEncode(rgbyteRaw, size, cbit, ccomp, ccomp == 3 ? ILV_SAMPLE : ILV_NONE, &rgbyteCompressed[0], int(rgbyteCompressed.size()), 0);
|
||||
|
||||
//CString strDst = strName;
|
||||
//strDst = strDst + ".jls";
|
||||
//WriteFile(strDst.GetString(), &rgbyteCompressed[0], cbyteCompressed);
|
||||
|
||||
double dwtimeEncodeComplete = getTime();
|
||||
|
||||
JpegLsDecode(&rgbyteOut[0], rgbyteOut.size(), &rgbyteCompressed[0], int(cbyteCompressed));
|
||||
@ -169,27 +163,16 @@ void TestCompliance(const BYTE* pbyteCompressed, int cbyteCompressed, const BYTE
|
||||
|
||||
JLS_ERROR error = JpegLsVerifyEncode(&rgbyteRaw[0], cbyteRaw, pbyteCompressed, cbyteCompressed);
|
||||
ASSERT(error == OK);
|
||||
// JpegLsEncode(&rgbyteOut[0], rgbyteOut.size(), &cbyteCompressedActual, &rgbyteRaw[0], cbyteRaw, ¶ms);
|
||||
|
||||
//BYTE* pbyteOut = &rgbyteOut[0];
|
||||
//for (UINT i = 0; i < cbyteCompressed; ++i)
|
||||
//{
|
||||
// if (pbyteCompressed[i] != pbyteOut[i])
|
||||
// {
|
||||
// ASSERT(false);
|
||||
// break;
|
||||
// }
|
||||
//}
|
||||
}
|
||||
|
||||
|
||||
void TestFile(SZC strName, int ioffs, Size size2, int cbit, int ccomp)
|
||||
{
|
||||
std::vector<BYTE> rgbyteNoise;
|
||||
std::vector<BYTE> rgbyteUncompressed;
|
||||
|
||||
ReadFile(strName, &rgbyteNoise, ioffs);
|
||||
ReadFile(strName, &rgbyteUncompressed, ioffs);
|
||||
|
||||
TestRoundTrip(strName, &rgbyteNoise[0], size2, cbit, ccomp);
|
||||
TestRoundTrip(strName, &rgbyteUncompressed[0], size2, cbit, ccomp);
|
||||
|
||||
};
|
||||
|
||||
@ -341,6 +324,36 @@ void TestSampleAnnexH3()
|
||||
// TestJls(vecRaw, size, 8, 1, ILV_NONE, rgbyteComp, sizeof(rgbyteComp), false);
|
||||
}
|
||||
|
||||
void TestSmallBuffer()
|
||||
{
|
||||
std::vector<BYTE> rgbyteCompressed;
|
||||
ReadFile("..\\test\\lena8b.jls", &rgbyteCompressed, 0);
|
||||
|
||||
std::vector<BYTE> rgbyteOut;
|
||||
rgbyteOut.resize(512 * 511);
|
||||
JLS_ERROR error = JpegLsDecode(&rgbyteOut[0], rgbyteOut.size(), &rgbyteCompressed[0], int(rgbyteCompressed.size()));
|
||||
ASSERT(error == JLS_ERROR::UncompressedBufferTooSmall);
|
||||
}
|
||||
|
||||
|
||||
void TestDamagedBitStream()
|
||||
{
|
||||
|
||||
std::vector<BYTE> rgbyteCompressed;
|
||||
ReadFile("..\\test\\lena8b.jls", &rgbyteCompressed, 0);
|
||||
|
||||
rgbyteCompressed.resize(900);
|
||||
rgbyteCompressed.resize(40000,3);
|
||||
|
||||
std::vector<BYTE> rgbyteOut;
|
||||
rgbyteOut.resize(512 * 512);
|
||||
JLS_ERROR error = JpegLsDecode(&rgbyteOut[0], rgbyteOut.size(), &rgbyteCompressed[0], int(rgbyteCompressed.size()));
|
||||
ASSERT(error == JLS_ERROR::InvalidCompressedData);
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
void TestConformance()
|
||||
{
|
||||
|
||||
@ -382,9 +395,6 @@ void TestConformance()
|
||||
|
||||
// additional, Lena compressed with other codec (UBC?), vfy with CharLS
|
||||
DecompressFile("..\\test\\lena8b.jls", "..\\test\\lena8b.raw",0);
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -392,6 +402,8 @@ void TestConformance()
|
||||
|
||||
int _tmain(int argc, _TCHAR* argv[])
|
||||
{
|
||||
TestDamagedBitStream();
|
||||
TestSmallBuffer();
|
||||
TestConformance();
|
||||
TestSampleAnnexH3();
|
||||
TestTraits16bit();
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user