krajcevski | 9a3cdbb | 2014-06-05 07:03:39 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2014 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 | |
tfarina | bcbc178 | 2014-06-18 14:32:48 -0700 | [diff] [blame^] | 8 | #include "Resources.h" |
krajcevski | 9a3cdbb | 2014-06-05 07:03:39 -0700 | [diff] [blame] | 9 | #include "SkBenchmark.h" |
| 10 | #include "SkCanvas.h" |
| 11 | #include "SkData.h" |
| 12 | #include "SkDecodingImageGenerator.h" |
| 13 | #include "SkImageDecoder.h" |
| 14 | #include "SkOSFile.h" |
| 15 | #include "SkPixelRef.h" |
| 16 | |
| 17 | #ifndef SK_IGNORE_ETC1_SUPPORT |
| 18 | |
| 19 | #include "etc1.h" |
| 20 | |
| 21 | // This takes the etc1 data pointed to by orig, and copies it `factor` times in each |
| 22 | // dimension. The return value is the new data or NULL on error. |
| 23 | static etc1_byte* create_expanded_etc1_bitmap(const uint8_t* orig, int factor) { |
| 24 | SkASSERT(NULL != orig); |
| 25 | SkASSERT(factor > 1); |
| 26 | |
| 27 | const etc1_byte* origData = reinterpret_cast<const etc1_byte*>(orig); |
| 28 | if (!etc1_pkm_is_valid(orig)) { |
| 29 | return NULL; |
| 30 | } |
| 31 | |
| 32 | etc1_uint32 origWidth = etc1_pkm_get_width(origData); |
| 33 | etc1_uint32 origHeight = etc1_pkm_get_height(origData); |
| 34 | |
| 35 | // The width and height must be aligned along block boundaries |
| 36 | static const etc1_uint32 kETC1BlockWidth = 4; |
| 37 | static const etc1_uint32 kETC1BlockHeight = 4; |
| 38 | if ((origWidth % kETC1BlockWidth) != 0 || |
| 39 | (origHeight % kETC1BlockHeight) != 0) { |
| 40 | return NULL; |
| 41 | } |
| 42 | |
| 43 | // The picture must be at least as large as a block. |
| 44 | if (origWidth <= kETC1BlockWidth || origHeight <= kETC1BlockHeight) { |
| 45 | return NULL; |
| 46 | } |
| 47 | |
| 48 | etc1_uint32 newWidth = origWidth * factor; |
| 49 | etc1_uint32 newHeight = origHeight * factor; |
| 50 | |
| 51 | etc1_uint32 newDataSz = etc1_get_encoded_data_size(newWidth, newHeight); |
| 52 | etc1_byte* newData = reinterpret_cast<etc1_byte *>( |
| 53 | sk_malloc_throw(newDataSz + ETC_PKM_HEADER_SIZE)); |
| 54 | etc1_pkm_format_header(newData, newWidth, newHeight); |
| 55 | |
| 56 | etc1_byte* copyInto = newData; |
| 57 | |
| 58 | copyInto += ETC_PKM_HEADER_SIZE; |
| 59 | origData += ETC_PKM_HEADER_SIZE; |
| 60 | |
| 61 | etc1_uint32 origBlocksX = (origWidth >> 2); |
| 62 | etc1_uint32 origBlocksY = (origHeight >> 2); |
| 63 | etc1_uint32 newBlocksY = (newHeight >> 2); |
| 64 | etc1_uint32 origRowSzInBytes = origBlocksX * ETC1_ENCODED_BLOCK_SIZE; |
| 65 | |
| 66 | for (etc1_uint32 j = 0; j < newBlocksY; ++j) { |
| 67 | const etc1_byte* rowStart = origData + ((j % origBlocksY) * origRowSzInBytes); |
| 68 | for(etc1_uint32 i = 0; i < newWidth; i += origWidth) { |
| 69 | memcpy(copyInto, rowStart, origRowSzInBytes); |
| 70 | copyInto += origRowSzInBytes; |
| 71 | } |
| 72 | } |
| 73 | return newData; |
| 74 | } |
| 75 | |
| 76 | // This is the base class for all of the benches in this file. In general |
| 77 | // the ETC1 benches should all be working on the same data. Due to the |
| 78 | // simplicity of the PKM file, that data is the 128x128 mandrill etc1 |
| 79 | // compressed texture repeated by some factor (currently 8 -> 1024x1024) |
| 80 | class ETCBitmapBenchBase : public SkBenchmark { |
| 81 | public: |
| 82 | ETCBitmapBenchBase() : fPKMData(loadPKM()) { |
| 83 | if (NULL == fPKMData) { |
| 84 | SkDebugf("Could not load PKM data!"); |
| 85 | } |
| 86 | } |
| 87 | |
| 88 | protected: |
| 89 | SkAutoDataUnref fPKMData; |
| 90 | |
| 91 | private: |
| 92 | SkData *loadPKM() { |
tfarina | 880914c | 2014-06-09 12:05:34 -0700 | [diff] [blame] | 93 | SkString resourcePath = GetResourcePath(); |
| 94 | SkString filename = SkOSPath::SkPathJoin(resourcePath.c_str(), |
| 95 | "mandrill_128.pkm"); |
krajcevski | 9a3cdbb | 2014-06-05 07:03:39 -0700 | [diff] [blame] | 96 | |
| 97 | // Expand the data |
| 98 | SkAutoDataUnref fileData(SkData::NewFromFileName(filename.c_str())); |
| 99 | if (NULL == fileData) { |
| 100 | SkDebugf("Could not open the file. Did you forget to set the resourcePath?\n"); |
| 101 | return NULL; |
| 102 | } |
| 103 | |
| 104 | const etc1_uint32 kExpansionFactor = 8; |
| 105 | etc1_byte* expandedETC1 = |
| 106 | create_expanded_etc1_bitmap(fileData->bytes(), kExpansionFactor); |
| 107 | if (NULL == expandedETC1) { |
| 108 | SkDebugf("Error expanding ETC1 data by factor of %d\n", kExpansionFactor); |
| 109 | return NULL; |
| 110 | } |
| 111 | |
| 112 | etc1_uint32 width = etc1_pkm_get_width(expandedETC1); |
| 113 | etc1_uint32 height = etc1_pkm_get_width(expandedETC1); |
| 114 | etc1_uint32 dataSz = ETC_PKM_HEADER_SIZE + etc1_get_encoded_data_size(width, height); |
| 115 | return SkData::NewFromMalloc(expandedETC1, dataSz); |
| 116 | } |
| 117 | |
| 118 | typedef SkBenchmark INHERITED; |
| 119 | }; |
| 120 | |
| 121 | // This is the rendering benchmark. Prior to rendering the data, create a |
| 122 | // bitmap using the etc1 data. |
| 123 | class ETCBitmapBench : public ETCBitmapBenchBase { |
| 124 | public: |
| 125 | ETCBitmapBench(bool decompress, Backend backend) |
| 126 | : fDecompress(decompress), fBackend(backend) { } |
| 127 | |
| 128 | virtual bool isSuitableFor(Backend backend) SK_OVERRIDE { |
| 129 | return backend == this->fBackend; |
| 130 | } |
| 131 | |
| 132 | protected: |
| 133 | virtual const char* onGetName() SK_OVERRIDE { |
| 134 | if (kGPU_Backend == this->fBackend) { |
| 135 | if (this->fDecompress) { |
| 136 | return "etc1bitmap_render_gpu_decompressed"; |
| 137 | } else { |
| 138 | return "etc1bitmap_render_gpu_compressed"; |
| 139 | } |
| 140 | } else { |
| 141 | SkASSERT(kRaster_Backend == this->fBackend); |
| 142 | if (this->fDecompress) { |
| 143 | return "etc1bitmap_render_raster_decompressed"; |
| 144 | } else { |
| 145 | return "etc1bitmap_render_raster_compressed"; |
| 146 | } |
| 147 | } |
| 148 | } |
| 149 | |
| 150 | virtual void onPreDraw() SK_OVERRIDE { |
| 151 | if (NULL == fPKMData) { |
| 152 | SkDebugf("Failed to load PKM data!\n"); |
| 153 | return; |
| 154 | } |
| 155 | |
| 156 | // Install pixel ref |
| 157 | if (!SkInstallDiscardablePixelRef( |
| 158 | SkDecodingImageGenerator::Create( |
| 159 | fPKMData, SkDecodingImageGenerator::Options()), &(this->fBitmap))) { |
| 160 | SkDebugf("Could not install discardable pixel ref.\n"); |
| 161 | return; |
| 162 | } |
| 163 | |
| 164 | // Decompress it if necessary |
| 165 | if (this->fDecompress) { |
| 166 | this->fBitmap.lockPixels(); |
| 167 | } |
| 168 | } |
| 169 | |
| 170 | virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE { |
| 171 | for (int i = 0; i < loops; ++i) { |
| 172 | canvas->drawBitmap(this->fBitmap, 0, 0, NULL); |
| 173 | } |
| 174 | } |
| 175 | |
| 176 | protected: |
| 177 | SkBitmap fBitmap; |
| 178 | bool decompress() const { return fDecompress; } |
| 179 | Backend backend() const { return fBackend; } |
| 180 | private: |
| 181 | const bool fDecompress; |
| 182 | const Backend fBackend; |
| 183 | typedef ETCBitmapBenchBase INHERITED; |
| 184 | }; |
| 185 | |
| 186 | // This benchmark is identical to the previous benchmark, but it explicitly forces |
| 187 | // an upload to the GPU before each draw call. We do this by notifying the bitmap |
| 188 | // that the pixels have changed (even though they haven't). |
| 189 | class ETCBitmapUploadBench : public ETCBitmapBench { |
| 190 | public: |
| 191 | ETCBitmapUploadBench(bool decompress, Backend backend) |
| 192 | : ETCBitmapBench(decompress, backend) { } |
| 193 | |
| 194 | protected: |
| 195 | virtual const char* onGetName() SK_OVERRIDE { |
| 196 | if (kGPU_Backend == this->backend()) { |
| 197 | if (this->decompress()) { |
| 198 | return "etc1bitmap_upload_gpu_decompressed"; |
| 199 | } else { |
| 200 | return "etc1bitmap_upload_gpu_compressed"; |
| 201 | } |
| 202 | } else { |
| 203 | SkASSERT(kRaster_Backend == this->backend()); |
| 204 | if (this->decompress()) { |
| 205 | return "etc1bitmap_upload_raster_decompressed"; |
| 206 | } else { |
| 207 | return "etc1bitmap_upload_raster_compressed"; |
| 208 | } |
| 209 | } |
| 210 | } |
| 211 | |
| 212 | virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE { |
| 213 | for (int i = 0; i < loops; ++i) { |
| 214 | this->fBitmap.pixelRef()->notifyPixelsChanged(); |
| 215 | canvas->drawBitmap(this->fBitmap, 0, 0, NULL); |
| 216 | } |
| 217 | } |
| 218 | |
| 219 | private: |
| 220 | typedef ETCBitmapBench INHERITED; |
| 221 | }; |
| 222 | |
| 223 | DEF_BENCH(return new ETCBitmapBench(false, SkBenchmark::kRaster_Backend);) |
| 224 | DEF_BENCH(return new ETCBitmapBench(true, SkBenchmark::kRaster_Backend);) |
| 225 | |
| 226 | DEF_BENCH(return new ETCBitmapBench(false, SkBenchmark::kGPU_Backend);) |
| 227 | DEF_BENCH(return new ETCBitmapBench(true, SkBenchmark::kGPU_Backend);) |
| 228 | |
| 229 | DEF_BENCH(return new ETCBitmapUploadBench(false, SkBenchmark::kRaster_Backend);) |
| 230 | DEF_BENCH(return new ETCBitmapUploadBench(true, SkBenchmark::kRaster_Backend);) |
| 231 | |
| 232 | DEF_BENCH(return new ETCBitmapUploadBench(false, SkBenchmark::kGPU_Backend);) |
| 233 | DEF_BENCH(return new ETCBitmapUploadBench(true, SkBenchmark::kGPU_Backend);) |
| 234 | |
| 235 | #endif // SK_IGNORE_ETC1_SUPPORT |