gif_reader.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_GIF_READER_H_
#define PAGESPEED_KERNEL_IMAGE_GIF_READER_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/string.h"
#include "pagespeed/kernel/image/image_frame_interface.h"
#include "pagespeed/kernel/image/image_util.h"
#include "pagespeed/kernel/image/png_optimizer.h"
#include "pagespeed/kernel/image/scanline_status.h"
#include "pagespeed/kernel/image/scanline_utils.h"

extern "C" {
#include "third_party/giflib/lib/gif_lib.h"

#ifdef USE_SYSTEM_LIBPNG
#include "png.h"                                               
#else
#include "third_party/libpng/src/png.h"
#endif
}

namespace pagespeed {

namespace image_compression {

using net_instaweb::MessageHandler;

class ScopedGifStruct;

FrameSpec::DisposalMethod GifDisposalToFrameSpecDisposal(int gif_disposal);

class GifReader : public PngReaderInterface {
 public:
  explicit GifReader(MessageHandler* handler);
  virtual ~GifReader();

  virtual bool ReadPng(const GoogleString& body,
                       png_structp png_ptr,
                       png_infop info_ptr,
                       int transforms,
                       bool require_opaque) const;

  virtual bool GetAttributes(const GoogleString& body,
                             int* out_width,
                             int* out_height,
                             int* out_bit_depth,
                             int* out_color_type) const;

 private:
  MessageHandler* message_handler_;
  
};

class GifFrameReader : public MultipleFrameReader {
 public:
  virtual ~GifFrameReader();

  virtual ScanlineStatus Reset();

  virtual ScanlineStatus Initialize();

  virtual bool HasMoreFrames() const {
    return (image_initialized_ && (next_frame_ < image_spec_.num_frames));
  }

  virtual bool HasMoreScanlines() const {
    return (frame_initialized_ && (next_row_ < frame_spec_.height));
  }

  virtual ScanlineStatus PrepareNextFrame();

  virtual ScanlineStatus ReadNextScanline(const void** out_scanline_bytes);

  virtual ScanlineStatus GetFrameSpec(FrameSpec* frame_spec) const {
    if (frame_spec == NULL) {
      return PS_LOGGED_STATUS(PS_LOG_DFATAL, message_handler(),
                              SCANLINE_STATUS_INVOCATION_ERROR,
                              FRAME_GIFREADER,
                              "Unexpected NULL pointer.");
    }
    *frame_spec = frame_spec_;
    return ScanlineStatus(SCANLINE_STATUS_SUCCESS);
  }

  virtual ScanlineStatus GetImageSpec(ImageSpec* image_spec) const {
    if (image_spec == NULL) {
      return PS_LOGGED_STATUS(PS_LOG_DFATAL, message_handler(),
                              SCANLINE_STATUS_INVOCATION_ERROR,
                              FRAME_GIFREADER,
                              "Unexpected NULL pointer.");
    }
    *image_spec = image_spec_;
    return ScanlineStatus(SCANLINE_STATUS_SUCCESS);
  }

  virtual ScanlineStatus set_quirks_mode(QuirksMode quirks_mode);

  static void ApplyQuirksModeToImage(QuirksMode quirks_mode,
                                     bool has_loop_count,
                                     const FrameSpec& frame_spec,
                                     ImageSpec* image_spec);

  static void ApplyQuirksModeToFirstFrame(QuirksMode quirks_mode,
                                          const ImageSpec& image_spec,
                                          FrameSpec* frame_spec);

 private:
  friend MultipleFrameReader* InstantiateImageFrameReader(
      ImageFormat image_type,
      MessageHandler* handler,
      ScanlineStatus* status);

  friend class TestGifFrameReader;

  explicit GifFrameReader(MessageHandler* handler);

  static const int kNoTransparentIndex;


  ScanlineStatus DecodeProgressiveGif();

  ScanlineStatus DecodeNonProgressiveGif();

  ScanlineStatus CreateColorMap();

  ScanlineStatus GetImageData();

  ScanlineStatus ProcessExtensionAffectingImage(bool past_first_frame);

  ScanlineStatus ProcessExtensionAffectingFrame();

  bool image_initialized_;

  bool frame_initialized_;

  ImageSpec image_spec_;

  FrameSpec frame_spec_;

  bool has_loop_count_;

  size_px next_frame_;


  size_px next_row_;

  int frame_transparent_index_;

  net_instaweb::scoped_array<PaletteRGBA> gif_palette_;

  net_instaweb::scoped_array<GifByteType> frame_buffer_;

  net_instaweb::scoped_array<GifByteType> frame_index_;

  net_instaweb::scoped_ptr<ScopedGifStruct> gif_struct_;

  int frame_palette_size_;

  bool frame_eagerly_read_;

  
};

}  

}  

#endif