Home | History | Annotate | Download | only in bench 
      1 /*
      2  * Copyright 2013 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 "SkBitmap.h"
     11 #include "SkData.h"
     12 #include "SkForceLinking.h"
     13 #include "SkImageDecoder.h"
     14 #include "SkOSFile.h"
     15 #include "SkStream.h"
     16 #include "SkString.h"
     17 
     18 __SK_FORCE_IMAGE_DECODER_LINKING;
     19 
     20 class SkCanvas;
     21 
     22 class SkipZeroesBench : public Benchmark {
     23 public:
     24     SkipZeroesBench(const char* filename, bool skipZeroes)
     25     : fName("SkipZeroes_")
     26     , fDecoder(nullptr)
     27     , fFilename(filename)
     28     , fStream()
     29     , fSkipZeroes(skipZeroes)
     30     , fValid(false) {
     31         fName.append(filename);
     32         if (skipZeroes) {
     33             fName.append("_skip_zeroes");
     34         } else {
     35             fName.append("_write_zeroes");
     36         }
     37     }
     38 
     39     bool isSuitableFor(Backend backend) override {
     40         return backend == kNonRendering_Backend;
     41     }
     42 
     43 protected:
     44     const char* onGetName() override {
     45         return fName.c_str();
     46     }
     47 
     48     void onDelayedSetup() override {
     49         SkString resourcePath = GetResourcePath();
     50         if (resourcePath.isEmpty()) {
     51             fValid = false;
     52             return;
     53         }
     54 
     55         SkString fullPath = SkOSPath::Join(resourcePath.c_str(), fFilename.c_str());
     56         SkFILEStream fileStream(fullPath.c_str());
     57         fValid = fileStream.isValid() && fileStream.getLength() > 0;
     58         if (fValid) {
     59             const size_t size = fileStream.getLength();
     60             void* data = sk_malloc_throw(size);
     61             if (fileStream.read(data, size) < size) {
     62                 fValid = false;
     63             } else {
     64                 SkAutoTUnref<SkData> skdata(SkData::NewFromMalloc(data, size));
     65                 fStream.setData(skdata.get());
     66                 fDecoder.reset(SkImageDecoder::Factory(&fStream));
     67                 if (fDecoder.get()) {
     68                     fDecoder->setSkipWritingZeroes(fSkipZeroes);
     69                 } else {
     70                     fValid = false;
     71                 }
     72             }
     73         }
     74     }
     75 
     76     void onDraw(int loops, SkCanvas*) override {
     77         if (!fValid) {
     78 #ifdef SK_DEBUG
     79             SkDebugf("stream was invalid: %s\n", fFilename.c_str());
     80 #endif
     81             return;
     82         }
     83         // Decode a bunch of times
     84         SkBitmap bm;
     85         for (int i = 0; i < loops; ++i) {
     86             SkDEBUGCODE(SkImageDecoder::Result result =) fDecoder->decode(&fStream, &bm,
     87                     SkImageDecoder::kDecodePixels_Mode);
     88 #ifdef SK_DEBUG
     89             if (SkImageDecoder::kFailure == result) {
     90                 SkDebugf("failed to decode %s\n", fFilename.c_str());
     91                 return;
     92             }
     93 #endif
     94             SkDEBUGCODE(bool success =) fStream.rewind();
     95 #ifdef SK_DEBUG
     96             if (!success) {
     97                 SkDebugf("failed to rewind %s\n", fFilename.c_str());
     98                 return;
     99             }
    100 #endif
    101         }
    102     }
    103 
    104 private:
    105     SkString                        fName;
    106     SkAutoTDelete<SkImageDecoder>   fDecoder;
    107     const SkString                  fFilename;
    108     SkMemoryStream                  fStream;
    109     bool                            fSkipZeroes;
    110     bool                            fValid;
    111 
    112     typedef Benchmark INHERITED;
    113 };
    114 
    115 // Enable the true version once the feature is checked in.
    116 DEF_BENCH(return new SkipZeroesBench("arrow.png", true));
    117 DEF_BENCH(return new SkipZeroesBench("arrow.png", false));
    118