1/*
2 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "SkData.h"
9#include "SkFlate.h"
10#include "SkStream.h"
11#include "Test.h"
12
13// A memory stream that reports zero size with the standard call, like
14// an unseekable file stream would.
15class SkZeroSizeMemStream : public SkMemoryStream {
16public:
17    virtual size_t read(void* buffer, size_t size) {
18        if (buffer == NULL && size == 0)
19            return 0;
20        if (buffer == NULL && size == kGetSizeKey)
21            size = 0;
22        return SkMemoryStream::read(buffer, size);
23    }
24
25    static const size_t kGetSizeKey = 0xDEADBEEF;
26};
27
28// Returns a deterministic data of the given size that should be
29// very compressible.
30static SkData* new_test_data(size_t dataSize) {
31    SkAutoTMalloc<uint8_t> testBuffer(dataSize);
32    for (size_t i = 0; i < dataSize; ++i) {
33        testBuffer[i] = i % 64;
34    }
35    return SkData::NewFromMalloc(testBuffer.detach(), dataSize);
36}
37
38static void TestFlate(skiatest::Reporter* reporter, SkMemoryStream* testStream,
39                      size_t dataSize) {
40    SkASSERT(testStream != NULL);
41
42    SkAutoDataUnref testData(new_test_data(dataSize));
43    SkASSERT(testData->size() == dataSize);
44
45    testStream->setMemory(testData->data(), dataSize, /*copyData=*/ true);
46    SkDynamicMemoryWStream compressed;
47    bool deflateSuccess = SkFlate::Deflate(testStream, &compressed);
48    REPORTER_ASSERT(reporter, deflateSuccess);
49
50    // Check that the input data wasn't changed.
51    size_t inputSize = testStream->getLength();
52    if (inputSize == 0) {
53        inputSize = testStream->read(NULL, SkZeroSizeMemStream::kGetSizeKey);
54    }
55    REPORTER_ASSERT(reporter, dataSize == inputSize);
56    if (dataSize == inputSize) {
57        REPORTER_ASSERT(reporter, memcmp(testData->data(),
58                                         testStream->getMemoryBase(),
59                                         dataSize) == 0);
60    }
61
62    size_t compressedSize = compressed.getOffset();
63
64    SkAutoDataUnref compressedData(compressed.copyToData());
65    testStream->setData(compressedData.get());
66
67    SkDynamicMemoryWStream uncompressed;
68    bool inflateSuccess = SkFlate::Inflate(testStream, &uncompressed);
69    REPORTER_ASSERT(reporter, inflateSuccess);
70
71    // Check that the input data wasn't changed.
72    inputSize = testStream->getLength();
73    if (inputSize == 0) {
74        inputSize = testStream->read(NULL, SkZeroSizeMemStream::kGetSizeKey);
75    }
76    REPORTER_ASSERT(reporter,  compressedSize == inputSize);
77    if (compressedData->size() == inputSize) {
78        REPORTER_ASSERT(reporter, memcmp(testStream->getMemoryBase(),
79                                         compressedData->data(),
80                                         compressedData->size()) == 0);
81    }
82
83    // Check that the uncompressed data matches the source data.
84    SkAutoDataUnref uncompressedData(uncompressed.copyToData());
85    REPORTER_ASSERT(reporter, dataSize == uncompressedData->size());
86    if (dataSize == uncompressedData->size()) {
87        REPORTER_ASSERT(reporter, memcmp(testData->data(),
88                                         uncompressedData->data(),
89                                         dataSize) == 0);
90    }
91
92    if (compressedSize < 1) { return; }
93
94    double compressionRatio = static_cast<double>(dataSize) / compressedSize;
95    // Assert that some compression took place.
96    REPORTER_ASSERT(reporter, compressionRatio > 1.2);
97
98    if (reporter->verbose()) {
99        SkDebugf("Flate Test: \t input size: " SK_SIZE_T_SPECIFIER
100                 "\tcompressed size: " SK_SIZE_T_SPECIFIER
101                 "\tratio: %.4g\n",
102                 dataSize, compressedSize, compressionRatio);
103    }
104}
105
106DEF_TEST(Flate, reporter) {
107#ifdef SK_HAS_ZLIB
108    REPORTER_ASSERT(reporter, SkFlate::HaveFlate());
109#endif
110    if (SkFlate::HaveFlate()) {
111        SkMemoryStream memStream;
112        TestFlate(reporter, &memStream, 512);
113        TestFlate(reporter, &memStream, 10240);
114
115        SkZeroSizeMemStream fileStream;
116        TestFlate(reporter, &fileStream, 512);
117        TestFlate(reporter, &fileStream, 10240);
118    }
119}
120