image_frame_interface.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_FRAME_INTERFACE_H_
#define PAGESPEED_KERNEL_IMAGE_IMAGE_FRAME_INTERFACE_H_

#include <cstddef>
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/image/image_util.h"
#include "pagespeed/kernel/image/scanline_status.h"

namespace net_instaweb {
class MessageHandler;
}

namespace pagespeed {

namespace image_compression {

using net_instaweb::MessageHandler;

struct FrameSpec;

struct ImageSpec {
  ImageSpec();
  void Reset();

  size_px width;
  size_px height;
  size_px num_frames;

  unsigned int loop_count;

  PixelRgbaChannels bg_color;
  bool use_bg_color;

  bool image_size_adjusted;

  size_px TruncateXIndex(size_px x) const;

  size_px TruncateYIndex(size_px y) const;

  bool CanContainFrame(const FrameSpec& frame_spec) const;

  GoogleString ToString() const;
  bool Equals(const ImageSpec& other) const;
};

struct FrameSpec {
  enum DisposalMethod {
    DISPOSAL_UNKNOWN = 0,
    DISPOSAL_NONE,
    DISPOSAL_BACKGROUND,

    DISPOSAL_RESTORE
  };

  FrameSpec();
  void Reset();

  size_px width;
  size_px height;
  size_px top;
  size_px left;
  PixelFormat pixel_format;
  size_t duration_ms;
  DisposalMethod disposal;

  bool hint_progressive;

  GoogleString ToString() const;
  bool Equals(const FrameSpec& other) const;
};

#if defined(IF_OK_RUN)
#error "Preprocessor macro collision."
#endif

#define IF_OK_RUN(_STATUS, _CALL)                               \
  if (!_STATUS->Success()) {                                    \
    return false;                                               \
  }                                                             \
  *_STATUS = _CALL;                                             \
  return _STATUS->Success();

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

  virtual ScanlineStatus Reset() = 0;

  virtual ScanlineStatus Initialize() = 0;

  ScanlineStatus Initialize(const void* image_buffer, size_t buffer_length) {
    image_buffer_ = image_buffer;
    buffer_length_ = buffer_length;
    return Initialize();
  }

  virtual bool HasMoreFrames() const = 0;

  virtual bool HasMoreScanlines() const = 0;

  virtual ScanlineStatus PrepareNextFrame() = 0;

  virtual ScanlineStatus ReadNextScanline(const void** out_scanline_bytes) = 0;

  virtual ScanlineStatus GetFrameSpec(FrameSpec* frame_spec) const = 0;

  virtual ScanlineStatus GetImageSpec(ImageSpec* image_spec) const = 0;

  MessageHandler* message_handler() const {
    return message_handler_;
  }

  virtual ScanlineStatus set_quirks_mode(QuirksMode quirks_mode) {
    quirks_mode_ = quirks_mode;
    return ScanlineStatus(SCANLINE_STATUS_SUCCESS);
  }

  virtual QuirksMode quirks_mode() const {
    return quirks_mode_;
  }


  bool Reset(ScanlineStatus* status) {
    IF_OK_RUN(status, Reset());
  }
  bool Initialize(const void* image_buffer, size_t buffer_length,
                  ScanlineStatus* status) {
    IF_OK_RUN(status, Initialize(image_buffer, buffer_length));
  }
  bool Initialize(ScanlineStatus* status) {
    IF_OK_RUN(status, Initialize());
  }
  bool PrepareNextFrame(ScanlineStatus* status) {
    IF_OK_RUN(status, PrepareNextFrame());
  }
  bool ReadNextScanline(const void** out_scanline_bytes,
                        ScanlineStatus* status) {
    IF_OK_RUN(status, ReadNextScanline(out_scanline_bytes));
  }
  bool GetFrameSpec(FrameSpec* frame_spec,
                    ScanlineStatus* status) {
    IF_OK_RUN(status, GetFrameSpec(frame_spec));
  }
  bool GetImageSpec(ImageSpec* image_spec,
                    ScanlineStatus* status) {
    IF_OK_RUN(status, GetImageSpec(image_spec));
  }

  bool set_quirks_mode(QuirksMode quirks_mode,
                       ScanlineStatus* status) {
    IF_OK_RUN(status, set_quirks_mode(quirks_mode));
  }

 protected:
  const void* image_buffer_;
  size_t buffer_length_;

 private:
  MessageHandler* message_handler_;

  QuirksMode quirks_mode_;

  
};


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

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

  virtual ScanlineStatus PrepareImage(const ImageSpec* image_spec) = 0;

  virtual ScanlineStatus PrepareNextFrame(const FrameSpec* frame_spec) = 0;

  virtual ScanlineStatus WriteNextScanline(const void *scanline_bytes) = 0;

  virtual ScanlineStatus FinalizeWrite() = 0;

  MessageHandler* message_handler() const {
    return message_handler_;
  }


  bool Initialize(const void* config, GoogleString* out,
                  ScanlineStatus* status) {
    IF_OK_RUN(status, Initialize(config, out));
  }
  bool PrepareImage(const ImageSpec* image_spec, ScanlineStatus* status) {
    IF_OK_RUN(status, PrepareImage(image_spec));
  }
  bool PrepareNextFrame(const FrameSpec* frame_spec, ScanlineStatus* status) {
    IF_OK_RUN(status, PrepareNextFrame(frame_spec));
  }
  bool WriteNextScanline(const void* scanline_bytes, ScanlineStatus* status) {
    IF_OK_RUN(status, WriteNextScanline(scanline_bytes));
  }
  bool FinalizeWrite(ScanlineStatus* status) {
    IF_OK_RUN(status, FinalizeWrite());
  }

 private:
  MessageHandler* message_handler_;

  
};

#undef IF_OK_RUN

}  

}  

#endif