webp_optimizer.h

Go to the documentation of this file.

/*
 * Copyright 2009 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_WEBP_OPTIMIZER_H_
#define PAGESPEED_KERNEL_IMAGE_WEBP_OPTIMIZER_H_

#include <cstddef>
#include "third_party/libwebp/src/webp/encode.h"
#include "third_party/libwebp/src/webp/mux.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/image/image_frame_interface.h"
#include "pagespeed/kernel/image/image_util.h"
#include "pagespeed/kernel/image/scanline_interface.h"
#include "pagespeed/kernel/image/scanline_status.h"

namespace net_instaweb {
class MessageHandler;
}

namespace pagespeed {

namespace image_compression {

using net_instaweb::MessageHandler;

struct WebpConfiguration : public ScanlineWriterConfig {

  typedef bool (*WebpProgressHook)(int percent, void* user_data);

  WebpConfiguration()
      : lossless(true), quality(75), method(3), target_size(0),
        alpha_compression(1), alpha_filtering(1), alpha_quality(100),
        kmin(0), kmax(0), progress_hook(NULL), user_data(NULL) {}

  ~WebpConfiguration() override;

  void CopyTo(WebPConfig* webp_config) const;

  int lossless; 
  float quality; 
  int method; 

  int target_size; 
  int alpha_compression; 
  int alpha_filtering; 
  int alpha_quality; 

  size_px kmin; 
  size_px kmax; 

  WebpProgressHook progress_hook; 

  void* user_data; 

};

class WebpFrameWriter : public MultipleFrameWriter {
 public:
  explicit WebpFrameWriter(MessageHandler* handler);
  virtual ~WebpFrameWriter();

  virtual ScanlineStatus Initialize(const void* config, GoogleString* out);

  virtual ScanlineStatus PrepareImage(const ImageSpec* image_spec);

  virtual ScanlineStatus PrepareNextFrame(const FrameSpec* frame_spec);

  virtual ScanlineStatus WriteNextScanline(const void *scanline_bytes);

  virtual ScanlineStatus FinalizeWrite();

 private:
  static int ProgressHook(int percent, const WebPPicture* picture);

  ScanlineStatus CacheCurrentFrame();

  void FreeWebpStructs();

  const ImageSpec* image_spec_;
  FrameSpec frame_spec_;

  size_px next_frame_;

  size_px next_scanline_;

  bool empty_frame_;

  size_px frame_stride_px_;

  uint32_t* frame_position_px_;

  uint32_t frame_bytes_per_pixel_;

  WebPPicture webp_image_;

  WebPPicture* webp_image_restore_;

  FrameSpec previous_frame_spec_;

  WebPAnimEncoder* webp_encoder_;

  WebPConfig libwebp_config_;

  int timestamp_;

#ifndef NDEBUG
  WebPAuxStats stats_;
#endif

  GoogleString* output_image_;

  bool has_alpha_;

  bool image_prepared_;

  WebpConfiguration::WebpProgressHook progress_hook_;

  void* progress_hook_data_;

  bool should_expand_gray_to_rgb_;

  size_px kmin_;
  size_px kmax_;

  
};

class WebpScanlineReader : public ScanlineReaderInterface {
 public:
  explicit WebpScanlineReader(MessageHandler* handler);
  virtual ~WebpScanlineReader();

  virtual bool Reset();

  virtual ScanlineStatus InitializeWithStatus(const void* image_buffer,
                                              size_t buffer_length);

  virtual ScanlineStatus ReadNextScanlineWithStatus(void** out_scanline_bytes);

  virtual size_t GetBytesPerScanline() { return bytes_per_row_; }

  virtual bool HasMoreScanLines() { return (row_ < height_); }
  virtual PixelFormat GetPixelFormat() { return pixel_format_; }
  virtual size_t GetImageHeight() { return height_; }
  virtual size_t GetImageWidth() {  return width_; }
  virtual bool IsProgressive() { return false; }

 private:
  const uint8_t* image_buffer_;
  int buffer_length_;

  PixelFormat pixel_format_;
  size_t height_;
  size_t width_;
  size_t bytes_per_row_;
  size_t row_;
  bool was_initialized_;

  net_instaweb::scoped_array<uint8_t> pixels_;

  MessageHandler* message_handler_;

  
};

}  

}  

#endif