852 lines
28 KiB
C
852 lines
28 KiB
C
/*
|
|
** SPDX-License-Identifier: BSD-3-Clause
|
|
** Copyright Contributors to the OpenEXR Project.
|
|
*/
|
|
|
|
#ifndef OPENEXR_PART_H
|
|
#define OPENEXR_PART_H
|
|
|
|
#include "openexr_context.h"
|
|
|
|
#include "openexr_attr.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/** @file */
|
|
|
|
/**
|
|
* @defgroup PartInfo Part related definitions.
|
|
*
|
|
* A part is a separate entity in the OpenEXR file. This was
|
|
* formalized in the OpenEXR 2.0 timeframe to allow there to be a
|
|
* clear set of eyes for stereo, or just a simple list of AOVs within
|
|
* a single OpenEXR file. Prior, it was managed by name convention,
|
|
* but with a multi-part file, they are clearly separate types, and
|
|
* can have separate behavior.
|
|
*
|
|
* This is a set of functions to query, or set up when writing, that
|
|
* set of parts within a file. This remains backward compatible to
|
|
* OpenEXR files from before this change, in that a file with a single
|
|
* part is a subset of a multi-part file. As a special case, creating
|
|
* a file with a single part will write out as if it is a file which
|
|
* is not multi-part aware, so as to be compatible with those old
|
|
* libraries.
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
/** @brief Query how many parts are in the file. */
|
|
EXR_EXPORT exr_result_t exr_get_count (exr_const_context_t ctxt, int* count);
|
|
|
|
/** @brief Query the part name for the specified part.
|
|
*
|
|
* NB: If this file is a single part file and name has not been set, this
|
|
* will return `NULL`.
|
|
*/
|
|
EXR_EXPORT exr_result_t
|
|
exr_get_name (exr_const_context_t ctxt, int part_index, const char** out);
|
|
|
|
/** @brief Query the storage type for the specified part. */
|
|
EXR_EXPORT exr_result_t
|
|
exr_get_storage (exr_const_context_t ctxt, int part_index, exr_storage_t* out);
|
|
|
|
/** @brief Define a new part in the file. */
|
|
EXR_EXPORT exr_result_t exr_add_part (
|
|
exr_context_t ctxt,
|
|
const char* partname,
|
|
exr_storage_t type,
|
|
int* new_index);
|
|
|
|
/** @brief Query how many levels are in the specified part.
|
|
*
|
|
* If the part is a tiled part, fill in how many tile levels are present.
|
|
*
|
|
* Return `ERR_SUCCESS` on success, an error otherwise (i.e. if the part
|
|
* is not tiled).
|
|
*
|
|
* It is valid to pass `NULL` to either of the @p levelsx or @p levelsy
|
|
* arguments, which enables testing if this part is a tiled part, or
|
|
* if you don't need both (i.e. in the case of a mip-level tiled
|
|
* image)
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_get_tile_levels (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
int32_t* levelsx,
|
|
int32_t* levelsy);
|
|
|
|
/** @brief Query the tile size for a particular level in the specified part.
|
|
*
|
|
* If the part is a tiled part, fill in the tile size for the
|
|
* specified part/level.
|
|
*
|
|
* Return `ERR_SUCCESS` on success, an error otherwise (i.e. if the
|
|
* part is not tiled).
|
|
*
|
|
* It is valid to pass `NULL` to either of the @p tilew or @p tileh
|
|
* arguments, which enables testing if this part is a tiled part, or
|
|
* if you don't need both (i.e. in the case of a mip-level tiled
|
|
* image)
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_get_tile_sizes (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
int levelx,
|
|
int levely,
|
|
int32_t* tilew,
|
|
int32_t* tileh);
|
|
|
|
/** @brief Query the tile count for a particular level in the specified part.
|
|
*
|
|
* If the part is a tiled part, fills in the count for the
|
|
* specified levels.
|
|
*
|
|
* Return `ERR_SUCCESS` on success, an error otherwise (i.e. if the part
|
|
* is not tiled).
|
|
*
|
|
* It is valid to pass `NULL` to either of the @p countx or @p county
|
|
* arguments, which enables testing if this part is a tiled part, or
|
|
* if you don't need both for some reason.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_get_tile_counts (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
int levelx,
|
|
int levely,
|
|
int32_t* countx,
|
|
int32_t* county);
|
|
|
|
/** @brief Query the data sizes for a particular level in the specified part.
|
|
*
|
|
* If the part is a tiled part, fill in the width/height for the
|
|
* specified levels.
|
|
*
|
|
* Return `ERR_SUCCESS` on success, an error otherwise (i.e. if the part
|
|
* is not tiled).
|
|
*
|
|
* It is valid to pass `NULL` to either of the @p levw or @p levh
|
|
* arguments, which enables testing if this part is a tiled part, or
|
|
* if you don't need both for some reason.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_get_level_sizes (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
int levelx,
|
|
int levely,
|
|
int32_t* levw,
|
|
int32_t* levh);
|
|
|
|
/** Return the number of chunks contained in this part of the file.
|
|
*
|
|
* As in the technical documentation for OpenEXR, the chunk is the
|
|
* generic term for a pixel data block. This is the atomic unit that
|
|
* this library uses to negotiate data to and from a context.
|
|
*
|
|
* This should be used as a basis for splitting up how a file is
|
|
* processed. Depending on the compression, a different number of
|
|
* scanlines are encoded in each chunk, and since those need to be
|
|
* encoded/decoded as a block, the chunk should be the basis for I/O
|
|
* as well.
|
|
*/
|
|
EXR_EXPORT exr_result_t
|
|
exr_get_chunk_count (exr_const_context_t ctxt, int part_index, int32_t* out);
|
|
|
|
/** Return a pointer to the chunk table and the count
|
|
*
|
|
* TODO: consider removing this prior to release once C++ fully converted
|
|
*/
|
|
EXR_EXPORT exr_result_t
|
|
exr_get_chunk_table (exr_const_context_t ctxt, int part_index, uint64_t **table, int32_t* count);
|
|
|
|
/** Return whether the chunk table for this part is completely written.
|
|
*
|
|
* This only validates that all the offsets are valid.
|
|
*
|
|
* return EXR_ERR_INCOMPLETE_CHUNK_TABLE when incomplete, EXR_ERR_SUCCESS
|
|
* if it appears ok, or another error if otherwise problematic
|
|
*/
|
|
EXR_EXPORT exr_result_t
|
|
exr_validate_chunk_table (exr_context_t ctxt, int part_index);
|
|
|
|
/** Return the number of scanlines chunks for this file part.
|
|
*
|
|
* When iterating over a scanline file, this may be an easier metric
|
|
* for multi-threading or other access than only negotiating chunk
|
|
* counts, and so is provided as a utility.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_get_scanlines_per_chunk (
|
|
exr_const_context_t ctxt, int part_index, int32_t* out);
|
|
|
|
/** Return the maximum unpacked size of a chunk for the file part.
|
|
*
|
|
* This may be used ahead of any actual reading of data, so can be
|
|
* used to pre-allocate buffers for multiple threads in one block or
|
|
* whatever your application may require.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_get_chunk_unpacked_size (
|
|
exr_const_context_t ctxt, int part_index, uint64_t* out);
|
|
|
|
/** @brief Retrieve the zip compression level used for the specified part.
|
|
*
|
|
* This only applies when the compression method involves using zip
|
|
* compression (zip, zips, some modes of DWAA/DWAB).
|
|
*
|
|
* This value is NOT persisted in the file, and only exists for the
|
|
* lifetime of the context, so will be at the default value when just
|
|
* reading a file.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_get_zip_compression_level (
|
|
exr_const_context_t ctxt, int part_index, int* level);
|
|
|
|
/** @brief Set the zip compression method used for the specified part.
|
|
*
|
|
* This only applies when the compression method involves using zip
|
|
* compression (zip, zips, some modes of DWAA/DWAB).
|
|
*
|
|
* This value is NOT persisted in the file, and only exists for the
|
|
* lifetime of the context, so this value will be ignored when
|
|
* reading a file.
|
|
*/
|
|
EXR_EXPORT exr_result_t
|
|
exr_set_zip_compression_level (exr_context_t ctxt, int part_index, int level);
|
|
|
|
/** @brief Retrieve the dwa compression level used for the specified part.
|
|
*
|
|
* This only applies when the compression method is DWAA/DWAB.
|
|
*
|
|
* This value is NOT persisted in the file, and only exists for the
|
|
* lifetime of the context, so will be at the default value when just
|
|
* reading a file.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_get_dwa_compression_level (
|
|
exr_const_context_t ctxt, int part_index, float* level);
|
|
|
|
/** @brief Set the dwa compression method used for the specified part.
|
|
*
|
|
* This only applies when the compression method is DWAA/DWAB.
|
|
*
|
|
* This value is NOT persisted in the file, and only exists for the
|
|
* lifetime of the context, so this value will be ignored when
|
|
* reading a file.
|
|
*/
|
|
EXR_EXPORT exr_result_t
|
|
exr_set_dwa_compression_level (exr_context_t ctxt, int part_index, float level);
|
|
|
|
/**************************************/
|
|
|
|
/** @defgroup PartMetadata Functions to get and set metadata for a particular part.
|
|
* @{
|
|
*
|
|
*/
|
|
|
|
/** @brief Query the count of attributes in a part. */
|
|
EXR_EXPORT exr_result_t exr_get_attribute_count (
|
|
exr_const_context_t ctxt, int part_index, int32_t* count);
|
|
|
|
typedef enum exr_attr_list_access_mode
|
|
{
|
|
EXR_ATTR_LIST_FILE_ORDER, /**< Order they appear in the file */
|
|
EXR_ATTR_LIST_SORTED_ORDER /**< Alphabetically sorted */
|
|
} exr_attr_list_access_mode_t;
|
|
|
|
/** @brief Query a particular attribute by index. */
|
|
EXR_EXPORT exr_result_t exr_get_attribute_by_index (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
exr_attr_list_access_mode_t mode,
|
|
int32_t idx,
|
|
const exr_attribute_t** outattr);
|
|
|
|
/** @brief Query a particular attribute by name. */
|
|
EXR_EXPORT exr_result_t exr_get_attribute_by_name (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attribute_t** outattr);
|
|
|
|
/** @brief Query the list of attributes in a part.
|
|
*
|
|
* This retrieves a list of attributes currently defined in a part.
|
|
*
|
|
* If outlist is `NULL`, this function still succeeds, filling only the
|
|
* count. In this manner, the user can allocate memory for the list of
|
|
* attributes, then re-call this function to get the full list.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_get_attribute_list (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
exr_attr_list_access_mode_t mode,
|
|
int32_t* count,
|
|
const exr_attribute_t** outlist);
|
|
|
|
/** Declare an attribute within the specified part.
|
|
*
|
|
* Only valid when a file is opened for write.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_attr_declare_by_type (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const char* type,
|
|
exr_attribute_t** newattr);
|
|
|
|
/** @brief Declare an attribute within the specified part.
|
|
*
|
|
* Only valid when a file is opened for write.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_attr_declare (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attribute_type_t type,
|
|
exr_attribute_t** newattr);
|
|
|
|
/**
|
|
* @defgroup RequiredAttributeHelpers Required Attribute Utililities
|
|
*
|
|
* @brief These are a group of functions for attributes that are
|
|
* required to be in every part of every file.
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
/** @brief Initialize all required attributes for all files.
|
|
*
|
|
* NB: other file types do require other attributes, such as the tile
|
|
* description for a tiled file.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_initialize_required_attr (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const exr_attr_box2i_t* displayWindow,
|
|
const exr_attr_box2i_t* dataWindow,
|
|
float pixelaspectratio,
|
|
const exr_attr_v2f_t* screenWindowCenter,
|
|
float screenWindowWidth,
|
|
exr_lineorder_t lineorder,
|
|
exr_compression_t ctype);
|
|
|
|
/** @brief Initialize all required attributes to default values:
|
|
*
|
|
* - `displayWindow` is set to (0, 0 -> @p width - 1, @p height - 1)
|
|
* - `dataWindow` is set to (0, 0 -> @p width - 1, @p height - 1)
|
|
* - `pixelAspectRatio` is set to 1.0
|
|
* - `screenWindowCenter` is set to 0.f, 0.f
|
|
* - `screenWindowWidth` is set to 1.f
|
|
* - `lineorder` is set to `INCREASING_Y`
|
|
* - `compression` is set to @p ctype
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_initialize_required_attr_simple (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
int32_t width,
|
|
int32_t height,
|
|
exr_compression_t ctype);
|
|
|
|
/** @brief Copy the attributes from one part to another.
|
|
*
|
|
* This allows one to quickly unassigned attributes from one source to another.
|
|
*
|
|
* If an attribute in the source part has not been yet set in the
|
|
* destination part, the item will be copied over.
|
|
*
|
|
* For example, when you add a part, the storage type and name
|
|
* attributes are required arguments to the definition of a new part,
|
|
* but channels has not yet been assigned. So by calling this with an
|
|
* input file as the source, you can copy the channel definitions (and
|
|
* any other unassigned attributes from the source).
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_copy_unset_attributes (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
exr_const_context_t source,
|
|
int src_part_index);
|
|
|
|
/** @brief Retrieve the list of channels. */
|
|
EXR_EXPORT exr_result_t exr_get_channels (
|
|
exr_const_context_t ctxt, int part_index, const exr_attr_chlist_t** chlist);
|
|
|
|
/** @brief Define a new channel to the output file part.
|
|
*
|
|
* The @p percept parameter is used for lossy compression techniques
|
|
* to indicate that the value represented is closer to linear (1) or
|
|
* closer to logarithmic (0). For r, g, b, luminance, this is normally
|
|
* 0.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_add_channel (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_pixel_type_t ptype,
|
|
exr_perceptual_treatment_t percept,
|
|
int32_t xsamp,
|
|
int32_t ysamp);
|
|
|
|
/** @brief Copy the channels from another source.
|
|
*
|
|
* Useful if you are manually constructing the list or simply copying
|
|
* from an input file.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_set_channels (
|
|
exr_context_t ctxt, int part_index, const exr_attr_chlist_t* channels);
|
|
|
|
/** @brief Retrieve the compression method used for the specified part. */
|
|
EXR_EXPORT exr_result_t exr_get_compression (
|
|
exr_const_context_t ctxt, int part_index, exr_compression_t* compression);
|
|
/** @brief Set the compression method used for the specified part. */
|
|
EXR_EXPORT exr_result_t exr_set_compression (
|
|
exr_context_t ctxt, int part_index, exr_compression_t ctype);
|
|
|
|
/** @brief Retrieve the data window for the specified part. */
|
|
EXR_EXPORT exr_result_t exr_get_data_window (
|
|
exr_const_context_t ctxt, int part_index, exr_attr_box2i_t* out);
|
|
/** @brief Set the data window for the specified part. */
|
|
EXR_EXPORT int exr_set_data_window (
|
|
exr_context_t ctxt, int part_index, const exr_attr_box2i_t* dw);
|
|
|
|
/** @brief Retrieve the display window for the specified part. */
|
|
EXR_EXPORT exr_result_t exr_get_display_window (
|
|
exr_const_context_t ctxt, int part_index, exr_attr_box2i_t* out);
|
|
/** @brief Set the display window for the specified part. */
|
|
EXR_EXPORT int exr_set_display_window (
|
|
exr_context_t ctxt, int part_index, const exr_attr_box2i_t* dw);
|
|
|
|
/** @brief Retrieve the line order for storing data in the specified part (use 0 for single part images). */
|
|
EXR_EXPORT exr_result_t exr_get_lineorder (
|
|
exr_const_context_t ctxt, int part_index, exr_lineorder_t* out);
|
|
/** @brief Set the line order for storing data in the specified part (use 0 for single part images). */
|
|
EXR_EXPORT exr_result_t
|
|
exr_set_lineorder (exr_context_t ctxt, int part_index, exr_lineorder_t lo);
|
|
|
|
/** @brief Retrieve the pixel aspect ratio for the specified part (use 0 for single part images). */
|
|
EXR_EXPORT exr_result_t exr_get_pixel_aspect_ratio (
|
|
exr_const_context_t ctxt, int part_index, float* par);
|
|
/** @brief Set the pixel aspect ratio for the specified part (use 0 for single part images). */
|
|
EXR_EXPORT exr_result_t
|
|
exr_set_pixel_aspect_ratio (exr_context_t ctxt, int part_index, float par);
|
|
|
|
/** @brief Retrieve the screen oriented window center for the specified part (use 0 for single part images). */
|
|
EXR_EXPORT exr_result_t exr_get_screen_window_center (
|
|
exr_const_context_t ctxt, int part_index, exr_attr_v2f_t* wc);
|
|
/** @brief Set the screen oriented window center for the specified part (use 0 for single part images). */
|
|
EXR_EXPORT int exr_set_screen_window_center (
|
|
exr_context_t ctxt, int part_index, const exr_attr_v2f_t* wc);
|
|
|
|
/** @brief Retrieve the screen oriented window width for the specified part (use 0 for single part images). */
|
|
EXR_EXPORT exr_result_t exr_get_screen_window_width (
|
|
exr_const_context_t ctxt, int part_index, float* out);
|
|
/** @brief Set the screen oriented window width for the specified part (use 0 for single part images). */
|
|
EXR_EXPORT exr_result_t
|
|
exr_set_screen_window_width (exr_context_t ctxt, int part_index, float ssw);
|
|
|
|
/** @brief Retrieve the tiling info for a tiled part (use 0 for single part images). */
|
|
EXR_EXPORT exr_result_t exr_get_tile_descriptor (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
uint32_t* xsize,
|
|
uint32_t* ysize,
|
|
exr_tile_level_mode_t* level,
|
|
exr_tile_round_mode_t* round);
|
|
|
|
/** @brief Set the tiling info for a tiled part (use 0 for single part images). */
|
|
EXR_EXPORT exr_result_t exr_set_tile_descriptor (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
uint32_t x_size,
|
|
uint32_t y_size,
|
|
exr_tile_level_mode_t level_mode,
|
|
exr_tile_round_mode_t round_mode);
|
|
|
|
EXR_EXPORT exr_result_t
|
|
exr_set_name (exr_context_t ctxt, int part_index, const char* val);
|
|
|
|
EXR_EXPORT exr_result_t
|
|
exr_get_version (exr_const_context_t ctxt, int part_index, int32_t* out);
|
|
|
|
EXR_EXPORT exr_result_t
|
|
exr_set_version (exr_context_t ctxt, int part_index, int32_t val);
|
|
|
|
EXR_EXPORT exr_result_t
|
|
exr_set_chunk_count (exr_context_t ctxt, int part_index, int32_t val);
|
|
|
|
/** @} */ /* required attr group. */
|
|
|
|
/**
|
|
* @defgroup BuiltinAttributeHelpers Attribute utilities for builtin types
|
|
*
|
|
* @brief These are a group of functions for attributes that use the builtin types.
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_box2i (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_box2i_t* outval);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_box2i (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_box2i_t* val);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_box2f (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_box2f_t* outval);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_box2f (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_box2f_t* val);
|
|
|
|
/** @brief Zero-copy query of channel data.
|
|
*
|
|
* Do not free or manipulate the @p chlist data, or use
|
|
* after the lifetime of the context.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_attr_get_channels (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_chlist_t** chlist);
|
|
|
|
/** @brief This allows one to quickly copy the channels from one file
|
|
* to another.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_attr_set_channels (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_chlist_t* channels);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_chromaticities (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_chromaticities_t* chroma);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_chromaticities (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_chromaticities_t* chroma);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_compression (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_compression_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_compression (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_compression_t comp);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_double (
|
|
exr_const_context_t ctxt, int part_index, const char* name, double* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_double (
|
|
exr_context_t ctxt, int part_index, const char* name, double val);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_envmap (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_envmap_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_envmap (
|
|
exr_context_t ctxt, int part_index, const char* name, exr_envmap_t emap);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_float (
|
|
exr_const_context_t ctxt, int part_index, const char* name, float* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_float (
|
|
exr_context_t ctxt, int part_index, const char* name, float val);
|
|
|
|
/** @brief Zero-copy query of float data.
|
|
*
|
|
* Do not free or manipulate the @p out data, or use after the
|
|
* lifetime of the context.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_attr_get_float_vector (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
int32_t* sz,
|
|
const float** out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_float_vector (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
int32_t sz,
|
|
const float* vals);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_int (
|
|
exr_const_context_t ctxt, int part_index, const char* name, int32_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_int (
|
|
exr_context_t ctxt, int part_index, const char* name, int32_t val);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_keycode (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_keycode_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_keycode (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_keycode_t* kc);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_lineorder (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_lineorder_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_lineorder (
|
|
exr_context_t ctxt, int part_index, const char* name, exr_lineorder_t lo);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_m33f (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_m33f_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_m33f (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_m33f_t* m);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_m33d (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_m33d_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_m33d (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_m33d_t* m);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_m44f (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_m44f_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_m44f (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_m44f_t* m);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_m44d (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_m44d_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_m44d (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_m44d_t* m);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_preview (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_preview_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_preview (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_preview_t* p);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_rational (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_rational_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_rational (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_rational_t* r);
|
|
|
|
/** @brief Zero-copy query of string value.
|
|
*
|
|
* Do not modify the string pointed to by @p out, and do not use
|
|
* after the lifetime of the context.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_attr_get_string (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
int32_t* length,
|
|
const char** out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_string (
|
|
exr_context_t ctxt, int part_index, const char* name, const char* s);
|
|
|
|
/** @brief Zero-copy query of string data.
|
|
*
|
|
* Do not free the strings pointed to by the array.
|
|
*
|
|
* Must provide @p size.
|
|
*
|
|
* \p out must be a ``const char**`` array large enough to hold
|
|
* the string pointers for the string vector when provided.
|
|
*/
|
|
EXR_EXPORT exr_result_t exr_attr_get_string_vector (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
int32_t* size,
|
|
const char** out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_string_vector (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
int32_t size,
|
|
const char** sv);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_tiledesc (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_tiledesc_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_tiledesc (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_tiledesc_t* td);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_timecode (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_timecode_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_timecode (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_timecode_t* tc);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_v2i (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_v2i_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_v2i (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_v2i_t* v);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_v2f (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_v2f_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_v2f (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_v2f_t* v);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_v2d (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_v2d_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_v2d (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_v2d_t* v);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_v3i (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_v3i_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_v3i (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_v3i_t* v);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_v3f (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_v3f_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_v3f (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_v3f_t* v);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_v3d (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
exr_attr_v3d_t* out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_v3d (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const exr_attr_v3d_t* v);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_get_user (
|
|
exr_const_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const char** type,
|
|
int32_t* size,
|
|
const void** out);
|
|
|
|
EXR_EXPORT exr_result_t exr_attr_set_user (
|
|
exr_context_t ctxt,
|
|
int part_index,
|
|
const char* name,
|
|
const char* type,
|
|
int32_t size,
|
|
const void* out);
|
|
|
|
/** @} */ /* built-in attr group */
|
|
|
|
/** @} */ /* metadata group */
|
|
|
|
/** @} */ /* part group */
|
|
|
|
#ifdef __cplusplus
|
|
} /* extern "C" */
|
|
#endif
|
|
|
|
#endif /* OPENEXR_PART_H */
|