image.h

Go to the documentation of this file.

#ifndef ION_GFX_IMAGE_H_
#define ION_GFX_IMAGE_H_

#include "base/integral_types.h"
#include "ion/base/datacontainer.h"
#include "ion/base/notifier.h"

namespace ion {
namespace gfx {

class Image;
typedef base::ReferentPtr<Image>::Type ImagePtr;

class ION_API Image : public base::Notifier {
 public:
  enum Format {
    kAlpha,             // Single-component alpha image, 8 bits per pixel.
    kLuminance,         // Single-component luminance image, 8 bits per pixel.
    kLuminanceAlpha,    // Two-component luminance+alpha image, 8 bits each.
    kRgb888,            // RGB color image, 8 bits each.
    kRgba8888,          // RGBA color image, 8 bits each.
    kRgb565,            // RGB color image, 5 bits red and blue, 6 bits green.
    kRgba4444,          // RGBA color+alpha image, 4 bits each.
    kRgba5551,          // RGBA color+alpha image, 5 bits per color, 1 bit
    kRgbaFloat,         // RGBA 32-bit floating point image (for OpenGL ES 2.0

    kR8,                // Float image, 8-bits red.
    kRSigned8,          // Float image, 8-bits red, signed data.
    kR8i,               // Integer image, 8-bits red.
    kR8ui,              // Integer image, 8-bits red.
    kR16fFloat,         // Float image, 16-bits red, 32-bit float data.
    kR16fHalf,          // Float image, 16-bits red, 16-bit half float data.
    kR16i,              // Integer image, 16-bits red.
    kR16ui,             // Integer image, 16-bits red.
    kR32f,              // Float image, 32-bits red.
    kR32i,              // Integer image, 32-bits red.
    kR32ui,             // Integer image, 32-bits red.

    kRg8,               // Float image, 8-bits each component.
    kRgSigned8,         // Float image, 8-bits each component, signed data.
    kRg8i,              // Integer image, 8-bits each component.
    kRg8ui,             // Integer image, 8-bits each component.
    kRg16fFloat,        // Float image, 16-bits each component, float data.
    kRg16fHalf,         // Float image, 16-bits each component, half float data.
    kRg16i,             // Integer image, 16-bits each component.
    kRg16ui,            // Integer image, 16-bits each component.
    kRg32f,             // Float image, 32-bits each component.
    kRg32i,             // Integer image, 32-bits each component.
    kRg32ui,            // Integer image, 32-bits each component.

    kRgb8,              // Float image, 8-bits each component.
    kRgbSigned8,        // Float image, 8-bits each component, signed data.
    kRgb8i,             // Integer image, 8-bits each component, signed data.
    kRgb8ui,            // Integer image, 8-bits each component.
    kRgb16fFloat,       // Float image, 16-bits each component, float data.
    kRgb16fHalf,        // Float image, 16-bits each component, half float data.
    kRgb16i,            // Integer image, 16-bits each component, signed data.
    kRgb16ui,           // Integer image, 16-bits each component.
    kRgb32f,            // float image, 32-bits each component.
    kRgb32i,            // Integer image, 32-bits each component, signed data.
    kRgb32ui,           // Integer image, 32-bits each component.

    kRgba8,             // Float image, 8-bits each component.
    kRgbaSigned8,       // Float image, 8-bits each component, signed data.
    kRgba8i,            // Integer image, 8-bits each component, signed data.
    kRgba8ui,           // Integer image, 8-bits each component.
    kRgb10a2,           // Float image, 10 bits per color, 2 bits alpha.
    kRgb10a2ui,         // Integer image, 10 bits per color, 2 bits alpha.
    kRgba16fFloat,      // Float image, 16-bits each component, float data.
    kRgba16fHalf,       // Float image, 16-bits each component, half float data.
    kRgba16i,           // Integer image, 16-bits each component, signed data.
    kRgba16ui,          // Integer image, 16-bits each component.
    kRgba32f,           // Float image, 32-bits each component.
    kRgba32i,           // Integer image, 32-bits each component, signed data.
    kRgba32ui,          // Integer image, 32-bits each component.

    kRenderbufferDepth16,           // Depth rb, 16-bit depth.
    kRenderbufferDepth24,           // Depth rb, 24-bit depth.
    kRenderbufferDepth32f,          // Depth rb, 32-bit float depth.
    kRenderbufferDepth24Stencil8,   // Depth stencil rb, 24-bit depth, 8-bit
    kRenderbufferDepth32fStencil8,  // Depth stencil rb, 32-bit float depth,
                                     8-bit stencil.

    kTextureDepth16Int,        // Depth image, 16-bit depth, uint32 data.
    kTextureDepth16Short,      // Depth image, 16-bit depth, uint16 data.

    kStencil8,          // Stencil image, 8-bits

    kDxt1,              // DXT1-compressed image (no alpha).
    kDxt1Rgba,          // DXT1-compressed image (1 bit alpha).
    kDxt5,              // DXT5-compressed image (with alpha).
    kEtc1,              // ETC1-compressed image (no alpha).
    kPvrtc1Rgb2,        // PVRTC1-compressed image (2 bits per pixel, no alpha).
    kPvrtc1Rgb4,        // PVRTC1-compressed image (4 bits per pixel, no alpha).
    kPvrtc1Rgba2,       // PVRTC1-compressed image (2 bits per pixel, with
    kPvrtc1Rgba4,       // PVRTC1-compressed image (4 bits per pixel, with

    kSrgb8,             // Float image, 8-bits each component.
    kSrgba8,            // Float image, 8-bits each component.

    kRgb11f_11f_10f_Rev,       // RGB color image, 10 bits red and green, 11
    kRgb11f_11f_10f_RevFloat,  // RGB color image, 10 bits red and green, 11
    kRgb11f_11f_10f_RevHalf,   // RGB color image, 10 bits red and green, 11
    kRgb565Byte,               // RGB color image, 5 bits red and blue, 6 bits
    kRgb565Short,              // RGB color image, 5 bits red and blue, 6 bits
    kRgb5a1Byte,               // RGBA color+alpha image, 5 bits per color, 1
    kRgb5a1Short,              // RGBA color+alpha image, 5 bits per color, 1
    kRgb5a1Int,                // RGBA color+alpha image, 5 bits per color, 1
    kRgb9e5Float,              // RGB color+alpha image, 9 bits per color, 5
    kRgb9e5Half,               // RGB color+alpha image, 9 bits per color, 5
    kRgb9e5RevInt,             // RGB color+alpha image, 9 bits per color, 5
    kRgba4Byte,                // RGBA color+alpha image, 4 bits each, uint8
    kRgba4Short,               // RGBA color+alpha image, 4 bits each, packed

    kEglImage,                 // A texture backed by an EGLImage, which may

    kInvalid                   // An invalid format.
  };

  enum Type {
    kArray,
    kDense,
    kEgl,
    kExternalEgl,
  };

  enum Dimensions {
    k2d,
    k3d
  };

  struct PixelFormat {
    uint32 internal_format;
    uint32 format;
    uint32 type;
  };

  static const uint32 kNumFormats;

  Image();

  void Set(Format format, uint32 width, uint32 height,
           const base::DataContainerPtr& data);
  void Set(Format format, uint32 width, uint32 height, uint32 depth,
           const base::DataContainerPtr& data);

  void SetArray(Format format, uint32 width, uint32 num_planes,
                const base::DataContainerPtr& data);
  void SetArray(Format format, uint32 width, uint32 height, uint32 num_planes,
                const base::DataContainerPtr& data);

  void SetEglImage(const base::DataContainerPtr& image);

  void SetExternalEglImage(const base::DataContainerPtr& external_image);

  Format GetFormat() const { return format_; }
  Type GetType() const { return type_; }
  Dimensions GetDimensions() const { return dims_; }
  uint32 GetWidth() const { return width_; }
  uint32 GetHeight() const { return height_; }
  uint32 GetDepth() const { return depth_; }
  size_t GetDataSize() const { return data_size_; }
  const base::DataContainerPtr& GetData() const { return data_; }

  bool IsCompressed() const { return IsCompressedFormat(format_); }

  static const char* GetFormatString(Format format);

  static const PixelFormat& GetPixelFormat(Format format);

  static int GetNumComponentsForFormat(Format format);

  static bool IsCompressedFormat(Format format);
  static bool Is8BitPerChannelFormat(Format format);

  static size_t ComputeDataSize(Format format, uint32 width, uint32 height);
  static size_t ComputeDataSize(Format format, uint32 width, uint32 height,
                                uint32 depth);

 protected:
  ~Image() override;

 private:
  void OnNotify(const base::Notifier* notifier) override {
    if (notifier == data_.Get())
      Notify();
  }

  void SetData(Type type, Dimensions dims, Format format, uint32 width,
               uint32 height, uint32 depth, const base::DataContainerPtr& data);

  Format format_;
  uint32 width_;
  uint32 height_;
  uint32 depth_;
  size_t data_size_;
  Type type_;
  Dimensions dims_;
  base::DataContainerPtr data_;
};

inline bool Image::IsCompressedFormat(Image::Format format) {
  return format == kDxt1 || format == kDxt1Rgba || format == kDxt5 ||
         format == kEtc1 || format == kPvrtc1Rgb2 || format == kPvrtc1Rgb4 ||
         format == kPvrtc1Rgba2 || format == kPvrtc1Rgba4;
}

inline bool Image::Is8BitPerChannelFormat(Image::Format format) {
  if (format == Image::kRgb5a1Int ||
      format == Image::kRgb10a2 ||
      format == Image::kRgb10a2ui ||
      format == Image::kEglImage ||
      format == Image::kInvalid) {
    return false;
  }
  size_t bytes_per_pixel = Image::ComputeDataSize(format, 1, 1);
  size_t channels = Image::GetNumComponentsForFormat(format);
  return channels == bytes_per_pixel;
}

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_IMAGE_H_