Ignore:
Timestamp:
Jun 30, 2008, 10:13:07 AM (13 years ago)
Author:
Eugene Romanenko
Message:

PDF plugin: poppler library updated to version 0.8.3

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/mypoppler/poppler/JPXStream.cc

    r2 r250  
    178178//------------------------------------------------------------------------
    179179
     180#if 1 //----- disable coverage tracking
     181
     182#define cover(idx)
     183
     184#else //----- enable coverage tracking
     185
     186class JPXCover {
     187public:
     188
     189  JPXCover(int sizeA);
     190  ~JPXCover();
     191  void incr(int idx);
     192
     193private:
     194
     195  int size, used;
     196  int *data;
     197};
     198
     199JPXCover::JPXCover(int sizeA) {
     200  size = sizeA;
     201  used = -1;
     202  data = (int *)gmallocn(size, sizeof(int));
     203  memset(data, 0, size * sizeof(int));
     204}
     205
     206JPXCover::~JPXCover() {
     207  int i;
     208
     209  printf("JPX coverage:\n");
     210  for (i = 0; i <= used; ++i) {
     211    printf("  %4d: %8d\n", i, data[i]);
     212  }
     213  gfree(data);
     214}
     215
     216void JPXCover::incr(int idx) {
     217  if (idx < size) {
     218    ++data[idx];
     219    if (idx > used) {
     220      used = idx;
     221    }
     222  }
     223}
     224
     225JPXCover jpxCover(150);
     226
     227#define cover(idx) jpxCover.incr(idx)
     228
     229#endif //----- coverage tracking
     230
     231//------------------------------------------------------------------------
     232
    180233JPXStream::JPXStream(Stream *strA):
    181234  FilterStream(strA)
     
    197250
    198251JPXStream::~JPXStream() {
     252  close();
     253  delete str;
     254}
     255
     256void JPXStream::reset() {
     257  str->reset();
     258  if (readBoxes()) {
     259    curY = img.yOffset;
     260  } else {
     261    // readBoxes reported an error, so we go immediately to EOF
     262    curY = img.ySize;
     263  }
     264  curX = img.xOffset;
     265  curComp = 0;
     266  readBufLen = 0;
     267}
     268
     269void JPXStream::close() {
    199270  JPXTile *tile;
    200271  JPXTileComp *tileComp;
     
    206277
    207278  gfree(bpc);
     279  bpc = NULL;
    208280  if (havePalette) {
    209281    gfree(palette.bpc);
    210282    gfree(palette.c);
     283    havePalette = gFalse;
    211284  }
    212285  if (haveCompMap) {
     
    214287    gfree(compMap.type);
    215288    gfree(compMap.pComp);
     289    haveCompMap = gFalse;
    216290  }
    217291  if (haveChannelDefn) {
     
    219293    gfree(channelDefn.type);
    220294    gfree(channelDefn.assoc);
     295    haveChannelDefn = gFalse;
    221296  }
    222297
     
    237312                  precinct = &resLevel->precincts[pre];
    238313                  if (precinct->subbands) {
    239                     for (sb = 0; sb < (r == 0 ? 1 : 3); ++sb) {
     314                    for (sb = 0; sb < (Guint)(r == 0 ? 1 : 3); ++sb) {
    240315                      subband = &precinct->subbands[sb];
    241316                      gfree(subband->inclusion);
     
    268343    }
    269344    gfree(img.tiles);
    270   }
    271   delete str;
    272 }
    273 
    274 void JPXStream::reset() {
    275   str->reset();
    276   if (readBoxes()) {
    277     curY = img.yOffset;
    278   } else {
    279     // readBoxes reported an error, so we go immediately to EOF
    280     curY = img.ySize;
    281   }
    282   curX = img.xOffset;
    283   curComp = 0;
    284   readBufLen = 0;
     345    img.tiles = NULL;
     346  }
     347  FilterStream::close();
    285348}
    286349
     
    395458    while (readBoxHdr(&boxType, &boxLen, &dataLen)) {
    396459      if (boxType == 0x6a703268) { // JP2 header
     460        cover(0);
    397461        // skip the superbox
    398462      } else if (boxType == 0x69686472) { // image header
     463        cover(1);
    399464        if (readULong(&dummy) &&
    400465            readULong(&dummy) &&
     
    408473        }
    409474      } else if (boxType == 0x636F6C72) { // color specification
     475        cover(2);
    410476        if (readByte(&csMeth) &&
    411477            readByte(&csPrec1) &&
     
    441507        }
    442508      } else if (boxType == 0x6A703263) { // codestream
     509        cover(3);
    443510        if (!(haveBPC && haveCSMode)) {
    444511          getImageParams2(bitsPerComponent, csMode);
     
    446513        break;
    447514      } else {
     515        cover(4);
    448516        for (i = 0; i < dataLen; ++i) {
    449517          str->getChar();
     
    463531  while (readMarkerHdr(&segType, &segLen)) {
    464532    if (segType == 0x51) { // SIZ - image and tile size
     533      cover(5);
    465534      if (readUWord(&dummy) &&
    466535          readULong(&dummy) &&
     
    486555      break;
    487556    } else {
     557      cover(6);
    488558      if (segLen > 2) {
    489559        for (i = 0; i < segLen - 2; ++i) {
     
    506576  // Acrobat allows it
    507577  if (str->lookChar() == 0xff) {
     578    cover(7);
    508579    error(getPos(), "Naked JPEG 2000 codestream, missing JP2/JPX wrapper");
    509580    readCodestream(0);
     
    526597      // show up outside of it - so we simply ignore the JP2 header
    527598      // box
     599      cover(8);
    528600      break;
    529601    case 0x69686472:            // image header
     602      cover(9);
    530603      if (!readULong(&height) ||
    531604          !readULong(&width) ||
     
    549622      break;
    550623    case 0x62706363:            // bits per component
     624      cover(10);
    551625      if (!haveImgHdr) {
    552626        error(getPos(), "Found bits per component box before image header box in JPX stream");
     
    565639      break;
    566640    case 0x636F6C72:            // color specification
     641      cover(11);
    567642      if (!readColorSpecBox(dataLen)) {
    568643        return gFalse;
     
    570645      break;
    571646    case 0x70636c72:            // palette
     647      cover(12);
    572648      if (!readUWord(&palette.nEntries) ||
    573649          !readUByte(&palette.nComps)) {
     
    598674      break;
    599675    case 0x636d6170:            // component mapping
     676      cover(13);
    600677      compMap.nChannels = dataLen / 4;
    601678      compMap.comp = (Guint *)gmallocn(compMap.nChannels, sizeof(Guint));
     
    613690      break;
    614691    case 0x63646566:            // channel definition
     692      cover(14);
    615693      if (!readUWord(&channelDefn.nChannels)) {
    616694        error(getPos(), "Unexpected EOF in JPX stream");
     
    634712      break;
    635713    case 0x6A703263:            // contiguous codestream
     714      cover(15);
    636715      if (!bpc) {
    637716        error(getPos(), "JPX stream is missing the image header box");
     
    645724      break;
    646725    default:
     726      cover(16);
    647727      for (i = 0; i < dataLen; ++i) {
    648728        if (str->getChar() == EOF) {
     
    671751  switch (newCS.meth) {
    672752  case 1:                       // enumerated colorspace
     753    cover(17);
    673754    if (!readULong(&csEnum)) {
    674755      goto err;
     
    713794      } else if (dataLen == 7) {
    714795        //~ this assumes the 8-bit case
     796        cover(92);
    715797        newCS.enumerated.cieLab.rl = 100;
    716798        newCS.enumerated.cieLab.ol = 0;
     
    759841  case 3:                       // any ICC profile (JPX)
    760842  case 4:                       // vendor color (JPX)
     843    cover(18);
    761844    for (i = 0; i < dataLen - 3; ++i) {
    762845      if (str->getChar() == EOF) {
     
    785868  GBool haveSIZ, haveCOD, haveQCD, haveSOT;
    786869  Guint precinctSize, style;
    787   Guint segLen, capabilities, nTiles, comp, i, j, r;
     870  Guint segLen, capabilities, comp, i, j, r;
    788871
    789872  //----- main header
     
    797880    case 0x4f:                  // SOC - start of codestream
    798881      // marker only
     882      cover(19);
    799883      break;
    800884    case 0x51:                  // SIZ - image and tile size
     885      cover(20);
    801886      if (!readUWord(&capabilities) ||
    802887          !readULong(&img.xSize) ||
     
    820905      img.nYTiles = (img.ySize - img.yTileOffset + img.yTileSize - 1)
    821906                    / img.yTileSize;
    822       nTiles = img.nXTiles * img.nYTiles;
    823907      // check for overflow before allocating memory
    824       if (nTiles == 0 || nTiles / img.nXTiles != img.nYTiles) {
     908      if (img.nXTiles <= 0 || img.nYTiles <= 0 ||
     909          img.nXTiles >= INT_MAX / img.nYTiles) {
    825910        error(getPos(), "Bad tile count in JPX SIZ marker segment");
    826911        return gFalse;
    827912      }
    828       img.tiles = (JPXTile *)gmallocn(nTiles, sizeof(JPXTile));
     913      img.tiles = (JPXTile *)gmallocn(img.nXTiles * img.nYTiles,
     914                                      sizeof(JPXTile));
    829915      for (i = 0; i < img.nXTiles * img.nYTiles; ++i) {
    830916        img.tiles[i].tileComps = (JPXTileComp *)gmallocn(img.nComps,
     
    855941      break;
    856942    case 0x52:                  // COD - coding style default
     943      cover(21);
    857944      if (!readUByte(&img.tiles[0].tileComps[0].style) ||
    858945          !readUByte(&img.tiles[0].progOrder) ||
     
    901988      for (r = 0; r <= img.tiles[0].tileComps[0].nDecompLevels; ++r) {
    902989        if (img.tiles[0].tileComps[0].style & 0x01) {
     990          cover(91);
    903991          if (!readUByte(&precinctSize)) {
    904992            error(getPos(), "Error in JPX COD marker segment");
     
    9291017      break;
    9301018    case 0x53:                  // COC - coding style component
     1019      cover(22);
    9311020      if (!haveCOD) {
    9321021        error(getPos(), "JPX COC marker segment before COD segment");
     
    9981087      break;
    9991088    case 0x5c:                  // QCD - quantization default
     1089      cover(23);
    10001090      if (!readUByte(&img.tiles[0].tileComps[0].quantStyle)) {
    10011091        error(getPos(), "Error in JPX QCD marker segment");
     
    10611151      break;
    10621152    case 0x5d:                  // QCC - quantization component
     1153      cover(24);
    10631154      if (!haveQCD) {
    10641155        error(getPos(), "JPX QCC marker segment before QCD segment");
     
    11281219      break;
    11291220    case 0x5e:                  // RGN - region of interest
     1221      cover(25);
    11301222#if 1 //~ ROI is unimplemented
    11311223      fprintf(stderr, "RGN\n");
     
    11481240      break;
    11491241    case 0x5f:                  // POC - progression order change
     1242      cover(26);
    11501243#if 1 //~ progression order changes are unimplemented
    11511244      fprintf(stderr, "POC\n");
     
    11751268      break;
    11761269    case 0x60:                  // PPM - packed packet headers, main header
     1270      cover(27);
    11771271#if 1 //~ packed packet headers are unimplemented
    11781272      fprintf(stderr, "PPM\n");
     
    11871281    case 0x55:                  // TLM - tile-part lengths
    11881282      // skipped
     1283      cover(28);
    11891284      for (i = 0; i < segLen - 2; ++i) {
    11901285        if (str->getChar() == EOF) {
     
    11961291    case 0x57:                  // PLM - packet length, main header
    11971292      // skipped
     1293      cover(29);
    11981294      for (i = 0; i < segLen - 2; ++i) {
    11991295        if (str->getChar() == EOF) {
     
    12051301    case 0x63:                  // CRG - component registration
    12061302      // skipped
     1303      cover(30);
    12071304      for (i = 0; i < segLen - 2; ++i) {
    12081305        if (str->getChar() == EOF) {
     
    12141311    case 0x64:                  // COM - comment
    12151312      // skipped
     1313      cover(31);
    12161314      for (i = 0; i < segLen - 2; ++i) {
    12171315        if (str->getChar() == EOF) {
     
    12221320      break;
    12231321    case 0x90:                  // SOT - start of tile
     1322      cover(32);
    12241323      haveSOT = gTrue;
    12251324      break;
    12261325    default:
     1326      cover(33);
    12271327      error(getPos(), "Unknown marker segment %02x in JPX stream", segType);
    12281328      for (i = 0; i < segLen - 2; ++i) {
     
    13251425    switch (segType) {
    13261426    case 0x52:                  // COD - coding style default
     1427      cover(34);
    13271428      if (!readUByte(&img.tiles[tileIdx].tileComps[0].style) ||
    13281429          !readUByte(&img.tiles[tileIdx].progOrder) ||
     
    13921493      break;
    13931494    case 0x53:                  // COC - coding style component
     1495      cover(35);
    13941496      if ((img.nComps > 256 && !readUWord(&comp)) ||
    13951497          (img.nComps <= 256 && !readUByte(&comp)) ||
     
    14331535      break;
    14341536    case 0x5c:                  // QCD - quantization default
     1537      cover(36);
    14351538      if (!readUByte(&img.tiles[tileIdx].tileComps[0].quantStyle)) {
    14361539        error(getPos(), "Error in JPX QCD marker segment");
     
    14921595      break;
    14931596    case 0x5d:                  // QCC - quantization component
     1597      cover(37);
    14941598      if ((img.nComps > 256 && !readUWord(&comp)) ||
    14951599          (img.nComps <= 256 && !readUByte(&comp)) ||
     
    15431647      break;
    15441648    case 0x5e:                  // RGN - region of interest
     1649      cover(38);
    15451650#if 1 //~ ROI is unimplemented
    15461651      fprintf(stderr, "RGN\n");
     
    15631668      break;
    15641669    case 0x5f:                  // POC - progression order change
     1670      cover(39);
    15651671#if 1 //~ progression order changes are unimplemented
    15661672      fprintf(stderr, "POC\n");
     
    15901696      break;
    15911697    case 0x61:                  // PPT - packed packet headers, tile-part hdr
     1698      cover(40);
    15921699#if 1 //~ packed packet headers are unimplemented
    15931700      fprintf(stderr, "PPT\n");
     
    16011708    case 0x58:                  // PLT - packet length, tile-part header
    16021709      // skipped
     1710      cover(41);
    16031711      for (i = 0; i < segLen - 2; ++i) {
    16041712        if (str->getChar() == EOF) {
     
    16101718    case 0x64:                  // COM - comment
    16111719      // skipped
     1720      cover(42);
    16121721      for (i = 0; i < segLen - 2; ++i) {
    16131722        if (str->getChar() == EOF) {
     
    16181727      break;
    16191728    case 0x93:                  // SOD - start of data
     1729      cover(43);
    16201730      haveSOD = gTrue;
    16211731      break;
    16221732    default:
     1733      cover(44);
    16231734      error(getPos(), "Unknown marker segment %02x in JPX tile-part stream",
    16241735            segType);
     
    18181929    if (tilePartToEOC) {
    18191930      //~ peek for an EOC marker
     1931      cover(93);
    18201932    } else if (tilePartLen == 0) {
    18211933      break;
     
    18281940    //----- packet header
    18291941
     1942    // setup
     1943    startBitBuf(tilePartLen);
     1944
    18301945    // zero-length flag
    18311946    if (!readBits(1, &bits)) {
     
    18341949    if (!bits) {
    18351950      // packet is empty -- clear all code-block inclusion flags
    1836       for (sb = 0; sb < (tile->res == 0 ? 1 : 3); ++sb) {
     1951      cover(45);
     1952      for (sb = 0; sb < (Guint)(tile->res == 0 ? 1 : 3); ++sb) {
    18371953        subband = &precinct->subbands[sb];
    18381954        for (cbY = 0; cbY < subband->nYCBs; ++cbY) {
     
    18451961    } else {
    18461962
    1847       for (sb = 0; sb < (tile->res == 0 ? 1 : 3); ++sb) {
     1963      for (sb = 0; sb < (Guint)(tile->res == 0 ? 1 : 3); ++sb) {
    18481964        subband = &precinct->subbands[sb];
    18491965        for (cbY = 0; cbY < subband->nYCBs; ++cbY) {
     
    18531969            // skip code-blocks with no coefficients
    18541970            if (cb->x0 >= cb->x1 || cb->y0 >= cb->y1) {
     1971              cover(46);
    18551972              cb->included = gFalse;
    18561973              continue;
     
    18591976            // code-block inclusion
    18601977            if (cb->seen) {
     1978              cover(47);
    18611979              if (!readBits(1, &cb->included)) {
    18621980                goto err;
    18631981              }
    18641982            } else {
     1983              cover(48);
    18651984              ttVal = 0;
    18661985              i = 0;
     
    18962015
    18972016            if (cb->included) {
     2017              cover(49);
    18982018
    18992019              // zero bit-plane count
    19002020              if (!cb->seen) {
     2021                cover(50);
    19012022                ttVal = 0;
    19022023                i = 0;
     
    19322053              }
    19332054              if (bits == 0) {
     2055                cover(51);
    19342056                cb->nCodingPasses = 1;
    19352057              } else {
     
    19382060                }
    19392061                if (bits == 0) {
     2062                  cover(52);
    19402063                  cb->nCodingPasses = 2;
    19412064                } else {
     2065                  cover(53);
    19422066                  if (!readBits(2, &bits)) {
    19432067                    goto err;
    19442068                  }
    19452069                  if (bits < 3) {
     2070                    cover(54);
    19462071                    cb->nCodingPasses = 3 + bits;
    19472072                  } else {
     2073                    cover(55);
    19482074                    if (!readBits(5, &bits)) {
    19492075                      goto err;
    19502076                    }
    19512077                    if (bits < 31) {
     2078                      cover(56);
    19522079                      cb->nCodingPasses = 6 + bits;
    19532080                    } else {
     2081                      cover(57);
    19542082                      if (!readBits(7, &bits)) {
    19552083                        goto err;
     
    19852113      }
    19862114    }
    1987     tilePartLen -= byteCount;
    1988     clearBitBuf();
     2115    tilePartLen = finishBitBuf();
    19892116
    19902117    //----- packet data
    19912118
    1992     for (sb = 0; sb < (tile->res == 0 ? 1 : 3); ++sb) {
     2119    for (sb = 0; sb < (Guint)(tile->res == 0 ? 1 : 3); ++sb) {
    19932120      subband = &precinct->subbands[sb];
    19942121      for (cbY = 0; cbY < subband->nYCBs; ++cbY) {
     
    20112138    switch (tile->progOrder) {
    20122139    case 0: // layer, resolution level, component, precinct
     2140      cover(58);
    20132141      if (++tile->comp == img.nComps) {
    20142142        tile->comp = 0;
     
    20222150      break;
    20232151    case 1: // resolution level, layer, component, precinct
     2152      cover(59);
    20242153      if (++tile->comp == img.nComps) {
    20252154        tile->comp = 0;
     
    20342163    case 2: // resolution level, precinct, component, layer
    20352164      //~ this isn't correct -- see B.12.1.3
     2165      cover(60);
    20362166      if (++tile->layer == tile->nLayers) {
    20372167        tile->layer = 0;
     
    20462176    case 3: // precinct, component, resolution level, layer
    20472177      //~ this isn't correct -- see B.12.1.4
     2178      cover(61);
    20482179      if (++tile->layer == tile->nLayers) {
    20492180        tile->layer = 0;
     
    20582189    case 4: // component, precinct, resolution level, layer
    20592190      //~ this isn't correct -- see B.12.1.5
     2191      cover(62);
    20602192      if (++tile->layer == tile->nLayers) {
    20612193        tile->layer = 0;
     
    20902222
    20912223  if (cb->arithDecoder) {
     2224    cover(63);
    20922225    cb->arithDecoder->restart(cb->dataLen);
    20932226  } else {
     2227    cover(64);
    20942228    cb->arithDecoder = new JArithmeticDecoder();
    20952229    cb->arithDecoder->setStream(str, cb->dataLen);
     
    21062240    //----- significance propagation pass
    21072241    case jpxPassSigProp:
     2242      cover(65);
    21082243      for (y0 = cb->y0, coeff0 = cb->coeffs;
    21092244           y0 < cb->y1;
     
    21832318    //----- magnitude refinement pass
    21842319    case jpxPassMagRef:
     2320      cover(66);
    21852321      for (y0 = cb->y0, coeff0 = cb->coeffs;
    21862322           y0 < cb->y1;
     
    22442380    //----- cleanup pass
    22452381    case jpxPassCleanup:
     2382      cover(67);
    22462383      for (y0 = cb->y0, coeff0 = cb->coeffs;
    22472384           y0 < cb->y1;
     
    24052542  Guint r, cbX, cbY, x, y;
    24062543
     2544  cover(68);
     2545
    24072546  //----- (NL)LL subband (resolution level 0)
    24082547
     
    24152554  guard = (tileComp->quantStyle >> 5) & 7;
    24162555  if (qStyle == 0) {
     2556    cover(69);
    24172557    eps = (tileComp->quantSteps[0] >> 3) & 0x1f;
    24182558    shift = guard + eps - 1;
    24192559    mu = 0; // make gcc happy
    24202560  } else {
     2561    cover(70);
    24212562    shift = guard - 1 + tileComp->prec;
    24222563    mu = (double)(0x800 + (tileComp->quantSteps[0] & 0x7ff)) / 2048.0;
    24232564  }
    24242565  if (tileComp->transform == 0) {
     2566    cover(71);
    24252567    shift += fracBits;
    24262568  }
     
    24422584            shift2 = shift - (cb->nZeroBitPlanes + coeff->len);
    24432585            if (shift2 > 0) {
     2586              cover(94);
    24442587              val = (val << shift2) + (1 << (shift2 - 1));
    24452588            } else {
     2589              cover(95);
    24462590              val >>= -shift2;
    24472591            }
    24482592            if (qStyle == 0) {
     2593              cover(96);
    24492594              if (tileComp->transform == 0) {
     2595                cover(97);
    24502596                val &= -1 << fracBits;
    24512597              }
    24522598            } else {
     2599              cover(98);
    24532600              val = (int)((double)val * mu);
    24542601            }
    24552602            if (coeff->flags & jpxCoeffSign) {
     2603              cover(99);
    24562604              val = -val;
    24572605            }
     
    24742622    // in the upper-left corner of the tile-component data array
    24752623    if (r == tileComp->nDecompLevels) {
     2624      cover(72);
    24762625      nx0 = tileComp->x0;
    24772626      ny0 = tileComp->y0;
     
    24792628      ny1 = tileComp->y1;
    24802629    } else {
     2630      cover(73);
    24812631      nx0 = tileComp->resLevels[r+1].x0;
    24822632      ny0 = tileComp->resLevels[r+1].y0;
     
    25312681    // i-quant parameters
    25322682    if (qStyle == 0) {
     2683      cover(100);
    25332684      eps = (tileComp->quantSteps[3*r - 2 + sb] >> 3) & 0x1f;
    25342685      shift = guard + eps - 1;
    25352686      mu = 0; // make gcc happy
    25362687    } else {
     2688      cover(101);
    25372689      shift = guard + tileComp->prec;
    25382690      if (sb == 2) {
     2691        cover(102);
    25392692        ++shift;
    25402693      }
     
    25432696    }
    25442697    if (tileComp->transform == 0) {
     2698      cover(103);
    25452699      shift += fracBits;
    25462700    }
     
    25652719              shift2 = shift - (cb->nZeroBitPlanes + coeff->len);
    25662720              if (shift2 > 0) {
     2721                cover(74);
    25672722                val = (val << shift2) + (1 << (shift2 - 1));
    25682723              } else {
     2724                cover(75);
    25692725                val >>= -shift2;
    25702726              }
    25712727              if (qStyle == 0) {
     2728                cover(76);
    25722729                if (tileComp->transform == 0) {
    25732730                  val &= -1 << fracBits;
    25742731                }
    25752732              } else {
     2733                cover(77);
    25762734                val = (int)((double)val * mu);
    25772735              }
    25782736              if (coeff->flags & jpxCoeffSign) {
     2737                cover(78);
    25792738                val = -val;
    25802739              }
     
    26132772  //----- special case for length = 1
    26142773  if (i1 - i0 == 1) {
     2774    cover(79);
    26152775    if (i0 & 1) {
     2776      cover(104);
    26162777      *data >>= 1;
    26172778    }
    26182779
    26192780  } else {
     2781    cover(80);
    26202782
    26212783    // choose an offset: this makes even buf[] indexes correspond to
     
    26332795    buf[end] = buf[end - 2];
    26342796    if (i1 - i0 == 2) {
     2797      cover(81);
    26352798      buf[end+1] = buf[offset + 1];
    26362799      buf[end+2] = buf[offset];
    26372800      buf[end+3] = buf[offset + 1];
    26382801    } else {
     2802      cover(82);
    26392803      buf[end+1] = buf[end - 3];
    26402804      if (i1 - i0 == 3) {
     2805        cover(105);
    26412806        buf[end+2] = buf[offset + 1];
    26422807        buf[end+3] = buf[offset + 2];
    26432808      } else {
     2809        cover(106);
    26442810        buf[end+2] = buf[end - 4];
    26452811        if (i1 - i0 == 4) {
     2812          cover(107);
    26462813          buf[end+3] = buf[offset + 1];
    26472814        } else {
     2815          cover(108);
    26482816          buf[end+3] = buf[end - 5];
    26492817        }
     
    26562824    buf[offset - 3] = buf[offset + 3];
    26572825    if (offset == 4) {
     2826      cover(83);
    26582827      buf[0] = buf[offset + 4];
    26592828    }
     
    26622831
    26632832    if (tileComp->transform == 0) {
     2833      cover(84);
    26642834      // step 1 (even)
    26652835      for (i = 1; i <= end + 2; i += 2) {
     
    26902860
    26912861    } else {
     2862      cover(85);
    26922863      // step 1 (even)
    26932864      for (i = 3; i <= end; i += 2) {
     
    27182889
    27192890  if (tile->multiComp == 1) {
     2891    cover(86);
    27202892    if (img.nComps < 3 ||
    27212893        tile->tileComps[0].hSep != tile->tileComps[1].hSep ||
     
    27282900    // inverse irreversible multiple component transform
    27292901    if (tile->tileComps[0].transform == 0) {
     2902      cover(87);
    27302903      j = 0;
    27312904      for (y = 0; y < tile->tileComps[0].y1 - tile->tileComps[0].y0; ++y) {
     
    27442917    // inverse reversible multiple component transform
    27452918    } else {
     2919      cover(88);
    27462920      j = 0;
    27472921      for (y = 0; y < tile->tileComps[0].y1 - tile->tileComps[0].y0; ++y) {
     
    27652939    // signed: clip
    27662940    if (tileComp->sgned) {
     2941      cover(89);
    27672942      minVal = -(1 << (tileComp->prec - 1));
    27682943      maxVal = (1 << (tileComp->prec - 1)) - 1;
     
    27722947          coeff = *dataPtr;
    27732948          if (tileComp->transform == 0) {
     2949            cover(109);
    27742950            coeff >>= fracBits;
    27752951          }
    27762952          if (coeff < minVal) {
     2953            cover(110);
    27772954            coeff = minVal;
    27782955          } else if (coeff > maxVal) {
     2956            cover(111);
    27792957            coeff = maxVal;
    27802958          }
     
    27852963    // unsigned: inverse DC level shift and clip
    27862964    } else {
     2965      cover(90);
    27872966      maxVal = (1 << tileComp->prec) - 1;
    27882967      zeroVal = 1 << (tileComp->prec - 1);
     
    27922971          coeff = *dataPtr;
    27932972          if (tileComp->transform == 0) {
     2973            cover(112);
    27942974            coeff >>= fracBits;
    27952975          }
    27962976          coeff += zeroVal;
    27972977          if (coeff < 0) {
     2978            cover(113);
    27982979            coeff = 0;
    27992980          } else if (coeff > maxVal) {
     2981            cover(114);
    28002982            coeff = maxVal;
    28012983          }
     
    29303112
    29313113  while (bitBufLen < nBits) {
    2932     if ((c = str->getChar()) == EOF) {
     3114    if (byteCount == 0 || (c = str->getChar()) == EOF) {
    29333115      return gFalse;
    29343116    }
    2935     ++byteCount;
     3117    --byteCount;
    29363118    if (bitBufSkip) {
    29373119      bitBuf = (bitBuf << 7) | (c & 0x7f);
     
    29483130}
    29493131
    2950 void JPXStream::clearBitBuf() {
     3132void JPXStream::startBitBuf(Guint byteCountA) {
    29513133  bitBufLen = 0;
    29523134  bitBufSkip = gFalse;
    2953   byteCount = 0;
    2954 }
     3135  byteCount = byteCountA;
     3136}
     3137
     3138Guint JPXStream::finishBitBuf() {
     3139  if (bitBufSkip) {
     3140    str->getChar();
     3141    --byteCount;
     3142  }
     3143  return byteCount;
     3144}
Note: See TracChangeset for help on using the changeset viewer.