16 :
Filter(attachment), m_counting(false), m_bitCount(0), m_buffer(0)
17 , m_bitsBuffered(0), m_bytesBuffered(0)
21 void LowFirstBitWriter::StartCounting()
28 unsigned long LowFirstBitWriter::FinishCounting()
35 void LowFirstBitWriter::PutBits(
unsigned long value,
unsigned int length)
41 m_buffer |= value << m_bitsBuffered;
42 m_bitsBuffered += length;
43 assert(m_bitsBuffered <=
sizeof(
unsigned long)*8);
44 while (m_bitsBuffered >= 8)
46 m_outputBuffer[m_bytesBuffered++] = (byte)m_buffer;
47 if (m_bytesBuffered == m_outputBuffer.
size())
58 void LowFirstBitWriter::FlushBitBuffer()
61 m_bitCount += 8*(m_bitsBuffered > 0);
64 if (m_bytesBuffered > 0)
69 if (m_bitsBuffered > 0)
78 void LowFirstBitWriter::ClearBitBuffer()
94 : symbol(0), parent(0) {}
96 : symbol(rhs.symbol), parent(rhs.parent) {}
99 union {
size_t parent;
unsigned depth, freq;};
104 inline bool operator()(
unsigned int lhs,
const HuffmanNode &rhs) {
return lhs < rhs.freq;}
105 inline bool operator()(
const HuffmanNode &lhs,
const HuffmanNode &rhs)
const {
return lhs.freq < rhs.freq;}
107 inline bool operator()(
const HuffmanNode &lhs,
unsigned int rhs) {
return lhs.freq < rhs;}
110 void HuffmanEncoder::GenerateCodeLengths(
unsigned int *codeBits,
unsigned int maxCodeBits,
const unsigned int *codeCounts,
size_t nCodes)
113 assert(nCodes <= ((
size_t)1 << maxCodeBits));
117 for (i=0; i<nCodes; i++)
120 tree[i].freq = codeCounts[i];
124 if (treeBegin == nCodes)
126 std::fill(codeBits, codeBits+nCodes, 0);
129 tree.
resize(nCodes + nCodes - treeBegin - 1);
131 size_t leastLeaf = treeBegin, leastInterior = nCodes;
132 for (i=nCodes; i<tree.
size(); i++)
135 least = (leastLeaf == nCodes || (leastInterior < i && tree[leastInterior].freq < tree[leastLeaf].freq)) ? leastInterior++ : leastLeaf++;
136 tree[i].freq = tree[least].freq;
137 tree[least].parent = i;
138 least = (leastLeaf == nCodes || (leastInterior < i && tree[leastInterior].freq < tree[leastLeaf].freq)) ? leastInterior++ : leastLeaf++;
139 tree[i].freq += tree[least].freq;
140 tree[least].parent = i;
143 tree[tree.
size()-1].depth = 0;
144 if (tree.
size() >= 2)
145 for (i=tree.
size()-2; i>=nCodes; i--)
146 tree[i].depth = tree[tree[i].parent].depth + 1;
147 unsigned int sum = 0;
149 std::fill(blCount.
begin(), blCount.
end(), 0);
150 for (i=treeBegin; i<nCodes; i++)
152 const size_t n = tree[i].parent;
153 const size_t depth =
STDMIN(maxCodeBits, tree[n].depth + 1);
155 sum += 1 << (maxCodeBits - depth);
158 unsigned int overflow = sum > (
unsigned int)(1 << maxCodeBits) ? sum - (1 << maxCodeBits) : 0;
162 unsigned int bits = maxCodeBits-1;
163 while (blCount[bits] == 0)
166 blCount[bits+1] += 2;
167 assert(blCount[maxCodeBits] > 0);
168 blCount[maxCodeBits]--;
171 for (i=0; i<treeBegin; i++)
172 codeBits[tree[i].symbol] = 0;
173 unsigned int bits = maxCodeBits;
174 for (i=treeBegin; i<nCodes; i++)
176 while (blCount[bits] == 0)
178 codeBits[tree[i].symbol] = bits;
181 assert(blCount[bits] == 0);
187 unsigned int maxCodeBits = *std::max_element(codeBits, codeBits+nCodes);
188 if (maxCodeBits == 0)
192 std::fill(blCount.
begin(), blCount.
end(), 0);
194 for (i=0; i<nCodes; i++)
195 blCount[codeBits[i]]++;
200 for (i=2; i<=maxCodeBits; i++)
202 code = (code + blCount[i-1]) << 1;
205 assert(maxCodeBits == 1 || code == (1 << maxCodeBits) - blCount[maxCodeBits]);
207 m_valueToCode.resize(nCodes);
208 for (i=0; i<nCodes; i++)
210 unsigned int len = m_valueToCode[i].len = codeBits[i];
212 m_valueToCode[i].code =
BitReverse(nextCode[len]++) >> (8*
sizeof(code_t)-len);
216 inline void HuffmanEncoder::Encode(
LowFirstBitWriter &writer, value_t value)
const 218 assert(m_valueToCode[value].len > 0);
219 writer.PutBits(m_valueToCode[value].code, m_valueToCode[value].len);
226 InitializeStaticEncoders();
234 InitializeStaticEncoders();
238 void Deflator::InitializeStaticEncoders()
240 unsigned int codeLengths[288];
241 std::fill(codeLengths + 0, codeLengths + 144, 8);
242 std::fill(codeLengths + 144, codeLengths + 256, 9);
243 std::fill(codeLengths + 256, codeLengths + 280, 7);
244 std::fill(codeLengths + 280, codeLengths + 288, 8);
245 m_staticLiteralEncoder.
Initialize(codeLengths, 288);
246 std::fill(codeLengths + 0, codeLengths + 32, 5);
247 m_staticDistanceEncoder.
Initialize(codeLengths, 32);
253 if (!(MIN_LOG2_WINDOW_SIZE <= log2WindowSize && log2WindowSize <= MAX_LOG2_WINDOW_SIZE))
256 m_log2WindowSize = log2WindowSize;
257 DSIZE = 1 << m_log2WindowSize;
259 HSIZE = 1 << m_log2WindowSize;
261 m_byteBuffer.
New(2*DSIZE);
264 m_matchBuffer.
New(DSIZE/2);
268 assert(deflateLevel >= MIN_DEFLATE_LEVEL && deflateLevel <= MAX_DEFLATE_LEVEL );
271 m_compressibleDeflateLevel = detectUncompressible ? m_deflateLevel : 0;
274 void Deflator::Reset(
bool forceReset)
279 assert(m_bitsBuffered == 0);
281 m_headerWritten =
false;
282 m_matchAvailable =
false;
286 m_minLookahead = MAX_MATCH;
287 m_matchBufferEnd = 0;
295 std::fill(m_head.
begin(), m_head.
end(), byte(0));
297 std::fill(m_literalCounts.
begin(), m_literalCounts.
end(), byte(0));
298 std::fill(m_distanceCounts.
begin(), m_distanceCounts.
end(), byte(0));
303 if (!(MIN_DEFLATE_LEVEL <= deflateLevel && deflateLevel <= MAX_DEFLATE_LEVEL))
306 if (deflateLevel == m_deflateLevel)
311 static const unsigned int configurationTable[10][4] = {
321 {32, 128, 258, 1024},
322 {32, 258, 258, 4096}};
324 GOOD_MATCH = configurationTable[deflateLevel][0];
325 MAX_LAZYLENGTH = configurationTable[deflateLevel][1];
326 MAX_CHAIN_LENGTH = configurationTable[deflateLevel][3];
328 m_deflateLevel = deflateLevel;
331 unsigned int Deflator::FillWindow(
const byte *str,
size_t length)
333 unsigned int maxBlockSize = (
unsigned int)
STDMIN(2UL*DSIZE, 0xffffUL);
335 if (m_stringStart >= maxBlockSize - MAX_MATCH)
337 if (m_blockStart < DSIZE)
340 memcpy(m_byteBuffer, m_byteBuffer + DSIZE, DSIZE);
342 m_dictionaryEnd = m_dictionaryEnd < DSIZE ? 0 : m_dictionaryEnd-DSIZE;
343 assert(m_stringStart >= DSIZE);
344 m_stringStart -= DSIZE;
345 assert(!m_matchAvailable || m_previousMatch >= DSIZE);
346 m_previousMatch -= DSIZE;
347 assert(m_blockStart >= DSIZE);
348 m_blockStart -= DSIZE;
352 assert(DSIZE == HSIZE);
355 for (i=0; i<HSIZE; i++)
358 for (i=0; i<DSIZE; i++)
362 assert(maxBlockSize > m_stringStart+m_lookahead);
363 unsigned int accepted =
UnsignedMin(maxBlockSize-(m_stringStart+m_lookahead), length);
364 assert(accepted > 0);
365 memcpy(m_byteBuffer + m_stringStart + m_lookahead, str, accepted);
366 m_lookahead += accepted;
370 inline unsigned int Deflator::ComputeHash(
const byte *str)
const 372 assert(str+3 <= m_byteBuffer + m_stringStart + m_lookahead);
373 return ((str[0] << 10) ^ (str[1] << 5) ^ str[2]) & HMASK;
376 unsigned int Deflator::LongestMatch(
unsigned int &bestMatch)
const 378 assert(m_previousLength < MAX_MATCH);
381 unsigned int bestLength =
STDMAX(m_previousLength, (
unsigned int)MIN_MATCH-1);
382 if (m_lookahead <= bestLength)
385 const byte *scan = m_byteBuffer + m_stringStart, *scanEnd = scan +
STDMIN((
unsigned int)MAX_MATCH, m_lookahead);
386 unsigned int limit = m_stringStart > (DSIZE-MAX_MATCH) ? m_stringStart - (DSIZE-MAX_MATCH) : 0;
387 unsigned int current = m_head[ComputeHash(scan)];
389 unsigned int chainLength = MAX_CHAIN_LENGTH;
390 if (m_previousLength >= GOOD_MATCH)
393 while (current > limit && --chainLength > 0)
395 const byte *match = m_byteBuffer + current;
396 assert(scan + bestLength < m_byteBuffer + m_stringStart + m_lookahead);
397 if (scan[bestLength-1] == match[bestLength-1] && scan[bestLength] == match[bestLength] && scan[0] == match[0] && scan[1] == match[1])
399 assert(scan[2] == match[2]);
400 unsigned int len = (
unsigned int)(
401 #
if defined(_STDEXT_BEGIN) && !(defined(_MSC_VER) && (_MSC_VER < 1400 || _MSC_VER >= 1600)) && !defined(_STLPORT_VERSION)
402 stdext::unchecked_mismatch
407 (stdext::make_unchecked_array_iterator(scan)+3, stdext::make_unchecked_array_iterator(scanEnd), stdext::make_unchecked_array_iterator(match)+3).first - stdext::make_unchecked_array_iterator(scan));
409 (scan+3, scanEnd, match+3).first - scan);
411 assert(len != bestLength);
412 if (len > bestLength)
417 assert(scanEnd >= scan);
418 if (len == (
unsigned int)(scanEnd - scan))
422 current = m_prev[current & DMASK];
424 return (bestMatch > 0) ? bestLength : 0;
427 inline void Deflator::InsertString(
unsigned int start)
429 assert(start <= 0xffff);
430 unsigned int hash = ComputeHash(m_byteBuffer + start);
431 m_prev[start & DMASK] = m_head[hash];
432 m_head[hash] = word16(start);
435 void Deflator::ProcessBuffer()
437 if (!m_headerWritten)
439 WritePrestreamHeader();
440 m_headerWritten =
true;
443 if (m_deflateLevel == 0)
445 m_stringStart += m_lookahead;
447 m_blockLength = m_stringStart - m_blockStart;
448 m_matchAvailable =
false;
452 while (m_lookahead > m_minLookahead)
454 while (m_dictionaryEnd < m_stringStart && m_dictionaryEnd+3 <= m_stringStart+m_lookahead)
455 InsertString(m_dictionaryEnd++);
457 if (m_matchAvailable)
459 unsigned int matchPosition = 0, matchLength = 0;
460 bool usePreviousMatch;
461 if (m_previousLength >= MAX_LAZYLENGTH)
462 usePreviousMatch =
true;
465 matchLength = LongestMatch(matchPosition);
466 usePreviousMatch = (matchLength == 0);
468 if (usePreviousMatch)
470 MatchFound(m_stringStart-1-m_previousMatch, m_previousLength);
471 m_stringStart += m_previousLength-1;
472 m_lookahead -= m_previousLength-1;
473 m_matchAvailable =
false;
477 m_previousLength = matchLength;
478 m_previousMatch = matchPosition;
479 LiteralByte(m_byteBuffer[m_stringStart-1]);
486 m_previousLength = 0;
487 m_previousLength = LongestMatch(m_previousMatch);
488 if (m_previousLength)
489 m_matchAvailable =
true;
491 LiteralByte(m_byteBuffer[m_stringStart]);
496 assert(m_stringStart - (m_blockStart+m_blockLength) == (
unsigned int)m_matchAvailable);
499 if (m_minLookahead == 0 && m_matchAvailable)
501 LiteralByte(m_byteBuffer[m_stringStart-1]);
502 m_matchAvailable =
false;
506 size_t Deflator::Put2(
const byte *str,
size_t length,
int messageEnd,
bool blocking)
512 while (accepted < length)
514 unsigned int newAccepted = FillWindow(str+accepted, length-accepted);
517 ProcessUncompressedData(str+accepted, newAccepted);
518 accepted += newAccepted;
520 assert(accepted == length);
528 WritePoststreamTail();
532 Output(0, NULL, 0, messageEnd, blocking);
543 m_minLookahead = MAX_MATCH;
546 EncodeBlock(
false, STORED);
550 void Deflator::LiteralByte(byte b)
552 if (m_matchBufferEnd == m_matchBuffer.
size())
555 m_matchBuffer[m_matchBufferEnd++].literalCode = b;
556 m_literalCounts[b]++;
560 void Deflator::MatchFound(
unsigned int distance,
unsigned int length)
562 if (m_matchBufferEnd == m_matchBuffer.
size())
565 static const unsigned int lengthCodes[] = {
566 257, 258, 259, 260, 261, 262, 263, 264, 265, 265, 266, 266, 267, 267, 268, 268,
567 269, 269, 269, 269, 270, 270, 270, 270, 271, 271, 271, 271, 272, 272, 272, 272,
568 273, 273, 273, 273, 273, 273, 273, 273, 274, 274, 274, 274, 274, 274, 274, 274,
569 275, 275, 275, 275, 275, 275, 275, 275, 276, 276, 276, 276, 276, 276, 276, 276,
570 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277,
571 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
572 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279,
573 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280,
574 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281,
575 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281,
576 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282,
577 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282,
578 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
579 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
580 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284,
581 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 285};
582 static const unsigned int lengthBases[] =
583 {3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,
585 static const unsigned int distanceBases[30] =
586 {1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,
587 4097,6145,8193,12289,16385,24577};
589 assert(m_matchBufferEnd < m_matchBuffer.
size());
590 EncodedMatch &m = m_matchBuffer[m_matchBufferEnd++];
591 assert(length >= 3 && length <
COUNTOF(lengthCodes));
592 unsigned int lengthCode = lengthCodes[length-3];
593 m.literalCode = lengthCode;
594 m.literalExtra = length - lengthBases[lengthCode-257];
595 unsigned int distanceCode = (
unsigned int)(std::upper_bound(distanceBases, distanceBases+30, distance) - distanceBases - 1);
596 m.distanceCode = distanceCode;
597 m.distanceExtra = distance - distanceBases[distanceCode];
599 m_literalCounts[lengthCode]++;
600 m_distanceCounts[distanceCode]++;
601 m_blockLength += length;
604 inline unsigned int CodeLengthEncode(
const unsigned int *begin,
605 const unsigned int *end,
606 const unsigned int *& p,
607 unsigned int &extraBits,
608 unsigned int &extraBitsLength)
613 const unsigned int *oldp = p;
614 if (v==0 && p[1]==0 && p[2]==0)
616 for (p=p+3; p!=end && *p==0 && p!=oldp+138; p++) {}
617 unsigned int repeat = (
unsigned int)(p - oldp);
620 extraBits = repeat-3;
626 extraBits = repeat-11;
631 else if (p!=begin && v==p[-1] && v==p[1] && v==p[2])
633 for (p=p+3; p!=end && *p==v && p!=oldp+6; p++) {}
634 unsigned int repeat = (
unsigned int)(p - oldp);
635 extraBits = repeat-3;
646 void Deflator::EncodeBlock(
bool eof,
unsigned int blockType)
649 PutBits(blockType, 2);
651 if (blockType == STORED)
653 assert(m_blockStart + m_blockLength <= m_byteBuffer.
size());
654 assert(m_blockLength <= 0xffff);
662 if (blockType == DYNAMIC)
664 #if defined(_MSC_VER) && !defined(__MWERKS__) && (_MSC_VER <= 1300) 666 typedef reverse_bidirectional_iterator<unsigned int *, unsigned int> RevIt;
667 #elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) 668 typedef std::reverse_iterator<unsigned int *, random_access_iterator_tag, unsigned int> RevIt;
670 typedef std::reverse_iterator<unsigned int *> RevIt;
676 m_literalCounts[256] = 1;
677 HuffmanEncoder::GenerateCodeLengths(literalCodeLengths, 15, m_literalCounts, 286);
678 m_dynamicLiteralEncoder.
Initialize(literalCodeLengths, 286);
679 unsigned int hlit = (
unsigned int)(std::find_if(RevIt(literalCodeLengths.
end()), RevIt(literalCodeLengths.
begin()+257), std::bind2nd(std::not_equal_to<unsigned int>(), 0)).base() - (literalCodeLengths.
begin()+257));
681 HuffmanEncoder::GenerateCodeLengths(distanceCodeLengths, 15, m_distanceCounts, 30);
682 m_dynamicDistanceEncoder.
Initialize(distanceCodeLengths, 30);
683 unsigned int hdist = (
unsigned int)(std::find_if(RevIt(distanceCodeLengths.
end()), RevIt(distanceCodeLengths.
begin()+1), std::bind2nd(std::not_equal_to<unsigned int>(), 0)).base() - (distanceCodeLengths.
begin()+1));
686 memcpy(combinedLengths, literalCodeLengths, (hlit+257)*
sizeof(
unsigned int));
687 memcpy(combinedLengths+hlit+257, distanceCodeLengths, (hdist+1)*
sizeof(
unsigned int));
690 std::fill(codeLengthCodeCounts.
begin(), codeLengthCodeCounts.
end(), 0);
691 const unsigned int *p = combinedLengths.
begin(), *begin = combinedLengths.
begin(), *end = combinedLengths.
end();
694 unsigned int code=0, extraBits=0, extraBitsLength=0;
695 code = CodeLengthEncode(begin, end, p, extraBits, extraBitsLength);
696 codeLengthCodeCounts[code]++;
698 HuffmanEncoder::GenerateCodeLengths(codeLengthCodeLengths, 7, codeLengthCodeCounts, 19);
700 static const unsigned int border[] = {
701 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
702 unsigned int hclen = 19;
703 while (hclen > 4 && codeLengthCodeLengths[border[hclen-1]] == 0)
711 for (
unsigned int i=0; i<hclen+4; i++)
712 PutBits(codeLengthCodeLengths[border[i]], 3);
714 p = combinedLengths.
begin();
717 unsigned int code=0, extraBits=0, extraBitsLength=0;
718 code = CodeLengthEncode(begin, end, p, extraBits, extraBitsLength);
719 codeLengthEncoder.Encode(*
this, code);
720 PutBits(extraBits, extraBitsLength);
724 static const unsigned int lengthExtraBits[] = {
725 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
726 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0};
727 static const unsigned int distanceExtraBits[] = {
728 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
729 7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
732 const HuffmanEncoder &literalEncoder = (blockType == STATIC) ? m_staticLiteralEncoder : m_dynamicLiteralEncoder;
733 const HuffmanEncoder &distanceEncoder = (blockType == STATIC) ? m_staticDistanceEncoder : m_dynamicDistanceEncoder;
735 for (
unsigned int i=0; i<m_matchBufferEnd; i++)
737 unsigned int literalCode = m_matchBuffer[i].literalCode;
738 literalEncoder.Encode(*
this, literalCode);
739 if (literalCode >= 257)
741 assert(literalCode <= 285);
742 PutBits(m_matchBuffer[i].literalExtra, lengthExtraBits[literalCode-257]);
743 unsigned int distanceCode = m_matchBuffer[i].distanceCode;
744 distanceEncoder.Encode(*
this, distanceCode);
745 PutBits(m_matchBuffer[i].distanceExtra, distanceExtraBits[distanceCode]);
748 literalEncoder.Encode(*
this, 256);
752 void Deflator::EndBlock(
bool eof)
754 if (m_blockLength == 0 && !eof)
757 if (m_deflateLevel == 0)
759 EncodeBlock(eof, STORED);
761 if (m_compressibleDeflateLevel > 0 && ++m_detectCount == m_detectSkip)
763 m_deflateLevel = m_compressibleDeflateLevel;
769 unsigned long storedLen = 8*((
unsigned long)m_blockLength+4) +
RoundUpToMultipleOf(m_bitsBuffered+3, 8U)-m_bitsBuffered;
772 EncodeBlock(eof, STATIC);
773 unsigned long staticLen = FinishCounting();
775 unsigned long dynamicLen;
776 if (m_blockLength < 128 && m_deflateLevel < 8)
777 dynamicLen = ULONG_MAX;
781 EncodeBlock(eof, DYNAMIC);
782 dynamicLen = FinishCounting();
785 if (storedLen <= staticLen && storedLen <= dynamicLen)
787 EncodeBlock(eof, STORED);
789 if (m_compressibleDeflateLevel > 0)
793 m_detectSkip = m_detectSkip ?
STDMIN(2*m_detectSkip, 128U) : 1;
798 if (staticLen <= dynamicLen)
799 EncodeBlock(eof, STATIC);
801 EncodeBlock(eof, DYNAMIC);
803 if (m_compressibleDeflateLevel > 0)
808 m_matchBufferEnd = 0;
809 m_blockStart += m_blockLength;
811 std::fill(m_literalCounts.
begin(), m_literalCounts.
end(), 0);
812 std::fill(m_distanceCounts.
begin(), m_distanceCounts.
end(), 0);
iterator end()
Provides an iterator pointing beyond the last element in the memory block.
An invalid argument was detected.
Stack-based SecBlock that grows into the heap.
Utility functions for the Crypto++ library.
T GetValueWithDefault(const char *name, T defaultValue) const
Get a named value.
void resize(size_type newSize)
Change size and preserve contents.
size_type size() const
Provides the count of elements in the SecBlock.
void New(size_type newSize)
Change size without preserving contents.
bool IsolatedFlush(bool hardFlush, bool blocking)
Flushes data buffered by this object, without signal propagation.
byte BitReverse(byte value)
Reverses bits in a 8-bit value.
int GetIntValueWithDefault(const char *name, int defaultValue) const
Get a named value with type int, with default.
AlgorithmParameters MakeParameters(const char *name, const T &value, bool throwIfNotUsed=true)
Create an object that implements NameValuePairs.
BufferedTransformation * AttachedTransformation()
Retrieve attached transformation.
T1 SaturatingSubtract(const T1 &a, const T2 &b)
Performs a saturating subtract clamped at 0.
const T1 UnsignedMin(const T1 &a, const T2 &b)
Safe comparison of values that could be neagtive and incorrectly promoted.
#define COUNTOF(arr)
Counts elements in an array.
const T & STDMIN(const T &a, const T &b)
Replacement function for std::min.
HuffmanEncoder()
Construct a HuffmanEncoder.
void SetDeflateLevel(int deflateLevel)
this function can be used to set the deflate level in the middle of compression
iterator begin()
Provides an iterator pointing to the first element in the memory block.
Deflator(BufferedTransformation *attachment=NULL, int deflateLevel=DEFAULT_DEFLATE_LEVEL, int log2WindowSize=DEFAULT_LOG2_WINDOW_SIZE, bool detectUncompressible=true)
void Initialize(const unsigned int *codeBits, unsigned int nCodes)
Initialize or reinitialize this object.
Implementation of BufferedTransformation's attachment interface.
std::string IntToString(T value, unsigned int base=10)
Converts a value to a string.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
T1 RoundUpToMultipleOf(const T1 &n, const T2 &m)
Rounds a value up to a multiple of a second value.
const T & STDMAX(const T &a, const T &b)
Replacement function for std::max.
void Initialize(const NameValuePairs ¶meters=g_nullNameValuePairs, int propagation=-1)
Initialize or reinitialize this object, with signal propagation.
Crypto++ library namespace.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
Interface for retrieving values given their names.