halcanary | d9e5715 | 2015-08-12 11:24:40 -0700 | [diff] [blame] | 1 | |
| 2 | /* |
| 3 | * Copyright 2010 The Android Open Source Project |
| 4 | * |
| 5 | * Use of this source code is governed by a BSD-style license that can be |
| 6 | * found in the LICENSE file. |
| 7 | */ |
| 8 | |
| 9 | |
| 10 | #include "SkData.h" |
| 11 | #include "SkDeflate.h" |
| 12 | #include "SkStream.h" |
| 13 | |
halcanary | d9e5715 | 2015-08-12 11:24:40 -0700 | [diff] [blame] | 14 | #ifdef ZLIB_INCLUDE |
| 15 | #include ZLIB_INCLUDE |
| 16 | #else |
| 17 | #include "zlib.h" |
| 18 | #endif |
| 19 | |
thakis | 41c054e | 2015-10-15 10:52:23 -0700 | [diff] [blame] | 20 | namespace { |
| 21 | |
halcanary | d9e5715 | 2015-08-12 11:24:40 -0700 | [diff] [blame] | 22 | // Different zlib implementations use different T. |
| 23 | // We've seen size_t and unsigned. |
| 24 | template <typename T> void* skia_alloc_func(void*, T items, T size) { |
| 25 | return sk_calloc_throw(SkToSizeT(items) * SkToSizeT(size)); |
| 26 | } |
| 27 | |
halcanary | 48305e8 | 2015-08-18 13:30:25 -0700 | [diff] [blame] | 28 | void skia_free_func(void*, void* address) { sk_free(address); } |
halcanary | d9e5715 | 2015-08-12 11:24:40 -0700 | [diff] [blame] | 29 | |
halcanary | 48305e8 | 2015-08-18 13:30:25 -0700 | [diff] [blame] | 30 | } // namespace |
halcanary | d9e5715 | 2015-08-12 11:24:40 -0700 | [diff] [blame] | 31 | |
| 32 | #define SKDEFLATEWSTREAM_INPUT_BUFFER_SIZE 4096 |
| 33 | #define SKDEFLATEWSTREAM_OUTPUT_BUFFER_SIZE 4224 // 4096 + 128, usually big |
| 34 | // enough to always do a |
| 35 | // single loop. |
| 36 | |
| 37 | // called by both write() and finalize() |
| 38 | static void do_deflate(int flush, |
| 39 | z_stream* zStream, |
| 40 | SkWStream* out, |
| 41 | unsigned char* inBuffer, |
| 42 | size_t inBufferSize) { |
| 43 | zStream->next_in = inBuffer; |
| 44 | zStream->avail_in = SkToInt(inBufferSize); |
| 45 | unsigned char outBuffer[SKDEFLATEWSTREAM_OUTPUT_BUFFER_SIZE]; |
| 46 | SkDEBUGCODE(int returnValue;) |
| 47 | do { |
| 48 | zStream->next_out = outBuffer; |
| 49 | zStream->avail_out = sizeof(outBuffer); |
| 50 | SkDEBUGCODE(returnValue =) deflate(zStream, flush); |
| 51 | SkASSERT(!zStream->msg); |
| 52 | |
| 53 | out->write(outBuffer, sizeof(outBuffer) - zStream->avail_out); |
| 54 | } while (zStream->avail_in || !zStream->avail_out); |
| 55 | SkASSERT(flush == Z_FINISH |
| 56 | ? returnValue == Z_STREAM_END |
| 57 | : returnValue == Z_OK); |
| 58 | } |
| 59 | |
| 60 | // Hide all zlib impl details. |
| 61 | struct SkDeflateWStream::Impl { |
| 62 | SkWStream* fOut; |
| 63 | unsigned char fInBuffer[SKDEFLATEWSTREAM_INPUT_BUFFER_SIZE]; |
| 64 | size_t fInBufferIndex; |
| 65 | z_stream fZStream; |
| 66 | }; |
| 67 | |
halcanary | e365bfa | 2016-02-08 09:34:34 -0800 | [diff] [blame] | 68 | SkDeflateWStream::SkDeflateWStream(SkWStream* out, |
| 69 | int compressionLevel, |
| 70 | bool gzip) |
| 71 | : fImpl(new SkDeflateWStream::Impl) { |
halcanary | d9e5715 | 2015-08-12 11:24:40 -0700 | [diff] [blame] | 72 | fImpl->fOut = out; |
| 73 | fImpl->fInBufferIndex = 0; |
| 74 | if (!fImpl->fOut) { |
| 75 | return; |
| 76 | } |
halcanary | e365bfa | 2016-02-08 09:34:34 -0800 | [diff] [blame] | 77 | fImpl->fZStream.next_in = nullptr; |
halcanary | d9e5715 | 2015-08-12 11:24:40 -0700 | [diff] [blame] | 78 | fImpl->fZStream.zalloc = &skia_alloc_func; |
| 79 | fImpl->fZStream.zfree = &skia_free_func; |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 80 | fImpl->fZStream.opaque = nullptr; |
halcanary | e365bfa | 2016-02-08 09:34:34 -0800 | [diff] [blame] | 81 | SkASSERT(compressionLevel <= 9 && compressionLevel >= -1); |
| 82 | SkDEBUGCODE(int r =) deflateInit2(&fImpl->fZStream, compressionLevel, |
| 83 | Z_DEFLATED, gzip ? 0x1F : 0x0F, |
| 84 | 8, Z_DEFAULT_STRATEGY); |
halcanary | d9e5715 | 2015-08-12 11:24:40 -0700 | [diff] [blame] | 85 | SkASSERT(Z_OK == r); |
| 86 | } |
| 87 | |
| 88 | SkDeflateWStream::~SkDeflateWStream() { this->finalize(); } |
| 89 | |
| 90 | void SkDeflateWStream::finalize() { |
| 91 | if (!fImpl->fOut) { |
| 92 | return; |
| 93 | } |
| 94 | do_deflate(Z_FINISH, &fImpl->fZStream, fImpl->fOut, fImpl->fInBuffer, |
| 95 | fImpl->fInBufferIndex); |
| 96 | (void)deflateEnd(&fImpl->fZStream); |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 97 | fImpl->fOut = nullptr; |
halcanary | d9e5715 | 2015-08-12 11:24:40 -0700 | [diff] [blame] | 98 | } |
| 99 | |
| 100 | bool SkDeflateWStream::write(const void* void_buffer, size_t len) { |
| 101 | if (!fImpl->fOut) { |
| 102 | return false; |
| 103 | } |
| 104 | const char* buffer = (const char*)void_buffer; |
| 105 | while (len > 0) { |
| 106 | size_t tocopy = |
| 107 | SkTMin(len, sizeof(fImpl->fInBuffer) - fImpl->fInBufferIndex); |
| 108 | memcpy(fImpl->fInBuffer + fImpl->fInBufferIndex, buffer, tocopy); |
| 109 | len -= tocopy; |
| 110 | buffer += tocopy; |
| 111 | fImpl->fInBufferIndex += tocopy; |
| 112 | SkASSERT(fImpl->fInBufferIndex <= sizeof(fImpl->fInBuffer)); |
| 113 | |
| 114 | // if the buffer isn't filled, don't call into zlib yet. |
| 115 | if (sizeof(fImpl->fInBuffer) == fImpl->fInBufferIndex) { |
| 116 | do_deflate(Z_NO_FLUSH, &fImpl->fZStream, fImpl->fOut, |
| 117 | fImpl->fInBuffer, fImpl->fInBufferIndex); |
| 118 | fImpl->fInBufferIndex = 0; |
| 119 | } |
| 120 | } |
| 121 | return true; |
| 122 | } |
| 123 | |
| 124 | size_t SkDeflateWStream::bytesWritten() const { |
| 125 | return fImpl->fZStream.total_in + fImpl->fInBufferIndex; |
| 126 | } |