Skip to content

GitLab

T
tangled
Commit 93c6800e authored by David Staessens's avatar David Staessens Committed by Commit Bot
Browse files
Options

media/gpu: Improve jpeg HW encode tests, so they can be executed from Tast. 

Fixed a bug that would prevent using absolute input file paths. This is required
by tast, since the test image data is uploaded to a custom directory.

Temporary files are generated, written to a temporary file, and read into memory
again. This unnecessary step has been removed. File operations introduce
additional points of failure, and it can be tricky to write to temporary files
when using the Tast framework. This also prevents files cluttering the temp
folder when not being cleaned up on crashes.

The encode output of generated images is now written to the current folder using
HxW_[black|white].jpg as output file name.

TEST=ran jpeg_encode_accelerator_unittest on eve

BUG=899605

Change-Id: Ie3f0e299ef85ce663586b4ba4c1177e84ec7a8ca
Reviewed-on: https://chromium-review.googlesource.com/c/1333011
Commit-Queue: David Staessens <dstaessens@chromium.org>
Reviewed-by: default avatarHirokazu Honda <hiroh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#608176}
parent bd611e3e
Show whitespace changes
Inline Side-by-side
Showing with 154 additions and 194 deletions
media/gpu/jpeg_encode_accelerator_unittest.cc
View file @ 93c6800e
// Copyright 2018 The Chromium Authors. All rights reserved. // Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be // Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. // found in the LICENSE file.
// This has to be included first.
// See http://code.google.com/p/googletest/issues/detail?id=371
#include "testing/gtest/include/gtest/gtest.h"
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
...@@ -34,6 +29,7 @@ ...@@ -34,6 +29,7 @@
#include "media/gpu/test/video_accelerator_unittest_helpers.h" #include "media/gpu/test/video_accelerator_unittest_helpers.h"
#include "media/video/jpeg_encode_accelerator.h" #include "media/video/jpeg_encode_accelerator.h"
#include "mojo/core/embedder/embedder.h" #include "mojo/core/embedder/embedder.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/libyuv/include/libyuv.h" #include "third_party/libyuv/include/libyuv.h"
#include "ui/gfx/codec/jpeg_codec.h" #include "ui/gfx/codec/jpeg_codec.h"
...@@ -47,9 +43,10 @@ namespace { ...@@ -47,9 +43,10 @@ namespace {
// Default test image file. // Default test image file.
const base::FilePath::CharType kDefaultYuvFilename[] = const base::FilePath::CharType kDefaultYuvFilename[] =
FILE_PATH_LITERAL("bali_640x360_P420.yuv:640x360"); FILE_PATH_LITERAL("bali_640x360_P420.yuv:640x360");
// Whether to save encode results to files. Output files will be saved // Whether to save encode results to files. Output files will be saved in the
// in the same directory with unittest. File name is like input file but // same directory as the input files, with the '.jpg' extension appended to
// changing the extension to "jpg". // their names. The encode result of generated images is written to the current
// folder using HxW_[black|white].jpg as output file name.
bool g_save_to_file = false; bool g_save_to_file = false;
const double kMeanDiffThreshold = 10.0; const double kMeanDiffThreshold = 10.0;
...@@ -59,18 +56,21 @@ const int kJpegDefaultQuality = 90; ...@@ -59,18 +56,21 @@ const int kJpegDefaultQuality = 90;
class JpegEncodeAcceleratorTestEnvironment; class JpegEncodeAcceleratorTestEnvironment;
JpegEncodeAcceleratorTestEnvironment* g_env; JpegEncodeAcceleratorTestEnvironment* g_env;
struct TestImageFile { struct TestImage {
TestImageFile(const base::FilePath::StringType& filename, TestImage(std::vector<uint8_t> image_data,
gfx::Size visible_size) const gfx::Size& visible_size,
: filename(filename), visible_size(visible_size) {} const base::FilePath output_filename)
: image_data(std::move(image_data)),
base::FilePath::StringType filename; visible_size(visible_size),
output_filename(output_filename) {}
// The input content of |filename|.
std::string data_str;
// Test image data.
std::vector<uint8_t> image_data;
gfx::Size visible_size; gfx::Size visible_size;
size_t output_size;
// Output filename, only used when '--save_to_file' is specified.
base::FilePath output_filename;
size_t output_size = 0;
}; };
enum class ClientState { enum class ClientState {
...@@ -95,50 +95,41 @@ class JpegEncodeAcceleratorTestEnvironment : public ::testing::Environment { ...@@ -95,50 +95,41 @@ class JpegEncodeAcceleratorTestEnvironment : public ::testing::Environment {
void LogToFile(const std::string& key, const std::string& value); void LogToFile(const std::string& key, const std::string& value);
// Read image from |filename| to |image_data|. // Read image from |filename| to |image_data|.
void ReadTestYuvImage(base::FilePath& filename, TestImageFile* image_data); std::unique_ptr<TestImage> ReadTestYuvImage(const base::FilePath& filename,
const gfx::Size& image_size);
// Returns a file path for a file in what name specified or media/test/data // Returns a file path for a file in what name specified or media/test/data
// directory. If the original file path is existed, returns it first. // directory. If the original file path is existed, returns it first.
base::FilePath GetOriginalOrTestDataFilePath(const std::string& name); base::FilePath GetOriginalOrTestDataFilePath(const std::string& name);
// Parsed data from command line. // Parsed data from command line.
std::vector<std::unique_ptr<TestImageFile>> image_data_user_; std::vector<std::unique_ptr<TestImage>> image_data_user_;
// Parsed data of |test_4160x3120_yuv_file_|. // Generated 4160x3120 white I420 image.
std::unique_ptr<TestImageFile> image_data_4160x3120_white_; std::unique_ptr<TestImage> image_data_4160x3120_white_;
// Parsed data of |test_2560x1920_yuv_file_|. // Generated 2560x1920 white I420 image.
std::unique_ptr<TestImageFile> image_data_2560x1920_white_; std::unique_ptr<TestImage> image_data_2560x1920_white_;
// Scarlet doesn't support 1080 width, it only suports 1088 width. // Scarlet doesn't support 1080 width, it only suports 1088 width.
// Parsed data of |test_1280x720_yuv_file_|. // Generated 1280x720 white I420 image.
std::unique_ptr<TestImageFile> image_data_1280x720_white_; std::unique_ptr<TestImage> image_data_1280x720_white_;
// Parsed data of |test_640x480_yuv_file_|. // Generated 640x480 black I420 image.
std::unique_ptr<TestImageFile> image_data_640x480_black_; std::unique_ptr<TestImage> image_data_640x480_black_;
// Parsed data of |test_640x368_yuv_file_|. // Generated 640x368 black I420 image.
std::unique_ptr<TestImageFile> image_data_640x368_black_; std::unique_ptr<TestImage> image_data_640x368_black_;
// Parsed data of |test_640x360_yuv_file_|. // Generated 640x360 black I420 image.
std::unique_ptr<TestImageFile> image_data_640x360_black_; std::unique_ptr<TestImage> image_data_640x360_black_;
// Number of times SimpleEncodeTest should repeat for an image. // Number of times SimpleEncodeTest should repeat for an image.
const size_t repeat_; const size_t repeat_;
private: private:
// Create black or white test image with |width| and |height| size. // Create black or white test image with specified |size|.
void CreateTestYuvImage(int width, std::unique_ptr<TestImage> CreateTestYuvImage(const gfx::Size& image_size,
int height, bool is_black);
bool is_black,
base::FilePath* filename);
const base::FilePath::CharType* user_yuv_files_; const base::FilePath::CharType* user_yuv_files_;
const base::FilePath log_path_; const base::FilePath log_path_;
std::unique_ptr<base::File> log_file_; std::unique_ptr<base::File> log_file_;
// Programatically generated YUV files.
base::FilePath test_4160x3120_yuv_file_;
base::FilePath test_2560x1920_yuv_file_;
base::FilePath test_1280x720_yuv_file_;
base::FilePath test_640x480_yuv_file_;
base::FilePath test_640x360_yuv_file_;
base::FilePath test_640x368_yuv_file_;
}; };
void JpegEncodeAcceleratorTestEnvironment::SetUp() { void JpegEncodeAcceleratorTestEnvironment::SetUp() {
...@@ -148,42 +139,14 @@ void JpegEncodeAcceleratorTestEnvironment::SetUp() { ...@@ -148,42 +139,14 @@ void JpegEncodeAcceleratorTestEnvironment::SetUp() {
LOG_ASSERT(log_file_->IsValid()); LOG_ASSERT(log_file_->IsValid());
} }
CreateTestYuvImage(4160, 3120, false, &test_4160x3120_yuv_file_); image_data_4160x3120_white_ =
CreateTestYuvImage(2560, 1920, false, &test_2560x1920_yuv_file_); CreateTestYuvImage(gfx::Size(4160, 3120), false);
CreateTestYuvImage(1280, 720, false, &test_1280x720_yuv_file_); image_data_2560x1920_white_ =
CreateTestYuvImage(640, 480, true, &test_640x480_yuv_file_); CreateTestYuvImage(gfx::Size(2560, 1920), false);
CreateTestYuvImage(640, 360, true, &test_640x360_yuv_file_); image_data_1280x720_white_ = CreateTestYuvImage(gfx::Size(1280, 720), false);
CreateTestYuvImage(640, 368, true, &test_640x368_yuv_file_); image_data_640x480_black_ = CreateTestYuvImage(gfx::Size(640, 480), true);
image_data_640x368_black_ = CreateTestYuvImage(gfx::Size(640, 368), true);
image_data_4160x3120_white_.reset(new TestImageFile( image_data_640x360_black_ = CreateTestYuvImage(gfx::Size(640, 360), true);
test_4160x3120_yuv_file_.value(), gfx::Size(4160, 3120)));
ASSERT_NO_FATAL_FAILURE(ReadTestYuvImage(test_4160x3120_yuv_file_,
image_data_4160x3120_white_.get()));
image_data_2560x1920_white_.reset(new TestImageFile(
test_2560x1920_yuv_file_.value(), gfx::Size(2560, 1920)));
ASSERT_NO_FATAL_FAILURE(ReadTestYuvImage(test_2560x1920_yuv_file_,
image_data_2560x1920_white_.get()));
image_data_1280x720_white_.reset(
new TestImageFile(test_1280x720_yuv_file_.value(), gfx::Size(1280, 720)));
ASSERT_NO_FATAL_FAILURE(ReadTestYuvImage(test_1280x720_yuv_file_,
image_data_1280x720_white_.get()));
image_data_640x480_black_.reset(
new TestImageFile(test_640x480_yuv_file_.value(), gfx::Size(640, 480)));
ASSERT_NO_FATAL_FAILURE(ReadTestYuvImage(test_640x480_yuv_file_,
image_data_640x480_black_.get()));
image_data_640x368_black_.reset(
new TestImageFile(test_640x368_yuv_file_.value(), gfx::Size(640, 368)));
ASSERT_NO_FATAL_FAILURE(ReadTestYuvImage(test_640x368_yuv_file_,
image_data_640x368_black_.get()));
image_data_640x360_black_.reset(
new TestImageFile(test_640x360_yuv_file_.value(), gfx::Size(640, 360)));
ASSERT_NO_FATAL_FAILURE(ReadTestYuvImage(test_640x360_yuv_file_,
image_data_640x360_black_.get()));
// |user_yuv_files_| may include many files and use ';' as delimiter. // |user_yuv_files_| may include many files and use ';' as delimiter.
std::vector<base::FilePath::StringType> files = std::vector<base::FilePath::StringType> files =
...@@ -209,21 +172,13 @@ void JpegEncodeAcceleratorTestEnvironment::SetUp() { ...@@ -209,21 +172,13 @@ void JpegEncodeAcceleratorTestEnvironment::SetUp() {
ASSERT_TRUE(!image_size.IsEmpty()); ASSERT_TRUE(!image_size.IsEmpty());
base::FilePath input_file = GetOriginalOrTestDataFilePath(filename); base::FilePath input_file = GetOriginalOrTestDataFilePath(filename);
auto image_data = std::make_unique<TestImageFile>(filename, image_size); auto image_data = ReadTestYuvImage(input_file, image_size);
ASSERT_NO_FATAL_FAILURE(ReadTestYuvImage(input_file, image_data.get()));
image_data_user_.push_back(std::move(image_data)); image_data_user_.push_back(std::move(image_data));
} }
} }
void JpegEncodeAcceleratorTestEnvironment::TearDown() { void JpegEncodeAcceleratorTestEnvironment::TearDown() {
log_file_.reset(); log_file_.reset();
base::DeleteFile(test_4160x3120_yuv_file_, false);
base::DeleteFile(test_2560x1920_yuv_file_, false);
base::DeleteFile(test_1280x720_yuv_file_, false);
base::DeleteFile(test_640x480_yuv_file_, false);
base::DeleteFile(test_640x368_yuv_file_, false);
base::DeleteFile(test_640x360_yuv_file_, false);
} }
void JpegEncodeAcceleratorTestEnvironment::LogToFile(const std::string& key, void JpegEncodeAcceleratorTestEnvironment::LogToFile(const std::string& key,
...@@ -235,51 +190,56 @@ void JpegEncodeAcceleratorTestEnvironment::LogToFile(const std::string& key, ...@@ -235,51 +190,56 @@ void JpegEncodeAcceleratorTestEnvironment::LogToFile(const std::string& key,
} }
} }
void JpegEncodeAcceleratorTestEnvironment::CreateTestYuvImage( std::unique_ptr<TestImage>
int width, JpegEncodeAcceleratorTestEnvironment::CreateTestYuvImage(
int height, const gfx::Size& image_size,
bool is_black, bool is_black) {
base::FilePath* filename) { const size_t num_pixels = image_size.width() * image_size.height();
std::vector<uint8_t> buffer(width * height * 3 / 2); std::vector<uint8_t> image_data(num_pixels * 3 / 2);
size_t size = width * height;
// Fill in Y values. // Fill in Y values.
memset(buffer.data(), is_black ? 0 : 255, size); std::fill(image_data.begin(), image_data.begin() + num_pixels,
// FIll in U and V values. is_black ? 0 : 255);
memset(buffer.data() + size, 128, size / 2); // Fill in U and V values.
LOG_ASSERT(base::CreateTemporaryFile(filename)); std::fill(image_data.begin() + num_pixels, image_data.end(), 128);
EXPECT_TRUE(base::AppendToFile(
*filename, reinterpret_cast<char*>(buffer.data()), buffer.size())); base::FilePath output_filename(std::to_string(image_size.width()) + "x" +
std::to_string(image_size.height()) +
(is_black ? "_black.jpg" : "_white.jpg"));
return std::make_unique<TestImage>(std::move(image_data), image_size,
output_filename);
} }
void JpegEncodeAcceleratorTestEnvironment::ReadTestYuvImage( std::unique_ptr<TestImage>
base::FilePath& input_file, JpegEncodeAcceleratorTestEnvironment::ReadTestYuvImage(
TestImageFile* image_data) { const base::FilePath& input_file,
ASSERT_TRUE(base::ReadFileToString(input_file, &image_data->data_str)); const gfx::Size& image_size) {
int64_t file_size = 0;
// This is just a placeholder. We will compute the real output size when we LOG_ASSERT(GetFileSize(input_file, &file_size));
// have encoder instance. std::vector<uint8_t> image_data(file_size);
image_data->output_size = LOG_ASSERT(ReadFile(input_file, reinterpret_cast<char*>(image_data.data()),
VideoFrame::AllocationSize(PIXEL_FORMAT_I420, image_data->visible_size); file_size) == file_size);
base::FilePath output_filename = input_file.AddExtension(".jpg");
return std::make_unique<TestImage>(std::move(image_data), image_size,
output_filename);
} }
base::FilePath base::FilePath
JpegEncodeAcceleratorTestEnvironment::GetOriginalOrTestDataFilePath( JpegEncodeAcceleratorTestEnvironment::GetOriginalOrTestDataFilePath(
const std::string& name) { const std::string& name) {
base::FilePath original_file_path = base::FilePath(name); base::FilePath file_path = base::FilePath(name);
base::FilePath return_file_path = GetTestDataFilePath(name); if (!PathExists(file_path)) {
file_path = GetTestDataFilePath(name);
if (PathExists(original_file_path)) }
return_file_path = original_file_path; VLOG(3) << "Using file path " << file_path.value();
return file_path;
VLOG(3) << "Use file path " << return_file_path.value();
return return_file_path;
} }
class JpegClient : public JpegEncodeAccelerator::Client { class JpegClient : public JpegEncodeAccelerator::Client {
public: public:
JpegClient(const std::vector<TestImageFile*>& test_aligned_image_files, JpegClient(const std::vector<TestImage*>& test_aligned_images,
const std::vector<TestImageFile*>& test_image_files, const std::vector<TestImage*>& test_images,
ClientStateNotification<ClientState>* note); ClientStateNotification<ClientState>* note);
~JpegClient() override; ~JpegClient() override;
void CreateJpegEncoder(); void CreateJpegEncoder();
...@@ -293,10 +253,10 @@ class JpegClient : public JpegEncodeAccelerator::Client { ...@@ -293,10 +253,10 @@ class JpegClient : public JpegEncodeAccelerator::Client {
private: private:
// Get the related test image file. // Get the related test image file.
TestImageFile* GetTestImageFile(int32_t bitstream_buffer_id); TestImage* GetTestImage(int32_t bitstream_buffer_id);
void PrepareMemory(int32_t bitstream_buffer_id); void PrepareMemory(int32_t bitstream_buffer_id);
void SetState(ClientState new_state); void SetState(ClientState new_state);
void SaveToFile(TestImageFile* image_file, size_t hw_size, size_t sw_size); void SaveToFile(TestImage* test_image, size_t hw_size, size_t sw_size);
bool CompareHardwareAndSoftwareResults(int width, bool CompareHardwareAndSoftwareResults(int width,
int height, int height,
size_t hw_encoded_size, size_t hw_encoded_size,
...@@ -314,14 +274,14 @@ class JpegClient : public JpegEncodeAccelerator::Client { ...@@ -314,14 +274,14 @@ class JpegClient : public JpegEncodeAccelerator::Client {
size_t* sw_encoded_size, size_t* sw_encoded_size,
base::TimeDelta* sw_encode_time); base::TimeDelta* sw_encode_time);
// JpegClient doesn't own |test_aligned_image_files_|. // JpegClient doesn't own |test_aligned_images_|.
// The resolutions of these images are all aligned. HW Accelerator must // The resolutions of these images are all aligned. HW Accelerator must
// support them. // support them.
const std::vector<TestImageFile*>& test_aligned_image_files_; const std::vector<TestImage*>& test_aligned_images_;
// JpegClient doesn't own |test_image_files_|. // JpegClient doesn't own |test_images_|.
// The resolutions of these images may be unaligned. // The resolutions of these images may be unaligned.
const std::vector<TestImageFile*>& test_image_files_; const std::vector<TestImage*>& test_images_;
// A map that stores HW encoding start timestamp for each output buffer id. // A map that stores HW encoding start timestamp for each output buffer id.
std::map<int, base::TimeTicks> buffer_id_to_start_time_; std::map<int, base::TimeTicks> buffer_id_to_start_time_;
...@@ -346,12 +306,11 @@ class JpegClient : public JpegEncodeAccelerator::Client { ...@@ -346,12 +306,11 @@ class JpegClient : public JpegEncodeAccelerator::Client {
DISALLOW_COPY_AND_ASSIGN(JpegClient); DISALLOW_COPY_AND_ASSIGN(JpegClient);
}; };
JpegClient::JpegClient( JpegClient::JpegClient(const std::vector<TestImage*>& test_aligned_images,
const std::vector<TestImageFile*>& test_aligned_image_files, const std::vector<TestImage*>& test_images,
const std::vector<TestImageFile*>& test_image_files,
ClientStateNotification<ClientState>* note) ClientStateNotification<ClientState>* note)
: test_aligned_image_files_(test_aligned_image_files), : test_aligned_images_(test_aligned_images),
test_image_files_(test_image_files), test_images_(test_images),
state_(ClientState::CREATED), state_(ClientState::CREATED),
note_(note) {} note_(note) {}
...@@ -396,12 +355,11 @@ void JpegClient::VideoFrameReady(int32_t buffer_id, size_t hw_encoded_size) { ...@@ -396,12 +355,11 @@ void JpegClient::VideoFrameReady(int32_t buffer_id, size_t hw_encoded_size) {
base::TimeDelta elapsed_hw = base::TimeDelta elapsed_hw =
hw_encode_end - buffer_id_to_start_time_[buffer_id]; hw_encode_end - buffer_id_to_start_time_[buffer_id];
TestImageFile* test_image; TestImage* test_image;
if (buffer_id < static_cast<int32_t>(test_aligned_image_files_.size())) { if (buffer_id < static_cast<int32_t>(test_aligned_images_.size())) {
test_image = test_aligned_image_files_[buffer_id]; test_image = test_aligned_images_[buffer_id];
} else { } else {
test_image = test_image = test_images_[buffer_id - test_aligned_images_.size()];
test_image_files_[buffer_id - test_aligned_image_files_.size()];
} }
size_t sw_encoded_size = 0; size_t sw_encoded_size = 0;
...@@ -519,44 +477,43 @@ void JpegClient::NotifyError(int32_t buffer_id, ...@@ -519,44 +477,43 @@ void JpegClient::NotifyError(int32_t buffer_id,
encoded_buffer_.reset(nullptr); encoded_buffer_.reset(nullptr);
} }
TestImageFile* JpegClient::GetTestImageFile(int32_t bitstream_buffer_id) { TestImage* JpegClient::GetTestImage(int32_t bitstream_buffer_id) {
DCHECK_LT(static_cast<size_t>(bitstream_buffer_id), DCHECK_LT(static_cast<size_t>(bitstream_buffer_id),
test_aligned_image_files_.size() + test_image_files_.size()); test_aligned_images_.size() + test_images_.size());
TestImageFile* image_file; TestImage* image_file;
if (bitstream_buffer_id < if (bitstream_buffer_id < static_cast<int32_t>(test_aligned_images_.size())) {
static_cast<int32_t>(test_aligned_image_files_.size())) { image_file = test_aligned_images_[bitstream_buffer_id];
image_file = test_aligned_image_files_[bitstream_buffer_id];
} else { } else {
image_file = test_image_files_[bitstream_buffer_id - image_file =
test_aligned_image_files_.size()]; test_images_[bitstream_buffer_id - test_aligned_images_.size()];
} }
return image_file; return image_file;
} }
void JpegClient::PrepareMemory(int32_t bitstream_buffer_id) { void JpegClient::PrepareMemory(int32_t bitstream_buffer_id) {
TestImageFile* image_file = GetTestImageFile(bitstream_buffer_id); TestImage* test_image = GetTestImage(bitstream_buffer_id);
size_t input_size = image_file->data_str.size(); size_t input_size = test_image->image_data.size();
if (!in_shm_.get() || input_size > in_shm_->mapped_size()) { if (!in_shm_.get() || input_size > in_shm_->mapped_size()) {
in_shm_.reset(new base::SharedMemory); in_shm_.reset(new base::SharedMemory);
LOG_ASSERT(in_shm_->CreateAndMapAnonymous(input_size)); LOG_ASSERT(in_shm_->CreateAndMapAnonymous(input_size));
} }
memcpy(in_shm_->memory(), image_file->data_str.data(), input_size); memcpy(in_shm_->memory(), test_image->image_data.data(), input_size);
if (!hw_out_shm_.get() || if (!hw_out_shm_.get() ||
image_file->output_size > hw_out_shm_->mapped_size()) { test_image->output_size > hw_out_shm_->mapped_size()) {
hw_out_shm_.reset(new base::SharedMemory); hw_out_shm_.reset(new base::SharedMemory);
LOG_ASSERT(hw_out_shm_->CreateAndMapAnonymous(image_file->output_size)); LOG_ASSERT(hw_out_shm_->CreateAndMapAnonymous(test_image->output_size));
} }
memset(hw_out_shm_->memory(), 0, image_file->output_size); memset(hw_out_shm_->memory(), 0, test_image->output_size);
if (!sw_out_shm_.get() || if (!sw_out_shm_.get() ||
image_file->output_size > sw_out_shm_->mapped_size()) { test_image->output_size > sw_out_shm_->mapped_size()) {
sw_out_shm_.reset(new base::SharedMemory); sw_out_shm_.reset(new base::SharedMemory);
LOG_ASSERT(sw_out_shm_->CreateAndMapAnonymous(image_file->output_size)); LOG_ASSERT(sw_out_shm_->CreateAndMapAnonymous(test_image->output_size));
} }
memset(sw_out_shm_->memory(), 0, image_file->output_size); memset(sw_out_shm_->memory(), 0, test_image->output_size);
} }
void JpegClient::SetState(ClientState new_state) { void JpegClient::SetState(ClientState new_state) {
...@@ -568,39 +525,43 @@ void JpegClient::SetState(ClientState new_state) { ...@@ -568,39 +525,43 @@ void JpegClient::SetState(ClientState new_state) {
state_ = new_state; state_ = new_state;
} }
void JpegClient::SaveToFile(TestImageFile* image_file, void JpegClient::SaveToFile(TestImage* test_image,
size_t hw_size, size_t hw_size,
size_t sw_size) { size_t sw_size) {
DCHECK_NE(nullptr, image_file); DCHECK_NE(nullptr, test_image);
base::FilePath in_filename(image_file->filename); base::FilePath out_filename_hw = test_image->output_filename;
base::FilePath out_filename = in_filename.ReplaceExtension(".jpg"); LOG(INFO) << "Writing HW encode results to "
<< out_filename_hw.MaybeAsASCII();
ASSERT_EQ( ASSERT_EQ(
static_cast<int>(hw_size), static_cast<int>(hw_size),
base::WriteFile(out_filename, static_cast<char*>(hw_out_shm_->memory()), base::WriteFile(out_filename_hw,
hw_size)); static_cast<char*>(hw_out_shm_->memory()), hw_size));
base::FilePath out_filename_sw = out_filename_hw.InsertBeforeExtension("_sw");
LOG(INFO) << "Writing SW encode results to "
<< out_filename_sw.MaybeAsASCII();
ASSERT_EQ( ASSERT_EQ(
static_cast<int>(sw_size), static_cast<int>(sw_size),
base::WriteFile(out_filename.InsertBeforeExtension("_sw"), base::WriteFile(out_filename_sw,
static_cast<char*>(sw_out_shm_->memory()), sw_size)); static_cast<char*>(sw_out_shm_->memory()), sw_size));
} }
void JpegClient::StartEncode(int32_t bitstream_buffer_id) { void JpegClient::StartEncode(int32_t bitstream_buffer_id) {
TestImageFile* image_file = GetTestImageFile(bitstream_buffer_id); TestImage* test_image = GetTestImage(bitstream_buffer_id);
image_file->output_size = test_image->output_size =
encoder_->GetMaxCodedBufferSize(image_file->visible_size); encoder_->GetMaxCodedBufferSize(test_image->visible_size);
PrepareMemory(bitstream_buffer_id); PrepareMemory(bitstream_buffer_id);
base::SharedMemoryHandle dup_handle; base::SharedMemoryHandle dup_handle;
dup_handle = base::SharedMemory::DuplicateHandle(hw_out_shm_->handle()); dup_handle = base::SharedMemory::DuplicateHandle(hw_out_shm_->handle());
encoded_buffer_ = std::make_unique<BitstreamBuffer>( encoded_buffer_ = std::make_unique<BitstreamBuffer>(
bitstream_buffer_id, dup_handle, image_file->output_size); bitstream_buffer_id, dup_handle, test_image->output_size);
scoped_refptr<VideoFrame> input_frame_ = VideoFrame::WrapExternalSharedMemory( scoped_refptr<VideoFrame> input_frame_ = VideoFrame::WrapExternalSharedMemory(
PIXEL_FORMAT_I420, image_file->visible_size, PIXEL_FORMAT_I420, test_image->visible_size,
gfx::Rect(image_file->visible_size), image_file->visible_size, gfx::Rect(test_image->visible_size), test_image->visible_size,
static_cast<uint8_t*>(in_shm_->memory()), image_file->data_str.size(), static_cast<uint8_t*>(in_shm_->memory()), test_image->image_data.size(),
in_shm_->handle(), 0, base::TimeDelta()); in_shm_->handle(), 0, base::TimeDelta());
LOG_ASSERT(input_frame_.get()); LOG_ASSERT(input_frame_.get());
...@@ -620,10 +581,10 @@ class JpegEncodeAcceleratorTest : public ::testing::Test { ...@@ -620,10 +581,10 @@ class JpegEncodeAcceleratorTest : public ::testing::Test {
// JpegEncodeAccelerator implementations. // JpegEncodeAccelerator implementations.
base::test::ScopedTaskEnvironment scoped_task_environment_; base::test::ScopedTaskEnvironment scoped_task_environment_;
// The elements of |test_aligned_image_files_| and |test_image_files_| are // The elements of |test_aligned_images_| and |test_images_| are
// owned by JpegEncodeAcceleratorTestEnvironment. // owned by JpegEncodeAcceleratorTestEnvironment.
std::vector<TestImageFile*> test_aligned_image_files_; std::vector<TestImage*> test_aligned_images_;
std::vector<TestImageFile*> test_image_files_; std::vector<TestImage*> test_images_;
protected: protected:
DISALLOW_COPY_AND_ASSIGN(JpegEncodeAcceleratorTest); DISALLOW_COPY_AND_ASSIGN(JpegEncodeAcceleratorTest);
...@@ -639,18 +600,18 @@ void JpegEncodeAcceleratorTest::TestEncode(size_t num_concurrent_encoders) { ...@@ -639,18 +600,18 @@ void JpegEncodeAcceleratorTest::TestEncode(size_t num_concurrent_encoders) {
for (size_t i = 0; i < num_concurrent_encoders; i++) { for (size_t i = 0; i < num_concurrent_encoders; i++) {
notes.push_back(std::make_unique<ClientStateNotification<ClientState>>()); notes.push_back(std::make_unique<ClientStateNotification<ClientState>>());
clients.push_back(std::make_unique<JpegClient>( clients.push_back(std::make_unique<JpegClient>(
test_aligned_image_files_, test_image_files_, notes.back().get())); test_aligned_images_, test_images_, notes.back().get()));
encoder_thread.task_runner()->PostTask( encoder_thread.task_runner()->PostTask(
FROM_HERE, base::BindOnce(&JpegClient::CreateJpegEncoder, FROM_HERE, base::BindOnce(&JpegClient::CreateJpegEncoder,
base::Unretained(clients.back().get()))); base::Unretained(clients.back().get())));
ASSERT_EQ(notes[i]->Wait(), ClientState::INITIALIZED); ASSERT_EQ(notes[i]->Wait(), ClientState::INITIALIZED);
} }
for (size_t index = 0; index < test_aligned_image_files_.size(); index++) { for (size_t index = 0; index < test_aligned_images_.size(); index++) {
VLOG(3) << index << ",width:" VLOG(3) << index
<< test_aligned_image_files_[index]->visible_size.width(); << ",width:" << test_aligned_images_[index]->visible_size.width();
VLOG(3) << index << ",height:" VLOG(3) << index
<< test_aligned_image_files_[index]->visible_size.height(); << ",height:" << test_aligned_images_[index]->visible_size.height();
for (size_t i = 0; i < num_concurrent_encoders; i++) { for (size_t i = 0; i < num_concurrent_encoders; i++) {
encoder_thread.task_runner()->PostTask( encoder_thread.task_runner()->PostTask(
FROM_HERE, base::BindOnce(&JpegClient::StartEncode, FROM_HERE, base::BindOnce(&JpegClient::StartEncode,
...@@ -661,12 +622,12 @@ void JpegEncodeAcceleratorTest::TestEncode(size_t num_concurrent_encoders) { ...@@ -661,12 +622,12 @@ void JpegEncodeAcceleratorTest::TestEncode(size_t num_concurrent_encoders) {
} }
} }
for (size_t index = 0; index < test_image_files_.size(); index++) { for (size_t index = 0; index < test_images_.size(); index++) {
int buffer_id = index + test_aligned_image_files_.size(); int buffer_id = index + test_aligned_images_.size();
VLOG(3) << buffer_id VLOG(3) << buffer_id
<< ",width:" << test_image_files_[index]->visible_size.width(); << ",width:" << test_images_[index]->visible_size.width();
VLOG(3) << buffer_id VLOG(3) << buffer_id
<< ",height:" << test_image_files_[index]->visible_size.height(); << ",height:" << test_images_[index]->visible_size.height();
for (size_t i = 0; i < num_concurrent_encoders; i++) { for (size_t i = 0; i < num_concurrent_encoders; i++) {
encoder_thread.task_runner()->PostTask( encoder_thread.task_runner()->PostTask(
FROM_HERE, FROM_HERE,
...@@ -698,7 +659,7 @@ void JpegEncodeAcceleratorTest::TestEncode(size_t num_concurrent_encoders) { ...@@ -698,7 +659,7 @@ void JpegEncodeAcceleratorTest::TestEncode(size_t num_concurrent_encoders) {
TEST_F(JpegEncodeAcceleratorTest, SimpleEncode) { TEST_F(JpegEncodeAcceleratorTest, SimpleEncode) {
for (size_t i = 0; i < g_env->repeat_; i++) { for (size_t i = 0; i < g_env->repeat_; i++) {
for (auto& image : g_env->image_data_user_) { for (auto& image : g_env->image_data_user_) {
test_image_files_.push_back(image.get()); test_images_.push_back(image.get());
} }
} }
TestEncode(1); TestEncode(1);
...@@ -706,29 +667,28 @@ TEST_F(JpegEncodeAcceleratorTest, SimpleEncode) { ...@@ -706,29 +667,28 @@ TEST_F(JpegEncodeAcceleratorTest, SimpleEncode) {
TEST_F(JpegEncodeAcceleratorTest, MultipleEncoders) { TEST_F(JpegEncodeAcceleratorTest, MultipleEncoders) {
for (auto& image : g_env->image_data_user_) { for (auto& image : g_env->image_data_user_) {
test_image_files_.push_back(image.get()); test_images_.push_back(image.get());
} }
TestEncode(3); TestEncode(3);
} }
TEST_F(JpegEncodeAcceleratorTest, ResolutionChange) { TEST_F(JpegEncodeAcceleratorTest, ResolutionChange) {
test_image_files_.push_back(g_env->image_data_640x368_black_.get()); test_images_.push_back(g_env->image_data_640x368_black_.get());
test_image_files_.push_back(g_env->image_data_640x360_black_.get()); test_images_.push_back(g_env->image_data_640x360_black_.get());
test_aligned_image_files_.push_back(g_env->image_data_1280x720_white_.get()); test_aligned_images_.push_back(g_env->image_data_1280x720_white_.get());
TestEncode(1); TestEncode(1);
} }
TEST_F(JpegEncodeAcceleratorTest, AlignedSizes) { TEST_F(JpegEncodeAcceleratorTest, AlignedSizes) {
test_aligned_image_files_.push_back(g_env->image_data_4160x3120_white_.get()); test_aligned_images_.push_back(g_env->image_data_4160x3120_white_.get());
test_aligned_image_files_.push_back(g_env->image_data_2560x1920_white_.get()); test_aligned_images_.push_back(g_env->image_data_2560x1920_white_.get());
test_aligned_image_files_.push_back(g_env->image_data_1280x720_white_.get()); test_aligned_images_.push_back(g_env->image_data_1280x720_white_.get());
test_aligned_image_files_.push_back(g_env->image_data_640x480_black_.get()); test_aligned_images_.push_back(g_env->image_data_640x480_black_.get());
TestEncode(1); TestEncode(1);
} }
TEST_F(JpegEncodeAcceleratorTest, CodedSizeAlignment) { TEST_F(JpegEncodeAcceleratorTest, CodedSizeAlignment) {
test_image_files_.push_back(g_env->image_data_640x360_black_.get()); test_images_.push_back(g_env->image_data_640x360_black_.get());
TestEncode(1); TestEncode(1);
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment