IMB_imbuf_types.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "DNA_vec_types.h" /* for rcti */
 
#include "BLI_sys_types.h"
 
#include "IMB_imbuf_enums.h"
 
struct ColormanageCache;
struct ColorSpace;
struct GPUTexture;
struct IDProperty;
 
#define IMB_MIPMAP_LEVELS 20
#define IMB_FILEPATH_SIZE 1024
 
#define OPENEXR_HALF (1 << 8)
/* careful changing this, it's used in DNA as well */
#define OPENEXR_COMPRESS (15)
 
#ifdef WITH_CINEON
#  define CINEON_LOG (1 << 8)
#  define CINEON_16BIT (1 << 7)
#  define CINEON_12BIT (1 << 6)
#  define CINEON_10BIT (1 << 5)
#endif
 
#ifdef WITH_OPENJPEG
#  define JP2_12BIT (1 << 9)
#  define JP2_16BIT (1 << 8)
#  define JP2_YCC (1 << 7)
#  define JP2_CINE (1 << 6)
#  define JP2_CINE_48FPS (1 << 5)
#  define JP2_JP2 (1 << 4)
#  define JP2_J2K (1 << 3)
#endif
 
#define PNG_16BIT (1 << 10)
 
#define RAWTGA 1
 
#define TIF_16BIT (1 << 8)
#define TIF_COMPRESS_NONE (1 << 7)
#define TIF_COMPRESS_DEFLATE (1 << 6)
#define TIF_COMPRESS_LZW (1 << 5)
#define TIF_COMPRESS_PACKBITS (1 << 4)
 
struct ImbFormatOptions {
  short flag;
  char quality;
};
 
/* -------------------------------------------------------------------- */
enum eImBufFlags {
  IB_rect = 1 << 0,
  IB_test = 1 << 1,
  IB_mem = 1 << 4,
  IB_rectfloat = 1 << 5,
  IB_multilayer = 1 << 7,
  IB_metadata = 1 << 8,
  IB_animdeinterlace = 1 << 9,
  IB_uninitialized_pixels = 1 << 10,
 
  IB_alphamode_premul = 1 << 12,
  IB_alphamode_detect = 1 << 13,
  /* alpha channel is unrelated to RGB and should not affect it */
  IB_alphamode_channel_packed = 1 << 14,
  IB_alphamode_ignore = 1 << 15,
  IB_thumbnail = 1 << 16,
  IB_multiview = 1 << 17,
  IB_halffloat = 1 << 18,
};
 
/* -------------------------------------------------------------------- */
/* Specialization of an ownership whenever a bare pointer is provided to the ImBuf buffers
 * assignment API. */
enum ImBufOwnership {
  /* The ImBuf simply shares pointer with data owned by someone else, and will not perform any
   * memory management when the ImBuf frees the buffer. */
  IB_DO_NOT_TAKE_OWNERSHIP = 0,
 
  /* The ImBuf takes ownership of the buffer data, and will use MEM_freeN() to free this memory
   * when the ImBuf needs to free the data. */
  IB_TAKE_OWNERSHIP = 1,
};
 
struct DDSData {
  unsigned int fourcc;
  unsigned int nummipmaps;
  unsigned char *data;
  unsigned int size;
  ImBufOwnership ownership;
};
 
/* Different storage specialization.
 *
 * NOTE: Avoid direct assignments and allocations, use the buffer utilities from the IMB_imbuf.hh
 * instead.
 *
 * Accessing the data pointer directly is fine and is an expected way of accessing it. */
 
struct ImBufByteBuffer {
  uint8_t *data;
  ImBufOwnership ownership;
 
  ColorSpace *colorspace;
};
 
struct ImBufFloatBuffer {
  float *data;
  ImBufOwnership ownership;
 
  ColorSpace *colorspace;
};
 
struct ImBufGPU {
  /* Texture which corresponds to the state of the ImBug on the GPU.
   *
   * Allocation is supposed to happen outside of the ImBug module from a proper GPU context.
   * De-referencing the ImBuf or its GPU texture can happen from any state. */
  /* TODO(sergey): This should become a list of textures, to support having high-res ImBuf on GPU
   * without hitting hardware limitations. */
  GPUTexture *texture;
};
 
/* -------------------------------------------------------------------- */
struct ImBuf {
  /* dimensions */
  int x, y;
 
  unsigned char planes;
  int channels;
 
  /* flags */
  int flags;
 
  /* pixels */
 
  ImBufByteBuffer byte_buffer;
 
  ImBufFloatBuffer float_buffer;
 
  /* Image buffer on the GPU. */
  ImBufGPU gpu;
 
  double ppm[2];
 
  /* parameters used by conversion between byte and float */
  float dither;
 
  /* mipmapping */
  ImBuf *mipmap[IMB_MIPMAP_LEVELS];
  int miptot, miplevel;
 
  /* externally used data */
  int index;
  int userflags;
  IDProperty *metadata;
  void *userdata;
 
  /* file information */
  enum eImbFileType ftype;
  ImbFormatOptions foptions;
  char filepath[IMB_FILEPATH_SIZE];
 
  /* memory cache limiter */
  int refcounter;
 
  /* some parameters to pass along for packing images */
  ImBufByteBuffer encoded_buffer;
  unsigned int encoded_size;
  unsigned int encoded_buffer_size;
 
  /* color management */
  unsigned int *display_buffer_flags;
  ColormanageCache *colormanage_cache;
  int colormanage_flag;
  rcti invalid_rect;
 
  /* information for compressed textures */
  DDSData dds_data;
};
 
enum {
  IB_BITMAPDIRTY = (1 << 1),
  IB_MIPMAP_INVALID = (1 << 2),
  IB_RECT_INVALID = (1 << 3),
  IB_DISPLAY_BUFFER_INVALID = (1 << 4),
  IB_PERSISTENT = (1 << 5),
};
 
/* -------------------------------------------------------------------- */
#define IB_PROFILE_NONE 0
#define IB_PROFILE_LINEAR_RGB 1
#define IB_PROFILE_SRGB 2
#define IB_PROFILE_CUSTOM 3
 
/* dds */
#ifndef DDS_MAKEFOURCC
#  define DDS_MAKEFOURCC(ch0, ch1, ch2, ch3) \
    ((unsigned long)(unsigned char)(ch0) | ((unsigned long)(unsigned char)(ch1) << 8) | \
     ((unsigned long)(unsigned char)(ch2) << 16) | ((unsigned long)(unsigned char)(ch3) << 24))
#endif /* DDS_MAKEFOURCC */
 
/*
 * FOURCC codes for DX compressed-texture pixel formats.
 */
 
#define FOURCC_DDS (DDS_MAKEFOURCC('D', 'D', 'S', ' '))
#define FOURCC_DX10 (DDS_MAKEFOURCC('D', 'X', '1', '0'))
#define FOURCC_DXT1 (DDS_MAKEFOURCC('D', 'X', 'T', '1'))
#define FOURCC_DXT2 (DDS_MAKEFOURCC('D', 'X', 'T', '2'))
#define FOURCC_DXT3 (DDS_MAKEFOURCC('D', 'X', 'T', '3'))
#define FOURCC_DXT4 (DDS_MAKEFOURCC('D', 'X', 'T', '4'))
#define FOURCC_DXT5 (DDS_MAKEFOURCC('D', 'X', 'T', '5'))
 
extern const char *imb_ext_image[];
extern const char *imb_ext_movie[];
extern const char *imb_ext_audio[];
 
/* -------------------------------------------------------------------- */
enum {
  IMB_COLORMANAGE_IS_DATA = (1 << 0),
};