| /* |
| * Copyright 2010 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| // Author: jmaessen@google.com (Jan Maessen) |
| |
| // Unit tests for Image class used in rewriting. |
| |
| #include "net/instaweb/rewriter/public/image.h" |
| |
| #include <algorithm> |
| #include <cstdlib> |
| |
| #include "net/instaweb/rewriter/cached_result.pb.h" |
| #include "net/instaweb/rewriter/image_testing_peer.h" |
| #include "net/instaweb/rewriter/public/image_data_lookup.h" |
| #include "net/instaweb/rewriter/public/image_test_base.h" |
| #include "net/instaweb/rewriter/public/image_url_encoder.h" |
| #include "pagespeed/kernel/base/base64_util.h" |
| #include "pagespeed/kernel/base/basictypes.h" |
| #include "pagespeed/kernel/base/dynamic_annotations.h" // RunningOnValgrind |
| #include "pagespeed/kernel/base/function.h" |
| #include "pagespeed/kernel/base/gtest.h" |
| #include "pagespeed/kernel/base/mock_message_handler.h" |
| #include "pagespeed/kernel/base/mock_timer.h" |
| #include "pagespeed/kernel/base/scoped_ptr.h" |
| #include "pagespeed/kernel/base/statistics.h" |
| #include "pagespeed/kernel/base/statistics_template.h" |
| #include "pagespeed/kernel/base/string.h" |
| #include "pagespeed/kernel/base/string_util.h" |
| #include "pagespeed/kernel/base/thread_system.h" |
| #include "pagespeed/kernel/http/content_type.h" |
| #include "pagespeed/kernel/http/data_url.h" |
| #include "pagespeed/kernel/image/image_util.h" |
| #include "pagespeed/kernel/image/jpeg_optimizer_test_helper.h" |
| #include "pagespeed/kernel/image/jpeg_utils.h" |
| #include "pagespeed/kernel/image/read_image.h" |
| #include "pagespeed/kernel/image/test_utils.h" |
| #include "pagespeed/kernel/util/platform.h" |
| #include "pagespeed/kernel/util/simple_stats.h" |
| |
| using pagespeed_testing::image_compression::GetColorProfileMarker; |
| using pagespeed_testing::image_compression::GetExifDataMarker; |
| using pagespeed_testing::image_compression::GetJpegNumComponentsAndSamplingFactors; |
| using pagespeed_testing::image_compression::GetNumScansInJpeg; |
| using pagespeed_testing::image_compression::IsJpegSegmentPresent; |
| using pagespeed::image_compression::JpegUtils; |
| using pagespeed::image_compression::kMessagePatternAnimatedGif; |
| using pagespeed::image_compression::kMessagePatternPixelFormat; |
| using pagespeed::image_compression::kMessagePatternStats; |
| using pagespeed::image_compression::kMessagePatternUnexpectedEOF; |
| using pagespeed::image_compression::kMessagePatternWritingToWebp; |
| using pagespeed::image_compression::PixelFormat; |
| using pagespeed::image_compression::WEBP_NONE; |
| using pagespeed::image_compression::WEBP_LOSSY; |
| using pagespeed::image_compression::WEBP_LOSSLESS; |
| using pagespeed::image_compression::WEBP_ANIMATED; |
| |
| namespace net_instaweb { |
| namespace { |
| |
| const char kProgressiveHeader[] = "\xFF\xC2"; |
| const int kProgressiveHeaderStartIndex = 158; |
| const char kMessagePatternDataTruncated[] = "*data truncated*"; |
| const char kMessagePatternFailedToCreateWebp[] = "*Failed to create webp*"; |
| const char kMessagePatternFailedToEncodeWebp[] = "*Could not encode webp data*"; |
| const char kMessagePatternNoDimension[] = "*Couldn't find * dimensions*"; |
| const char kMessagePatternTimedOut[] = "*conversion timed out*"; |
| const char kMessagePatternFailedToDecoode[] = "*failed to decode the image*"; |
| |
| class ConversionVarChecker { |
| public: |
| explicit ConversionVarChecker(Image::CompressionOptions* options) |
| : thread_system_(Platform::CreateThreadSystem()), |
| simple_stats_(thread_system_.get()) { |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_GIF)->timeout_count = |
| simple_stats_.AddVariable("gif_webp_timeout"); |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_GIF)->success_ms = |
| simple_stats_.AddHistogram("gif_webp_success"); |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_GIF)->failure_ms = |
| simple_stats_.AddHistogram("gif_webp_failure"); |
| |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_PNG)->timeout_count = |
| simple_stats_.AddVariable("png_webp_timeout"); |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_PNG)->success_ms = |
| simple_stats_.AddHistogram("png_webp_success"); |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_PNG)->failure_ms = |
| simple_stats_.AddHistogram("png_webp_failure"); |
| |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_JPEG)->timeout_count = |
| simple_stats_.AddVariable("jpeg_webp_timeout"); |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_JPEG)->success_ms = |
| simple_stats_.AddHistogram("jpeg_webp_success"); |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_JPEG)->failure_ms = |
| simple_stats_.AddHistogram("jpeg_webp_failure"); |
| |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::NONOPAQUE)->timeout_count = |
| simple_stats_.AddVariable("webp_alpha_timeout"); |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::NONOPAQUE)->success_ms = |
| simple_stats_.AddHistogram("webp_alpha_success"); |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::NONOPAQUE)->failure_ms = |
| simple_stats_.AddHistogram("webp_alpha_failure"); |
| |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::OPAQUE)->timeout_count = |
| simple_stats_.AddVariable("webp_opaque_timeout"); |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::OPAQUE)->success_ms = |
| simple_stats_.AddHistogram("webp_opaque_success"); |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::OPAQUE)->failure_ms = |
| simple_stats_.AddHistogram("webp_opaque_failure"); |
| |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_GIF_ANIMATED)->timeout_count = |
| simple_stats_.AddVariable("gif_webp_animated_timeout"); |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_GIF_ANIMATED)->success_ms = |
| simple_stats_.AddHistogram("gif_webp_animated_success"); |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_GIF_ANIMATED)->failure_ms = |
| simple_stats_.AddHistogram("gif_webp_animated_failure"); |
| |
| options->webp_conversion_variables = &webp_conversion_variables_; |
| } |
| |
| void Test(int gif_webp_timeout, |
| int gif_webp_success, |
| int gif_webp_failure, |
| |
| int png_webp_timeout, |
| int png_webp_success, |
| int png_webp_failure, |
| |
| int jpeg_webp_timeout, |
| int jpeg_webp_success, |
| int jpeg_webp_failure, |
| |
| int gif_webp_animated_timeout, |
| int gif_webp_animated_success, |
| int gif_webp_animated_failure, |
| |
| bool opaque) { |
| EXPECT_EQ(gif_webp_timeout, |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_GIF)-> |
| timeout_count->Get()); |
| EXPECT_EQ(gif_webp_success, |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_GIF)-> |
| success_ms->Count()); |
| EXPECT_EQ(gif_webp_failure, |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_GIF)-> |
| failure_ms->Count()); |
| |
| EXPECT_EQ(png_webp_timeout, |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_PNG)-> |
| timeout_count->Get()); |
| EXPECT_EQ(png_webp_success, |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_PNG)-> |
| success_ms->Count()); |
| EXPECT_EQ(png_webp_failure, |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_PNG)-> |
| failure_ms->Count()); |
| |
| EXPECT_EQ(jpeg_webp_timeout, |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_JPEG)-> |
| timeout_count->Get()); |
| EXPECT_EQ(jpeg_webp_success, |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_JPEG)-> |
| success_ms->Count()); |
| EXPECT_EQ(jpeg_webp_failure, |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_JPEG)-> |
| failure_ms->Count()); |
| |
| EXPECT_EQ(gif_webp_animated_timeout, |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_GIF_ANIMATED)-> |
| timeout_count->Get()); |
| EXPECT_EQ(gif_webp_animated_success, |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_GIF_ANIMATED)-> |
| success_ms->Count()); |
| EXPECT_EQ(gif_webp_animated_failure, |
| webp_conversion_variables_.Get( |
| Image::ConversionVariables::FROM_GIF_ANIMATED)-> |
| failure_ms->Count()); |
| |
| int total_timeout = |
| gif_webp_timeout + |
| png_webp_timeout + |
| jpeg_webp_timeout + |
| gif_webp_animated_timeout; |
| int total_success = |
| gif_webp_success + |
| png_webp_success + |
| jpeg_webp_success + |
| gif_webp_animated_success; |
| int total_failure = |
| gif_webp_failure + |
| png_webp_failure + |
| jpeg_webp_failure + |
| gif_webp_animated_failure; |
| |
| Image::ConversionBySourceVariable* webp_transparency = |
| webp_conversion_variables_.Get( |
| (opaque ? |
| Image::ConversionVariables::OPAQUE : |
| Image::ConversionVariables::NONOPAQUE)); |
| |
| EXPECT_EQ(total_timeout, |
| webp_transparency->timeout_count->Get()); |
| EXPECT_EQ(total_success, |
| webp_transparency->success_ms->Count()); |
| EXPECT_EQ(total_failure, |
| webp_transparency->failure_ms->Count()); |
| } |
| |
| private: |
| scoped_ptr<ThreadSystem> thread_system_; |
| SimpleStats simple_stats_; |
| Image::ConversionVariables webp_conversion_variables_; |
| }; |
| |
| } // namespace |
| |
| class ImageTest : public ImageTestBase { |
| public: |
| ImageTest() : |
| options_(new Image::CompressionOptions()) { |
| } |
| |
| protected: |
| virtual void SetUp() { |
| message_handler_.AddPatternToSkipPrinting(kMessagePatternAnimatedGif); |
| message_handler_.AddPatternToSkipPrinting(kMessagePatternDataTruncated); |
| message_handler_.AddPatternToSkipPrinting( |
| kMessagePatternFailedToCreateWebp); |
| message_handler_.AddPatternToSkipPrinting(kMessagePatternFailedToDecoode); |
| message_handler_.AddPatternToSkipPrinting( |
| kMessagePatternFailedToEncodeWebp); |
| message_handler_.AddPatternToSkipPrinting(kMessagePatternNoDimension); |
| message_handler_.AddPatternToSkipPrinting(kMessagePatternPixelFormat); |
| message_handler_.AddPatternToSkipPrinting(kMessagePatternStats); |
| message_handler_.AddPatternToSkipPrinting(kMessagePatternTimedOut); |
| message_handler_.AddPatternToSkipPrinting(kMessagePatternUnexpectedEOF); |
| message_handler_.AddPatternToSkipPrinting(kMessagePatternWritingToWebp); |
| } |
| |
| GoogleString* GetOutputContents(Image* image) { |
| return &(image->output_contents_); |
| } |
| |
| void WriteToBuffer(const char* contents, GoogleString* str) { |
| *str = contents; |
| } |
| |
| void ExpectEmptyOutput(Image* image) { |
| EXPECT_FALSE(image->output_valid_); |
| EXPECT_TRUE(image->output_contents_.empty()); |
| } |
| |
| void ExpectContentType(ImageType image_type, Image* image) { |
| EXPECT_EQ(image_type, image->image_type_); |
| } |
| |
| void ExpectDimensions(ImageType image_type, int size, |
| int expected_width, int expected_height, |
| Image *image) { |
| EXPECT_EQ(size, image->input_size()); |
| EXPECT_EQ(image_type, image->image_type()); |
| ImageDim image_dim; |
| image_dim.Clear(); |
| image->Dimensions(&image_dim); |
| EXPECT_TRUE(ImageUrlEncoder::HasValidDimensions(image_dim)); |
| EXPECT_EQ(expected_width, image_dim.width()); |
| EXPECT_EQ(expected_height, image_dim.height()); |
| EXPECT_EQ(StringPrintf("%dx%dxZZ", image_dim.width(), image_dim.height()), |
| EncodeUrlAndDimensions("ZZ", image_dim)); |
| } |
| |
| void CheckInvalid(const GoogleString& name, const GoogleString& contents, |
| ImageType input_type, ImageType output_type, |
| bool progressive) { |
| ImagePtr image(ImageFromString(output_type, name, contents, progressive)); |
| EXPECT_EQ(contents.size(), image->input_size()); |
| EXPECT_EQ(input_type, image->image_type()); |
| ImageDim image_dim; |
| image_dim.Clear(); |
| image->Dimensions(&image_dim); |
| EXPECT_FALSE(ImageUrlEncoder::HasValidDimension(image_dim)); |
| EXPECT_FALSE(image_dim.has_width()); |
| EXPECT_FALSE(image_dim.has_height()); |
| EXPECT_EQ(contents.size(), image->output_size()); |
| EXPECT_EQ("xZZ", EncodeUrlAndDimensions("ZZ", image_dim)); |
| } |
| |
| bool CheckImageFromFile(const char* filename, |
| ImageType input_type, |
| ImageType output_type, |
| int min_bytes_to_type, |
| int min_bytes_to_dimensions, |
| int width, int height, |
| int size, bool optimizable) { |
| return CheckImageFromFile(filename, input_type, output_type, output_type, |
| input_type, min_bytes_to_type, |
| min_bytes_to_dimensions, width, height, size, |
| optimizable); |
| } |
| |
| bool CheckImageFromFile(const char* filename, |
| ImageType input_type, |
| ImageType intended_output_type, |
| ImageType actual_output_type, |
| ImageType type_for_truncated_image, |
| int min_bytes_to_type, |
| int min_bytes_to_dimensions, |
| int width, int height, |
| int size, bool optimizable) { |
| // Set options to convert to intended_output_type, but to allow for |
| // negative tests, don't clear any other options. |
| if (intended_output_type == IMAGE_WEBP) { |
| options_->preferred_webp = WEBP_LOSSY; |
| } else if (intended_output_type == IMAGE_WEBP_LOSSLESS_OR_ALPHA) { |
| options_->preferred_webp = WEBP_LOSSLESS; |
| } |
| switch (intended_output_type) { |
| case IMAGE_WEBP: |
| case IMAGE_WEBP_LOSSLESS_OR_ALPHA: |
| options_->convert_jpeg_to_webp = true; |
| FALLTHROUGH_INTENDED; |
| case IMAGE_JPEG: |
| options_->convert_png_to_jpeg = true; |
| FALLTHROUGH_INTENDED; |
| case IMAGE_PNG: |
| options_->convert_gif_to_png = true; |
| break; |
| default: |
| break; |
| } |
| |
| bool progressive = options_->progressive_jpeg; |
| int jpeg_quality = options_->jpeg_quality; |
| GoogleString contents; |
| ImagePtr image(ReadFromFileWithOptions( |
| filename, &contents, options_.release())); |
| ExpectDimensions(input_type, size, width, height, image.get()); |
| if (optimizable) { |
| EXPECT_GT(size, image->output_size()); |
| ExpectDimensions(actual_output_type, size, width, height, image.get()); |
| } else { |
| EXPECT_EQ(size, image->output_size()); |
| ExpectDimensions(input_type, size, width, height, image.get()); |
| } |
| |
| // Construct data url, then decode it and check for match. |
| CachedResult cached; |
| GoogleString data_url; |
| EXPECT_NE(IMAGE_UNKNOWN, image->image_type()); |
| StringPiece image_contents = image->Contents(); |
| |
| progressive &= ImageTestingPeer::ShouldConvertToProgressive(jpeg_quality, |
| image.get()); |
| if (progressive) { |
| EXPECT_STREQ(kProgressiveHeader, image_contents.substr( |
| kProgressiveHeaderStartIndex, strlen(kProgressiveHeader))); |
| } |
| |
| cached.set_inlined_data(image_contents.data(), image_contents.size()); |
| cached.set_inlined_image_type(static_cast<int>(image->image_type())); |
| DataUrl( |
| *Image::TypeToContentType( |
| static_cast<ImageType>(cached.inlined_image_type())), |
| BASE64, cached.inlined_data(), &data_url); |
| GoogleString data_header("data:"); |
| data_header.append(image->content_type()->mime_type()); |
| data_header.append(";base64,"); |
| EXPECT_EQ(data_header, data_url.substr(0, data_header.size())); |
| StringPiece encoded_contents( |
| data_url.data() + data_header.size(), |
| data_url.size() - data_header.size()); |
| GoogleString decoded_contents; |
| EXPECT_TRUE(Mime64Decode(encoded_contents, &decoded_contents)); |
| EXPECT_EQ(image->Contents(), decoded_contents); |
| |
| // Now truncate the file in various ways and make sure we still |
| // get partial data. |
| GoogleString dim_data(contents, 0, min_bytes_to_dimensions); |
| ImagePtr dim_image( |
| ImageFromString(intended_output_type, filename, dim_data, progressive)); |
| ExpectDimensions(input_type, min_bytes_to_dimensions, width, height, |
| dim_image.get()); |
| EXPECT_EQ(min_bytes_to_dimensions, dim_image->output_size()); |
| |
| GoogleString no_dim_data(contents, 0, min_bytes_to_dimensions - 1); |
| CheckInvalid(filename, no_dim_data, type_for_truncated_image, |
| intended_output_type, progressive); |
| GoogleString type_data(contents, 0, min_bytes_to_type); |
| CheckInvalid(filename, type_data, type_for_truncated_image, |
| intended_output_type, progressive); |
| GoogleString junk(contents, 0, min_bytes_to_type - 1); |
| CheckInvalid(filename, junk, IMAGE_UNKNOWN, IMAGE_UNKNOWN, |
| progressive); |
| return progressive; |
| } |
| |
| GoogleString EncodeUrlAndDimensions(const StringPiece& origin_url, |
| const ImageDim& dim) { |
| StringVector v; |
| v.push_back(origin_url.as_string()); |
| GoogleString out; |
| ResourceContext data; |
| *data.mutable_desired_image_dims() = dim; |
| encoder_.Encode(v, &data, &out); |
| return out; |
| } |
| |
| bool DecodeUrlAndDimensions(const StringPiece& encoded, |
| ImageDim* dim, |
| GoogleString* url) { |
| ResourceContext context; |
| StringVector urls; |
| bool result = encoder_.Decode(encoded, &urls, &context, &message_handler_); |
| if (result) { |
| EXPECT_EQ(1, urls.size()); |
| url->assign(urls.back()); |
| *dim = context.desired_image_dims(); |
| } |
| return result; |
| } |
| |
| void ExpectBadDim(const StringPiece& url) { |
| GoogleString origin_url; |
| ImageDim dim; |
| EXPECT_FALSE(DecodeUrlAndDimensions(url, &dim, &origin_url)); |
| EXPECT_FALSE(ImageUrlEncoder::HasValidDimension(dim)); |
| } |
| |
| void SetJpegRecompressionAndQuality(Image::CompressionOptions* options) { |
| options->jpeg_quality = 85; |
| options->recompress_jpeg = true; |
| } |
| |
| ImageUrlEncoder encoder_; |
| scoped_ptr<Image::CompressionOptions> options_; |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(ImageTest); |
| }; |
| |
| namespace { |
| |
| TEST_F(ImageTest, EmptyImageUnidentified) { |
| CheckInvalid("Empty string", "", IMAGE_UNKNOWN, IMAGE_UNKNOWN, |
| false); |
| } |
| |
| TEST_F(ImageTest, InputWebpTest) { |
| CheckImageFromFile( |
| kScenery, IMAGE_WEBP, IMAGE_WEBP, IMAGE_WEBP, IMAGE_UNKNOWN, |
| 29, // Min bytes to bother checking file type at all. |
| 30, |
| 550, 368, |
| 30320, false); |
| } |
| |
| |
| TEST_F(ImageTest, WebpLowResTest) { |
| // FYI: Takes ~20000 ms to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| Image::CompressionOptions* options = new Image::CompressionOptions(); |
| options->recompress_webp = true; |
| options->preferred_webp = WEBP_LOSSY; |
| GoogleString contents; |
| ImagePtr image(ReadFromFileWithOptions(kScenery, &contents, options)); |
| int filesize = 30320; |
| image->SetTransformToLowRes(); |
| EXPECT_GT(filesize, image->output_size()); |
| } |
| |
| TEST_F(ImageTest, WebpLaLowResTest) { |
| // FYI: This test will also probably take very long to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| Image::CompressionOptions* options = new Image::CompressionOptions(); |
| options->recompress_webp = true; |
| options->preferred_webp = WEBP_LOSSLESS; |
| GoogleString contents; |
| ImagePtr image(ReadFromFileWithOptions(kScenery, &contents, options)); |
| int filesize = 30320; |
| image->SetTransformToLowRes(); |
| EXPECT_GT(filesize, image->output_size()); |
| } |
| |
| TEST_F(ImageTest, PngTest) { |
| options_->recompress_png = true; |
| CheckImageFromFile( |
| kBikeCrash, IMAGE_PNG, IMAGE_PNG, |
| ImageHeaders::kPngHeaderLength, |
| ImageHeaders::kIHDRDataStart + ImageHeaders::kPngIntSize * 2, |
| 100, 100, |
| 26548, true); |
| } |
| |
| TEST_F(ImageTest, PngToWebpTest) { |
| // FYI: This test will also probably take very long to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| ConversionVarChecker conversion_var_checker(options_.get()); |
| options_->webp_quality = 75; |
| CheckImageFromFile( |
| kBikeCrash, IMAGE_PNG, IMAGE_WEBP, |
| ImageHeaders::kPngHeaderLength, |
| ImageHeaders::kIHDRDataStart + ImageHeaders::kPngIntSize * 2, |
| 100, 100, |
| 26548, true); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 1, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| true); |
| } |
| |
| TEST_F(ImageTest, PngToWebpFailToJpegDueToPreferredTest) { |
| // FYI: This test will also probably take very long to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| ConversionVarChecker conversion_var_checker(options_.get()); |
| options_->preferred_webp = WEBP_NONE; |
| options_->webp_quality = 75; |
| options_->jpeg_quality = 85; |
| options_->convert_jpeg_to_webp = true; |
| CheckImageFromFile( |
| kBikeCrash, IMAGE_PNG, IMAGE_JPEG, |
| ImageHeaders::kPngHeaderLength, |
| ImageHeaders::kIHDRDataStart + ImageHeaders::kPngIntSize * 2, |
| 100, 100, |
| 26548, true); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 0, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| true); |
| } |
| |
| TEST_F(ImageTest, PngToWebpLaTest) { |
| // FYI: This test will also probably take very long to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| ConversionVarChecker conversion_var_checker(options_.get()); |
| options_->webp_quality = 75; |
| CheckImageFromFile( |
| kCuppa, IMAGE_PNG, IMAGE_WEBP_LOSSLESS_OR_ALPHA, |
| ImageHeaders::kPngHeaderLength, |
| ImageHeaders::kIHDRDataStart + ImageHeaders::kPngIntSize * 2, |
| 65, 70, |
| 1763, true); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 1, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| true); |
| } |
| |
| TEST_F(ImageTest, PngAlphaFailToWebpLossyTest) { |
| // FYI: This test will also probably take very long to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| Image::CompressionOptions* options = new Image::CompressionOptions; |
| ConversionVarChecker conversion_var_checker(options); |
| options->preferred_webp = WEBP_LOSSY; |
| options->allow_webp_alpha = false; |
| options->webp_quality = 75; |
| options->jpeg_quality = 85; |
| options->convert_png_to_jpeg = true; |
| options->convert_jpeg_to_webp = true; |
| EXPECT_EQ(0, options->conversions_attempted); |
| |
| GoogleString buffer; |
| ImagePtr image(ReadFromFileWithOptions(kCuppaTransparent, &buffer, options)); |
| image->output_size(); |
| EXPECT_EQ(ContentType::kPng, image->content_type()->type()); |
| |
| // "kCuppaTransparent" is a graphic. It should be compressed losslessly, |
| // but the configuration only allows lossy compression, so no compression |
| // will be attempted. |
| EXPECT_EQ(0, options->conversions_attempted); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 0, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| true); |
| } |
| |
| TEST_F(ImageTest, PngAlphaToWebpLaTest) { |
| // FYI: This test will also probably take very long to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| Image::CompressionOptions* options = new Image::CompressionOptions; |
| ConversionVarChecker conversion_var_checker(options); |
| options->preferred_webp = WEBP_LOSSLESS; |
| options->allow_webp_alpha = true; |
| options->convert_png_to_jpeg = true; |
| options->convert_jpeg_to_webp = true; |
| options->webp_quality = 75; |
| options->jpeg_quality = 85; |
| EXPECT_EQ(0, options->conversions_attempted); |
| |
| GoogleString buffer; |
| ImagePtr image(ReadFromFileWithOptions(kCuppaTransparent, &buffer, options)); |
| image->output_size(); |
| EXPECT_EQ(ContentType::kWebp, image->content_type()->type()); |
| EXPECT_EQ(1, options->conversions_attempted); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 1, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| false); |
| } |
| |
| TEST_F(ImageTest, PngAlphaToWebpTestFailsBecauseTooManyTries) { |
| // FYI: This test will also probably take very long to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| Image::CompressionOptions* options = new Image::CompressionOptions; |
| ConversionVarChecker conversion_var_checker(options); |
| options->preferred_webp = WEBP_LOSSLESS; |
| options->allow_webp_alpha = true; |
| options->convert_png_to_jpeg = true; |
| options->convert_jpeg_to_webp = true; |
| options->webp_quality = 75; |
| options->jpeg_quality = 85; |
| options->conversions_attempted = 2; |
| |
| GoogleString buffer; |
| ImagePtr image(ReadFromFileWithOptions(kCuppaTransparent, &buffer, options)); |
| image->output_size(); |
| EXPECT_EQ(ContentType::kPng, image->content_type()->type()); |
| EXPECT_EQ(2, options->conversions_attempted); |
| // There were already enough (2) attempts, so we shouldn't try any |
| // more conversions. |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 0, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| false); |
| } |
| |
| // This tests that we compress the alpha channel on the webp. If we |
| // don't on this image, it becomes larger than the original. |
| TEST_F(ImageTest, PngLargeAlphaToWebpLaTest) { |
| // FYI: This test will also probably take very long to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| Image::CompressionOptions* options = new Image::CompressionOptions; |
| ConversionVarChecker conversion_var_checker(options); |
| options->preferred_webp = WEBP_LOSSLESS; |
| options->allow_webp_alpha = true; |
| options->convert_png_to_jpeg = true; |
| options->convert_jpeg_to_webp = true; |
| options->webp_quality = 75; |
| options->jpeg_quality = 85; |
| EXPECT_EQ(0, options->conversions_attempted); |
| |
| GoogleString buffer; |
| ImagePtr image(ReadFromFileWithOptions(kRedbrush, &buffer, options)); |
| EXPECT_GT(image->input_size(), image->output_size()); |
| EXPECT_EQ(ContentType::kWebp, image->content_type()->type()); |
| EXPECT_EQ(1, options->conversions_attempted); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 1, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| false); |
| // TODO(vchudnov): Check that the pixels match. |
| } |
| |
| // Same image and settings that succeed in PngLargeAlphaToWebpTest, |
| // should fail when using a very short timeout. |
| TEST_F(ImageTest, PngLargeAlphaToWebpTimesOutToPngTest) { |
| // FYI: This test will also probably take very long to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| Image::CompressionOptions* options = new Image::CompressionOptions; |
| ConversionVarChecker conversion_var_checker(options); |
| options->preferred_webp = WEBP_LOSSLESS; |
| options->allow_webp_alpha = true; |
| options->convert_png_to_jpeg = true; |
| options->convert_jpeg_to_webp = true; |
| options->webp_quality = 75; |
| options->jpeg_quality = 85; |
| options->webp_conversion_timeout_ms = 1; |
| EXPECT_EQ(0, options->conversions_attempted); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 0, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| false); |
| |
| GoogleString buffer; |
| ImagePtr image(ReadFromFileWithOptions(kRedbrush, &buffer, options)); |
| timer_.SetTimeDeltaUs(1); // When setting deadline |
| timer_.SetTimeDeltaUs(1); // Before attempting webp lossless |
| timer_.SetTimeDeltaUs( // During conversion |
| 1000 * options->webp_conversion_timeout_ms + 1); |
| image->output_size(); |
| EXPECT_EQ(ContentType::kPng, image->content_type()->type()); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 1, 0, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| false); |
| |
| // One attempt for WebpP conversion, one attempt for the fall-back |
| // to PNG/JPEG. |
| EXPECT_EQ(2, options->conversions_attempted); |
| } |
| |
| // Same image and settings that succeed in PngLargeAlphaToWebpTest, |
| // should succeed if processing is really fast. |
| TEST_F(ImageTest, PngLargeAlphaToWebpDoesNotTimeOutTest) { |
| // FYI: This test will also probably take very long to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| Image::CompressionOptions* options = new Image::CompressionOptions; |
| ConversionVarChecker conversion_var_checker(options); |
| options->preferred_webp = WEBP_LOSSLESS; |
| options->allow_webp_alpha = true; |
| options->convert_png_to_jpeg = true; |
| options->convert_jpeg_to_webp = true; |
| options->webp_quality = 75; |
| options->jpeg_quality = 85; |
| options->webp_conversion_timeout_ms = 1; |
| EXPECT_EQ(0, options->conversions_attempted); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 0, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| false); |
| |
| GoogleString buffer; |
| ImagePtr image(ReadFromFileWithOptions(kRedbrush, &buffer, options)); |
| timer_.SetTimeDeltaUs(1); // When setting deadline |
| timer_.SetTimeDeltaUs(1); // Before attempting webp lossless |
| timer_.SetTimeDeltaUs( // During conversion |
| 1000 * options->webp_conversion_timeout_ms - 2); |
| image->output_size(); |
| EXPECT_EQ(ContentType::kWebp, image->content_type()->type()); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 1, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| false); |
| |
| // One attempt for WebpP conversion. |
| EXPECT_EQ(1, options->conversions_attempted); |
| } |
| |
| TEST_F(ImageTest, PngToJpegTest) { |
| options_->jpeg_quality = 85; |
| CheckImageFromFile( |
| kBikeCrash, IMAGE_PNG, IMAGE_JPEG, |
| ImageHeaders::kPngHeaderLength, |
| ImageHeaders::kIHDRDataStart + ImageHeaders::kPngIntSize * 2, |
| 100, 100, |
| 26548, true); |
| } |
| |
| TEST_F(ImageTest, TooSmallToConvertPngToProgressiveJpegTest) { |
| options_->progressive_jpeg = true; |
| options_->jpeg_quality = 85; |
| bool progressive = CheckImageFromFile( |
| kBikeCrash, IMAGE_PNG, IMAGE_JPEG, |
| ImageHeaders::kPngHeaderLength, |
| ImageHeaders::kIHDRDataStart + ImageHeaders::kPngIntSize * 2, |
| 100, 100, |
| 26548, true); |
| EXPECT_FALSE(progressive); |
| } |
| |
| TEST_F(ImageTest, PngToProgressiveJpegTest) { |
| options_->progressive_jpeg = true; |
| options_->jpeg_quality = 85; |
| options_->progressive_jpeg_min_bytes = 100; // default is 10k. |
| bool progressive = CheckImageFromFile( |
| kBikeCrash, IMAGE_PNG, IMAGE_JPEG, |
| ImageHeaders::kPngHeaderLength, |
| ImageHeaders::kIHDRDataStart + ImageHeaders::kPngIntSize * 2, |
| 100, 100, |
| 26548, true); |
| EXPECT_TRUE(progressive); |
| } |
| |
| TEST_F(ImageTest, GifToPngTest) { |
| CheckImageFromFile( |
| kIronChef, IMAGE_GIF, IMAGE_PNG, |
| 8, // Min bytes to bother checking file type at all. |
| ImageHeaders::kGifDimStart + ImageHeaders::kGifIntSize * 2, |
| 192, 256, |
| 24941, true); |
| } |
| |
| TEST_F(ImageTest, GifToPngDisabledTest) { |
| Image::CompressionOptions* options = new Image::CompressionOptions; |
| options->convert_gif_to_png = false; |
| EXPECT_EQ(0, options->conversions_attempted); |
| |
| GoogleString buffer; |
| ImagePtr image(ReadFromFileWithOptions(kIronChef, &buffer, options)); |
| image->output_size(); |
| EXPECT_EQ(ContentType::kGif, image->content_type()->type()); |
| EXPECT_EQ(0, options->conversions_attempted); |
| } |
| |
| TEST_F(ImageTest, GifToJpegTest) { |
| options_->jpeg_quality = 85; |
| CheckImageFromFile( |
| kIronChef, IMAGE_GIF, IMAGE_JPEG, |
| 8, // Min bytes to bother checking file type at all. |
| ImageHeaders::kGifDimStart + ImageHeaders::kGifIntSize * 2, |
| 192, 256, |
| 24941, true); |
| } |
| |
| TEST_F(ImageTest, GifToWebpTest) { |
| // FYI: This test will also probably take very long to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| ConversionVarChecker conversion_var_checker(options_.get()); |
| options_->webp_quality = 25; |
| CheckImageFromFile( |
| kIronChef, IMAGE_GIF, IMAGE_WEBP, |
| 8, // Min bytes to bother checking file type at all. |
| ImageHeaders::kGifDimStart + ImageHeaders::kGifIntSize * 2, |
| 192, 256, |
| 24941, true); |
| conversion_var_checker.Test(0, 1, 0, // gif |
| 0, 0, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| true); |
| } |
| |
| TEST_F(ImageTest, GifToWebpLaTest) { |
| // FYI: This test will also probably take very long to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| ConversionVarChecker conversion_var_checker(options_.get()); |
| options_->webp_quality = 75; |
| CheckImageFromFile( |
| kTransparent, IMAGE_GIF, IMAGE_WEBP_LOSSLESS_OR_ALPHA, |
| 8, // Min bytes to bother checking file type at all. |
| ImageHeaders::kGifDimStart + ImageHeaders::kGifIntSize * 2, |
| 320, 320, |
| 55800, true); |
| conversion_var_checker.Test(0, 1, 0, // gif |
| 0, 0, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| false); |
| } |
| |
| TEST_F(ImageTest, AnimatedFilterNotEnabledTest) { |
| CheckImageFromFile( |
| kCradle, IMAGE_GIF, IMAGE_PNG, |
| 8, // Min bytes to bother checking file type at all. |
| ImageHeaders::kGifDimStart + ImageHeaders::kGifIntSize * 2, |
| 200, 150, |
| 583374, false); |
| } |
| |
| TEST_F(ImageTest, JpegTest) { |
| options_->recompress_jpeg = true; |
| CheckImageFromFile( |
| kPuzzle, IMAGE_JPEG, IMAGE_JPEG, |
| 8, // Min bytes to bother checking file type at all. |
| 6468, // Specific to this test |
| 1023, 766, |
| 241260, true); |
| } |
| |
| TEST_F(ImageTest, ProgressiveJpegTest) { |
| options_->recompress_jpeg = true; |
| options_->progressive_jpeg = true; |
| CheckImageFromFile( |
| kPuzzle, IMAGE_JPEG, IMAGE_JPEG, |
| 8, // Min bytes to bother checking file type at all. |
| 6468, // Specific to this test |
| 1023, 766, |
| 241260, true); |
| } |
| |
| TEST_F(ImageTest, NumProgressiveScansTest) { |
| Image::CompressionOptions* options = new Image::CompressionOptions(); |
| SetJpegRecompressionAndQuality(options); |
| options->progressive_jpeg = true; |
| options->jpeg_num_progressive_scans = 3; |
| |
| GoogleString buffer; |
| ImagePtr image(ReadFromFileWithOptions(kPuzzle, &buffer, options)); |
| EXPECT_GT(buffer.size(), image->output_size()); |
| EXPECT_EQ(3, GetNumScansInJpeg(image->Contents().as_string())); |
| } |
| |
| TEST_F(ImageTest, UseJpegLossyIfInputQualityIsLowTest) { |
| Image::CompressionOptions* options = new Image::CompressionOptions(); |
| SetJpegRecompressionAndQuality(options); |
| options->progressive_jpeg = true; |
| |
| GoogleString buffer; |
| // Input image quality is 50. |
| ImagePtr image(ReadFromFileWithOptions(kAppSegments, &buffer, options)); |
| EXPECT_GT(buffer.size(), image->output_size()); |
| EXPECT_EQ( |
| 50, JpegUtils::GetImageQualityFromImage(image->Contents().data(), |
| image->Contents().size(), |
| &message_handler_)); |
| |
| // When num progressive scans is set, we use lossy path. The compression |
| // quality is the minimum of the input and the configuration, i.e., 50. |
| options = new Image::CompressionOptions(); |
| SetJpegRecompressionAndQuality(options); |
| options->progressive_jpeg = true; |
| buffer.clear(); |
| options->jpeg_num_progressive_scans = 1; |
| image.reset(ReadFromFileWithOptions(kAppSegments, &buffer, options)); |
| EXPECT_GT(buffer.size(), image->output_size()); |
| EXPECT_EQ( |
| 50, JpegUtils::GetImageQualityFromImage(image->Contents().data(), |
| image->Contents().size(), |
| &message_handler_)); |
| |
| // Empty image will return -1 when we try to determine its quality. |
| options = new Image::CompressionOptions(); |
| SetJpegRecompressionAndQuality(options); |
| options->progressive_jpeg = true; |
| image.reset(NewImage("", "", GTestTempDir(), options, |
| &timer_, &message_handler_)); |
| EXPECT_EQ( |
| -1, JpegUtils::GetImageQualityFromImage(image->Contents().data(), |
| image->Contents().size(), |
| &message_handler_)); |
| } |
| |
| TEST_F(ImageTest, JpegRetainColorProfileTest) { |
| Image::CompressionOptions* options = new Image::CompressionOptions(); |
| SetJpegRecompressionAndQuality(options); |
| options->retain_color_profile = true; |
| |
| GoogleString buffer; |
| ImagePtr image(ReadFromFileWithOptions(kAppSegments, &buffer, options)); |
| EXPECT_TRUE(IsJpegSegmentPresent(buffer, GetColorProfileMarker())); |
| EXPECT_GT(buffer.size(), image->output_size()); |
| EXPECT_TRUE(IsJpegSegmentPresent(image->Contents().as_string(), |
| GetColorProfileMarker())); |
| // Try stripping the color profile information. |
| options = new Image::CompressionOptions(); |
| SetJpegRecompressionAndQuality(options); |
| options->retain_color_profile = false; |
| buffer.clear(); |
| image.reset(ReadFromFileWithOptions(kAppSegments, &buffer, options)); |
| EXPECT_TRUE(IsJpegSegmentPresent(buffer, GetColorProfileMarker())); |
| EXPECT_GT(buffer.size(), image->output_size()); |
| EXPECT_FALSE(IsJpegSegmentPresent(image->Contents().as_string(), |
| GetColorProfileMarker())); |
| } |
| |
| TEST_F(ImageTest, JpegRetainColorSamplingTest) { |
| int num_components, h_sampling_factor, v_sampling_factor; |
| Image::CompressionOptions* options = new Image::CompressionOptions(); |
| SetJpegRecompressionAndQuality(options); |
| options->retain_color_profile = false; |
| |
| GoogleString buffer; |
| // Input image color sampling is YUV 422. By defult we force YUV420. |
| ImagePtr image(ReadFromFileWithOptions(kPuzzle, &buffer, options)); |
| GetJpegNumComponentsAndSamplingFactors( |
| buffer, &num_components, &h_sampling_factor, &v_sampling_factor); |
| EXPECT_EQ(3, num_components); |
| EXPECT_EQ(2, h_sampling_factor); |
| EXPECT_EQ(1, v_sampling_factor); |
| EXPECT_GT(buffer.size(), image->output_size()); |
| GetJpegNumComponentsAndSamplingFactors( |
| image->Contents().as_string(), &num_components, &h_sampling_factor, |
| &v_sampling_factor); |
| EXPECT_EQ(3, num_components); |
| EXPECT_EQ(2, h_sampling_factor); |
| EXPECT_EQ(2, v_sampling_factor); |
| |
| // Try retaining the color sampling. |
| options = new Image::CompressionOptions(); |
| SetJpegRecompressionAndQuality(options); |
| options->retain_color_sampling = true; |
| buffer.clear(); |
| image.reset(ReadFromFileWithOptions(kPuzzle, &buffer, options)); |
| EXPECT_GT(buffer.size(), image->output_size()); |
| GetJpegNumComponentsAndSamplingFactors( |
| image->Contents().as_string(), &num_components, &h_sampling_factor, |
| &v_sampling_factor); |
| EXPECT_EQ(3, num_components); |
| EXPECT_EQ(2, h_sampling_factor); |
| EXPECT_EQ(1, v_sampling_factor); |
| } |
| |
| TEST_F(ImageTest, JpegRetainExifDataTest) { |
| Image::CompressionOptions* options = new Image::CompressionOptions(); |
| SetJpegRecompressionAndQuality(options); |
| options->retain_exif_data = true; |
| |
| GoogleString buffer; |
| ImagePtr image(ReadFromFileWithOptions(kAppSegments, &buffer, options)); |
| EXPECT_TRUE(IsJpegSegmentPresent(buffer, GetExifDataMarker())); |
| EXPECT_GT(buffer.size(), image->output_size()); |
| EXPECT_TRUE(IsJpegSegmentPresent(image->Contents().as_string(), |
| GetExifDataMarker())); |
| // Try stripping the color profile information. |
| options = new Image::CompressionOptions(); |
| SetJpegRecompressionAndQuality(options); |
| options->retain_exif_data = false; |
| buffer.clear(); |
| image.reset(ReadFromFileWithOptions(kAppSegments, &buffer, options)); |
| EXPECT_TRUE(IsJpegSegmentPresent(buffer, GetExifDataMarker())); |
| EXPECT_GT(buffer.size(), image->output_size()); |
| EXPECT_FALSE(IsJpegSegmentPresent(image->Contents().as_string(), |
| GetExifDataMarker())); |
| } |
| |
| TEST_F(ImageTest, WebpTest) { |
| // FYI: Takes ~70000 ms to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| options_->webp_quality = 75; |
| CheckImageFromFile( |
| kPuzzle, IMAGE_JPEG, IMAGE_WEBP, |
| 8, // Min bytes to bother checking file type at all. |
| 6468, // Specific to this test |
| 1023, 766, |
| 241260, true); |
| } |
| |
| TEST_F(ImageTest, JpegToWebpTimesOutTest) { |
| Image::CompressionOptions* options = new Image::CompressionOptions; |
| ConversionVarChecker conversion_var_checker(options); |
| options->recompress_jpeg = true; |
| options->convert_jpeg_to_webp = true; |
| options->preferred_webp = WEBP_LOSSY; |
| options->webp_quality = 75; |
| options->webp_conversion_timeout_ms = 1; |
| timer_.SetTimeDeltaUs(1); // 1st increment of time, used for setting deadline |
| timer_.SetTimeDeltaUs(1); // 2nd increment of time, used for setting deadline |
| timer_.SetTimeDeltaUs( // During conversion |
| 1000 * options->webp_conversion_timeout_ms + 1); |
| |
| EXPECT_EQ(0, options->conversions_attempted); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 0, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| true); |
| |
| GoogleString buffer; |
| ImagePtr image(ReadFromFileWithOptions(kPuzzle, &buffer, options)); |
| image->output_size(); |
| EXPECT_EQ(ContentType::kJpeg, image->content_type()->type()); |
| |
| EXPECT_EQ(2, options->conversions_attempted); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 0, 0, // png |
| 1, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| true); |
| } |
| |
| TEST_F(ImageTest, JpegToWebpDoesNotTimeOutTest) { |
| // FYI: This test will probably take very long to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| Image::CompressionOptions* options = new Image::CompressionOptions; |
| ConversionVarChecker conversion_var_checker(options); |
| options->recompress_jpeg = true; |
| options->convert_jpeg_to_webp = true; |
| options->preferred_webp = WEBP_LOSSY; |
| options->webp_quality = 75; |
| options->webp_conversion_timeout_ms = 1; |
| timer_.SetTimeDeltaUs(1); // When setting deadline |
| timer_.SetTimeDeltaUs( // During conversion |
| 1000 * options->webp_conversion_timeout_ms - 1); |
| |
| EXPECT_EQ(0, options->conversions_attempted); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 0, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 0, 0, // gif animated |
| true); |
| |
| GoogleString buffer; |
| ImagePtr image(ReadFromFileWithOptions(kPuzzle, &buffer, options)); |
| image->output_size(); |
| EXPECT_EQ(ContentType::kWebp, image->content_type()->type()); |
| |
| EXPECT_EQ(1, options->conversions_attempted); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 0, 0, // png |
| 0, 1, 0, // jpeg |
| 0, 0, 0, // gif animated |
| true); |
| } |
| |
| TEST_F(ImageTest, WebpNonLaFromJpgTest) { |
| // FYI: Takes ~70000 ms to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| ConversionVarChecker conversion_var_checker(options_.get()); |
| options_->webp_quality = 75; |
| // Note that jpeg->webp cannot return a lossless webp. |
| CheckImageFromFile( |
| kPuzzle, IMAGE_JPEG, IMAGE_WEBP_LOSSLESS_OR_ALPHA, |
| IMAGE_WEBP, IMAGE_JPEG, |
| 8, // Min bytes to bother checking file type at all. |
| 6468, // Specific to this test |
| 1023, 766, |
| 241260, true); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 0, 0, // png |
| 0, 1, 0, // jpeg |
| 0, 0, 0, // gif animated |
| true); |
| } |
| |
| TEST_F(ImageTest, DrawImage) { |
| Image::CompressionOptions* options = new Image::CompressionOptions(); |
| options->recompress_png = true; |
| GoogleString buf1; |
| ImagePtr image1(ReadFromFileWithOptions(kBikeCrash, &buf1, options)); |
| ImageDim image_dim1; |
| image1->Dimensions(&image_dim1); |
| |
| options = new Image::CompressionOptions(); |
| options->recompress_png = true; |
| GoogleString buf2; |
| ImagePtr image2(ReadFromFileWithOptions(kCuppa, &buf2, options)); |
| ImageDim image_dim2; |
| image2->Dimensions(&image_dim2); |
| |
| int width = std::max(image_dim1.width(), image_dim2.width()); |
| int height = image_dim1.height() + image_dim2.height(); |
| ASSERT_GT(width, 0); |
| ASSERT_GT(height, 0); |
| options = new Image::CompressionOptions(); |
| options->recompress_png = true; |
| ImagePtr canvas(BlankImageWithOptions(width, height, IMAGE_PNG, |
| GTestTempDir(), &timer_, |
| &message_handler_, options)); |
| EXPECT_TRUE(canvas->DrawImage(image1.get(), 0, 0)); |
| EXPECT_TRUE(canvas->DrawImage(image2.get(), 0, image_dim1.height())); |
| // The combined image should be bigger than either of the components, but |
| // smaller than their unoptimized sum. |
| EXPECT_GT(canvas->output_size(), image1->output_size()); |
| EXPECT_GT(canvas->output_size(), image2->output_size()); |
| EXPECT_GT(image1->input_size() + image2->input_size(), |
| canvas->output_size()); |
| } |
| |
| // Make sure that the image produced by 'DrawImage()' is accurate for every |
| // pixel. |
| TEST_F(ImageTest, DrawImageDetails) { |
| GoogleString buf1, buf2; |
| uint8_t* image1_pixels = NULL; |
| uint8_t* image2_pixels = NULL; |
| uint8_t* canvas_pixels = NULL; |
| PixelFormat image1_format, image2_format, canvas_format; |
| size_t image1_width, image2_width, canvas_width; |
| size_t image1_height, image2_height, canvas_height; |
| size_t image1_stride, image2_stride, canvas_stride; |
| Image::CompressionOptions* image1_options = new Image::CompressionOptions(); |
| Image::CompressionOptions* image2_options = new Image::CompressionOptions(); |
| Image::CompressionOptions* canvas_options = new Image::CompressionOptions(); |
| canvas_options->recompress_png = true; |
| |
| // 'kIronChef' is an RGB GIF image while 'kCuppaTransparent' is a grayscale |
| // transparent PNG image. |
| ImagePtr image1(ReadFromFileWithOptions(kIronChef, &buf1, image1_options)); |
| ImagePtr image2(ReadFromFileWithOptions(kCuppaTransparent, &buf2, |
| image2_options)); |
| |
| ASSERT_TRUE(ReadImage(pagespeed::image_compression::IMAGE_GIF, |
| buf1.data(), buf1.length(), |
| reinterpret_cast<void**>(&image1_pixels), |
| &image1_format, &image1_width, &image1_height, |
| &image1_stride, &message_handler_)); |
| |
| ASSERT_TRUE(ReadImage(pagespeed::image_compression::IMAGE_PNG, |
| buf2.data(), buf2.length(), |
| reinterpret_cast<void**>(&image2_pixels), |
| &image2_format, &image2_width, &image2_height, |
| &image2_stride, &message_handler_)); |
| |
| int width = std::max(image1_width, image2_width); |
| int height = image1_height + image2_height; |
| ImagePtr canvas(BlankImageWithOptions(width, height, IMAGE_PNG, |
| GTestTempDir(), &timer_, |
| &message_handler_, canvas_options)); |
| EXPECT_TRUE(canvas->DrawImage(image1.get(), 0, 0)); |
| EXPECT_TRUE(canvas->DrawImage(image2.get(), 0, image1_height)); |
| |
| ASSERT_TRUE(ReadImage(pagespeed::image_compression::IMAGE_PNG, |
| canvas->Contents().data(), canvas->Contents().length(), |
| reinterpret_cast<void**>(&canvas_pixels), |
| &canvas_format, &canvas_width, &canvas_height, |
| &canvas_stride, &message_handler_)); |
| |
| CompareImageRegions(image1_pixels, image1_format, image1_stride, 0, 0, |
| canvas_pixels, canvas_format, canvas_stride, 0, 0, |
| image1_width, image1_height, &message_handler_); |
| |
| CompareImageRegions(image2_pixels, image2_format, image2_stride, 0, 0, |
| canvas_pixels, canvas_format, canvas_stride, |
| 0, image1_height, image2_width, image2_height, |
| &message_handler_); |
| |
| free(image1_pixels); |
| free(image2_pixels); |
| free(canvas_pixels); |
| } |
| |
| TEST_F(ImageTest, BlankTransparentImage) { |
| int width = 1000, height = 1000; |
| Image::CompressionOptions* options = new Image::CompressionOptions(); |
| |
| options->use_transparent_for_blank_image = true; |
| ImagePtr blank(BlankImageWithOptions(width, height, IMAGE_PNG, GTestTempDir(), |
| &timer_, &message_handler_, options)); |
| bool loaded = blank->EnsureLoaded(false); |
| EXPECT_EQ(loaded, true); |
| EXPECT_GT(blank->Contents().size(), 0); |
| |
| ImageDim blank_dim; |
| blank->Dimensions(&blank_dim); |
| EXPECT_EQ(blank_dim.width(), width); |
| EXPECT_EQ(blank_dim.height(), height); |
| } |
| |
| TEST_F(ImageTest, ResizeTo) { |
| GoogleString buf; |
| ImagePtr image(ReadImageFromFile(IMAGE_JPEG, kPuzzle, &buf, false)); |
| |
| ImageDim new_dim; |
| new_dim.set_width(10); |
| new_dim.set_height(10); |
| image->ResizeTo(new_dim); |
| |
| ExpectEmptyOutput(image.get()); |
| ExpectContentType(IMAGE_JPEG, image.get()); |
| } |
| |
| TEST_F(ImageTest, CompressJpegUsingLossyOrLossless) { |
| Image::CompressionOptions* options = new Image::CompressionOptions(); |
| SetJpegRecompressionAndQuality(options); |
| GoogleString buffer; |
| |
| // Input image quality is 50. When jpeg_quality is set to -1, lossless |
| // will be used and the quality of the input image will be preserved. |
| options->jpeg_quality = -1; |
| ImagePtr image(ReadFromFileWithOptions(kAppSegments, &buffer, options)); |
| EXPECT_GT(buffer.size(), image->output_size()); |
| EXPECT_EQ( |
| 50, JpegUtils::GetImageQualityFromImage(image->Contents().data(), |
| image->Contents().size(), |
| &message_handler_)); |
| |
| // When jpeg_num_progressive_scans > 0, lossy will be used and the quality |
| // will be set to the minimum of input quality and jpeg_quality. |
| options = new Image::CompressionOptions(); |
| SetJpegRecompressionAndQuality(options); |
| options->jpeg_num_progressive_scans = 1; |
| options->jpeg_quality = 51; |
| buffer.clear(); |
| image.reset(ReadFromFileWithOptions(kAppSegments, &buffer, options)); |
| EXPECT_GT(buffer.size(), image->output_size()); |
| EXPECT_EQ( |
| 50, JpegUtils::GetImageQualityFromImage(image->Contents().data(), |
| image->Contents().size(), |
| &message_handler_)); |
| |
| // When jpeg_quality is less than input quality, lossy will be used and the |
| // output quality is the minimum of them. |
| options = new Image::CompressionOptions(); |
| SetJpegRecompressionAndQuality(options); |
| options->jpeg_quality = 49; |
| buffer.clear(); |
| image.reset(ReadFromFileWithOptions(kAppSegments, &buffer, options)); |
| EXPECT_GT(buffer.size(), image->output_size()); |
| EXPECT_EQ( |
| 49, JpegUtils::GetImageQualityFromImage(image->Contents().data(), |
| image->Contents().size(), |
| &message_handler_)); |
| } |
| |
| void SetBaseJpegOptions(Image::CompressionOptions* options) { |
| options->preferred_webp = WEBP_LOSSY; |
| options->allow_webp_alpha = true; |
| options->convert_gif_to_png = true; |
| options->convert_png_to_jpeg = true; |
| options->webp_quality = 75; |
| options->webp_animated_quality = 75; |
| options->jpeg_quality = 85; |
| } |
| |
| TEST_F(ImageTest, IgnoreTimeoutWhenFinishingWebp) { |
| // FYI: This test will also probably take very long to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| |
| // Get the jpeg reference image |
| Image::CompressionOptions* jpeg_options = new Image::CompressionOptions; |
| SetBaseJpegOptions(jpeg_options); |
| |
| GoogleString jpeg_buffer; |
| ImagePtr jpeg_image(ReadFromFileWithOptions(kBikeCrash, |
| &jpeg_buffer, |
| jpeg_options)); |
| |
| jpeg_image->output_size(); |
| EXPECT_EQ(ContentType::kJpeg, jpeg_image->content_type()->type()); |
| |
| |
| // Get the webp reference image |
| Image::CompressionOptions* webp_options = new Image::CompressionOptions; |
| SetBaseJpegOptions(webp_options); |
| webp_options->convert_jpeg_to_webp = true; |
| webp_options->webp_conversion_timeout_ms = 1; |
| GoogleString webp_buffer; |
| ImagePtr webp_image(ReadFromFileWithOptions(kBikeCrash, |
| &webp_buffer, |
| webp_options)); |
| |
| webp_image->output_size(); |
| EXPECT_EQ(ContentType::kWebp, webp_image->content_type()->type()); |
| |
| |
| // Make sure that if the timeout occurs before the first byte is |
| // written, we do indeed time out. |
| Image::CompressionOptions* timed_out_webp_options = |
| new Image::CompressionOptions; |
| SetBaseJpegOptions(timed_out_webp_options); |
| timed_out_webp_options->convert_jpeg_to_webp = true; |
| timed_out_webp_options->webp_conversion_timeout_ms = 1; |
| |
| GoogleString timed_out_webp_buffer; |
| ImagePtr timed_out_webp_image( |
| ReadFromFileWithOptions(kBikeCrash, |
| &timed_out_webp_buffer, |
| timed_out_webp_options)); |
| timer_.SetTimeMs(10); |
| timer_.SetTimeDeltaUs(1); // When setting deadline |
| timer_.SetTimeDeltaUs(1); // Before attempting webp lossless |
| timer_.SetTimeDeltaUs(1); |
| timer_.SetTimeDeltaUs(2000); |
| |
| timed_out_webp_image->output_size(); |
| EXPECT_EQ(ContentType::kJpeg, timed_out_webp_image->content_type()->type()); |
| EXPECT_EQ(jpeg_image->Contents(), |
| timed_out_webp_image->Contents()); |
| |
| // Test that if we time out after the first output byte is emitted, we keep |
| // going with the webp output. |
| Image::CompressionOptions* almost_done_webp_options = |
| new Image::CompressionOptions; |
| SetBaseJpegOptions(almost_done_webp_options); |
| almost_done_webp_options->convert_jpeg_to_webp = true; |
| almost_done_webp_options->webp_conversion_timeout_ms = 1; |
| |
| const char* kSomeData = "some data"; |
| GoogleString almost_done_webp_buffer; |
| ImagePtr almost_done_webp_image( |
| ReadFromFileWithOptions(kBikeCrash, |
| &almost_done_webp_buffer, |
| almost_done_webp_options)); |
| timer_.SetTimeMs(20); |
| timer_.SetTimeDeltaUs(1); // When setting deadline |
| timer_.SetTimeDeltaUs(1); // Before attempting webp lossless |
| timer_.SetTimeDeltaUs(1); |
| timer_.SetTimeDeltaUs(1); |
| timer_.SetTimeDeltaUs(1); |
| timer_.SetTimeDeltaUs(1); |
| // We need to specify the template typenames explicitly below |
| // because the compiler can't decide whether to use this test class |
| // or its base class, ImageTest. |
| timer_.SetTimeDeltaUsWithCallback( |
| 2000, |
| MakeFunction< |
| ImageTest_IgnoreTimeoutWhenFinishingWebp_Test, |
| const char*, |
| GoogleString*>( |
| this, |
| &ImageTest_IgnoreTimeoutWhenFinishingWebp_Test::WriteToBuffer, |
| kSomeData, |
| GetOutputContents(almost_done_webp_image.get()))); |
| |
| almost_done_webp_image->output_size(); |
| EXPECT_EQ(ContentType::kWebp, |
| almost_done_webp_image->content_type()->type()); |
| GoogleString expected = kSomeData; |
| expected.append(webp_image->Contents().as_string()); |
| EXPECT_EQ(expected, |
| almost_done_webp_image->Contents()); |
| } |
| |
| TEST_F(ImageTest, AnimatedGifToWebpTest) { |
| // FYI: This test will also probably take very long to run under Valgrind. |
| if (RunningOnValgrind()) { |
| return; |
| } |
| ConversionVarChecker conversion_var_checker(options_.get()); |
| options_->webp_animated_quality = 25; |
| options_->allow_webp_animated = true; |
| options_->preferred_webp = WEBP_ANIMATED; |
| CheckImageFromFile( |
| kCradle, IMAGE_GIF, IMAGE_WEBP_ANIMATED, |
| 8, // Min bytes to bother checking file type at all. |
| ImageHeaders::kGifDimStart + ImageHeaders::kGifIntSize * 2, |
| 200, 150, |
| 583374, true); |
| conversion_var_checker.Test(0, 0, 0, // gif |
| 0, 0, 0, // png |
| 0, 0, 0, // jpeg |
| 0, 1, 0, // gif animated |
| true); |
| } |
| |
| } // namespace |
| } // namespace net_instaweb |
