image.h

Go to the documentation of this file.

/*
 * 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.
 */


#ifndef NET_INSTAWEB_REWRITER_PUBLIC_IMAGE_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_IMAGE_H_

#include <cstddef>

#include "net/instaweb/rewriter/cached_result.pb.h"
#include "net/instaweb/rewriter/public/rewrite_options.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/http/image_types.pb.h"
#include "pagespeed/kernel/image/image_util.h"

namespace net_instaweb {
class Histogram;
class MessageHandler;
class Timer;
class Variable;
struct ContentType;

class Image {
 public:

  struct ConversionBySourceVariable {
    ConversionBySourceVariable()
        : timeout_count(NULL),
          success_ms(NULL),
          failure_ms(NULL) {}

    Variable* timeout_count; 
    Histogram* success_ms; 
    Histogram* failure_ms; 
  };

  struct ConversionVariables {
    enum VariableType {
      FROM_UNKNOWN_FORMAT = 0,
      FROM_GIF,
      FROM_PNG,
      FROM_JPEG,
      OPAQUE,
      NONOPAQUE,
      FROM_GIF_ANIMATED,
      NUM_VARIABLE_TYPE
    };
    ConversionBySourceVariable* Get(VariableType var_type) {
      if ((var_type < FROM_UNKNOWN_FORMAT) ||
          (var_type >= NUM_VARIABLE_TYPE)) {
        return NULL;
      }
      return &(vars[var_type]);
    }

    ConversionBySourceVariable vars[NUM_VARIABLE_TYPE];
  };

  struct CompressionOptions {
    CompressionOptions()
        : preferred_webp(pagespeed::image_compression::WEBP_NONE),
          allow_webp_alpha(false),
          allow_webp_animated(false),
          webp_quality(RewriteOptions::kDefaultImageRecompressQuality),
          webp_animated_quality(RewriteOptions::kDefaultImageRecompressQuality),
          jpeg_quality(RewriteOptions::kDefaultImageRecompressQuality),
          progressive_jpeg_min_bytes(
              RewriteOptions::kDefaultProgressiveJpegMinBytes),
          progressive_jpeg(false),
          convert_gif_to_png(false),
          convert_png_to_jpeg(false),
          convert_jpeg_to_webp(false),
          recompress_jpeg(false),
          recompress_png(false),
          recompress_webp(false),
          retain_color_profile(false),
          retain_color_sampling(false),
          retain_exif_data(false),
          use_transparent_for_blank_image(false),
          jpeg_num_progressive_scans(
              RewriteOptions::kDefaultImageJpegNumProgressiveScans),
          webp_conversion_timeout_ms(-1),
          conversions_attempted(0),
          preserve_lossless(false),
          webp_conversion_variables(NULL) {}

    pagespeed::image_compression::PreferredLibwebpLevel preferred_webp;
    bool allow_webp_alpha;
    bool allow_webp_animated;
    int64 webp_quality;
    int64 webp_animated_quality;
    int64 jpeg_quality;
    int64 progressive_jpeg_min_bytes;
    bool progressive_jpeg;
    bool convert_gif_to_png;
    bool convert_png_to_jpeg;
    bool convert_jpeg_to_webp;
    bool recompress_jpeg;
    bool recompress_png;
    bool recompress_webp;
    bool retain_color_profile;
    bool retain_color_sampling;
    bool retain_exif_data;
    bool use_transparent_for_blank_image;
    int64 jpeg_num_progressive_scans;
    int64 webp_conversion_timeout_ms;

    int conversions_attempted;
    bool preserve_lossless;

    ConversionVariables* webp_conversion_variables;
  };

  virtual ~Image();

  static const ContentType* TypeToContentType(ImageType t);

  virtual void Dimensions(ImageDim* natural_dim) = 0;

  size_t input_size() const {
    return original_contents_.size();
  }

  size_t output_size() {
    size_t ret;
    if (output_valid_ || ComputeOutputContents()) {
      ret = output_contents_.size();
    } else {
      ret = input_size();
    }
    return ret;
  }

  ImageType image_type() {
    if (image_type_ == IMAGE_UNKNOWN) {
      ComputeImageType();
    }
    return image_type_;
  }

  virtual bool ResizeTo(const ImageDim& new_dim) = 0;

  virtual void SetTransformToLowRes() = 0;

  const ContentType* content_type() {
    return TypeToContentType(image_type());
  }

  StringPiece Contents();

  virtual bool DrawImage(Image* image, int x, int y) = 0;

  virtual bool EnsureLoaded(bool output_useful) = 0;

  virtual const GoogleString& url() = 0;

  virtual const GoogleString& debug_message() = 0;

  virtual const GoogleString& resize_debug_message() = 0;

  virtual void SetDebugMessageUrl(const GoogleString& url) = 0;

 protected:
  explicit Image(const StringPiece& original_contents);
  explicit Image(ImageType type);

  virtual void ComputeImageType() = 0;
  virtual bool ComputeOutputContents() = 0;

  virtual void SetResizedDimensions(const ImageDim& dim) = 0;

  virtual bool ShouldConvertToProgressive(int64 quality) const = 0;


  ImageType image_type_; 
  const StringPiece original_contents_;
  GoogleString output_contents_; 
  bool output_valid_; 
  bool rewrite_attempted_; 

 private:
  friend class ImageTestingPeer;
  friend class ImageTest;

  
};

Image* NewImage(const StringPiece& original_contents,
                const GoogleString& url,
                const StringPiece& file_prefix,
                Image::CompressionOptions* options,
                Timer* timer,
                MessageHandler* handler);

Image* BlankImageWithOptions(int width, int height, ImageType type,
                             const StringPiece& tmp_dir,
                             Timer* timer,
                             MessageHandler* handler,
                             Image::CompressionOptions* options);

}  

#endif