| //======================================================================== |
| // |
| // JArithmeticDecoder.cc |
| // |
| // Copyright 2002-2004 Glyph & Cog, LLC |
| // |
| //======================================================================== |
| |
| //======================================================================== |
| // |
| // Modified under the Poppler project - http://poppler.freedesktop.org |
| // |
| // All changes made under the Poppler project to this file are licensed |
| // under GPL version 2 or later |
| // |
| // Copyright (C) 2019 Volker Krause <vkrause@kde.org> |
| // Copyright (C) 2020 Even Rouault <even.rouault@spatialys.com> |
| // |
| // To see a description of the changes please see the Changelog file that |
| // came with your tarball or type make ChangeLog if you are building from git |
| // |
| //======================================================================== |
| |
| #include <config.h> |
| |
| #include "Object.h" |
| #include "Stream.h" |
| #include "JArithmeticDecoder.h" |
| |
| //------------------------------------------------------------------------ |
| // JArithmeticDecoderStates |
| //------------------------------------------------------------------------ |
| |
| JArithmeticDecoderStats::JArithmeticDecoderStats(int contextSizeA) |
| { |
| contextSize = contextSizeA; |
| cxTab = (unsigned char *)gmallocn_checkoverflow(contextSize, sizeof(unsigned char)); |
| if (cxTab) { |
| reset(); |
| } |
| } |
| |
| JArithmeticDecoderStats::~JArithmeticDecoderStats() |
| { |
| gfree(cxTab); |
| } |
| |
| JArithmeticDecoderStats *JArithmeticDecoderStats::copy() |
| { |
| JArithmeticDecoderStats *stats; |
| |
| stats = new JArithmeticDecoderStats(contextSize); |
| memcpy(stats->cxTab, cxTab, contextSize); |
| return stats; |
| } |
| |
| void JArithmeticDecoderStats::reset() |
| { |
| memset(cxTab, 0, contextSize); |
| } |
| |
| void JArithmeticDecoderStats::copyFrom(JArithmeticDecoderStats *stats) |
| { |
| memcpy(cxTab, stats->cxTab, contextSize); |
| } |
| |
| void JArithmeticDecoderStats::setEntry(unsigned int cx, int i, int mps) |
| { |
| cxTab[cx] = (i << 1) + mps; |
| } |
| |
| //------------------------------------------------------------------------ |
| // JArithmeticDecoder |
| //------------------------------------------------------------------------ |
| |
| unsigned const int JArithmeticDecoder::qeTab[47] = { 0x56010000, 0x34010000, 0x18010000, 0x0AC10000, 0x05210000, 0x02210000, 0x56010000, 0x54010000, 0x48010000, 0x38010000, 0x30010000, 0x24010000, |
| 0x1C010000, 0x16010000, 0x56010000, 0x54010000, 0x51010000, 0x48010000, 0x38010000, 0x34010000, 0x30010000, 0x28010000, 0x24010000, 0x22010000, |
| 0x1C010000, 0x18010000, 0x16010000, 0x14010000, 0x12010000, 0x11010000, 0x0AC10000, 0x09C10000, 0x08A10000, 0x05210000, 0x04410000, 0x02A10000, |
| 0x02210000, 0x01410000, 0x01110000, 0x00850000, 0x00490000, 0x00250000, 0x00150000, 0x00090000, 0x00050000, 0x00010000, 0x56010000 }; |
| |
| const int JArithmeticDecoder::nmpsTab[47] = { 1, 2, 3, 4, 5, 38, 7, 8, 9, 10, 11, 12, 13, 29, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 45, 46 }; |
| |
| const int JArithmeticDecoder::nlpsTab[47] = { 1, 6, 9, 12, 29, 33, 6, 14, 14, 14, 17, 18, 20, 21, 14, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 46 }; |
| |
| const int JArithmeticDecoder::switchTab[47] = { 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; |
| |
| JArithmeticDecoder::JArithmeticDecoder() |
| { |
| str = nullptr; |
| dataLen = 0; |
| limitStream = false; |
| nBytesRead = 0; |
| } |
| |
| inline unsigned int JArithmeticDecoder::readByte() |
| { |
| if (limitStream) { |
| --dataLen; |
| if (dataLen < 0) { |
| return 0xff; |
| } |
| } |
| ++nBytesRead; |
| return (unsigned int)str->getChar() & 0xff; |
| } |
| |
| JArithmeticDecoder::~JArithmeticDecoder() |
| { |
| cleanup(); |
| } |
| |
| void JArithmeticDecoder::start() |
| { |
| buf0 = readByte(); |
| buf1 = readByte(); |
| |
| // INITDEC |
| c = (buf0 ^ 0xff) << 16; |
| byteIn(); |
| c <<= 7; |
| ct -= 7; |
| a = 0x80000000; |
| } |
| |
| void JArithmeticDecoder::restart(int dataLenA) |
| { |
| unsigned int cAdd; |
| bool prevFF; |
| int k, nBits; |
| |
| if (dataLen >= 0) { |
| dataLen = dataLenA; |
| } else if (dataLen == -1) { |
| dataLen = dataLenA; |
| buf1 = readByte(); |
| } else { |
| k = (-dataLen - 1) * 8 - ct; |
| dataLen = dataLenA; |
| cAdd = 0; |
| prevFF = false; |
| while (k > 0) { |
| buf0 = readByte(); |
| if (prevFF) { |
| cAdd += 0xfe00 - (buf0 << 9); |
| nBits = 7; |
| } else { |
| cAdd += 0xff00 - (buf0 << 8); |
| nBits = 8; |
| } |
| prevFF = buf0 == 0xff; |
| if (k > nBits) { |
| cAdd <<= nBits; |
| k -= nBits; |
| } else { |
| cAdd <<= k; |
| ct = nBits - k; |
| k = 0; |
| } |
| } |
| c += cAdd; |
| buf1 = readByte(); |
| } |
| } |
| |
| void JArithmeticDecoder::cleanup() |
| { |
| if (limitStream) { |
| while (dataLen > 0) { |
| buf0 = buf1; |
| buf1 = readByte(); |
| } |
| } |
| } |
| |
| int JArithmeticDecoder::decodeBit(unsigned int context, JArithmeticDecoderStats *stats) |
| { |
| int bit; |
| unsigned int qe; |
| int iCX, mpsCX; |
| |
| iCX = stats->cxTab[context] >> 1; |
| mpsCX = stats->cxTab[context] & 1; |
| qe = qeTab[iCX]; |
| a -= qe; |
| if (c < a) { |
| if (a & 0x80000000) { |
| bit = mpsCX; |
| } else { |
| // MPS_EXCHANGE |
| if (a < qe) { |
| bit = 1 - mpsCX; |
| if (switchTab[iCX]) { |
| stats->cxTab[context] = (nlpsTab[iCX] << 1) | (1 - mpsCX); |
| } else { |
| stats->cxTab[context] = (nlpsTab[iCX] << 1) | mpsCX; |
| } |
| } else { |
| bit = mpsCX; |
| stats->cxTab[context] = (nmpsTab[iCX] << 1) | mpsCX; |
| } |
| // RENORMD |
| do { |
| if (ct == 0) { |
| byteIn(); |
| } |
| a <<= 1; |
| c <<= 1; |
| --ct; |
| } while (!(a & 0x80000000)); |
| } |
| } else { |
| c -= a; |
| // LPS_EXCHANGE |
| if (a < qe) { |
| bit = mpsCX; |
| stats->cxTab[context] = (nmpsTab[iCX] << 1) | mpsCX; |
| } else { |
| bit = 1 - mpsCX; |
| if (switchTab[iCX]) { |
| stats->cxTab[context] = (nlpsTab[iCX] << 1) | (1 - mpsCX); |
| } else { |
| stats->cxTab[context] = (nlpsTab[iCX] << 1) | mpsCX; |
| } |
| } |
| a = qe; |
| // RENORMD |
| do { |
| if (ct == 0) { |
| byteIn(); |
| } |
| a <<= 1; |
| c <<= 1; |
| --ct; |
| } while (!(a & 0x80000000)); |
| } |
| return bit; |
| } |
| |
| int JArithmeticDecoder::decodeByte(unsigned int context, JArithmeticDecoderStats *stats) |
| { |
| int byte; |
| int i; |
| |
| byte = 0; |
| for (i = 0; i < 8; ++i) { |
| byte = (byte << 1) | decodeBit(context, stats); |
| } |
| return byte; |
| } |
| |
| bool JArithmeticDecoder::decodeInt(int *x, JArithmeticDecoderStats *stats) |
| { |
| int s; |
| unsigned int v; |
| int i; |
| |
| prev = 1; |
| s = decodeIntBit(stats); |
| if (decodeIntBit(stats)) { |
| if (decodeIntBit(stats)) { |
| if (decodeIntBit(stats)) { |
| if (decodeIntBit(stats)) { |
| if (decodeIntBit(stats)) { |
| v = 0; |
| for (i = 0; i < 32; ++i) { |
| v = (v << 1) | decodeIntBit(stats); |
| } |
| v += 4436; |
| } else { |
| v = 0; |
| for (i = 0; i < 12; ++i) { |
| v = (v << 1) | decodeIntBit(stats); |
| } |
| v += 340; |
| } |
| } else { |
| v = 0; |
| for (i = 0; i < 8; ++i) { |
| v = (v << 1) | decodeIntBit(stats); |
| } |
| v += 84; |
| } |
| } else { |
| v = 0; |
| for (i = 0; i < 6; ++i) { |
| v = (v << 1) | decodeIntBit(stats); |
| } |
| v += 20; |
| } |
| } else { |
| v = decodeIntBit(stats); |
| v = (v << 1) | decodeIntBit(stats); |
| v = (v << 1) | decodeIntBit(stats); |
| v = (v << 1) | decodeIntBit(stats); |
| v += 4; |
| } |
| } else { |
| v = decodeIntBit(stats); |
| v = (v << 1) | decodeIntBit(stats); |
| } |
| |
| if (s) { |
| if (v == 0) { |
| return false; |
| } |
| *x = -(int)v; |
| } else { |
| *x = (int)v; |
| } |
| return true; |
| } |
| |
| int JArithmeticDecoder::decodeIntBit(JArithmeticDecoderStats *stats) |
| { |
| int bit; |
| |
| bit = decodeBit(prev, stats); |
| if (prev < 0x100) { |
| prev = (prev << 1) | bit; |
| } else { |
| prev = (((prev << 1) | bit) & 0x1ff) | 0x100; |
| } |
| return bit; |
| } |
| |
| unsigned int JArithmeticDecoder::decodeIAID(unsigned int codeLen, JArithmeticDecoderStats *stats) |
| { |
| unsigned int i; |
| int bit; |
| |
| prev = 1; |
| for (i = 0; i < codeLen; ++i) { |
| bit = decodeBit(prev, stats); |
| prev = (prev << 1) | bit; |
| } |
| return prev - (1 << codeLen); |
| } |
| |
| void JArithmeticDecoder::byteIn() |
| { |
| if (buf0 == 0xff) { |
| if (buf1 > 0x8f) { |
| if (limitStream) { |
| buf0 = buf1; |
| buf1 = readByte(); |
| c = c + 0xff00 - (buf0 << 8); |
| } |
| ct = 8; |
| } else { |
| buf0 = buf1; |
| buf1 = readByte(); |
| c = c + 0xfe00 - (buf0 << 9); |
| ct = 7; |
| } |
| } else { |
| buf0 = buf1; |
| buf1 = readByte(); |
| c = c + 0xff00 - (buf0 << 8); |
| ct = 8; |
| } |
| } |
