Home | History | Annotate | Download | only in bench 
      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 
      8 #include "Benchmark.h"
      9 #include "Resources.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(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 Benchmark {
     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() {
     93         SkString pkmFilename = GetResourcePath("mandrill_128.pkm");
     94         // Expand the data
     95         SkAutoDataUnref fileData(SkData::NewFromFileName(pkmFilename.c_str()));
     96         if (NULL == fileData) {
     97             SkDebugf("Could not open the file. Did you forget to set the resourcePath?\n");
     98             return NULL;
     99         }
    100 
    101         const etc1_uint32 kExpansionFactor = 8;
    102         etc1_byte* expandedETC1 =
    103             create_expanded_etc1_bitmap(fileData->bytes(), kExpansionFactor);
    104         if (NULL == expandedETC1) {
    105             SkDebugf("Error expanding ETC1 data by factor of %d\n", kExpansionFactor);
    106             return NULL;
    107         }
    108 
    109         etc1_uint32 width = etc1_pkm_get_width(expandedETC1);
    110         etc1_uint32 height = etc1_pkm_get_width(expandedETC1);
    111         etc1_uint32 dataSz = ETC_PKM_HEADER_SIZE + etc1_get_encoded_data_size(width, height);
    112         return SkData::NewFromMalloc(expandedETC1, dataSz);
    113     }
    114 
    115     typedef Benchmark INHERITED;
    116 };
    117 
    118 // This is the rendering benchmark. Prior to rendering the data, create a
    119 // bitmap using the etc1 data.
    120 class ETCBitmapBench : public ETCBitmapBenchBase {
    121 public:
    122     ETCBitmapBench(bool decompress, Backend backend)
    123         : fDecompress(decompress), fBackend(backend) { }
    124 
    125     virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
    126         return backend == this->fBackend;
    127     }
    128 
    129 protected:
    130     virtual const char* onGetName() SK_OVERRIDE {
    131         if (kGPU_Backend == this->fBackend) {
    132             if (this->fDecompress) {
    133                 return "etc1bitmap_render_gpu_decompressed";
    134             } else {
    135                 return "etc1bitmap_render_gpu_compressed";
    136             }
    137         } else {
    138             SkASSERT(kRaster_Backend == this->fBackend);
    139             if (this->fDecompress) {
    140                 return "etc1bitmap_render_raster_decompressed";
    141             } else {
    142                 return "etc1bitmap_render_raster_compressed";
    143             }
    144         }
    145     }
    146 
    147     virtual void onPreDraw() SK_OVERRIDE {
    148         if (NULL == fPKMData) {
    149             SkDebugf("Failed to load PKM data!\n");
    150             return;
    151         }
    152 
    153         // Install pixel ref
    154         if (!SkInstallDiscardablePixelRef(
    155                 SkDecodingImageGenerator::Create(
    156                     fPKMData, SkDecodingImageGenerator::Options()), &(this->fBitmap))) {
    157             SkDebugf("Could not install discardable pixel ref.\n");
    158             return;
    159         }
    160 
    161         // Decompress it if necessary
    162         if (this->fDecompress) {
    163             this->fBitmap.lockPixels();
    164         }
    165     }
    166 
    167     virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
    168         for (int i = 0; i < loops; ++i) {
    169             canvas->drawBitmap(this->fBitmap, 0, 0, NULL);
    170         }
    171     }
    172 
    173 protected:
    174     SkBitmap fBitmap;
    175     bool decompress() const { return fDecompress; }
    176     Backend backend() const { return fBackend; }
    177 private:
    178     const bool fDecompress;
    179     const Backend fBackend;
    180     typedef ETCBitmapBenchBase INHERITED;
    181 };
    182 
    183 // This benchmark is identical to the previous benchmark, but it explicitly forces
    184 // an upload to the GPU before each draw call. We do this by notifying the bitmap
    185 // that the pixels have changed (even though they haven't).
    186 class ETCBitmapUploadBench : public ETCBitmapBench {
    187 public:
    188     ETCBitmapUploadBench(bool decompress, Backend backend)
    189         : ETCBitmapBench(decompress, backend) { }
    190 
    191 protected:
    192     virtual const char* onGetName() SK_OVERRIDE {
    193         if (kGPU_Backend == this->backend()) {
    194             if (this->decompress()) {
    195                 return "etc1bitmap_upload_gpu_decompressed";
    196             } else {
    197                 return "etc1bitmap_upload_gpu_compressed";
    198             }
    199         } else {
    200             SkASSERT(kRaster_Backend == this->backend());
    201             if (this->decompress()) {
    202                 return "etc1bitmap_upload_raster_decompressed";
    203             } else {
    204                 return "etc1bitmap_upload_raster_compressed";
    205             }
    206         }
    207     }
    208 
    209     virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
    210         SkPixelRef* pr = fBitmap.pixelRef();
    211         for (int i = 0; i < loops; ++i) {
    212             if (pr) {
    213                 pr->notifyPixelsChanged();
    214             }
    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, Benchmark::kRaster_Backend);)
    224 DEF_BENCH(return new ETCBitmapBench(true, Benchmark::kRaster_Backend);)
    225 
    226 DEF_BENCH(return new ETCBitmapBench(false, Benchmark::kGPU_Backend);)
    227 DEF_BENCH(return new ETCBitmapBench(true, Benchmark::kGPU_Backend);)
    228 
    229 DEF_BENCH(return new ETCBitmapUploadBench(false, Benchmark::kRaster_Backend);)
    230 DEF_BENCH(return new ETCBitmapUploadBench(true, Benchmark::kRaster_Backend);)
    231 
    232 DEF_BENCH(return new ETCBitmapUploadBench(false, Benchmark::kGPU_Backend);)
    233 DEF_BENCH(return new ETCBitmapUploadBench(true, Benchmark::kGPU_Backend);)
    234 
    235 #endif  // SK_IGNORE_ETC1_SUPPORT
    236