mirror of
https://github.com/team-charls/charls
synced 2025-03-28 21:03:13 +00:00
Refactorings for better color support in the future. (BGR format and 16/12 bits per sample color).
This commit is contained in:
jdv_cp
parent
3aaa171d3e
commit
24a29b1345
158
colortransform.h
158
colortransform.h
@ -4,18 +4,30 @@
|
||||
#ifndef CHARLS_COLORTRANSFORM
|
||||
#define CHARLS_COLORTRANSFORM
|
||||
|
||||
|
||||
struct TransformNone
|
||||
struct TransformNoneImpl
|
||||
{
|
||||
inlinehint static Triplet Apply(int v1, int v2, int v3)
|
||||
{ return Triplet(v1, v2, v3); }
|
||||
inlinehint static Triplet<BYTE> Apply(int v1, int v2, int v3)
|
||||
{ return Triplet<BYTE>(v1, v2, v3); }
|
||||
};
|
||||
|
||||
struct TransformRgbToHp1
|
||||
struct TransformNone : public TransformNoneImpl
|
||||
{
|
||||
inlinehint static Triplet Apply(int R, int G, int B)
|
||||
typedef struct TransformNoneImpl INVERSE;
|
||||
};
|
||||
|
||||
|
||||
struct TransformHp1ToRgb
|
||||
{
|
||||
inlinehint static Triplet<BYTE> Apply(int v1, int v2, int v3)
|
||||
{ return Triplet<BYTE>(v1 + v2 - 0x80, v2, v3 + v2 - 0x80); }
|
||||
};
|
||||
|
||||
struct TransformHp1
|
||||
{
|
||||
typedef struct TransformHp1ToRgb INVERSE;
|
||||
inlinehint static Triplet<BYTE> Apply(int R, int G, int B)
|
||||
{
|
||||
Triplet hp1;
|
||||
Triplet<BYTE> hp1;
|
||||
hp1.v2 = BYTE(G);
|
||||
hp1.v1 = BYTE(R - G + 0x80);
|
||||
hp1.v3 = BYTE(B - G + 0x80);
|
||||
@ -23,32 +35,26 @@ struct TransformRgbToHp1
|
||||
}
|
||||
};
|
||||
|
||||
struct TransformHp1ToRgb
|
||||
|
||||
struct TransformHp2
|
||||
{
|
||||
inlinehint static Triplet Apply(int v1, int v2, int v3)
|
||||
{ return Triplet(v1 + v2 - 0x80, v2, v3 + v2 - 0x80); }
|
||||
};
|
||||
|
||||
|
||||
|
||||
struct TransformRgbToHp2
|
||||
{
|
||||
inlinehint static Triplet Apply(int R, int G, int B)
|
||||
typedef struct TransformHp2ToRgb INVERSE;
|
||||
inlinehint static Triplet<BYTE> Apply(int R, int G, int B)
|
||||
{
|
||||
//Triplet hp2;
|
||||
//Triplet<BYTE> hp2;
|
||||
//hp2.v1 = BYTE(R - G + 0x80);
|
||||
//hp2.v2 = BYTE(G);
|
||||
//hp2.v3 = BYTE(B - ((R+G )>>1) - 0x80);
|
||||
//return hp2;
|
||||
return Triplet(R - G + 0x80, G, B - ((R+G )>>1) - 0x80);
|
||||
return Triplet<BYTE>(R - G + 0x80, G, B - ((R+G )>>1) - 0x80);
|
||||
}
|
||||
};
|
||||
|
||||
struct TransformHp2ToRgb
|
||||
{
|
||||
inlinehint static Triplet Apply(int v1, int v2, int v3)
|
||||
inlinehint static Triplet<BYTE> Apply(int v1, int v2, int v3)
|
||||
{
|
||||
Triplet rgb;
|
||||
Triplet<BYTE> rgb;
|
||||
rgb.R = BYTE(v1 + v2 - 0x80); // new R
|
||||
rgb.G = BYTE(v2); // new G
|
||||
rgb.B = BYTE(v3 + ((rgb.R + rgb.G) >> 1) - 0x80); // new B
|
||||
@ -56,15 +62,17 @@ struct TransformHp2ToRgb
|
||||
}
|
||||
};
|
||||
|
||||
struct TransformRgbToHp3
|
||||
|
||||
|
||||
struct TransformHp3
|
||||
{
|
||||
inlinehint static Triplet Apply(int R, int G, int B)
|
||||
typedef struct TransformHp3ToRgb INVERSE;
|
||||
inlinehint static Triplet<BYTE> Apply(int R, int G, int B)
|
||||
{
|
||||
Triplet hp3;
|
||||
Triplet<BYTE> hp3;
|
||||
hp3.v2 = BYTE(B - G + 0x80);
|
||||
hp3.v3 = BYTE(R - G + 0x80);
|
||||
|
||||
hp3.v1 = BYTE(G + ((hp3.v2 + hp3.v3 )>>2) - 0x40);
|
||||
hp3.v1 = BYTE(G + ((hp3.v2 + hp3.v3)>>2)) - 0x40;
|
||||
return hp3;
|
||||
}
|
||||
};
|
||||
@ -72,10 +80,10 @@ struct TransformRgbToHp3
|
||||
|
||||
struct TransformHp3ToRgb
|
||||
{
|
||||
inlinehint static Triplet Apply(int v1, int v2, int v3)
|
||||
inlinehint static Triplet<BYTE> Apply(int v1, int v2, int v3)
|
||||
{
|
||||
int G = v1 - ((v3 + v2)>>2)+0x40;
|
||||
Triplet rgb;
|
||||
int G = v1 - ((v3 + v2)>>2) + 0x40;
|
||||
Triplet<BYTE> rgb;
|
||||
rgb.R = BYTE(v3 + G - 0x80); // new R
|
||||
rgb.G = BYTE(G); // new G
|
||||
rgb.B = BYTE(v2 + G - 0x80); // new B
|
||||
@ -85,7 +93,7 @@ struct TransformHp3ToRgb
|
||||
|
||||
|
||||
template<class TRANSFORM>
|
||||
void TransformLine(Triplet* pDest, const Triplet* pSrc, int pixelCount, const TRANSFORM&)
|
||||
void TransformLine(Triplet<BYTE>* pDest, const Triplet<BYTE>* pSrc, int pixelCount, const TRANSFORM&)
|
||||
{
|
||||
for (int i = 0; i < pixelCount; ++i)
|
||||
{
|
||||
@ -98,7 +106,7 @@ template<class TRANSFORM>
|
||||
void TransformLineToTriplet(const BYTE* ptypeInput, LONG pixelStrideIn, BYTE* pbyteBuffer, LONG pixelStride, const TRANSFORM&)
|
||||
{
|
||||
int cpixel = MIN(pixelStride, pixelStrideIn);
|
||||
Triplet* ptypeBuffer = (Triplet*)pbyteBuffer;
|
||||
Triplet<BYTE>* ptypeBuffer = (Triplet<BYTE>*)pbyteBuffer;
|
||||
|
||||
for (int x = 0; x < cpixel; ++x)
|
||||
{
|
||||
@ -110,12 +118,12 @@ template<class TRANSFORM>
|
||||
void TransformTripletToLine(const BYTE* pbyteInput, LONG pixelStrideIn, BYTE* ptypeBuffer, LONG pixelStride, const TRANSFORM&)
|
||||
{
|
||||
int cpixel = MIN(pixelStride, pixelStrideIn);
|
||||
const Triplet* ptypeBufferIn = (Triplet*)pbyteInput;
|
||||
const Triplet<BYTE>* ptypeBufferIn = (Triplet<BYTE>*)pbyteInput;
|
||||
|
||||
for (int x = 0; x < cpixel; ++x)
|
||||
{
|
||||
Triplet color = ptypeBufferIn[x];
|
||||
Triplet colorTranformed = TRANSFORM::Apply(color.v1, color.v2, color.v3);
|
||||
Triplet<BYTE> color = ptypeBufferIn[x];
|
||||
Triplet<BYTE> colorTranformed = TRANSFORM::Apply(color.v1, color.v2, color.v3);
|
||||
|
||||
ptypeBuffer[x] = colorTranformed.v1;
|
||||
ptypeBuffer[x + pixelStride] = colorTranformed.v2;
|
||||
@ -124,4 +132,86 @@ void TransformTripletToLine(const BYTE* pbyteInput, LONG pixelStrideIn, BYTE* pt
|
||||
}
|
||||
|
||||
|
||||
class PostProcessLine
|
||||
{
|
||||
public:
|
||||
virtual ~PostProcessLine() {}
|
||||
virtual void NewLineDecoded(const void* pSrc, int pixelCount, int byteStride) = 0;
|
||||
virtual void NewLineRequested(void* pSrc, int pixelCount, int byteStride) = 0;
|
||||
};
|
||||
|
||||
|
||||
template<class TRANSFORM>
|
||||
class PostProcessTransformed : public PostProcessLine
|
||||
{
|
||||
PostProcessTransformed(const PostProcessTransformed&) {}
|
||||
public:
|
||||
PostProcessTransformed(void* pbyteOutput, const JlsParamaters& info) :
|
||||
_pbyteOutput((BYTE*)pbyteOutput),
|
||||
_info(info)
|
||||
{
|
||||
ASSERT(_info.components == 3);
|
||||
}
|
||||
|
||||
void NewLineRequested(void* pDst, int pixelCount, int byteStride)
|
||||
{
|
||||
if (_info.ilv == ILV_SAMPLE)
|
||||
{
|
||||
TransformLine((Triplet<BYTE>*)pDst, (const Triplet<BYTE>*)_pbyteOutput, pixelCount, TRANSFORM());
|
||||
}
|
||||
else
|
||||
{
|
||||
TransformTripletToLine((const BYTE*)_pbyteOutput, pixelCount, (BYTE*)pDst, byteStride, TRANSFORM());
|
||||
}
|
||||
_pbyteOutput += 3*pixelCount;
|
||||
}
|
||||
|
||||
void NewLineDecoded(const void* pSrc, int pixelCount, int byteStride)
|
||||
{
|
||||
if (_info.ilv == ILV_SAMPLE)
|
||||
{
|
||||
TransformLine((Triplet<BYTE>*)_pbyteOutput, (const Triplet<BYTE>*)pSrc, pixelCount, TRANSFORM::INVERSE());
|
||||
}
|
||||
else
|
||||
{
|
||||
TransformLineToTriplet((const BYTE*)pSrc, byteStride, _pbyteOutput, pixelCount, TRANSFORM::INVERSE());
|
||||
}
|
||||
_pbyteOutput += 3* pixelCount;
|
||||
}
|
||||
|
||||
private:
|
||||
BYTE* _pbyteOutput;
|
||||
const JlsParamaters& _info;
|
||||
};
|
||||
|
||||
|
||||
class PostProcesSingleComponent : public PostProcessLine
|
||||
{
|
||||
public:
|
||||
PostProcesSingleComponent(void* pbyteOutput, const JlsParamaters& info, int bytesPerPixel) :
|
||||
_pbyteOutput((BYTE*)pbyteOutput),
|
||||
_bytesPerPixel(bytesPerPixel),
|
||||
_info(info)
|
||||
{
|
||||
}
|
||||
|
||||
void NewLineRequested(void* pDst, int pixelCount, int byteStride)
|
||||
{
|
||||
::memcpy(pDst, _pbyteOutput, pixelCount * _bytesPerPixel);
|
||||
_pbyteOutput += pixelCount * _bytesPerPixel;
|
||||
}
|
||||
|
||||
void NewLineDecoded(const void* pSrc, int pixelCount, int byteStride)
|
||||
{
|
||||
::memcpy(_pbyteOutput, pSrc, pixelCount * _bytesPerPixel);
|
||||
_pbyteOutput += pixelCount * _bytesPerPixel;
|
||||
}
|
||||
|
||||
private:
|
||||
BYTE* _pbyteOutput;
|
||||
int _bytesPerPixel;
|
||||
const JlsParamaters& _info;
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
@ -16,18 +16,22 @@ public:
|
||||
_readCache(0),
|
||||
_validBits(0),
|
||||
_pbyteCompressed(0),
|
||||
_info(info)
|
||||
_info(info),
|
||||
_postProcessLine(0)
|
||||
{
|
||||
if (_info.ilv != ILV_LINE)
|
||||
{
|
||||
_info.components = 1;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
enum { IsDecoding = 1};
|
||||
|
||||
virtual ~DecoderStrategy()
|
||||
{}
|
||||
{
|
||||
delete _postProcessLine;
|
||||
}
|
||||
|
||||
virtual void SetPresets(const JlsCustomParameters& presets) = 0;
|
||||
virtual size_t DecodeScan(void* pvoidOut, const Size& size, const void* pvoidIn, size_t cbyte, bool bCheck) = 0;
|
||||
@ -49,63 +53,13 @@ public:
|
||||
}
|
||||
|
||||
|
||||
void OnLineBegin(int iline, LONG cpixel, void* ptypeBuffer, LONG pixelStride)
|
||||
void OnLineBegin(LONG cpixel, void* ptypeBuffer, LONG pixelStride)
|
||||
{}
|
||||
|
||||
|
||||
|
||||
void OnLineEnd(int iline, LONG cpixel, const Triplet* ptypeBuffer, LONG pixelStride)
|
||||
void OnLineEnd(LONG cpixel, const void* ptypeBuffer, LONG pixelStride)
|
||||
{
|
||||
Triplet* ptypeUnc = ((Triplet*)_ptypeUncompressed) + iline * cpixel;
|
||||
|
||||
switch(_info.colorTransform)
|
||||
{
|
||||
case COLORXFORM_NONE : return TransformLine(ptypeUnc, ptypeBuffer, cpixel, TransformNone());
|
||||
case COLORXFORM_HP1 : return TransformLine(ptypeUnc, ptypeBuffer, cpixel, TransformHp1ToRgb());
|
||||
case COLORXFORM_HP2 : return TransformLine(ptypeUnc, ptypeBuffer, cpixel, TransformHp2ToRgb());
|
||||
case COLORXFORM_HP3 : return TransformLine(ptypeUnc, ptypeBuffer, cpixel, TransformHp3ToRgb());
|
||||
}
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void OnLineEnd(int iline, LONG cpixel, const T* ptypeBuffer, LONG pixelStride)
|
||||
{
|
||||
|
||||
|
||||
for (int icomponent = 0; icomponent < _info.components; ++icomponent)
|
||||
{
|
||||
T* ptypeUnc = ((T*)_ptypeUncompressed) + (iline *_info.components + icomponent)* cpixel;
|
||||
#ifdef _DEBUG
|
||||
for (LONG i = 0; i < cpixel; ++i)
|
||||
{
|
||||
//CheckedAssign(ptypeLine[i], ptypeCur[i]);
|
||||
ptypeUnc[i] = ptypeBuffer[i + icomponent*pixelStride];
|
||||
}
|
||||
#else
|
||||
memcpy(ptypeUnc, ptypeBuffer+ icomponent*pixelStride, cpixel * sizeof(T) );
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
void OnLineEnd(int iline, LONG cpixel, const BYTE* ptypeBuffer, LONG pixelStride)
|
||||
{
|
||||
BYTE* ptypeUnc = ((BYTE*)(_ptypeUncompressed));
|
||||
if (_info.components == 1)
|
||||
{
|
||||
memcpy(ptypeUnc + cpixel * iline, ptypeBuffer, cpixel * sizeof(BYTE));
|
||||
return;
|
||||
}
|
||||
|
||||
ptypeUnc += iline * _info.components * cpixel;
|
||||
|
||||
switch(_info.colorTransform)
|
||||
{
|
||||
case COLORXFORM_NONE : return TransformLineToTriplet(ptypeBuffer, pixelStride, ptypeUnc, cpixel, TransformNone());
|
||||
case COLORXFORM_HP1 : return TransformLineToTriplet(ptypeBuffer, pixelStride, ptypeUnc, cpixel, TransformHp1ToRgb());
|
||||
case COLORXFORM_HP2 : return TransformLineToTriplet(ptypeBuffer, pixelStride, ptypeUnc, cpixel, TransformHp2ToRgb());
|
||||
case COLORXFORM_HP3 : return TransformLineToTriplet(ptypeBuffer, pixelStride, ptypeUnc, cpixel, TransformHp3ToRgb());
|
||||
}
|
||||
|
||||
_postProcessLine->NewLineDecoded(ptypeBuffer, cpixel, pixelStride);
|
||||
}
|
||||
|
||||
typedef size_t bufType;
|
||||
@ -142,8 +96,8 @@ public:
|
||||
return;
|
||||
}
|
||||
|
||||
bufType valnew = *_pbyteCompressed;
|
||||
_readCache |= bufType(_pbyteCompressed[0]) << (bufferbits - 8 - _validBits);
|
||||
bufType valnew = _pbyteCompressed[0];
|
||||
_readCache |= valnew << (bufferbits - 8 - _validBits);
|
||||
_pbyteCompressed += 1;
|
||||
_validBits += 8;
|
||||
|
||||
@ -155,6 +109,7 @@ public:
|
||||
while (_validBits < bufferbits - 8);
|
||||
|
||||
_pbyteNextFF = FindNextFF();
|
||||
return;
|
||||
|
||||
}
|
||||
|
||||
@ -163,9 +118,12 @@ public:
|
||||
{
|
||||
BYTE* pbyteNextFF =_pbyteCompressed;
|
||||
|
||||
while (pbyteNextFF < _pbyteCompressedEnd && *pbyteNextFF != 0xFF)
|
||||
while (pbyteNextFF < _pbyteCompressedEnd)
|
||||
{
|
||||
pbyteNextFF++;
|
||||
if (*pbyteNextFF == 0xFF)
|
||||
break;
|
||||
|
||||
pbyteNextFF++;
|
||||
}
|
||||
|
||||
return pbyteNextFF - (sizeof(bufType)-1);
|
||||
@ -279,6 +237,7 @@ public:
|
||||
protected:
|
||||
JlsParamaters _info;
|
||||
void* _ptypeUncompressed;
|
||||
PostProcessLine* _postProcessLine;
|
||||
|
||||
private:
|
||||
// decoding
|
||||
|
||||
@ -61,7 +61,7 @@ public:
|
||||
inlinehint bool IsNear(LONG lhs, LONG rhs) const
|
||||
{ return abs(lhs-rhs) <=NEAR; }
|
||||
|
||||
bool IsNear(Triplet lhs, Triplet rhs) const
|
||||
bool IsNear(Triplet<BYTE> lhs, Triplet<BYTE> rhs) const
|
||||
{
|
||||
return abs(lhs.v1-rhs.v1) <=NEAR && abs(lhs.v2-rhs.v2) <=NEAR && abs(lhs.v3-rhs.v3) <=NEAR;
|
||||
}
|
||||
|
||||
@ -18,61 +18,28 @@ public:
|
||||
bitpos(0),
|
||||
_bFFWritten(false),
|
||||
_cbyteWritten(0),
|
||||
_info(info)
|
||||
_info(info),
|
||||
_postProcessLine(0)
|
||||
{
|
||||
if (_info.ilv != ILV_LINE)
|
||||
{
|
||||
_info.components = 1;
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
virtual ~EncoderStrategy()
|
||||
{}
|
||||
{
|
||||
delete _postProcessLine;
|
||||
}
|
||||
|
||||
LONG PeekByte();
|
||||
|
||||
|
||||
|
||||
void OnLineBegin(int iline, LONG cpixel, Triplet* ptypeBuffer, LONG /*pixelStride*/)
|
||||
void OnLineBegin(LONG cpixel, void* ptypeBuffer, LONG pixelStride)
|
||||
{
|
||||
Triplet* ptypeInput = ((Triplet*)(_ptypeUncompressed));
|
||||
|
||||
switch(_info.colorTransform)
|
||||
{
|
||||
case COLORXFORM_NONE : return TransformLine(ptypeBuffer, ptypeInput + cpixel*iline, cpixel, TransformNone());
|
||||
case COLORXFORM_HP1 : return TransformLine(ptypeBuffer, ptypeInput + cpixel*iline, cpixel, TransformRgbToHp1());
|
||||
case COLORXFORM_HP2 : return TransformLine(ptypeBuffer, ptypeInput + cpixel*iline, cpixel, TransformRgbToHp2());
|
||||
case COLORXFORM_HP3 : return TransformLine(ptypeBuffer, ptypeInput + cpixel*iline, cpixel, TransformRgbToHp3());
|
||||
}
|
||||
_postProcessLine->NewLineRequested(ptypeBuffer, cpixel, pixelStride);
|
||||
}
|
||||
|
||||
void OnLineBegin(int iline, LONG cpixel, USHORT* ptypeBuffer, LONG /*pixelStride*/)
|
||||
{
|
||||
USHORT* ptypeInput = ((USHORT*)(_ptypeUncompressed));
|
||||
memcpy(ptypeBuffer, ptypeInput + cpixel*iline, cpixel * sizeof(USHORT));
|
||||
}
|
||||
|
||||
void OnLineBegin(int iline, LONG cpixel, BYTE* ptypeBuffer, LONG pixelStride)
|
||||
{
|
||||
BYTE* ptypeUnc = ((BYTE*)(_ptypeUncompressed));
|
||||
if (_info.components == 1)
|
||||
{
|
||||
memcpy(ptypeBuffer, ptypeUnc + cpixel * iline, cpixel * sizeof(BYTE));
|
||||
return;
|
||||
}
|
||||
|
||||
ptypeUnc += iline * _info.components * cpixel;
|
||||
|
||||
switch(_info.colorTransform)
|
||||
{
|
||||
case COLORXFORM_NONE : return TransformTripletToLine(ptypeUnc, cpixel, ptypeBuffer, pixelStride, TransformNone());
|
||||
case COLORXFORM_HP1 : return TransformTripletToLine(ptypeUnc, cpixel, ptypeBuffer, pixelStride, TransformRgbToHp1());
|
||||
case COLORXFORM_HP2 : return TransformTripletToLine(ptypeUnc, cpixel, ptypeBuffer, pixelStride, TransformRgbToHp2());
|
||||
case COLORXFORM_HP3 : return TransformTripletToLine(ptypeUnc, cpixel, ptypeBuffer, pixelStride, TransformRgbToHp3());
|
||||
}
|
||||
}
|
||||
|
||||
void OnLineEnd(int iline, LONG cpixel, void* ptypeBuffer, LONG pixelStride) {};
|
||||
void OnLineEnd(LONG cpixel, void* ptypeBuffer, LONG pixelStride) {};
|
||||
|
||||
virtual void SetPresets(const JlsCustomParameters& presets) = 0;
|
||||
|
||||
@ -167,7 +134,7 @@ protected:
|
||||
protected:
|
||||
JlsParamaters _info;
|
||||
const void* _ptypeUncompressed;
|
||||
|
||||
PostProcessLine* _postProcessLine;
|
||||
private:
|
||||
|
||||
unsigned int valcurrent;
|
||||
|
||||
@ -106,10 +106,10 @@ STRATEGY* JlsCodecFactory<STRATEGY>::GetCodecImpl(const JlsParamaters& _info)
|
||||
if (_info.components == 3 && _info.bitspersample == 8)
|
||||
{
|
||||
if (_info.allowedlossyerror == 0)
|
||||
return new JlsCodec<LosslessTraitsT<Triplet,8>, STRATEGY>(LosslessTraitsT<Triplet,8>(), _info);
|
||||
return new JlsCodec<LosslessTraitsT<Triplet<BYTE>,8>, STRATEGY>(LosslessTraitsT<Triplet<BYTE>,8>(), _info);
|
||||
|
||||
DefaultTraitsT<BYTE,Triplet> traits((1 << _info.bitspersample) - 1, _info.allowedlossyerror);
|
||||
return new JlsCodec<DefaultTraitsT<BYTE,Triplet>, STRATEGY>(traits, _info);
|
||||
DefaultTraitsT<BYTE,Triplet<BYTE>> traits((1 << _info.bitspersample) - 1, _info.allowedlossyerror);
|
||||
return new JlsCodec<DefaultTraitsT<BYTE,Triplet<BYTE>>, STRATEGY>(traits, _info);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
|
||||
@ -100,10 +100,10 @@ struct LosslessTraitsT<USHORT,16> : public LosslessTraitsImplT<USHORT,16>
|
||||
|
||||
|
||||
template<>
|
||||
struct LosslessTraitsT<Triplet,8> : public LosslessTraitsImplT<BYTE,8>
|
||||
struct LosslessTraitsT<Triplet<BYTE>,8> : public LosslessTraitsImplT<BYTE,8>
|
||||
{
|
||||
// enum { ccomponent = 3 };
|
||||
typedef Triplet PIXEL;
|
||||
typedef Triplet<BYTE> PIXEL;
|
||||
|
||||
static inlinehint bool IsNear(LONG lhs, LONG rhs)
|
||||
{ return lhs == rhs; }
|
||||
|
||||
63
scan.h
63
scan.h
@ -160,7 +160,7 @@ public:
|
||||
}
|
||||
|
||||
void InitQuantizationLUT();
|
||||
|
||||
|
||||
LONG DecodeValue(LONG k, LONG limit, LONG qbpp);
|
||||
inlinehint void EncodeMappedValue(LONG k, LONG mappederval, LONG limit);
|
||||
|
||||
@ -170,14 +170,14 @@ public:
|
||||
{ RUNindex = MAX(0,RUNindex - 1); }
|
||||
|
||||
LONG DecodeRIError(CContextRunMode& ctx);
|
||||
Triplet DecodeRIPixel(Triplet Ra, Triplet Rb);
|
||||
PIXEL DecodeRIPixel(LONG Ra, LONG Rb);
|
||||
Triplet<SAMPLE> DecodeRIPixel(Triplet<SAMPLE> Ra, Triplet<SAMPLE> Rb);
|
||||
SAMPLE DecodeRIPixel(LONG Ra, LONG Rb);
|
||||
LONG DecodeRunPixels(PIXEL Ra, PIXEL* ptype, LONG cpixelMac);
|
||||
LONG DoRunMode(LONG ipixel, DecoderStrategy*);
|
||||
|
||||
void EncodeRIError(CContextRunMode& ctx, LONG Errval);
|
||||
SAMPLE EncodeRIPixel(LONG x, LONG Ra, LONG Rb);
|
||||
Triplet EncodeRIPixel(Triplet x, Triplet Ra, Triplet Rb);
|
||||
Triplet<SAMPLE> EncodeRIPixel(Triplet<SAMPLE> x, Triplet<SAMPLE> Ra, Triplet<SAMPLE> Rb);
|
||||
void EncodeRunPixels(LONG runLength, bool bEndofline);
|
||||
LONG DoRunMode(LONG ipixel, EncoderStrategy*);
|
||||
|
||||
@ -185,11 +185,12 @@ public:
|
||||
inlinehint SAMPLE DoRegular(LONG Qs, LONG x, LONG pred, EncoderStrategy*);
|
||||
|
||||
void DoLine(SAMPLE* pdummy);
|
||||
void DoLine(Triplet* pdummy);
|
||||
void DoLine(Triplet<SAMPLE>* pdummy);
|
||||
void DoScan(BYTE* pbyteCompressed, size_t cbyteCompressed);
|
||||
|
||||
public:
|
||||
void InitDefault();
|
||||
void InitPostProcess(void* pvoidOut);
|
||||
void InitDefault();
|
||||
void InitParams(LONG t1, LONG t2, LONG t3, LONG nReset);
|
||||
|
||||
size_t EncodeScan(const void* pvoid, const Size& size, void* pvoidOut, size_t cbyte, void* pvoidCompare);
|
||||
@ -500,15 +501,14 @@ void JlsCodec<TRAITS,STRATEGY>::EncodeRIError(CContextRunMode& ctx, LONG Errval)
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<class TRAITS, class STRATEGY>
|
||||
Triplet JlsCodec<TRAITS,STRATEGY>::DecodeRIPixel(Triplet Ra, Triplet Rb)
|
||||
Triplet<typename TRAITS::SAMPLE> JlsCodec<TRAITS,STRATEGY>::DecodeRIPixel(Triplet<SAMPLE> Ra, Triplet<SAMPLE> Rb)
|
||||
{
|
||||
LONG Errval1 = DecodeRIError(_contextRunmode[0]);
|
||||
LONG Errval2 = DecodeRIError(_contextRunmode[0]);
|
||||
LONG Errval3 = DecodeRIError(_contextRunmode[0]);
|
||||
|
||||
return Triplet(traits.ComputeReconstructedSample(Rb.v1, Errval1 * Sign(Rb.v1 - Ra.v1)),
|
||||
return Triplet<SAMPLE>(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)));
|
||||
}
|
||||
@ -516,7 +516,7 @@ Triplet JlsCodec<TRAITS,STRATEGY>::DecodeRIPixel(Triplet Ra, Triplet Rb)
|
||||
|
||||
|
||||
template<class TRAITS, class STRATEGY>
|
||||
Triplet JlsCodec<TRAITS,STRATEGY>::EncodeRIPixel(Triplet x, Triplet Ra, Triplet Rb)
|
||||
Triplet<typename TRAITS::SAMPLE> JlsCodec<TRAITS,STRATEGY>::EncodeRIPixel(Triplet<SAMPLE> x, Triplet<SAMPLE> Ra, Triplet<SAMPLE> Rb)
|
||||
{
|
||||
const LONG RItype = 0;
|
||||
|
||||
@ -530,7 +530,7 @@ Triplet JlsCodec<TRAITS,STRATEGY>::EncodeRIPixel(Triplet x, Triplet Ra, Triplet
|
||||
EncodeRIError(_contextRunmode[RItype], errval3);
|
||||
|
||||
|
||||
return Triplet(traits.ComputeReconstructedSample(Rb.v1, errval1 * Sign(Rb.v1 - Ra.v1)),
|
||||
return Triplet<SAMPLE>(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)));
|
||||
}
|
||||
@ -538,7 +538,7 @@ Triplet JlsCodec<TRAITS,STRATEGY>::EncodeRIPixel(Triplet x, Triplet Ra, Triplet
|
||||
|
||||
|
||||
template<class TRAITS, class STRATEGY>
|
||||
typename TRAITS::PIXEL JlsCodec<TRAITS,STRATEGY>::DecodeRIPixel(LONG Ra, LONG Rb)
|
||||
typename TRAITS::SAMPLE JlsCodec<TRAITS,STRATEGY>::DecodeRIPixel(LONG Ra, LONG Rb)
|
||||
{
|
||||
if (abs(Ra - Rb) <= traits.NEAR)
|
||||
{
|
||||
@ -621,7 +621,7 @@ LONG JlsCodec<TRAITS,STRATEGY>::DoRunMode(LONG ipixelStart, DecoderStrategy*)
|
||||
|
||||
// run interruption
|
||||
PIXEL Rb = ptypePrev[ipixelEnd];
|
||||
ptypeCur[ipixelEnd] = DecodeRIPixel(Ra, Rb);
|
||||
ptypeCur[ipixelEnd] = DecodeRIPixel(Ra, Rb);
|
||||
DecrementRunIndex();
|
||||
return ipixelEnd - ipixelStart + 1;
|
||||
}
|
||||
@ -661,15 +661,15 @@ void JlsCodec<TRAITS,STRATEGY>::DoLine(SAMPLE*)
|
||||
|
||||
|
||||
template<class TRAITS, class STRATEGY>
|
||||
void JlsCodec<TRAITS,STRATEGY>::DoLine(Triplet*)
|
||||
void JlsCodec<TRAITS,STRATEGY>::DoLine(Triplet<SAMPLE>*)
|
||||
{
|
||||
LONG ipixel = 0;
|
||||
while(ipixel < _size.cx)
|
||||
{
|
||||
Triplet Ra = ptypeCur[ipixel -1];
|
||||
Triplet Rc = ptypePrev[ipixel-1];
|
||||
Triplet Rb = ptypePrev[ipixel];
|
||||
Triplet Rd = ptypePrev[ipixel + 1];
|
||||
Triplet<SAMPLE> Ra = ptypeCur[ipixel -1];
|
||||
Triplet<SAMPLE> Rc = ptypePrev[ipixel-1];
|
||||
Triplet<SAMPLE> Rb = ptypePrev[ipixel];
|
||||
Triplet<SAMPLE> Rd = ptypePrev[ipixel + 1];
|
||||
|
||||
LONG Qs1 = ComputeContextID(QuantizeGratient(Rd.v1 - Rb.v1), QuantizeGratient(Rb.v1 - Rc.v1), QuantizeGratient(Rc.v1 - Ra.v1));
|
||||
LONG Qs2 = ComputeContextID(QuantizeGratient(Rd.v2 - Rb.v2), QuantizeGratient(Rb.v2 - Rc.v2), QuantizeGratient(Rc.v2 - Ra.v2));
|
||||
@ -681,7 +681,7 @@ void JlsCodec<TRAITS,STRATEGY>::DoLine(Triplet*)
|
||||
}
|
||||
else
|
||||
{
|
||||
Triplet Rx;
|
||||
Triplet<SAMPLE> 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));
|
||||
@ -717,7 +717,7 @@ void JlsCodec<TRAITS,STRATEGY>::DoScan(BYTE* pbyteCompressed, size_t cbyteCompre
|
||||
std::swap(ptypePrev, ptypeCur);
|
||||
}
|
||||
|
||||
STRATEGY::OnLineBegin(iline, _size.cx, ptypeCur, pixelstride);
|
||||
STRATEGY::OnLineBegin(_size.cx, ptypeCur, pixelstride);
|
||||
|
||||
for (int component = 0; component < components; ++component)
|
||||
{
|
||||
@ -734,7 +734,7 @@ void JlsCodec<TRAITS,STRATEGY>::DoScan(BYTE* pbyteCompressed, size_t cbyteCompre
|
||||
ptypeCur += pixelstride;
|
||||
}
|
||||
|
||||
STRATEGY::OnLineEnd(iline, _size.cx, ptypeCur - (components * pixelstride), pixelstride);
|
||||
STRATEGY::OnLineEnd(_size.cx, ptypeCur - (components * pixelstride), pixelstride);
|
||||
}
|
||||
}
|
||||
|
||||
@ -743,6 +743,7 @@ void JlsCodec<TRAITS,STRATEGY>::DoScan(BYTE* pbyteCompressed, size_t cbyteCompre
|
||||
template<class TRAITS, class STRATEGY>
|
||||
size_t JlsCodec<TRAITS,STRATEGY>::EncodeScan(const void* pvoid, const Size& size, void* pvoidOut, size_t cbyte, void* pvoidCompare)
|
||||
{
|
||||
InitPostProcess(const_cast<void*>(pvoid));
|
||||
_size = size;
|
||||
|
||||
BYTE* pbyteCompressed = static_cast<BYTE*>(pvoidOut);
|
||||
@ -765,11 +766,31 @@ size_t JlsCodec<TRAITS,STRATEGY>::EncodeScan(const void* pvoid, const Size& size
|
||||
|
||||
}
|
||||
|
||||
template<class TRAITS, class STRATEGY>
|
||||
void JlsCodec<TRAITS,STRATEGY>::InitPostProcess(void* pvoidOut)
|
||||
{
|
||||
if (STRATEGY::_info.components == 1)
|
||||
{
|
||||
STRATEGY::_postProcessLine = new PostProcesSingleComponent(pvoidOut, STRATEGY::_info, sizeof(TRAITS::PIXEL));
|
||||
}
|
||||
else
|
||||
{
|
||||
switch(STRATEGY::_info.colorTransform)
|
||||
{
|
||||
case COLORXFORM_NONE: STRATEGY::_postProcessLine = new PostProcessTransformed<TransformNone>(pvoidOut, STRATEGY::_info); break;
|
||||
case COLORXFORM_HP1 : STRATEGY::_postProcessLine = new PostProcessTransformed<TransformHp1>(pvoidOut, STRATEGY::_info); break;
|
||||
case COLORXFORM_HP2 : STRATEGY::_postProcessLine = new PostProcessTransformed<TransformHp2>(pvoidOut, STRATEGY::_info); break;
|
||||
case COLORXFORM_HP3 : STRATEGY::_postProcessLine = new PostProcessTransformed<TransformHp3>(pvoidOut, STRATEGY::_info); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class TRAITS, class STRATEGY>
|
||||
size_t JlsCodec<TRAITS,STRATEGY>::DecodeScan(void* pvoidOut, const Size& size, const void* pvoidIn, size_t cbyte, bool bCompare)
|
||||
{
|
||||
InitPostProcess(pvoidOut);
|
||||
|
||||
PIXEL* ptypeOut = static_cast<PIXEL*>(pvoidOut);
|
||||
BYTE* pbyteCompressed = const_cast<BYTE*>(static_cast<const BYTE*>(pvoidIn));
|
||||
_bCompare = bCompare;
|
||||
|
||||
1
stdafx.h
1
stdafx.h
@ -9,6 +9,7 @@
|
||||
#if defined(WIN32)
|
||||
#define CHARLS_IMEXPORT __declspec(dllexport)
|
||||
#pragma warning (disable:4100)
|
||||
#pragma warning (disable:4512)
|
||||
#endif
|
||||
|
||||
#include "util.h"
|
||||
|
||||
13
util.h
13
util.h
@ -104,7 +104,8 @@ inline LONG BitWiseSign(LONG i)
|
||||
|
||||
#pragma pack(push, 1)
|
||||
|
||||
struct Triplet
|
||||
template<class SAMPLE>
|
||||
struct Triplet
|
||||
{
|
||||
Triplet() :
|
||||
v1(0),
|
||||
@ -113,9 +114,9 @@ struct Triplet
|
||||
{};
|
||||
|
||||
Triplet(LONG x1, LONG x2, LONG x3) :
|
||||
v1((BYTE)x1),
|
||||
v2((BYTE)x2),
|
||||
v3((BYTE)x3)
|
||||
v1((SAMPLE)x1),
|
||||
v2((SAMPLE)x2),
|
||||
v3((SAMPLE)x3)
|
||||
{};
|
||||
|
||||
union
|
||||
@ -141,10 +142,10 @@ struct Triplet
|
||||
|
||||
#include "interface.h"
|
||||
|
||||
inline bool operator==(const Triplet& lhs, const Triplet& rhs)
|
||||
inline bool operator==(const Triplet<BYTE>& lhs, const Triplet<BYTE>& rhs)
|
||||
{ return lhs.v1 == rhs.v1 && lhs.v2 == rhs.v2 && lhs.v3 == rhs.v3; }
|
||||
|
||||
inline bool operator!=(const Triplet& lhs, const Triplet& rhs)
|
||||
inline bool operator!=(const Triplet<BYTE>& lhs, const Triplet<BYTE>& rhs)
|
||||
{ return !(lhs == rhs); }
|
||||
|
||||
#endif
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user