Method doDecompressData

src/Compression/CompressionCodecMultiple.cpp:69–132

}

UInt32 CompressionCodecMultiple::doDecompressData(const char * source, UInt32 source_size, char * dest, UInt32 decompressed_size) const
{
    if (source_size < 1 || !source[0])
        throw Exception(decompression_error_code, "Wrong compression methods list");

    UInt8 compression_methods_size = source[0];
    /// +1 for the compression_methods_size byte itself
    if (static_cast<UInt32>(compression_methods_size) + 1 > source_size)
        throw Exception(decompression_error_code, "Wrong compression methods list: header claims {} codecs"
                        " but compressed data is only {} bytes",
                        static_cast<UInt32>(compression_methods_size), source_size);

    PODArray<char> compressed_buf(&source[compression_methods_size + 1], &source[source_size]);
    PODArray<char> uncompressed_buf;
    /// Insert all data into compressed buf
    source_size -= (compression_methods_size + 1);

    for (int idx = compression_methods_size - 1; idx >= 0; --idx)
    {
        UInt8 compression_method = source[idx + 1];
        const auto codec = CompressionCodecFactory::instance().get(compression_method);
        auto additional_size_at_the_end_of_buffer = codec->getAdditionalSizeAtTheEndOfBuffer();

        if (compressed_buf.size() >= 1_GiB)
            throw Exception(decompression_error_code, "Too large compressed size: {}", compressed_buf.size());

        if (source_size < COMPRESSED_BLOCK_HEADER_SIZE)
            throw Exception(decompression_error_code, "Compressed data is too short to contain a block header: {} bytes",
                            source_size);

        {
            UInt32 bytes_to_resize = 0;
            if (common::addOverflow(static_cast<UInt32>(compressed_buf.size()), additional_size_at_the_end_of_buffer, bytes_to_resize))
                throw Exception(decompression_error_code, "Too large compressed size: {}", compressed_buf.size());

            compressed_buf.resize(compressed_buf.size() + additional_size_at_the_end_of_buffer);
        }

        UInt32 uncompressed_size = readDecompressedBlockSize(compressed_buf.data());

        if (uncompressed_size >= 1_GiB)
            throw Exception(decompression_error_code, "Too large uncompressed size: {}", uncompressed_size);

        if (idx == 0 && uncompressed_size != decompressed_size)
            throw Exception(decompression_error_code, "Wrong final decompressed size in codec Multiple, got {}, expected {}",
                uncompressed_size, decompressed_size);

        {
            UInt32 bytes_to_resize = 0;
            if (common::addOverflow(uncompressed_size, additional_size_at_the_end_of_buffer, bytes_to_resize))
                throw Exception(decompression_error_code, "Too large uncompressed size: {}", uncompressed_size);

            uncompressed_buf.resize(bytes_to_resize);
        }

        codec->decompress(compressed_buf.data(), source_size, uncompressed_buf.data());
        uncompressed_buf.swap(compressed_buf);
        /// The call to decompress will validate uncompressed_size (same readDecompressedBlockSize call as here)