| Index: content/common/gpu/client/gl_helper_benchmark.cc
|
| diff --git a/content/common/gpu/client/gl_helper_benchmark.cc b/content/common/gpu/client/gl_helper_benchmark.cc
|
| deleted file mode 100644
|
| index 43a1dbcf29395e7ad132abaa6c59f021ed74f8ad..0000000000000000000000000000000000000000
|
| --- a/content/common/gpu/client/gl_helper_benchmark.cc
|
| +++ /dev/null
|
| @@ -1,290 +0,0 @@
|
| -// Copyright (c) 2012 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.
|
| -
|
| -// This file looks like a unit test, but it contains benchmarks and test
|
| -// utilities intended for manual evaluation of the scalers in
|
| -// gl_helper*. These tests produce output in the form of files and printouts,
|
| -// but cannot really "fail". There is no point in making these tests part
|
| -// of any test automation run.
|
| -
|
| -#include <stddef.h>
|
| -#include <stdio.h>
|
| -#include <cmath>
|
| -#include <string>
|
| -#include <vector>
|
| -
|
| -#include <GLES2/gl2.h>
|
| -#include <GLES2/gl2ext.h>
|
| -#include <GLES2/gl2extchromium.h>
|
| -
|
| -#include "base/at_exit.h"
|
| -#include "base/command_line.h"
|
| -#include "base/files/file_util.h"
|
| -#include "base/macros.h"
|
| -#include "base/strings/stringprintf.h"
|
| -#include "base/time/time.h"
|
| -#include "content/common/gpu/client/gl_helper.h"
|
| -#include "content/common/gpu/client/gl_helper_scaling.h"
|
| -#include "gpu/blink/webgraphicscontext3d_in_process_command_buffer_impl.h"
|
| -#include "testing/gtest/include/gtest/gtest.h"
|
| -#include "third_party/skia/include/core/SkBitmap.h"
|
| -#include "third_party/skia/include/core/SkTypes.h"
|
| -#include "ui/gfx/codec/png_codec.h"
|
| -#include "ui/gl/gl_surface.h"
|
| -
|
| -namespace content {
|
| -
|
| -using blink::WebGLId;
|
| -using blink::WebGraphicsContext3D;
|
| -
|
| -content::GLHelper::ScalerQuality kQualities[] = {
|
| - content::GLHelper::SCALER_QUALITY_BEST,
|
| - content::GLHelper::SCALER_QUALITY_GOOD,
|
| - content::GLHelper::SCALER_QUALITY_FAST,
|
| -};
|
| -
|
| -const char *kQualityNames[] = {
|
| - "best",
|
| - "good",
|
| - "fast",
|
| -};
|
| -
|
| -class GLHelperTest : public testing::Test {
|
| - protected:
|
| - void SetUp() override {
|
| - WebGraphicsContext3D::Attributes attributes;
|
| - bool lose_context_when_out_of_memory = false;
|
| - context_ = gpu_blink::WebGraphicsContext3DInProcessCommandBufferImpl::
|
| - CreateOffscreenContext(attributes, lose_context_when_out_of_memory);
|
| - context_->InitializeOnCurrentThread();
|
| -
|
| - helper_.reset(
|
| - new content::GLHelper(context_->GetGLInterface(),
|
| - context_->GetContextSupport()));
|
| - helper_scaling_.reset(new content::GLHelperScaling(
|
| - context_->GetGLInterface(),
|
| - helper_.get()));
|
| - }
|
| -
|
| - void TearDown() override {
|
| - helper_scaling_.reset(NULL);
|
| - helper_.reset(NULL);
|
| - context_.reset(NULL);
|
| - }
|
| -
|
| -
|
| - void LoadPngFileToSkBitmap(const base::FilePath& filename,
|
| - SkBitmap* bitmap) {
|
| - std::string compressed;
|
| - base::ReadFileToString(base::MakeAbsoluteFilePath(filename), &compressed);
|
| - ASSERT_TRUE(compressed.size());
|
| - ASSERT_TRUE(gfx::PNGCodec::Decode(
|
| - reinterpret_cast<const unsigned char*>(compressed.data()),
|
| - compressed.size(), bitmap));
|
| - }
|
| -
|
| - // Save the image to a png file. Used to create the initial test files.
|
| - void SaveToFile(SkBitmap* bitmap, const base::FilePath& filename) {
|
| - std::vector<unsigned char> compressed;
|
| - ASSERT_TRUE(gfx::PNGCodec::Encode(
|
| - static_cast<unsigned char*>(bitmap->getPixels()),
|
| - gfx::PNGCodec::FORMAT_BGRA,
|
| - gfx::Size(bitmap->width(), bitmap->height()),
|
| - static_cast<int>(bitmap->rowBytes()),
|
| - true,
|
| - std::vector<gfx::PNGCodec::Comment>(),
|
| - &compressed));
|
| - ASSERT_TRUE(compressed.size());
|
| - FILE* f = base::OpenFile(filename, "wb");
|
| - ASSERT_TRUE(f);
|
| - ASSERT_EQ(fwrite(&*compressed.begin(), 1, compressed.size(), f),
|
| - compressed.size());
|
| - base::CloseFile(f);
|
| - }
|
| -
|
| - scoped_ptr<gpu_blink::WebGraphicsContext3DInProcessCommandBufferImpl>
|
| - context_;
|
| - scoped_ptr<content::GLHelper> helper_;
|
| - scoped_ptr<content::GLHelperScaling> helper_scaling_;
|
| - std::deque<GLHelperScaling::ScaleOp> x_ops_, y_ops_;
|
| -};
|
| -
|
| -
|
| -TEST_F(GLHelperTest, ScaleBenchmark) {
|
| - int output_sizes[] = { 1920, 1080,
|
| - 1249, 720, // Output size on pixel
|
| - 256, 144 };
|
| - int input_sizes[] = { 3200, 2040,
|
| - 2560, 1476, // Pixel tab size
|
| - 1920, 1080,
|
| - 1280, 720,
|
| - 800, 480,
|
| - 256, 144 };
|
| -
|
| - for (size_t q = 0; q < arraysize(kQualities); q++) {
|
| - for (size_t outsize = 0;
|
| - outsize < arraysize(output_sizes);
|
| - outsize += 2) {
|
| - for (size_t insize = 0;
|
| - insize < arraysize(input_sizes);
|
| - insize += 2) {
|
| - WebGLId src_texture = context_->createTexture();
|
| - WebGLId dst_texture = context_->createTexture();
|
| - WebGLId framebuffer = context_->createFramebuffer();
|
| - const gfx::Size src_size(input_sizes[insize],
|
| - input_sizes[insize + 1]);
|
| - const gfx::Size dst_size(output_sizes[outsize],
|
| - output_sizes[outsize + 1]);
|
| - SkBitmap input;
|
| - input.allocN32Pixels(src_size.width(), src_size.height());
|
| -
|
| - SkBitmap output_pixels;
|
| - output_pixels.allocN32Pixels(dst_size.width(), dst_size.height());
|
| -
|
| - context_->bindFramebuffer(GL_FRAMEBUFFER, framebuffer);
|
| - context_->bindTexture(GL_TEXTURE_2D, dst_texture);
|
| - context_->texImage2D(GL_TEXTURE_2D,
|
| - 0,
|
| - GL_RGBA,
|
| - dst_size.width(),
|
| - dst_size.height(),
|
| - 0,
|
| - GL_RGBA,
|
| - GL_UNSIGNED_BYTE,
|
| - 0);
|
| - context_->bindTexture(GL_TEXTURE_2D, src_texture);
|
| - context_->texImage2D(GL_TEXTURE_2D,
|
| - 0,
|
| - GL_RGBA,
|
| - src_size.width(),
|
| - src_size.height(),
|
| - 0,
|
| - GL_RGBA,
|
| - GL_UNSIGNED_BYTE,
|
| - input.getPixels());
|
| -
|
| - gfx::Rect src_subrect(0, 0,
|
| - src_size.width(), src_size.height());
|
| - scoped_ptr<content::GLHelper::ScalerInterface> scaler(
|
| - helper_->CreateScaler(kQualities[q],
|
| - src_size,
|
| - src_subrect,
|
| - dst_size,
|
| - false,
|
| - false));
|
| - // Scale once beforehand before we start measuring.
|
| - scaler->Scale(src_texture, dst_texture);
|
| - context_->finish();
|
| -
|
| - base::TimeTicks start_time = base::TimeTicks::Now();
|
| - int iterations = 0;
|
| - base::TimeTicks end_time;
|
| - while (true) {
|
| - for (int i = 0; i < 50; i++) {
|
| - iterations++;
|
| - scaler->Scale(src_texture, dst_texture);
|
| - context_->flush();
|
| - }
|
| - context_->finish();
|
| - end_time = base::TimeTicks::Now();
|
| - if (iterations > 2000) {
|
| - break;
|
| - }
|
| - if ((end_time - start_time).InMillisecondsF() > 1000) {
|
| - break;
|
| - }
|
| - }
|
| - context_->deleteTexture(dst_texture);
|
| - context_->deleteTexture(src_texture);
|
| - context_->deleteFramebuffer(framebuffer);
|
| -
|
| - std::string name;
|
| - name = base::StringPrintf("scale_%dx%d_to_%dx%d_%s",
|
| - src_size.width(),
|
| - src_size.height(),
|
| - dst_size.width(),
|
| - dst_size.height(),
|
| - kQualityNames[q]);
|
| -
|
| - float ms = (end_time - start_time).InMillisecondsF() / iterations;
|
| - printf("*RESULT gpu_scale_time: %s=%.2f ms\n", name.c_str(), ms);
|
| - }
|
| - }
|
| - }
|
| -}
|
| -
|
| -// This is more of a test utility than a test.
|
| -// Put an PNG image called "testimage.png" in your
|
| -// current directory, then run this test. It will
|
| -// create testoutput_Q_P.png, where Q is the scaling
|
| -// mode and P is the scaling percentage taken from
|
| -// the table below.
|
| -TEST_F(GLHelperTest, DISABLED_ScaleTestImage) {
|
| - int percents[] = {
|
| - 230,
|
| - 180,
|
| - 150,
|
| - 110,
|
| - 90,
|
| - 70,
|
| - 50,
|
| - 49,
|
| - 40,
|
| - 20,
|
| - 10,
|
| - };
|
| -
|
| - SkBitmap input;
|
| - LoadPngFileToSkBitmap(base::FilePath(
|
| - FILE_PATH_LITERAL("testimage.png")), &input);
|
| -
|
| - WebGLId framebuffer = context_->createFramebuffer();
|
| - WebGLId src_texture = context_->createTexture();
|
| - const gfx::Size src_size(input.width(), input.height());
|
| - context_->bindFramebuffer(GL_FRAMEBUFFER, framebuffer);
|
| - context_->bindTexture(GL_TEXTURE_2D, src_texture);
|
| - context_->texImage2D(GL_TEXTURE_2D,
|
| - 0,
|
| - GL_RGBA,
|
| - src_size.width(),
|
| - src_size.height(),
|
| - 0,
|
| - GL_RGBA,
|
| - GL_UNSIGNED_BYTE,
|
| - input.getPixels());
|
| -
|
| - for (size_t q = 0; q < arraysize(kQualities); q++) {
|
| - for (size_t p = 0; p < arraysize(percents); p++) {
|
| - const gfx::Size dst_size(input.width() * percents[p] / 100,
|
| - input.height() * percents[p] / 100);
|
| - WebGLId dst_texture = helper_->CopyAndScaleTexture(
|
| - src_texture,
|
| - src_size,
|
| - dst_size,
|
| - false,
|
| - kQualities[q]);
|
| -
|
| - SkBitmap output_pixels;
|
| - output_pixels.allocN32Pixels(dst_size.width(), dst_size.height());
|
| -
|
| - helper_->ReadbackTextureSync(
|
| - dst_texture,
|
| - gfx::Rect(0, 0,
|
| - dst_size.width(),
|
| - dst_size.height()),
|
| - static_cast<unsigned char *>(output_pixels.getPixels()),
|
| - kN32_SkColorType);
|
| - context_->deleteTexture(dst_texture);
|
| - std::string filename = base::StringPrintf("testoutput_%s_%d.ppm",
|
| - kQualityNames[q],
|
| - percents[p]);
|
| - VLOG(0) << "Writing " << filename;
|
| - SaveToFile(&output_pixels, base::FilePath::FromUTF8Unsafe(filename));
|
| - }
|
| - }
|
| - context_->deleteTexture(src_texture);
|
| - context_->deleteFramebuffer(framebuffer);
|
| -}
|
| -
|
| -} // namespace
|
|
|