Lines Matching refs:d_stream

267     z_stream d_stream; /* decompression stream */

269     d_stream.zalloc = nullptr;

270     d_stream.zfree = nullptr;

271     d_stream.opaque = nullptr;

272     d_stream.next_in  = compr;

273     d_stream.avail_in = 0;

274     d_stream.next_out = uncompr;

275     err = inflateInit(&d_stream);

279     while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) {

280         d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */

281         err = inflate(&d_stream, Z_NO_FLUSH);

289     fprintf(stderr, "inflateEnd result: %d\n", inflateEnd(&d_stream));

370     z_stream d_stream; /* decompression stream */

372     d_stream.zalloc = nullptr;

373     d_stream.zfree = nullptr;

374     d_stream.opaque = nullptr;

375     d_stream.next_in  = compr;

376     d_stream.avail_in = static_cast<uInt>(comprLen);

377     err = inflateInit(&d_stream);

381         d_stream.next_out = uncompr;            /* discard the output */

382         d_stream.avail_out = static_cast<uInt>(uncomprLen);

383         err = inflate(&d_stream, Z_NO_FLUSH);

390     err = inflateEnd(&d_stream);

452     z_stream d_stream; /* decompression stream */

454     d_stream.zalloc = nullptr;

455     d_stream.zfree = nullptr;

456     d_stream.opaque = nullptr;

457     d_stream.next_in  = compr;

458     d_stream.avail_in = 2; /* just read the zlib header */

459     err = inflateInit(&d_stream);

462     d_stream.next_out = uncompr;

463     d_stream.avail_out = static_cast<uInt>(uncomprLen);

465     inflate(&d_stream, Z_NO_FLUSH);

466     d_stream.avail_in = static_cast<uInt>(comprLen) - 2;   /* read all compressed data */

467     inflateSync(&d_stream);

468     inflate(&d_stream, Z_FINISH);

469     inflateEnd(&d_stream);

529     z_stream d_stream; /* decompression stream */

531     d_stream.zalloc = nullptr;

532     d_stream.zfree = nullptr;

533     d_stream.opaque = nullptr;

534     d_stream.next_in  = compr;

535     d_stream.avail_in = static_cast<uInt>(comprLen);

536     err = inflateInit(&d_stream);

538     d_stream.next_out = uncompr;

539     d_stream.avail_out = static_cast<uInt>(uncomprLen);

541         err = inflate(&d_stream, Z_NO_FLUSH);

547                 &d_stream, reinterpret_cast<const Bytef*>(DICTIONARY), static_cast<int>(sizeof(DICTIONARY)));

555     err = inflateEnd(&d_stream);

1376     z_stream d_stream; /* decompression stream */

1378     d_stream.zalloc = nullptr;

1379     d_stream.zfree = nullptr;

1380     d_stream.opaque = nullptr;

1381     d_stream.next_in  = compr;

1382     d_stream.avail_in = 0;

1383     d_stream.next_out = uncompr;

1384     err = inflateCodesUsed(&d_stream);

1421     z_stream d_stream; /* decompression stream */

1423     d_stream.zalloc = nullptr;

1424     d_stream.zfree = nullptr;

1425     d_stream.opaque = nullptr;

1426     d_stream.next_in  = compr;

1427     d_stream.avail_in = static_cast<uInt>(comprLen);

1428     err = inflateInit(&d_stream);

1430     d_stream.next_out = uncompr;

1431     d_stream.avail_out = static_cast<uInt>(uncomprLen);

1432     err = inflate(&d_stream, Z_NO_FLUSH);

1433     err = inflateGetDictionary(&d_stream, uncompr, nullptr);

1435     inflateMark(&d_stream);

1436     err = inflateEnd(&d_stream);

1592     z_stream d_stream; /* decompression stream */

1594     d_stream.zalloc = nullptr;

1595     d_stream.zfree = nullptr;

1596     d_stream.opaque = nullptr;

1597     d_stream.next_in  = compr;

1598     d_stream.avail_in = 2; /* just read the zlib header */

1599     err = inflateInit(&d_stream);

1601     d_stream.next_out = uncompr;

1602     d_stream.avail_out = static_cast<uInt>(uncomprLen);

1603     inflate(&d_stream, Z_NO_FLUSH);

1604     err = inflateReset(&d_stream);

1607     err = inflateResetKeep(&d_stream);

1609     err = inflateInit2(&d_stream, windowBits);

1610     inflate(&d_stream, Z_NO_FLUSH);

1611     err = inflateReset2(&d_stream, windowBits);

1630     z_stream d_stream; /* decompression stream */

1632     d_stream.zalloc = nullptr;

1633     d_stream.zfree = nullptr;

1634     d_stream.opaque = nullptr;

1635     d_stream.next_in  = compr;

1636     d_stream.avail_in = static_cast<uInt>(comprLen);

1637     err = inflateInit(&d_stream);

1639     d_stream.next_out = uncompr;

1640     d_stream.avail_out = static_cast<uInt>(uncomprLen);

1641     inflate(&d_stream, Z_NO_FLUSH);

1642     inflateSetDictionary(&d_stream, reinterpret_cast<const Bytef*>(DICTIONARY), static_cast<int>(sizeof(DICTIONARY)));

1643     err = inflateEnd(&d_stream);

1664     z_stream d_stream; /* decompression stream */

1666     d_stream.zalloc = nullptr;

1667     d_stream.zfree = nullptr;

1668     d_stream.opaque = nullptr;

1669     d_stream.next_in  = compr;

1670     d_stream.avail_in = static_cast<uInt>(comprLen);

1671     err = inflateInit(&d_stream);

1673     d_stream.next_out = uncompr;

1674     d_stream.avail_out = static_cast<uInt>(uncomprLen);

1675     err = inflateSyncPoint(&d_stream);

1696     z_stream d_stream; /* decompression stream */

1698     d_stream.zalloc = nullptr;

1699     d_stream.zfree = nullptr;

1700     d_stream.opaque = nullptr;

1701     d_stream.next_in  = compr;

1702     d_stream.avail_in = static_cast<uInt>(comprLen);

1703     err = inflateInit(&d_stream);

1705     d_stream.next_out = uncompr;

1706     d_stream.avail_out = static_cast<uInt>(uncomprLen);

1707     err = inflateUndermine(&d_stream, 1);

1728     z_stream d_stream; /* decompression stream */

1730     d_stream.zalloc = nullptr;

1731     d_stream.zfree = nullptr;

1732     d_stream.opaque = nullptr;

1733     d_stream.next_in  = compr;

1734     d_stream.avail_in = static_cast<uInt>(comprLen);

1735     err = inflateInit(&d_stream);

1737     d_stream.next_out = uncompr;

1738     d_stream.avail_out = static_cast<uInt>(uncomprLen);

1739     err = inflateValidate(&d_stream, 1);