#include #if defined(__QT__) && (defined(_WIN32) || defined(__EMSCRIPTEN__)) #include #else #include #endif #include #include #include // Check zlib library version. [[maybe_unused]] const static bool zlibVersionCheck = []() { const char *const version = zlibVersion(); if (version[0] != ZLIB_VERSION[0]) { char message[96]; snprintf( message, 96, "zlib version mismatch: headers report %s, but library reports %s", ZLIB_VERSION, version); throw std::runtime_error(message); } return true; }(); namespace mbgl { namespace util { // Needed when using a zlib compiled with -DZ_PREFIX // because it will mess with this function name and // cause a link error. #undef compress bool is_compressed(const std::string &v) { if (v.size() > 2) { const auto byte0 = static_cast(v[0]); const auto byte1 = static_cast(v[1]); if (byte0 == 0x1f && byte1 == 0x8b) { // gzip (rfc1952) return true; } else if (byte0 == 0x78) { // zlib (rfc1950) switch (byte1) { case 0x01: // 78 01 - No Compression/low case 0x5E: // 78 5E - Fast Compression case 0x9C: // 78 9C - Default Compression case 0xDA: // 78 DA - Best Compression return true; default: return false; } } } return false; } std::string compress(const std::string &raw, int windowBits) { z_stream deflate_stream; memset(&deflate_stream, 0, sizeof(deflate_stream)); // TODO: reuse z_streams if (deflateInit2(&deflate_stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, windowBits, 8, Z_DEFAULT_STRATEGY) != Z_OK) { throw std::runtime_error("failed to initialize deflate"); } deflate_stream.next_in = reinterpret_cast(const_cast(raw.data())); deflate_stream.avail_in = uInt(raw.size()); std::string result; char out[16384]; int code; do { deflate_stream.next_out = reinterpret_cast(out); deflate_stream.avail_out = sizeof(out); code = deflate(&deflate_stream, Z_FINISH); if (result.size() < deflate_stream.total_out) { // append the block to the output string result.append(out, deflate_stream.total_out - result.size()); } } while (code == Z_OK); deflateEnd(&deflate_stream); if (code != Z_STREAM_END) { throw std::runtime_error(deflate_stream.msg); } return result; } std::string decompress(const std::string &raw, int windowBits) { z_stream inflate_stream; memset(&inflate_stream, 0, sizeof(inflate_stream)); // TODO: reuse z_streams if (inflateInit2(&inflate_stream, windowBits) != Z_OK) { throw std::runtime_error("failed to initialize inflate"); } inflate_stream.next_in = reinterpret_cast(const_cast(raw.data())); inflate_stream.avail_in = uInt(raw.size()); std::string result; char out[16384]; int code; do { inflate_stream.next_out = reinterpret_cast(out); inflate_stream.avail_out = sizeof(out); code = inflate(&inflate_stream, 0); if (result.size() < inflate_stream.total_out) { result.append(out, inflate_stream.total_out - result.size()); } } while (code == Z_OK); inflateEnd(&inflate_stream); if (code != Z_STREAM_END) { throw std::runtime_error(inflate_stream.msg ? inflate_stream.msg : "decompression error"); } return result; } std::uint32_t crc32(const void *raw, size_t size) noexcept { auto hash = ::crc32(0L, Z_NULL, 0); if (raw) { const auto *p = static_cast(raw); while (size > 0) { const auto blockSize = static_cast(size); hash = ::crc32(hash, p, blockSize); p += blockSize; size -= blockSize; } } return static_cast(hash); } } // namespace util } // namespace mbgl