Add raster timing to ImageDecodeBench

third_party/WebKit/Source/platform/testing/ImageDecodeBench.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Provides a minimal wrapping of the Blink image decoders. Used to perform
-// a non-threaded, memory-to-memory image decode using micro second accuracy
-// clocks to measure image decode time. Optionally applies color correction
-// during image decoding on supported platforms (default off). Usage:
+// Provides a minimal wrapping of the Blink image decoders & Skia raster.
+// Used to perform a non-threaded, memory-to-memory image decode/raster using
+// micro second accuracy clocks to measure image decode time. Optionally
+// applies color correction during image decoding on supported platforms
+// (default off). Usage:
 //
 //   % ninja -C out/Release image_decode_bench &&
 //      ./out/Release/image_decode_bench file [iterations]
 //
 // If --raw-output is specified, the output is formatted for use in a .csv file
 // (comma-separated variable).
 // Each row represents successive frames in an animated image.
 // (frame 0, frame 1, frame 2...)
 // Each column represents a single frame decoded from successive iterations.
 // Iteration 0: (frame 0, frame 1, frame 2...)
 // Iteration 1: (frame 0, frame 1, frame 2...)
 //
 // This means non-animated images will show up as one column.
+// Raster timing also shows up as one column.
 //
 // This .csv-formatted output is a common format for spreadsheet and data
 // visualization programs. A user can take timings before and after a change,
 // import the two .csv files, and overlay their line graphs ontop of each other
 // to see how the two measurements compare.
 //
 // It should tell the user 1.) if the change was an improvement, 2.) if so, how
 // much, and 3.) if the measurements are noisy and thus reduce our trust in the
 // improvement.
 //
@@ skipping 10 matching lines @@
 
 #include <cmath>
 #include <memory>
 #include <vector>
 #include "base/command_line.h"
 #include "platform/SharedBuffer.h"
 #include "platform/image-decoders/ImageDecoder.h"
 #include "platform/wtf/PassRefPtr.h"
 #include "platform/wtf/PtrUtil.h"
 #include "public/platform/Platform.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkSurface.h"
 #include "ui/gfx/test/icc_profiles.h"
 
 #if defined(_WIN32)
 #include <mmsystem.h>
 #include <sys/stat.h>
 #include <time.h>
 #define stat(x, y) _stat(x, y)
 typedef struct _stat sttype;
 #else
 #include <sys/stat.h>
@@ skipping 238 matching lines @@
                            ColorBehavior::Ignore());
   size_t frame_count = frame_count_decoder->FrameCount();
 
   IterationsOfFrameTimings timings(iterations, FrameTimings(frame_count, 0.0));
 
   for (size_t i = 0; i < iterations; ++i) {
     std::unique_ptr<ImageDecoder> decoder = ImageDecoder::Create(
         data.Get(), true, ImageDecoder::kAlphaPremultiplied,
         apply_color_correction ? ColorBehavior::TransformToTargetForTesting()
                                : ColorBehavior::Ignore());
-    constexpr bool all_data_received = true;
+    bool all_data_received = true;
     decoder->SetData(data.Get(), all_data_received);
     for (size_t frame_index = 0; frame_index < frame_count; ++frame_index) {
       double start_time = GetCurrentTime();
       ImageFrame* frame = decoder->FrameBufferAtIndex(frame_index);
       double elapsed_time = GetCurrentTime() - start_time;
       if (frame->GetStatus() != ImageFrame::kFrameComplete) {
         fprintf(stderr, "Image decode failed\n");
         exit(3);
       }
       timings[i][frame_index] = elapsed_time;
     }
   }
 
   return timings;
 }
 
 // This function mimics deferred decoding in Chromium when not all data has been
 // received yet.
 IterationsOfFrameTimings TimePacketedDecode(PassRefPtr<SharedBuffer> data,
                                             bool apply_color_correction,
                                             size_t packet_size,
                                             size_t iterations) {
   // Find total frame count.
   // Doing this requires a decoder with full data (no packet size).
   std::unique_ptr<ImageDecoder> frame_count_decoder =
       ImageDecoder::Create(data.Get(), true, ImageDecoder::kAlphaPremultiplied,
                            ColorBehavior::Ignore());
 
-  constexpr bool total_all_data_received = true;
+  bool total_all_data_received = true;
   frame_count_decoder->SetData(data.Get(), total_all_data_received);
   size_t total_frame_count = frame_count_decoder->FrameCount();
 
   IterationsOfFrameTimings timings(iterations,
                                    FrameTimings(total_frame_count, 0.0));
 
   RefPtr<SharedBuffer> packet_data = SharedBuffer::Create();
   size_t position = 0;
   size_t next_frame_to_decode = 0;
   while (true) {
@@ skipping 28 matching lines @@
       if (all_data_received || decoder->Failed()) {
         fprintf(stderr, "Image decode failed\n");
         exit(3);
       }
     }
   }
 
   return timings;
 }
 
+IterationsOfFrameTimings TimeRaster(PassRefPtr<SharedBuffer> data,
+                                    size_t iterations) {
+  std::unique_ptr<ImageDecoder> decoder =
+      ImageDecoder::Create(data.Get(), true, ImageDecoder::kAlphaPremultiplied,
+                           ColorBehavior::Ignore());
+
+  bool all_data_received = true;
+  decoder->SetData(data.Get(), all_data_received);
+
+  if (!decoder->IsSizeAvailable()) {
+    fprintf(stderr, "failed to decode size\n");
+    exit(3);
+  }
+
+  size_t frame_count = decoder->FrameCount();
+
+  auto size = decoder->Size();
+  auto surface = SkSurface::MakeRasterN32Premul(size.Width(), size.Height());
+  auto canvas = surface->getCanvas();
+
+  IterationsOfFrameTimings timings(iterations, FrameTimings(frame_count, 0.0));
+  for (size_t i = 0; i < iterations; ++i) {
+    for (size_t frame_index = 0; frame_index < frame_count; ++frame_index) {
+      ImageFrame* frame = decoder->FrameBufferAtIndex(frame_index);
+      if (frame->GetStatus() != ImageFrame::kFrameComplete) {
+        fprintf(stderr, "failed to decode frame\n");
+        exit(3);
+      }
+
+      double start_time = GetCurrentTime();
+      canvas->drawBitmap(frame->Bitmap(), 0, 0, nullptr);
+      double elapsed_time = GetCurrentTime() - start_time;
+      timings[i][frame_index] = elapsed_time;
+    }
+  }
+
+  return timings;
+}
+
 }  // namespace
 
 int Main(int argc, char* argv[]) {
   base::CommandLine::Init(argc, argv);
 
   // If the platform supports color correction, allow it to be controlled.
 
   bool apply_color_correction = false;
   if (argc >= 2 && strcmp(argv[1], "--color-correct") == 0) {
     --argc;
     ++argv;
     apply_color_correction = true;
     gfx::ICCProfile profile = gfx::ICCProfileForTestingColorSpin();
     ColorBehavior::SetGlobalTargetColorProfile(profile);
   }
 
+  bool time_raster = false;
+  if (argc >= 2 && strcmp(argv[1], "--raster") == 0) {
+    --argc;
+    ++argv;
+    time_raster = true;
+  }
+
   const char* raw_output_file = nullptr;
   if (argc >= 2 && strcmp(argv[1], "--raw-output") == 0) {
     if (argc < 3) {
       fprintf(stderr,
               "--raw-output specified without also specifying a file after it");
       exit(1);
     }
 
     raw_output_file = argv[2];
     argc -= 2;
     argv += 2;
   }
 
   if (argc < 2) {
     fprintf(stderr,
-            "Usage: %s [--color-correct] [--raw-output output_file] file "
-            "[iterations] [packetSize]\n",
+            "Usage: %s [--color-correct] [--raw-output output_file] [--raster] "
+            "file [iterations] [packetSize]\n",
             argv[0]);
     exit(1);
   }
 
   // Control decode bench iterations and packet size.
 
   size_t iterations = 1;
   if (argc >= 3) {
     char* end = 0;
     iterations = strtol(argv[2], &end, 10);
@@ skipping 13 matching lines @@
     if (*end != '\0') {
       fprintf(stderr,
               "Third argument should be packet size. Default is "
               "0, meaning to decode the entire image in one packet. You "
               "supplied %s\n",
               argv[3]);
       exit(1);
     }
   }
 
+  if (time_raster && packet_size) {
+    fprintf(stderr,
+            "It does not make sense to specify a packet size when "
+            "timing raster\n");
+    exit(1);
+  }
+
   // Create a web platform.  blink::Platform can't be used directly because its
   // constructor is protected.
 
   class WebPlatform : public blink::Platform {};
 
   Platform::Initialize(new WebPlatform());
 
   // Read entire file content to data, and consolidate the SharedBuffer data
   // segments into one, contiguous block of memory.
 
   RefPtr<SharedBuffer> data = ReadFile(argv[1]);
   if (!data.Get() || !data->size()) {
     fprintf(stderr, "Error reading image data from [%s]\n", argv[1]);
     exit(2);
   }
 
   data->Data();
 
   IterationsOfFrameTimings timings;
-  if (packet_size) {
-    timings = TimePacketedDecode(data.Get(), apply_color_correction,
-                                 packet_size, iterations);
+  if (time_raster) {
+    timings = TimeRaster(data.Get(), iterations);
   } else {
-    timings = TimeDecode(data.Get(), apply_color_correction, iterations);
+    if (packet_size) {
+      timings = TimePacketedDecode(data.Get(), apply_color_correction,
+                                   packet_size, iterations);
+    } else {
+      timings = TimeDecode(data.Get(), apply_color_correction, iterations);
+    }
   }
 
   if (raw_output_file)
     Write2DResultsToFile(timings, raw_output_file);
 
   double mean = GetMean(timings);
   double standard_deviation = GetStandardDeviation(timings, mean);
 
   printf("mean: %f standard deviation: %f\n", mean, standard_deviation);
 
   return 0;
 }
 
 }  // namespace blink
 
 int main(int argc, char* argv[]) {
   return blink::Main(argc, argv);
 }