| /* |
| * 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) |
| |
| #include "net/instaweb/rewriter/public/image.h" |
| |
| #include <algorithm> |
| #include <cstddef> |
| |
| #include "base/logging.h" |
| #include "net/instaweb/rewriter/cached_result.pb.h" |
| #include "net/instaweb/rewriter/public/image_data_lookup.h" |
| #include "net/instaweb/rewriter/public/image_url_encoder.h" |
| #include "net/instaweb/rewriter/public/webp_optimizer.h" |
| #include "pagespeed/kernel/base/annotated_message_handler.h" |
| #include "pagespeed/kernel/base/basictypes.h" |
| #include "pagespeed/kernel/base/message_handler.h" |
| #include "pagespeed/kernel/base/scoped_ptr.h" |
| #include "pagespeed/kernel/base/statistics.h" |
| #include "pagespeed/kernel/base/string.h" |
| #include "pagespeed/kernel/base/string_util.h" |
| #include "pagespeed/kernel/http/content_type.h" |
| #include "pagespeed/kernel/image/gif_reader.h" |
| #include "pagespeed/kernel/image/image_analysis.h" |
| #include "pagespeed/kernel/image/image_converter.h" |
| #include "pagespeed/kernel/image/image_frame_interface.h" |
| #include "pagespeed/kernel/image/image_resizer.h" |
| #include "pagespeed/kernel/image/image_util.h" |
| #include "pagespeed/kernel/image/jpeg_optimizer.h" |
| #include "pagespeed/kernel/image/jpeg_utils.h" |
| #include "pagespeed/kernel/image/png_optimizer.h" |
| #include "pagespeed/kernel/image/read_image.h" |
| #include "pagespeed/kernel/image/scanline_interface.h" |
| #include "pagespeed/kernel/image/scanline_status.h" |
| #include "pagespeed/kernel/image/scanline_utils.h" |
| #include "pagespeed/kernel/image/webp_optimizer.h" |
| |
| extern "C" { |
| #ifdef USE_SYSTEM_LIBWEBP |
| #include "webp/decode.h" |
| #else |
| #include "third_party/libwebp/src/webp/decode.h" |
| #endif |
| #ifdef USE_SYSTEM_LIBPNG |
| #include "png.h" // NOLINT |
| #else |
| #include "third_party/libpng/src/png.h" |
| #endif |
| } |
| |
| using pagespeed::image_compression::AnalyzeImage; |
| using pagespeed::image_compression::ConversionTimeoutHandler; |
| using pagespeed::image_compression::CreateScanlineReader; |
| using pagespeed::image_compression::CreateScanlineWriter; |
| using pagespeed::image_compression::GifReader; |
| using pagespeed::image_compression::GRAY_8; |
| using pagespeed::image_compression::ImageConverter; |
| using pagespeed::image_compression::ImageFormat; |
| using pagespeed::image_compression::ImageFormatToString; |
| using pagespeed::image_compression::JpegCompressionOptions; |
| using pagespeed::image_compression::JpegScanlineWriter; |
| using pagespeed::image_compression::JpegUtils; |
| using pagespeed::image_compression::OptimizeJpegWithOptions; |
| using pagespeed::image_compression::PixelFormat; |
| using pagespeed::image_compression::PngCompressParams; |
| using pagespeed::image_compression::PngOptimizer; |
| using pagespeed::image_compression::PngReader; |
| using pagespeed::image_compression::PngReaderInterface; |
| using pagespeed::image_compression::PngScanlineWriter; |
| using pagespeed::image_compression::PreferredLibwebpLevel; |
| using pagespeed::image_compression::RETAIN; |
| using pagespeed::image_compression::RGB_888; |
| using pagespeed::image_compression::RGBA_8888; |
| using pagespeed::image_compression::ScanlineReaderInterface; |
| using pagespeed::image_compression::ScanlineResizer; |
| using pagespeed::image_compression::ScanlineWriterInterface; |
| using pagespeed::image_compression::WebpConfiguration; |
| 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 ImageHeaders { |
| |
| const char kPngHeader[] = "\x89PNG\r\n\x1a\n"; |
| const size_t kPngHeaderLength = STATIC_STRLEN(kPngHeader); |
| const char kPngIHDR[] = "\0\0\0\x0dIHDR"; |
| const size_t kPngIntSize = 4; |
| const size_t kPngSectionHeaderLength = 2 * kPngIntSize; |
| const size_t kIHDRDataStart = kPngHeaderLength + kPngSectionHeaderLength; |
| const size_t kPngSectionMinSize = kPngSectionHeaderLength + kPngIntSize; |
| const size_t kPngColourTypeOffset = kIHDRDataStart + 2 * kPngIntSize + 1; |
| const char kPngAlphaChannel = 0x4; // bit of ColourType set for alpha channel |
| const char kPngIDAT[] = "IDAT"; |
| const char kPngtRNS[] = "tRNS"; |
| |
| const char kGifHeader[] = "GIF8"; |
| const size_t kGifHeaderLength = STATIC_STRLEN(kGifHeader); |
| const size_t kGifDimStart = kGifHeaderLength + 2; |
| const size_t kGifIntSize = 2; |
| |
| const size_t kJpegIntSize = 2; |
| const int64 kMaxJpegQuality = 100; |
| const int64 kQualityForJpegWithUnkownQuality = 85; |
| |
| } // namespace ImageHeaders |
| |
| namespace { |
| |
| const char kGifString[] = "gif"; |
| const char kPngString[] = "png"; |
| const uint8 kAlphaOpaque = 255; |
| |
| void UpdateWebpStats(bool ok, bool was_timed_out, int64 time_elapsed_ms, |
| Image::ConversionVariables::VariableType var_type, |
| Image::ConversionVariables* conversion_vars) { |
| if (conversion_vars != NULL) { |
| Image::ConversionBySourceVariable* the_var = conversion_vars->Get(var_type); |
| if (the_var != NULL) { |
| if (was_timed_out) { |
| the_var->timeout_count->Add(1); |
| DCHECK(!ok); |
| } else { |
| if (ok) { |
| the_var->success_ms->Add(time_elapsed_ms); |
| } else { |
| the_var->failure_ms->Add(time_elapsed_ms); |
| } |
| } |
| } |
| } |
| } |
| |
| // TODO(huibao): Unify ImageType and ImageFormat. |
| ImageFormat ImageTypeToImageFormat(ImageType type) { |
| ImageFormat format = pagespeed::image_compression::IMAGE_UNKNOWN; |
| switch (type) { |
| case IMAGE_UNKNOWN: |
| format = pagespeed::image_compression::IMAGE_UNKNOWN; |
| break; |
| case IMAGE_JPEG: |
| format = pagespeed::image_compression::IMAGE_JPEG; |
| break; |
| case IMAGE_PNG: |
| format = pagespeed::image_compression::IMAGE_PNG; |
| break; |
| case IMAGE_GIF: |
| format = pagespeed::image_compression::IMAGE_GIF; |
| break; |
| case IMAGE_WEBP: |
| case IMAGE_WEBP_LOSSLESS_OR_ALPHA: |
| case IMAGE_WEBP_ANIMATED: |
| format = pagespeed::image_compression::IMAGE_WEBP; |
| break; |
| } |
| return format; |
| } |
| |
| ImageFormat GetOutputImageFormat(ImageFormat in_format) { |
| if (in_format == pagespeed::image_compression::IMAGE_GIF) { |
| return pagespeed::image_compression::IMAGE_PNG; |
| } else { |
| return in_format; |
| } |
| } |
| |
| ScanlineWriterInterface* CreateUncompressedPngWriter( |
| size_t width, size_t height, GoogleString* output, |
| MessageHandler* handler, bool use_transparent_for_blank_image) { |
| PngCompressParams config(PNG_FILTER_NONE, Z_NO_COMPRESSION, false); |
| PixelFormat pixel_format = |
| use_transparent_for_blank_image ? |
| RGBA_8888 : |
| RGB_888; |
| return CreateScanlineWriter( |
| pagespeed::image_compression::IMAGE_PNG, |
| pixel_format, width, height, &config, output, handler); |
| } |
| |
| } // namespace |
| |
| // TODO(jmaessen): Put ImageImpl into private namespace. |
| |
| class ImageImpl : public Image { |
| public: |
| ImageImpl(const StringPiece& original_contents, |
| const GoogleString& url, |
| const StringPiece& file_prefix, |
| CompressionOptions* options, |
| Timer* timer, |
| MessageHandler* handler); |
| ImageImpl(int width, int height, ImageType type, |
| const StringPiece& tmp_dir, |
| Timer* timer, MessageHandler* handler, |
| CompressionOptions* options); |
| |
| virtual void Dimensions(ImageDim* natural_dim); |
| virtual bool ResizeTo(const ImageDim& new_dim); |
| virtual bool DrawImage(Image* image, int x, int y); |
| virtual bool EnsureLoaded(bool output_useful); |
| virtual bool ShouldConvertToProgressive(int64 quality) const; |
| virtual void SetResizedDimensions(const ImageDim& dims) { dims_ = dims; } |
| virtual void SetTransformToLowRes(); |
| virtual const GoogleString& url() { return url_; } |
| virtual const GoogleString& debug_message() { return debug_message_; } |
| virtual const GoogleString& resize_debug_message() { |
| return resize_debug_message_; |
| } |
| |
| bool GenerateBlankImage(); |
| |
| StringPiece original_contents() { return original_contents_; } |
| |
| private: |
| // Maximum number of libpagespeed conversion attempts. |
| // TODO(vchudnov): Consider making this tunable. |
| static const int kMaxConversionAttempts = 2; |
| |
| // Concrete helper methods called by parent class |
| virtual void ComputeImageType(); |
| virtual bool ComputeOutputContents(); |
| |
| bool ComputeOutputContentsFromGifOrPng( |
| const GoogleString& string_for_image, |
| const PngReaderInterface* png_reader, |
| bool fall_back_to_png, |
| const char* dbg_input_format, |
| ImageType input_type, |
| ConversionVariables::VariableType var_type); |
| |
| // Helper methods |
| static bool ComputePngTransparency(const StringPiece& buf); |
| |
| // Internal methods used only in the implementation |
| void UndoChange(); |
| void FindJpegSize(); |
| void FindPngSize(); |
| void FindGifSize(); |
| void FindWebpSize(); |
| |
| // Convert the given options object to jpeg compression options. |
| void ConvertToJpegOptions(const Image::CompressionOptions& options, |
| JpegCompressionOptions* jpeg_options); |
| |
| // Optimizes the png image_data, readable via png_reader. |
| bool OptimizePng( |
| const PngReaderInterface& png_reader, |
| const GoogleString& image_data); |
| |
| // Converts image_data, readable via png_reader, to a jpeg if |
| // possible or a png if not, using the settings in options_. |
| bool OptimizePngOrConvertToJpeg( |
| const PngReaderInterface& png_reader, |
| const GoogleString& image_data); |
| |
| // Converts image_data, readable via png_reader, to a webp using the |
| // settings in options_, if allowed by those settings. The alpha channel |
| // is always losslessly compressed, while the color may be lossily or |
| // or losslessly compressed, depending on 'compress_color_losslessly'. |
| bool ConvertPngToWebp( |
| const PngReaderInterface& png_reader, |
| const GoogleString& image_data, |
| bool compress_color_losslessly, |
| bool has_transparency, |
| ConversionVariables::VariableType var_type); |
| |
| // Convert the JPEG in original_jpeg to WebP format in |
| // compressed_webp using the quality specified in |
| // configured_quality. |
| bool ConvertJpegToWebp( |
| const GoogleString& original_jpeg, int configured_quality, |
| GoogleString* compressed_webp); |
| |
| static bool ContinueWebpConversion( |
| int percent, |
| void* user_data); |
| |
| // Determines whether we can attempt a libpagespeed conversion |
| // without exceeding kMaxConversionAttempts. If so, increments the |
| // number of attempts. |
| bool MayConvert() { |
| if (options_.get()) { |
| VLOG(1) << "Conversions attempted: " |
| << options_->conversions_attempted; |
| if (options_->conversions_attempted < kMaxConversionAttempts) { |
| ++options_->conversions_attempted; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| int GetJpegQualityFromImage(const StringPiece& contents) { |
| const int quality = JpegUtils::GetImageQualityFromImage(contents.data(), |
| contents.size(), |
| handler_.get()); |
| return quality; |
| } |
| |
| // Quality level for compressing the resized image. |
| int EstimateQualityForResizedJpeg(); |
| |
| bool ConvertAnimatedGifToWebp(bool has_transparency); |
| |
| const GoogleString file_prefix_; |
| scoped_ptr<MessageHandler> handler_; |
| bool changed_; |
| const GoogleString url_; |
| ImageDim dims_; |
| ImageDim resized_dimensions_; |
| GoogleString resized_image_; |
| scoped_ptr<Image::CompressionOptions> options_; |
| bool low_quality_enabled_; |
| Timer* timer_; |
| GoogleString debug_message_; |
| GoogleString resize_debug_message_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ImageImpl); |
| }; |
| |
| void ImageImpl::SetTransformToLowRes() { |
| // TODO(vchudnov): Deprecate low_quality_enabled_. |
| low_quality_enabled_ = true; |
| // TODO(vchudnov): All these settings should probably be tunable. |
| if (options_->preferred_webp != WEBP_NONE) { |
| options_->preferred_webp = WEBP_LOSSY; |
| } |
| options_->webp_quality = 10; |
| options_->webp_animated_quality = 10; |
| options_->jpeg_quality = 10; |
| } |
| |
| Image::Image(const StringPiece& original_contents) |
| : image_type_(IMAGE_UNKNOWN), |
| original_contents_(original_contents), |
| output_contents_(), |
| output_valid_(false), |
| rewrite_attempted_(false) { } |
| |
| ImageImpl::ImageImpl(const StringPiece& original_contents, |
| const GoogleString& url, |
| const StringPiece& file_prefix, |
| CompressionOptions* options, |
| Timer* timer, |
| MessageHandler* handler) |
| : Image(original_contents), |
| file_prefix_(file_prefix.data(), file_prefix.size()), |
| changed_(false), |
| url_(url), |
| options_(options), |
| low_quality_enabled_(false), |
| timer_(timer) { |
| const GoogleString annotation = StrCat(url, ": "); |
| handler_.reset(new AnnotatedMessageHandler(annotation, handler)); |
| } |
| |
| Image* NewImage(const StringPiece& original_contents, |
| const GoogleString& url, |
| const StringPiece& file_prefix, |
| Image::CompressionOptions* options, |
| Timer* timer, |
| MessageHandler* handler) { |
| return new ImageImpl(original_contents, url, file_prefix, options, |
| timer, handler); |
| } |
| |
| Image::Image(ImageType type) |
| : image_type_(type), |
| original_contents_(), |
| output_contents_(), |
| output_valid_(false), |
| rewrite_attempted_(false) { } |
| |
| ImageImpl::ImageImpl(int width, int height, ImageType type, |
| const StringPiece& tmp_dir, |
| Timer* timer, MessageHandler* handler, |
| CompressionOptions* options) |
| : Image(type), |
| file_prefix_(tmp_dir.data(), tmp_dir.size()), |
| changed_(false), |
| low_quality_enabled_(false), |
| timer_(timer) { |
| options_.reset(options); |
| dims_.set_width(width); |
| dims_.set_height(height); |
| handler_.reset(new AnnotatedMessageHandler(handler)); |
| } |
| |
| bool ImageImpl::GenerateBlankImage() { |
| DCHECK(image_type_ == IMAGE_PNG) << "Blank image must be a PNG."; |
| |
| if (pagespeed::image_compression::GenerateBlankImage(dims_.width(), |
| dims_.height(), options_->use_transparent_for_blank_image, |
| &output_contents_, handler_.get())) { |
| output_valid_ = true; |
| return true; |
| } |
| return false; |
| } |
| |
| Image* BlankImageWithOptions(int width, int height, ImageType type, |
| const StringPiece& tmp_dir, |
| Timer* timer, MessageHandler* handler, |
| Image::CompressionOptions* options) { |
| scoped_ptr<ImageImpl> image(new ImageImpl(width, height, type, tmp_dir, |
| timer, handler, options)); |
| if (image != NULL && image->GenerateBlankImage()) { |
| return image.release(); |
| } |
| return NULL; |
| } |
| |
| Image::~Image() { |
| } |
| |
| // Looks through blocks of jpeg stream to find SOFn block |
| // indicating encoding and dimensions of image. |
| // Loosely based on code and FAQs found here: |
| // http://www.faqs.org/faqs/jpeg-faq/part1/ |
| void ImageImpl::FindJpegSize() { |
| const StringPiece& buf = original_contents_; |
| size_t pos = 2; // Position of first data block after header. |
| while (pos < buf.size()) { |
| // Read block identifier |
| int id = CharToInt(buf[pos++]); |
| if (id == 0xff) { // Padding byte |
| continue; |
| } |
| // At this point pos points to first data byte in block. In any block, |
| // first two data bytes are size (including these 2 bytes). But first, |
| // make sure block wasn't truncated on download. |
| if (pos + ImageHeaders::kJpegIntSize > buf.size()) { |
| break; |
| } |
| int length = JpegIntAtPosition(buf, pos); |
| // Now check for a SOFn header, which describes image dimensions. |
| if (0xc0 <= id && id <= 0xcf && // SOFn header |
| length >= 8 && // Valid SOFn block size |
| pos + 1 + 3 * ImageHeaders::kJpegIntSize <= buf.size() && |
| // Above avoids case where dimension data was truncated |
| id != 0xc4 && id != 0xc8 && id != 0xcc) { |
| // 0xc4, 0xc8, 0xcc aren't actually valid SOFn headers. |
| // NOTE: we don't care if we have the whole SOFn block, |
| // just that we can fetch both dimensions without trouble. |
| // Our image download could be truncated at this point for |
| // all we care. |
| // We're a bit sloppy about SOFn block size, as it's |
| // actually 8 + 3 * buf[pos+2], but for our purposes this |
| // will suffice as we don't parse subsequent metadata (which |
| // describes the formatting of chunks of image data). |
| dims_.set_height( |
| JpegIntAtPosition(buf, pos + 1 + ImageHeaders::kJpegIntSize)); |
| dims_.set_width( |
| JpegIntAtPosition(buf, pos + 1 + 2 * ImageHeaders::kJpegIntSize)); |
| break; |
| } |
| pos += length; |
| } |
| if (!ImageUrlEncoder::HasValidDimensions(dims_) || |
| (dims_.height() <= 0) || (dims_.width() <= 0)) { |
| dims_.Clear(); |
| PS_LOG_INFO(handler_, "Couldn't find jpeg dimensions (data truncated?)."); |
| } |
| } |
| |
| // Looks at first (IHDR) block of png stream to find image dimensions. |
| // See also: http://www.w3.org/TR/PNG/ |
| void ImageImpl::FindPngSize() { |
| const StringPiece& buf = original_contents_; |
| // Here we make sure that buf contains at least enough data that we'll be able |
| // to decipher the image dimensions first, before we actually check for the |
| // headers and attempt to decode the dimensions (which are the first two ints |
| // after the IHDR section label). |
| if ((buf.size() >= // Not truncated |
| ImageHeaders::kIHDRDataStart + 2 * ImageHeaders::kPngIntSize) && |
| (StringPiece(buf.data() + ImageHeaders::kPngHeaderLength, |
| ImageHeaders::kPngSectionHeaderLength) == |
| StringPiece(ImageHeaders::kPngIHDR, |
| ImageHeaders::kPngSectionHeaderLength))) { |
| dims_.set_width(PngIntAtPosition(buf, ImageHeaders::kIHDRDataStart)); |
| dims_.set_height(PngIntAtPosition( |
| buf, ImageHeaders::kIHDRDataStart + ImageHeaders::kPngIntSize)); |
| } else { |
| PS_LOG_INFO(handler_, "Couldn't find png dimensions " |
| "(data truncated or IHDR missing)."); |
| } |
| } |
| |
| // Looks at header of GIF file to extract image dimensions. |
| // See also: http://en.wikipedia.org/wiki/Graphics_Interchange_Format |
| void ImageImpl::FindGifSize() { |
| const StringPiece& buf = original_contents_; |
| // Make sure that buf contains enough data that we'll be able to |
| // decipher the image dimensions before we attempt to do so. |
| if (buf.size() >= |
| ImageHeaders::kGifDimStart + 2 * ImageHeaders::kGifIntSize) { |
| // Not truncated |
| dims_.set_width(GifIntAtPosition(buf, ImageHeaders::kGifDimStart)); |
| dims_.set_height(GifIntAtPosition( |
| buf, ImageHeaders::kGifDimStart + ImageHeaders::kGifIntSize)); |
| } else { |
| PS_LOG_INFO(handler_, "Couldn't find gif dimensions (data truncated)"); |
| } |
| } |
| |
| void ImageImpl::FindWebpSize() { |
| const uint8* webp = reinterpret_cast<const uint8*>(original_contents_.data()); |
| const int webp_size = original_contents_.size(); |
| int width = 0, height = 0; |
| if (WebPGetInfo(webp, webp_size, &width, &height) > 0) { |
| dims_.set_width(width); |
| dims_.set_height(height); |
| } else { |
| PS_LOG_INFO(handler_, "Couldn't find webp dimensions "); |
| } |
| } |
| |
| // Looks at image data in order to determine image type, and also fills in any |
| // dimension information it can (setting image_type_ and dims_). |
| void ImageImpl::ComputeImageType() { |
| image_type_ = |
| pagespeed::image_compression::ComputeImageType(original_contents_); |
| |
| switch (image_type_) { |
| case IMAGE_JPEG: |
| FindJpegSize(); |
| break; |
| case IMAGE_PNG: |
| FindPngSize(); |
| break; |
| case IMAGE_GIF: |
| FindGifSize(); |
| break; |
| case IMAGE_WEBP: |
| case IMAGE_WEBP_LOSSLESS_OR_ALPHA: |
| case IMAGE_WEBP_ANIMATED: |
| FindWebpSize(); |
| break; |
| case IMAGE_UNKNOWN: |
| break; |
| } |
| } |
| |
| const ContentType* Image::TypeToContentType(ImageType image_type) { |
| const ContentType* res = NULL; |
| switch (image_type) { |
| case IMAGE_UNKNOWN: |
| break; |
| case IMAGE_JPEG: |
| res = &kContentTypeJpeg; |
| break; |
| case IMAGE_PNG: |
| res = &kContentTypePng; |
| break; |
| case IMAGE_GIF: |
| res = &kContentTypeGif; |
| break; |
| case IMAGE_WEBP: |
| case IMAGE_WEBP_LOSSLESS_OR_ALPHA: |
| case IMAGE_WEBP_ANIMATED: |
| res = &kContentTypeWebp; |
| break; |
| } |
| return res; |
| } |
| |
| // Compute whether a PNG can have transparent / semi-transparent pixels |
| // by walking the image data in accordance with the spec: |
| // http://www.w3.org/TR/PNG/ |
| // If the colour type (UK spelling from spec) includes an alpha channel, or |
| // there is a tRNS section with at least one entry before IDAT, then we assume |
| // the image contains non-opaque pixels and return true. |
| bool ImageImpl::ComputePngTransparency(const StringPiece& buf) { |
| // We assume the image has transparency until we prove otherwise. |
| // This allows us to deal conservatively with truncation etc. |
| bool has_transparency = true; |
| if (buf.size() > ImageHeaders::kPngColourTypeOffset && |
| ((buf[ImageHeaders::kPngColourTypeOffset] & |
| ImageHeaders::kPngAlphaChannel) == 0)) { |
| // The colour type indicates that there is no dedicated alpha channel. Now |
| // we must look for a tRNS section indicating the existence of transparent |
| // colors or palette entries. |
| size_t section_start = ImageHeaders::kPngHeaderLength; |
| while (section_start + ImageHeaders::kPngSectionHeaderLength < buf.size()) { |
| size_t section_size = PngIntAtPosition(buf, section_start); |
| if (PngSectionIdIs(ImageHeaders::kPngIDAT, buf, section_start)) { |
| // tRNS section must occur before first IDAT. This image doesn't have a |
| // tRNS section, and thus doesn't have transparency. |
| has_transparency = false; |
| break; |
| } else if (PngSectionIdIs(ImageHeaders::kPngtRNS, buf, section_start) && |
| section_size > 0) { |
| // Found a nonempty tRNS section. This image has_transparency. |
| break; |
| } else { |
| // Move on to next section. |
| section_start += section_size + ImageHeaders::kPngSectionMinSize; |
| } |
| } |
| } |
| return has_transparency; |
| } |
| |
| bool ImageImpl::EnsureLoaded(bool output_useful) { |
| return true; |
| } |
| |
| // Determine the quality level for compressing the resized image. |
| // If a JPEG image needs resizing, we decompress it first, then resize it, |
| // and finally compress it into a new JPEG image. To compress the output image, |
| // We would like to use the quality level that was used in the input image, |
| // if such information can be calculated from the input image; otherwise, we |
| // will use the quality level set in the configuration; otherwise, we will use |
| // a predefined default quality. |
| int ImageImpl::EstimateQualityForResizedJpeg() { |
| int input_quality = GetJpegQualityFromImage(original_contents_); |
| int output_quality = std::min(ImageHeaders::kMaxJpegQuality, |
| options_->jpeg_quality); |
| if (input_quality > 0 && output_quality > 0) { |
| return std::min(input_quality, output_quality); |
| } else if (input_quality > 0) { |
| return input_quality; |
| } else if (output_quality > 0) { |
| return output_quality; |
| } else { |
| return ImageHeaders::kQualityForJpegWithUnkownQuality; |
| } |
| } |
| |
| void ImageImpl::Dimensions(ImageDim* natural_dim) { |
| if (!ImageUrlEncoder::HasValidDimensions(dims_)) { |
| ComputeImageType(); |
| } |
| *natural_dim = dims_; |
| } |
| |
| bool ImageImpl::ResizeTo(const ImageDim& new_dim) { |
| CHECK(ImageUrlEncoder::HasValidDimensions(new_dim)); |
| if ((new_dim.width() <= 0) || (new_dim.height() <= 0)) { |
| return false; |
| } |
| |
| if (changed_) { |
| // If we already resized, drop data and work with original image. |
| UndoChange(); |
| } |
| |
| // TODO(huibao): Enable resizing for WebP and images with alpha channel. |
| // We have the tools ready but no tests. |
| const ImageFormat original_format = ImageTypeToImageFormat(image_type()); |
| if (original_format == pagespeed::image_compression::IMAGE_WEBP) { |
| return false; |
| } |
| |
| scoped_ptr<ScanlineReaderInterface> image_reader( |
| CreateScanlineReader(original_format, |
| original_contents_.data(), |
| original_contents_.length(), |
| handler_.get())); |
| if (image_reader == NULL) { |
| resize_debug_message_ = "Cannot resize: Cannot open the image to resize"; |
| PS_LOG_INFO(handler_, "Cannot open the image to resize."); |
| return false; |
| } |
| |
| ScanlineResizer resizer(handler_.get()); |
| if (!resizer.Initialize(image_reader.get(), new_dim.width(), |
| new_dim.height())) { |
| resize_debug_message_ = "Cannot resize: Unable to initialize resizer"; |
| return false; |
| } |
| |
| // Create a writer. |
| scoped_ptr<ScanlineWriterInterface> writer; |
| const ImageFormat resized_format = GetOutputImageFormat(original_format); |
| switch (resized_format) { |
| case pagespeed::image_compression::IMAGE_JPEG: |
| { |
| JpegCompressionOptions jpeg_config; |
| jpeg_config.lossy = true; |
| jpeg_config.lossy_options.quality = EstimateQualityForResizedJpeg(); |
| writer.reset(CreateScanlineWriter(resized_format, |
| resizer.GetPixelFormat(), |
| resizer.GetImageWidth(), |
| resizer.GetImageHeight(), |
| &jpeg_config, |
| &resized_image_, |
| handler_.get())); |
| } |
| break; |
| |
| case pagespeed::image_compression::IMAGE_PNG: |
| { |
| PngCompressParams png_config(PNG_FILTER_NONE, Z_DEFAULT_STRATEGY, |
| false); |
| writer.reset(CreateScanlineWriter(resized_format, |
| resizer.GetPixelFormat(), |
| resizer.GetImageWidth(), |
| resizer.GetImageHeight(), |
| &png_config, |
| &resized_image_, |
| handler_.get())); |
| } |
| break; |
| |
| default: |
| resize_debug_message_ = "Cannot resize: Unsupported image format"; |
| PS_LOG_DFATAL(handler_, "Unsupported image format"); |
| } |
| |
| if (writer == NULL) { |
| return false; |
| } |
| |
| // Resize the image and save the results in 'resized_image_'. |
| void* scanline = NULL; |
| while (resizer.HasMoreScanLines()) { |
| if (!resizer.ReadNextScanline(&scanline)) { |
| resize_debug_message_ = "Cannot resize: Reading image failed"; |
| return false; |
| } |
| if (!writer->WriteNextScanline(scanline)) { |
| resize_debug_message_ = "Cannot resize: Writing image failed"; |
| return false; |
| } |
| } |
| if (!writer->FinalizeWrite()) { |
| resize_debug_message_ = "Cannot resize: Finalizing writing image failed"; |
| return false; |
| } |
| |
| changed_ = true; |
| output_valid_ = false; |
| rewrite_attempted_ = false; |
| output_contents_.clear(); |
| resized_dimensions_ = new_dim; |
| resize_debug_message_ = StringPrintf( |
| "Resized image from %dx%d to %dx%d", dims_.width(), dims_.height(), |
| resized_dimensions_.width(), resized_dimensions_.height()); |
| return true; |
| } |
| |
| void ImageImpl::UndoChange() { |
| if (changed_) { |
| output_valid_ = false; |
| rewrite_attempted_ = false; |
| output_contents_.clear(); |
| resized_image_.clear(); |
| image_type_ = IMAGE_UNKNOWN; |
| changed_ = false; |
| } |
| } |
| |
| // TODO(huibao): Refactor image rewriting. We may have a centralized |
| // controller and a set of naive image writers. The controller looks at |
| // the input image type and the filter settings, and decides which output |
| // format(s) to try and the configuration for each output format. The writers |
| // simply write the output based on the specified configurations and should not |
| // be aware of the input type nor the filters. |
| // |
| // Here are some thoughts for the new design. |
| // 1. Create a scanline reader based on the type of input image. |
| // 2. If the image is going to be resized, wrap the reader into a resizer, which |
| // is also a scanline reader. |
| // 3. Create a scanline writer or mutliple writers based the filter settings. |
| // The parameters for the writer will also be determined by the filters. |
| // |
| // Transfer all of the scanlines from the reader to the writer and the image is |
| // rewritten (and resized)! |
| |
| // Performs image optimization and output |
| bool ImageImpl::ComputeOutputContents() { |
| if (rewrite_attempted_) { |
| return output_valid_; |
| } |
| rewrite_attempted_ = true; |
| if (!output_valid_) { |
| StringPiece contents; |
| bool resized; |
| |
| // Choose appropriate source for image contents. |
| // Favor original contents if image unchanged. |
| resized = !resized_image_.empty(); |
| if (resized) { |
| contents = resized_image_; |
| } else { |
| contents = original_contents_; |
| } |
| |
| // Take image contents and re-compress them. |
| // The basic logic is this: |
| // * low_quality_enabled_ acts as though convert_gif_to_png and |
| // convert_png_to_webp were both set for this image. |
| // * We compute the intended final end state of all the |
| // convert_X_to_Y options, and try to convert to the final |
| // option in one shot. If that fails, we back off by each of the stages. |
| // * We return as soon as any applicable conversion succeeds. We |
| // do not compare the sizes of alternative conversions. |
| // If we can't optimize the image, we'll fail. |
| bool ok = false; |
| // We copy the data to a string eagerly as we're very likely to need it |
| // (only unrecognized formats don't require it, in which case we probably |
| // don't get this far in the first place). |
| // TODO(jmarantz): The PageSpeed library should, ideally, take StringPiece |
| // args rather than const string&. We would save lots of string-copying |
| // if we made that change. |
| GoogleString string_for_image(contents.data(), contents.size()); |
| scoped_ptr<PngReaderInterface> png_reader; |
| switch (image_type()) { |
| case IMAGE_UNKNOWN: |
| break; |
| case IMAGE_WEBP: |
| case IMAGE_WEBP_LOSSLESS_OR_ALPHA: |
| if (resized || options_->recompress_webp) { |
| ok = MayConvert() && |
| ReduceWebpImageQuality(string_for_image, |
| options_->webp_quality, |
| &output_contents_); |
| } |
| // TODO(pulkitg): Convert a webp image to jpeg image if |
| // web_preferred_ is false. |
| break; |
| case IMAGE_WEBP_ANIMATED: |
| // TODO(huibao): Recompress animated WebP. |
| ok = false; |
| break; |
| case IMAGE_JPEG: |
| if (MayConvert() && |
| options_->convert_jpeg_to_webp && |
| (options_->preferred_webp != WEBP_NONE)) { |
| ok = ConvertJpegToWebp(string_for_image, options_->webp_quality, |
| &output_contents_); |
| VLOG(1) << "Image conversion: " << ok << " jpeg->webp for " << url_; |
| if (!ok) { |
| // Image is not going to be webp-converted! |
| PS_LOG_INFO(handler_, "Failed to create webp!"); |
| } |
| } |
| if (ok) { |
| image_type_ = IMAGE_WEBP; |
| } else if (MayConvert() && |
| (resized || options_->recompress_jpeg)) { |
| JpegCompressionOptions jpeg_options; |
| ConvertToJpegOptions(*options_.get(), &jpeg_options); |
| ok = OptimizeJpegWithOptions(string_for_image, &output_contents_, |
| jpeg_options, handler_.get()); |
| VLOG(1) << "Image conversion: " << ok << " jpeg->jpeg for " << url_; |
| } |
| break; |
| case IMAGE_PNG: |
| png_reader.reset(new PngReader(handler_.get())); |
| ok = ComputeOutputContentsFromGifOrPng( |
| string_for_image, |
| png_reader.get(), |
| (resized || options_->recompress_png) /* fall_back_to_png */, |
| kPngString, |
| IMAGE_PNG, |
| Image::ConversionVariables::FROM_PNG); |
| break; |
| case IMAGE_GIF: |
| ImageType current_image_type = IMAGE_GIF; |
| if (resized) { |
| // If the GIF image has been resized, it has already been |
| // converted to a PNG image. |
| png_reader.reset(new PngReader(handler_.get())); |
| current_image_type = IMAGE_PNG; |
| } else if (options_->convert_gif_to_png || low_quality_enabled_ || |
| options_->allow_webp_animated) { |
| png_reader.reset(new GifReader(handler_.get())); |
| } else { |
| break; |
| } |
| ok = ComputeOutputContentsFromGifOrPng( |
| string_for_image, |
| png_reader.get(), |
| options_->convert_gif_to_png /* fall_back_to_png */, |
| kGifString, |
| current_image_type, |
| Image::ConversionVariables::FROM_GIF); |
| break; |
| } |
| output_valid_ = ok; |
| } |
| return output_valid_; |
| } |
| |
| inline bool ImageImpl::ConvertJpegToWebp( |
| const GoogleString& original_jpeg, int configured_quality, |
| GoogleString* compressed_webp) { |
| ConversionTimeoutHandler timeout_handler(options_->webp_conversion_timeout_ms, |
| timer_, handler_.get()); |
| timeout_handler.Start(compressed_webp); |
| bool ok = OptimizeWebp(original_jpeg, configured_quality, |
| ConversionTimeoutHandler::Continue, &timeout_handler, |
| compressed_webp, handler_.get()); |
| timeout_handler.Stop(); |
| |
| bool was_timed_out = timeout_handler.was_timed_out(); |
| int64 time_elapsed_ms = timeout_handler.time_elapsed_ms(); |
| |
| UpdateWebpStats(ok, was_timed_out, time_elapsed_ms, |
| Image::ConversionVariables::FROM_JPEG, |
| options_->webp_conversion_variables); |
| |
| UpdateWebpStats(ok, was_timed_out, time_elapsed_ms, |
| Image::ConversionVariables::OPAQUE, |
| options_->webp_conversion_variables); |
| return ok; |
| } |
| |
| bool ImageImpl::ConvertAnimatedGifToWebp(bool has_transparency) { |
| ConversionTimeoutHandler timeout_handler( |
| options_->webp_conversion_timeout_ms, timer_, handler_.get()); |
| timeout_handler.Start(&output_contents_); |
| |
| // Parameters controlling WebP compression. |
| WebpConfiguration webp_config; |
| webp_config.quality = options_->webp_animated_quality; |
| webp_config.progress_hook = ConversionTimeoutHandler::Continue; |
| webp_config.user_data = &timeout_handler; |
| // TODO(huibao): Evaluate the following parameters. |
| webp_config.method = 3; |
| webp_config.kmin = 3; |
| webp_config.kmax = 5; |
| webp_config.lossless = false; |
| webp_config.alpha_quality = 100; |
| webp_config.alpha_compression = 1; // alpha plane compressed losslessly |
| |
| pagespeed::image_compression::ScanlineStatus status; |
| scoped_ptr<pagespeed::image_compression::MultipleFrameReader> reader( |
| CreateImageFrameReader( |
| pagespeed::image_compression::IMAGE_GIF, |
| original_contents_.data(), |
| original_contents_.length(), |
| handler_.get(), &status)); |
| if (!status.Success()) { |
| PS_LOG_ERROR(handler_, "Cannot read the animated GIF image."); |
| return false; |
| } |
| |
| scoped_ptr<pagespeed::image_compression::MultipleFrameWriter> writer( |
| CreateImageFrameWriter( |
| pagespeed::image_compression::IMAGE_WEBP, |
| &webp_config, |
| &output_contents_, |
| handler_.get(), &status)); |
| if (!status.Success()) { |
| PS_LOG_ERROR(handler_, "Cannot create an animated WebP image for output."); |
| return false; |
| } |
| |
| // Copy all pixels in all frames from the reader to the writer. This will do |
| // format conversion and compression. |
| pagespeed::image_compression::ImageSpec image_spec; |
| pagespeed::image_compression::FrameSpec frame_spec; |
| const void* scan_row = NULL; |
| if (reader->GetImageSpec(&image_spec, &status) && |
| writer->PrepareImage(&image_spec, &status)) { |
| while (reader->HasMoreFrames() && |
| reader->PrepareNextFrame(&status) && |
| reader->GetFrameSpec(&frame_spec, &status) && |
| writer->PrepareNextFrame(&frame_spec, &status)) { |
| while (reader->HasMoreScanlines() && |
| reader->ReadNextScanline(&scan_row, &status) && |
| writer->WriteNextScanline(scan_row, &status)) { |
| // intentional empty loop body |
| } |
| } |
| } |
| writer->FinalizeWrite(&status); |
| |
| timeout_handler.Stop(); |
| bool was_timed_out = timeout_handler.was_timed_out(); |
| int64 time_elapsed_ms = timeout_handler.time_elapsed_ms(); |
| bool ok = status.Success(); |
| |
| UpdateWebpStats(ok, was_timed_out, time_elapsed_ms, |
| Image::ConversionVariables::FROM_GIF_ANIMATED, |
| options_->webp_conversion_variables); |
| |
| UpdateWebpStats(ok, was_timed_out, time_elapsed_ms, |
| (has_transparency ? |
| Image::ConversionVariables::NONOPAQUE : |
| Image::ConversionVariables::OPAQUE), |
| options_->webp_conversion_variables); |
| |
| return ok; |
| } |
| |
| inline bool ImageImpl::ComputeOutputContentsFromGifOrPng( |
| const GoogleString& string_for_image, |
| const PngReaderInterface* png_reader, |
| bool fall_back_to_png, |
| const char* dbg_input_format, |
| ImageType input_type, |
| ConversionVariables::VariableType var_type) { |
| // Don't try to optimize empty images, it just messes things up. |
| if (dims_.width() <= 0 || dims_.height() <= 0) { |
| return false; |
| } |
| |
| bool ok = false; |
| bool is_animated = false; |
| bool has_transparency = false; |
| bool is_photo = false; |
| bool compress_color_losslessly = false; |
| ImageType output_type = IMAGE_UNKNOWN; |
| |
| AnalyzeImage(ImageTypeToImageFormat(input_type), |
| string_for_image.data(), string_for_image.length(), |
| NULL /* width */, NULL /* height */, NULL /* is_progressive */, |
| &is_animated, &has_transparency, &is_photo, |
| NULL /* quality */, NULL /* reader */, handler_.get()); |
| |
| debug_message_ = StringPrintf("Image has%s transparent pixels," |
| " is%s sensitive to compression noise, and" |
| " has%s animation.", |
| (has_transparency ? "" : " no"), |
| (is_photo ? " not" : ""), |
| (is_animated ? "" : " no")); |
| |
| // By default, a lossless image conversion is eligible for lossless webp |
| // conversion. |
| if (is_animated) { |
| if (options_->preferred_webp == WEBP_ANIMATED && |
| options_->webp_animated_quality > 0) { |
| output_type = IMAGE_WEBP_ANIMATED; |
| } |
| // else we can't recompress this image |
| } else if (is_photo && options_->convert_png_to_jpeg && |
| (input_type == IMAGE_PNG || |
| (input_type == IMAGE_GIF && options_->convert_gif_to_png))) { |
| // Can be converted to lossy format. |
| if (!has_transparency) { |
| // No alpha; can be converted to WebP lossy or JPEG. |
| if (options_->preferred_webp != WEBP_NONE && |
| options_->convert_jpeg_to_webp && |
| options_->webp_quality > 0) { |
| compress_color_losslessly = false; |
| output_type = IMAGE_WEBP; |
| } else if (options_->jpeg_quality > 0) { |
| output_type = IMAGE_JPEG; |
| } |
| } else { |
| if (options_->allow_webp_alpha && |
| options_->convert_jpeg_to_webp && |
| options_->webp_quality > 0) { |
| compress_color_losslessly = false; |
| output_type = IMAGE_WEBP_LOSSLESS_OR_ALPHA; |
| } |
| } |
| } else { |
| // Must be converted to lossless format. |
| if (options_->preferred_webp == WEBP_ANIMATED || |
| options_->preferred_webp == WEBP_LOSSLESS) { |
| compress_color_losslessly = true; |
| output_type = IMAGE_WEBP_LOSSLESS_OR_ALPHA; |
| } |
| } |
| |
| if (output_type == IMAGE_WEBP_ANIMATED) { |
| ok = ConvertAnimatedGifToWebp(has_transparency); |
| } else { |
| if (output_type == IMAGE_WEBP || |
| output_type == IMAGE_WEBP_LOSSLESS_OR_ALPHA) { |
| ok = MayConvert() && |
| ConvertPngToWebp(*png_reader, string_for_image, |
| compress_color_losslessly, has_transparency, |
| var_type); |
| // TODO(huibao): Re-evaluate why we need to try a different format, if the |
| // conversion to WebP failed. |
| if (!ok) { |
| // If the conversion to WebP failed, we will try converting the image to |
| // jpeg or png. |
| if (output_type == IMAGE_WEBP) { |
| output_type = IMAGE_JPEG; |
| } else { |
| fall_back_to_png = true; |
| } |
| } |
| } |
| |
| if (output_type == IMAGE_JPEG) { |
| JpegCompressionOptions jpeg_options; |
| ConvertToJpegOptions(*options_.get(), &jpeg_options); |
| ok = MayConvert() && |
| ImageConverter::ConvertPngToJpeg(*png_reader, string_for_image, |
| jpeg_options, &output_contents_, |
| handler_.get()); |
| } |
| |
| if (!ok && fall_back_to_png) { |
| ok = MayConvert() && |
| PngOptimizer::OptimizePngBestCompression(*png_reader, |
| string_for_image, |
| &output_contents_, |
| handler_.get()); |
| output_type = IMAGE_PNG; |
| } |
| } |
| |
| if (ok) { |
| image_type_ = output_type; |
| } else { |
| image_type_ = input_type; |
| } |
| |
| VLOG(1) << "Image conversion: " << ok << " " << dbg_input_format << "->" |
| << ImageFormatToString(ImageTypeToImageFormat(image_type_)) << " for " |
| << url_; |
| |
| return ok; |
| } |
| |
| bool ImageImpl::ConvertPngToWebp( |
| const PngReaderInterface& png_reader, |
| const GoogleString& input_image, |
| bool compress_color_losslessly, |
| bool has_transparency, |
| ConversionVariables::VariableType var_type) { |
| ConversionTimeoutHandler timeout_handler(options_->webp_conversion_timeout_ms, |
| timer_, handler_.get()); |
| WebpConfiguration webp_config; |
| |
| // Quality/speed trade-off (0=fast, 6=slower-better). |
| // This is the default value in libpagespeed. We should evaluate |
| // whether this is the optimal value, and consider making it |
| // tunable. |
| webp_config.method = 3; |
| webp_config.quality = options_->webp_quality; |
| webp_config.progress_hook = ConversionTimeoutHandler::Continue; |
| webp_config.user_data = &timeout_handler; |
| |
| ImageType target_image_type = IMAGE_WEBP_LOSSLESS_OR_ALPHA; |
| if (compress_color_losslessly) { |
| // Note that webp_config.alpha_quality and |
| // webp_config.alpha_compression are only meaningful in the |
| // lossy compression case. |
| webp_config.lossless = true; |
| } else { |
| webp_config.lossless = false; |
| if (has_transparency) { |
| webp_config.alpha_quality = 100; |
| webp_config.alpha_compression = 1; |
| } else { |
| webp_config.alpha_quality = 0; |
| webp_config.alpha_compression = 0; |
| image_type_ = IMAGE_WEBP; |
| } |
| } |
| |
| // TODO(huibao): Remove "is_opaque" from the returned arguments in |
| // ConvertPngToWebp() and PngScanlineReader::InitializeRead(). |
| // The technique they use can only detect some of the opaque images. |
| // PixelFormatOptimizer has a more expensive, but comprehensive solution. |
| bool not_used; |
| timeout_handler.Start(&output_contents_); |
| bool ok = ImageConverter::ConvertPngToWebp( |
| png_reader, input_image, webp_config, |
| &output_contents_, ¬_used, handler_.get()); |
| |
| if (ok) { |
| image_type_ = target_image_type; |
| } |
| timeout_handler.Stop(); |
| |
| bool was_timed_out = timeout_handler.was_timed_out(); |
| int64 time_elapsed_ms = timeout_handler.time_elapsed_ms(); |
| |
| UpdateWebpStats(ok, was_timed_out, time_elapsed_ms, var_type, |
| options_->webp_conversion_variables); |
| |
| UpdateWebpStats(ok, was_timed_out, time_elapsed_ms, |
| (has_transparency ? |
| Image::ConversionVariables::NONOPAQUE : |
| Image::ConversionVariables::OPAQUE), |
| options_->webp_conversion_variables); |
| |
| return ok; |
| } |
| |
| bool ImageImpl::OptimizePng( |
| const PngReaderInterface& png_reader, |
| const GoogleString& image_data) { |
| bool ok = MayConvert() && |
| PngOptimizer::OptimizePngBestCompression(png_reader, |
| image_data, |
| &output_contents_, |
| handler_.get()); |
| if (ok) { |
| image_type_ = IMAGE_PNG; |
| } |
| return ok; |
| } |
| |
| bool ImageImpl::OptimizePngOrConvertToJpeg( |
| const PngReaderInterface& png_reader, |
| const GoogleString& image_data) { |
| bool is_png; |
| JpegCompressionOptions jpeg_options; |
| ConvertToJpegOptions(*options_.get(), &jpeg_options); |
| bool ok = MayConvert() && |
| ImageConverter::OptimizePngOrConvertToJpeg( |
| png_reader, image_data, jpeg_options, |
| &output_contents_, &is_png, handler_.get()); |
| if (ok) { |
| if (is_png) { |
| image_type_ = IMAGE_PNG; |
| } else { |
| image_type_ = IMAGE_JPEG; |
| } |
| } |
| return ok; |
| } |
| |
| void ImageImpl::ConvertToJpegOptions(const Image::CompressionOptions& options, |
| JpegCompressionOptions* jpeg_options) { |
| int input_quality = GetJpegQualityFromImage(original_contents_); |
| jpeg_options->retain_color_profile = options.retain_color_profile; |
| jpeg_options->retain_exif_data = options.retain_exif_data; |
| int output_quality = EstimateQualityForResizedJpeg(); |
| |
| if (options.jpeg_quality > 0) { |
| // If the source image is JPEG we want to fallback to lossless if the input |
| // quality is less than the quality we want to set for final compression and |
| // num progressive scans is not set. Incase we are not able to decode the |
| // input image quality, then we use lossless path. |
| if (image_type() != IMAGE_JPEG || |
| options.jpeg_num_progressive_scans > 0 || |
| input_quality > output_quality) { |
| jpeg_options->lossy = true; |
| jpeg_options->lossy_options.quality = output_quality; |
| if (options.progressive_jpeg) { |
| jpeg_options->lossy_options.num_scans = |
| options.jpeg_num_progressive_scans; |
| } |
| |
| if (options.retain_color_sampling) { |
| jpeg_options->lossy_options.color_sampling = RETAIN; |
| } |
| } |
| } |
| |
| jpeg_options->progressive = options.progressive_jpeg && |
| ShouldConvertToProgressive(output_quality); |
| } |
| |
| bool ImageImpl::ShouldConvertToProgressive(int64 quality) const { |
| bool progressive = false; |
| const ImageDim* expected_dimensions = &dims_; |
| if (ImageUrlEncoder::HasValidDimensions(resized_dimensions_)) { |
| expected_dimensions = &resized_dimensions_; |
| } |
| if (ImageUrlEncoder::HasValidDimensions(*expected_dimensions)) { |
| progressive = pagespeed::image_compression::ShouldConvertToProgressive( |
| quality, options_->progressive_jpeg_min_bytes, |
| original_contents_.size(), expected_dimensions->width(), |
| expected_dimensions->height()); |
| } else { |
| progressive = (static_cast<int64>(original_contents_.size()) >= |
| options_->progressive_jpeg_min_bytes); |
| } |
| return progressive; |
| } |
| |
| StringPiece Image::Contents() { |
| StringPiece contents; |
| if (this->image_type() != IMAGE_UNKNOWN) { |
| contents = original_contents_; |
| if (output_valid_ || ComputeOutputContents()) { |
| contents = output_contents_; |
| } |
| } |
| return contents; |
| } |
| |
| bool ImageImpl::DrawImage(Image* image, int x, int y) { |
| // Create a reader for reading the original canvas image. |
| scoped_ptr<ScanlineReaderInterface> canvas_reader(CreateScanlineReader( |
| pagespeed::image_compression::IMAGE_PNG, |
| output_contents_.data(), |
| output_contents_.length(), |
| handler_.get())); |
| if (canvas_reader == NULL) { |
| PS_LOG_ERROR(handler_, "Cannot open canvas image."); |
| return false; |
| } |
| |
| // Get the size and pixel format of the original canvas image. |
| const size_t canvas_width = canvas_reader->GetImageWidth(); |
| const size_t canvas_height = canvas_reader->GetImageHeight(); |
| const PixelFormat canvas_pixel_format = canvas_reader->GetPixelFormat(); |
| |
| // Initialize a reader for reading the image which will be sprited. |
| ImageImpl* impl = static_cast<ImageImpl*>(image); |
| scoped_ptr<ScanlineReaderInterface> image_reader(CreateScanlineReader( |
| ImageTypeToImageFormat(impl->image_type()), |
| impl->original_contents().data(), |
| impl->original_contents().length(), |
| handler_.get())); |
| if (image_reader == NULL) { |
| PS_LOG_INFO(handler_, "Cannot open the image which will be sprited."); |
| return false; |
| } |
| |
| // Get the size of the image which will be sprited. |
| const size_t image_width = image_reader->GetImageWidth(); |
| const size_t image_height = image_reader->GetImageHeight(); |
| const PixelFormat image_pixel_format = image_reader->GetPixelFormat(); |
| |
| if (x + image_width > canvas_width || y + image_height > canvas_height) { |
| PS_LOG_INFO(handler_, "The new image cannot fit into the canvas."); |
| return false; |
| } |
| |
| bool has_transparency = false; |
| PixelFormat output_pixel_format = RGB_888; |
| if (image_pixel_format == RGBA_8888 || |
| canvas_pixel_format == RGBA_8888) { |
| has_transparency = true; |
| output_pixel_format = RGBA_8888; |
| } |
| |
| const size_t bytes_per_pixel = |
| GetNumChannelsFromPixelFormat(output_pixel_format, handler_.get()); |
| const size_t bytes_per_scanline = canvas_width * bytes_per_pixel; |
| scoped_array<uint8> scanline(new uint8[bytes_per_scanline]); |
| |
| // Create a writer for writing the new canvas image. |
| GoogleString canvas_image; |
| scoped_ptr<ScanlineWriterInterface> canvas_writer( |
| CreateUncompressedPngWriter(canvas_width, canvas_height, |
| &canvas_image, handler_.get(), |
| has_transparency)); |
| if (canvas_writer == NULL) { |
| PS_LOG_ERROR(handler_, "Failed to create canvas writer."); |
| return false; |
| } |
| |
| // Overlay the new image onto the canvas image. |
| for (int row = 0; row < static_cast<int>(canvas_height); ++row) { |
| uint8* canvas_line = NULL; |
| if (!canvas_reader->ReadNextScanline( |
| reinterpret_cast<void**>(&canvas_line))) { |
| PS_LOG_ERROR(handler_, "Failed to read canvas image."); |
| return false; |
| } |
| |
| if (row >= y && row < y + static_cast<int>(image_height)) { |
| uint8* image_line = NULL; |
| if (!image_reader->ReadNextScanline( |
| reinterpret_cast<void**>(&image_line))) { |
| PS_LOG_INFO(handler_, |
| "Failed to read the image which will be sprited."); |
| return false; |
| } |
| |
| // Set the entire scanline to white. This operation has no effect |
| // on the webpage; it just gives a clean background to the |
| // sprite image. |
| memset(scanline.get(), kAlphaOpaque, x * bytes_per_pixel); |
| memset(scanline.get() + (x + image_width) * bytes_per_pixel, |
| kAlphaOpaque, |
| (canvas_width - image_width - x) * bytes_per_pixel); |
| |
| ExpandPixelFormat(image_width, image_pixel_format, 0, image_line, |
| output_pixel_format, x, scanline.get(), handler_.get()); |
| } else { |
| ExpandPixelFormat(canvas_width, canvas_pixel_format, 0, canvas_line, |
| output_pixel_format, 0, scanline.get(), handler_.get()); |
| } |
| |
| if (!canvas_writer->WriteNextScanline( |
| reinterpret_cast<void*>(scanline.get()))) { |
| PS_LOG_ERROR(handler_, "Failed to write canvas image."); |
| return false; |
| } |
| } |
| |
| if (!canvas_writer->FinalizeWrite()) { |
| PS_LOG_ERROR(handler_, "Failed to close canvas file."); |
| return false; |
| } |
| |
| output_contents_ = canvas_image; |
| output_valid_ = true; |
| return true; |
| } |
| |
| } // namespace net_instaweb |
