image_util.h

Go to the documentation of this file.

/*
 * Copyright 2014 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 PAGESPEED_KERNEL_IMAGE_IMAGE_UTIL_H_
#define PAGESPEED_KERNEL_IMAGE_IMAGE_UTIL_H_

#include <cstddef>

#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/countdown_timer.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/http/image_types.pb.h"

namespace net_instaweb {
class MessageHandler;
class Timer;
}

namespace pagespeed {

namespace image_compression {

enum QuirksMode {
  QUIRKS_NONE = 0,
  QUIRKS_CHROME,
  QUIRKS_FIREFOX
};

enum ImageFormat {
  IMAGE_UNKNOWN,
  IMAGE_JPEG,
  IMAGE_PNG,
  IMAGE_GIF,
  IMAGE_WEBP
};

enum PixelFormat {
  UNSUPPORTED,  
  RGB_888,      
  RGBA_8888,    
  GRAY_8        
};

enum RgbaChannels {
  RGBA_RED = 0,
  RGBA_GREEN,
  RGBA_BLUE,
  RGBA_ALPHA,

  RGBA_NUM_CHANNELS
};

enum PreferredLibwebpLevel {
  WEBP_NONE = 0,
  WEBP_LOSSY,
  WEBP_LOSSLESS,
  WEBP_ANIMATED
};

const uint8_t kAlphaOpaque = 255;
const uint8_t kAlphaTransparent = 0;
typedef uint8_t PixelRgbaChannels[RGBA_NUM_CHANNELS];

inline uint32_t PackHiToLo(uint8_t i3,
                           uint8_t i2,
                           uint8_t i1,
                           uint8_t i0) {
  return
      (static_cast<uint32_t>(i3) << 24) |
      (i2 << 16) |
      (i1 << 8) |
      (i0);
}

inline uint32_t PackAsArgb(uint8_t alpha,
                           uint8_t red,
                           uint8_t green,
                           uint8_t blue) {
  return PackHiToLo(alpha, red, green, blue);
}

inline uint32_t RgbaToPackedArgb(const PixelRgbaChannels rgba) {
  return PackAsArgb(rgba[RGBA_ALPHA],
                    rgba[RGBA_RED],
                    rgba[RGBA_GREEN],
                    rgba[RGBA_BLUE]);
}

inline uint32_t RgbToPackedArgb(const PixelRgbaChannels rgba) {
  return PackAsArgb(kAlphaOpaque,
                    rgba[RGBA_RED],
                    rgba[RGBA_GREEN],
                    rgba[RGBA_BLUE]);
}

inline uint32_t GrayscaleToPackedArgb(const uint8_t luminance) {
  return PackAsArgb(kAlphaOpaque,
                    luminance,
                    luminance,
                    luminance);
}

typedef uint32 size_px;

const char* ImageFormatToMimeTypeString(ImageFormat image_type);

const char* ImageFormatToString(ImageFormat image_type);

const char* GetPixelFormatString(PixelFormat pixel_format);

size_t GetBytesPerPixel(PixelFormat pixel_format);

net_instaweb::ImageType ComputeImageType(const StringPiece& buf);

class ConversionTimeoutHandler {
 public:
  ConversionTimeoutHandler(int64 time_allowed_ms,
                           net_instaweb::Timer* timer,
                           net_instaweb::MessageHandler* handler) :
    countdown_timer_(timer, NULL, time_allowed_ms),
    time_allowed_ms_(time_allowed_ms),
    time_elapsed_ms_(0),
    was_timed_out_(false),
    output_(NULL),
    handler_(handler) {}

  static bool Continue(int percent, void* user_data);

  void Start(GoogleString* output) {
    output_ = output;
    countdown_timer_.Reset(time_allowed_ms_);
  }

  void Stop() {
    time_elapsed_ms_ = countdown_timer_.TimeElapsedMs();
  }

  bool was_timed_out() const { return was_timed_out_; }
  int64 time_elapsed_ms() const { return time_elapsed_ms_; }

 private:
  net_instaweb::CountdownTimer countdown_timer_;
  const int64 time_allowed_ms_;
  int64 time_elapsed_ms_;
  bool was_timed_out_;
  GoogleString* output_;
  net_instaweb::MessageHandler* handler_;
};

struct ScanlineWriterConfig {
  virtual ~ScanlineWriterConfig();
};

}  

}  

#endif