?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/OpenEXR.zip
???????
PK �!�[��� � OpenEXRConfig.cmakenu �[��� ####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### ####### Any changes to this file will be overwritten by the next CMake run #### ####### The input file was OpenEXRConfig.cmake.in ######## get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) # Use original install prefix when loaded through a "/usr move" # cross-prefix symbolic link such as /lib -> /usr/lib. get_filename_component(_realCurr "${CMAKE_CURRENT_LIST_DIR}" REALPATH) get_filename_component(_realOrig "/usr/lib64/cmake/OpenEXR" REALPATH) if(_realCurr STREQUAL _realOrig) set(PACKAGE_PREFIX_DIR "/usr") endif() unset(_realOrig) unset(_realCurr) macro(set_and_check _var _file) set(${_var} "${_file}") if(NOT EXISTS "${_file}") message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") endif() endmacro() macro(check_required_components _NAME) foreach(comp ${${_NAME}_FIND_COMPONENTS}) if(NOT ${_NAME}_${comp}_FOUND) if(${_NAME}_FIND_REQUIRED_${comp}) set(${_NAME}_FOUND FALSE) endif() endif() endforeach() endmacro() #################################################################################### include(CMakeFindDependencyMacro) if (ON) find_dependency(Threads REQUIRED) endif() find_dependency(ZLIB REQUIRED) find_dependency(Imath REQUIRED) include("${CMAKE_CURRENT_LIST_DIR}/OpenEXRTargets.cmake") check_required_components("OpenEXR") PK �!�[f� c� � OpenEXRTargets.cmakenu �[��� # Generated by CMake if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) message(FATAL_ERROR "CMake >= 2.8.0 required") endif() if(CMAKE_VERSION VERSION_LESS "2.8.3") message(FATAL_ERROR "CMake >= 2.8.3 required") endif() cmake_policy(PUSH) cmake_policy(VERSION 2.8.3...3.24) #---------------------------------------------------------------- # Generated CMake target import file. #---------------------------------------------------------------- # Commands may need to know the format version. set(CMAKE_IMPORT_FILE_VERSION 1) # Protect against multiple inclusion, which would fail when already imported targets are added once more. set(_cmake_targets_defined "") set(_cmake_targets_not_defined "") set(_cmake_expected_targets "") foreach(_cmake_expected_target IN ITEMS OpenEXR::OpenEXRConfig OpenEXR::IexConfig OpenEXR::IlmThreadConfig OpenEXR::Iex OpenEXR::IlmThread OpenEXR::OpenEXRCore OpenEXR::OpenEXR OpenEXR::OpenEXRUtil) list(APPEND _cmake_expected_targets "${_cmake_expected_target}") if(TARGET "${_cmake_expected_target}") list(APPEND _cmake_targets_defined "${_cmake_expected_target}") else() list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") endif() endforeach() unset(_cmake_expected_target) if(_cmake_targets_defined STREQUAL _cmake_expected_targets) unset(_cmake_targets_defined) unset(_cmake_targets_not_defined) unset(_cmake_expected_targets) unset(CMAKE_IMPORT_FILE_VERSION) cmake_policy(POP) return() endif() if(NOT _cmake_targets_defined STREQUAL "") string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") endif() unset(_cmake_targets_defined) unset(_cmake_targets_not_defined) unset(_cmake_expected_targets) # Compute the installation prefix relative to this file. get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) # Use original install prefix when loaded through a # cross-prefix symbolic link such as /lib -> /usr/lib. get_filename_component(_realCurr "${_IMPORT_PREFIX}" REALPATH) get_filename_component(_realOrig "/usr/lib64/cmake/OpenEXR" REALPATH) if(_realCurr STREQUAL _realOrig) set(_IMPORT_PREFIX "/usr/lib64/cmake/OpenEXR") endif() unset(_realOrig) unset(_realCurr) get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) if(_IMPORT_PREFIX STREQUAL "/") set(_IMPORT_PREFIX "") endif() # Create imported target OpenEXR::OpenEXRConfig add_library(OpenEXR::OpenEXRConfig INTERFACE IMPORTED) set_target_properties(OpenEXR::OpenEXRConfig PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include;${_IMPORT_PREFIX}/include/OpenEXR" ) # Create imported target OpenEXR::IexConfig add_library(OpenEXR::IexConfig INTERFACE IMPORTED) set_target_properties(OpenEXR::IexConfig PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include;${_IMPORT_PREFIX}/include/OpenEXR" ) # Create imported target OpenEXR::IlmThreadConfig add_library(OpenEXR::IlmThreadConfig INTERFACE IMPORTED) set_target_properties(OpenEXR::IlmThreadConfig PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include;${_IMPORT_PREFIX}/include/OpenEXR" ) # Create imported target OpenEXR::Iex add_library(OpenEXR::Iex SHARED IMPORTED) set_target_properties(OpenEXR::Iex PROPERTIES INTERFACE_COMPILE_FEATURES "cxx_std_11" INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" INTERFACE_LINK_LIBRARIES "OpenEXR::IlmThreadConfig;OpenEXR::IlmThreadConfig" ) # Create imported target OpenEXR::IlmThread add_library(OpenEXR::IlmThread SHARED IMPORTED) set_target_properties(OpenEXR::IlmThread PROPERTIES INTERFACE_COMPILE_FEATURES "cxx_std_11" INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" INTERFACE_LINK_LIBRARIES "OpenEXR::IlmThreadConfig;OpenEXR::IlmThreadConfig;OpenEXR::Iex;Threads::Threads" ) # Create imported target OpenEXR::OpenEXRCore add_library(OpenEXR::OpenEXRCore SHARED IMPORTED) set_target_properties(OpenEXR::OpenEXRCore PROPERTIES INTERFACE_COMPILE_FEATURES "cxx_std_11" INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" INTERFACE_LINK_LIBRARIES "OpenEXR::IlmThreadConfig;ZLIB::ZLIB" ) # Create imported target OpenEXR::OpenEXR add_library(OpenEXR::OpenEXR SHARED IMPORTED) set_target_properties(OpenEXR::OpenEXR PROPERTIES INTERFACE_COMPILE_FEATURES "cxx_std_11" INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" INTERFACE_LINK_LIBRARIES "OpenEXR::IlmThreadConfig;Imath::Imath;OpenEXR::IlmThreadConfig;OpenEXR::Iex;OpenEXR::IlmThread;ZLIB::ZLIB" ) # Create imported target OpenEXR::OpenEXRUtil add_library(OpenEXR::OpenEXRUtil SHARED IMPORTED) set_target_properties(OpenEXR::OpenEXRUtil PROPERTIES INTERFACE_COMPILE_FEATURES "cxx_std_11" INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" INTERFACE_LINK_LIBRARIES "OpenEXR::IlmThreadConfig;OpenEXR::OpenEXR" ) if(CMAKE_VERSION VERSION_LESS 3.0.0) message(FATAL_ERROR "This file relies on consumers using CMake 3.0.0 or greater.") endif() # Load information for each installed configuration. file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/OpenEXRTargets-*.cmake") foreach(_cmake_config_file IN LISTS _cmake_config_files) include("${_cmake_config_file}") endforeach() unset(_cmake_config_file) unset(_cmake_config_files) # Cleanup temporary variables. set(_IMPORT_PREFIX) # Loop over all imported files and verify that they actually exist foreach(_cmake_target IN LISTS _cmake_import_check_targets) foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") if(NOT EXISTS "${_cmake_file}") message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file \"${_cmake_file}\" but this file does not exist. Possible reasons include: * The file was deleted, renamed, or moved to another location. * An install or uninstall procedure did not complete successfully. * The installation package was faulty and contained \"${CMAKE_CURRENT_LIST_FILE}\" but not all the files it references. ") endif() endforeach() unset(_cmake_file) unset("_cmake_import_check_files_for_${_cmake_target}") endforeach() unset(_cmake_target) unset(_cmake_import_check_targets) # This file does not depend on other imported targets which have # been exported from the same project but in a separate export set. # Commands beyond this point should not need to know the version. set(CMAKE_IMPORT_FILE_VERSION) cmake_policy(POP) PK �!�[C�@�� � OpenEXRTargets-release.cmakenu �[��� #---------------------------------------------------------------- # Generated CMake target import file for configuration "Release". #---------------------------------------------------------------- # Commands may need to know the format version. set(CMAKE_IMPORT_FILE_VERSION 1) # Import target "OpenEXR::Iex" for configuration "Release" set_property(TARGET OpenEXR::Iex APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) set_target_properties(OpenEXR::Iex PROPERTIES IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libIex-3_1.so.30.1.0" IMPORTED_SONAME_RELEASE "libIex-3_1.so.30" ) list(APPEND _cmake_import_check_targets OpenEXR::Iex ) list(APPEND _cmake_import_check_files_for_OpenEXR::Iex "${_IMPORT_PREFIX}/lib64/libIex-3_1.so.30.1.0" ) # Import target "OpenEXR::IlmThread" for configuration "Release" set_property(TARGET OpenEXR::IlmThread APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) set_target_properties(OpenEXR::IlmThread PROPERTIES IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libIlmThread-3_1.so.30.1.0" IMPORTED_SONAME_RELEASE "libIlmThread-3_1.so.30" ) list(APPEND _cmake_import_check_targets OpenEXR::IlmThread ) list(APPEND _cmake_import_check_files_for_OpenEXR::IlmThread "${_IMPORT_PREFIX}/lib64/libIlmThread-3_1.so.30.1.0" ) # Import target "OpenEXR::OpenEXRCore" for configuration "Release" set_property(TARGET OpenEXR::OpenEXRCore APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) set_target_properties(OpenEXR::OpenEXRCore PROPERTIES IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libOpenEXRCore-3_1.so.30.1.0" IMPORTED_SONAME_RELEASE "libOpenEXRCore-3_1.so.30" ) list(APPEND _cmake_import_check_targets OpenEXR::OpenEXRCore ) list(APPEND _cmake_import_check_files_for_OpenEXR::OpenEXRCore "${_IMPORT_PREFIX}/lib64/libOpenEXRCore-3_1.so.30.1.0" ) # Import target "OpenEXR::OpenEXR" for configuration "Release" set_property(TARGET OpenEXR::OpenEXR APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) set_target_properties(OpenEXR::OpenEXR PROPERTIES IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libOpenEXR-3_1.so.30.1.0" IMPORTED_SONAME_RELEASE "libOpenEXR-3_1.so.30" ) list(APPEND _cmake_import_check_targets OpenEXR::OpenEXR ) list(APPEND _cmake_import_check_files_for_OpenEXR::OpenEXR "${_IMPORT_PREFIX}/lib64/libOpenEXR-3_1.so.30.1.0" ) # Import target "OpenEXR::OpenEXRUtil" for configuration "Release" set_property(TARGET OpenEXR::OpenEXRUtil APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) set_target_properties(OpenEXR::OpenEXRUtil PROPERTIES IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libOpenEXRUtil-3_1.so.30.1.0" IMPORTED_SONAME_RELEASE "libOpenEXRUtil-3_1.so.30" ) list(APPEND _cmake_import_check_targets OpenEXR::OpenEXRUtil ) list(APPEND _cmake_import_check_files_for_OpenEXR::OpenEXRUtil "${_IMPORT_PREFIX}/lib64/libOpenEXRUtil-3_1.so.30.1.0" ) # Commands beyond this point should not need to know the version. set(CMAKE_IMPORT_FILE_VERSION) PK �!�[��)�� � OpenEXRConfigVersion.cmakenu �[��� # This is a basic version file for the Config-mode of find_package(). # It is used by write_basic_package_version_file() as input file for configure_file() # to create a version-file which can be installed along a config.cmake file. # # The created file sets PACKAGE_VERSION_EXACT if the current version string and # the requested version string are exactly the same and it sets # PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version, # but only if the requested major version is the same as the current one. # The variable CVF_VERSION must be set before calling configure_file(). set(PACKAGE_VERSION "3.1.1") if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) set(PACKAGE_VERSION_COMPATIBLE FALSE) else() if("3.1.1" MATCHES "^([0-9]+)\\.") set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}") if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0) string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}") endif() else() set(CVF_VERSION_MAJOR "3.1.1") endif() if(PACKAGE_FIND_VERSION_RANGE) # both endpoints of the range must have the expected major version math (EXPR CVF_VERSION_MAJOR_NEXT "${CVF_VERSION_MAJOR} + 1") if (NOT PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX_MAJOR STREQUAL CVF_VERSION_MAJOR) OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX VERSION_LESS_EQUAL CVF_VERSION_MAJOR_NEXT))) set(PACKAGE_VERSION_COMPATIBLE FALSE) elseif(PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR AND ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS_EQUAL PACKAGE_FIND_VERSION_MAX) OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MAX))) set(PACKAGE_VERSION_COMPATIBLE TRUE) else() set(PACKAGE_VERSION_COMPATIBLE FALSE) endif() else() if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR) set(PACKAGE_VERSION_COMPATIBLE TRUE) else() set(PACKAGE_VERSION_COMPATIBLE FALSE) endif() if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) set(PACKAGE_VERSION_EXACT TRUE) endif() endif() endif() # if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") return() endif() # check that the installed version has the same 32/64bit-ness as the one which is currently searching: if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") math(EXPR installedBits "8 * 8") set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") set(PACKAGE_VERSION_UNSUITABLE TRUE) endif() PK rM�[�L��Z Z ImfExport.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMFEXPORT_H #define INCLUDED_IMFEXPORT_H #include "OpenEXRConfig.h" /// \addtogroup ExportMacros /// @{ // are we making a DLL under windows (might be msvc or mingw or others) #if defined(OPENEXR_DLL) // when building as a DLL for windows, typical dllexport / import case // where we need to switch depending on whether we are compiling // internally or not # if defined(OPENEXR_EXPORTS) # define IMF_EXPORT __declspec(dllexport) // mingw needs the export when the extern is defined # if defined(__MINGW32__) # define IMF_EXPORT_EXTERN_TEMPLATE IMF_EXPORT # define IMF_EXPORT_TEMPLATE_INSTANCE // for mingw windows, we need to cause this to export the // typeinfo tables (but you don't need to have the // complementary import, because might be a local template too!) # define IMF_EXPORT_TEMPLATE_TYPE IMF_EXPORT # else // for normal msvc, need to export the actual instantiation in // the cpp code, and none of the others # define IMF_EXPORT_EXTERN_TEMPLATE # define IMF_EXPORT_TEMPLATE_INSTANCE IMF_EXPORT # define IMF_EXPORT_TEMPLATE_TYPE # endif # else // OPENEXR_EXPORTS # define IMF_EXPORT __declspec(dllimport) # define IMF_EXPORT_EXTERN_TEMPLATE IMF_EXPORT # define IMF_EXPORT_TEMPLATE_INSTANCE # define IMF_EXPORT_TEMPLATE_TYPE # endif // DLLs don't support these types of visibility controls, just leave them as empty # define IMF_EXPORT_TYPE # define IMF_EXPORT_ENUM # define IMF_HIDDEN #else // not an OPENEXR_DLL // just pass these through from the top level config # define IMF_EXPORT OPENEXR_EXPORT # define IMF_HIDDEN OPENEXR_HIDDEN # define IMF_EXPORT_ENUM OPENEXR_EXPORT_ENUM # define IMF_EXPORT_TYPE OPENEXR_EXPORT_TYPE # define IMF_EXPORT_TEMPLATE_TYPE OPENEXR_EXPORT_TEMPLATE_TYPE # define IMF_EXPORT_EXTERN_TEMPLATE OPENEXR_EXPORT_EXTERN_TEMPLATE # define IMF_EXPORT_TEMPLATE_INSTANCE OPENEXR_EXPORT_TEMPLATE_INSTANCE #endif // OPENEXR_DLL /// @} #endif // INCLUDED_IMFEXPORT_H PK rM�[�"�n[) [) ImfSampleCountChannel.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_SAMPLE_COUNT_CHANNEL_H #define INCLUDED_IMF_SAMPLE_COUNT_CHANNEL_H //---------------------------------------------------------------------------- // // class SampleCountChannel // // For an explanation of images, levels and channels, // see the comments in header file Image.h. // //---------------------------------------------------------------------------- #include "ImfUtilExport.h" #include "ImfImageChannel.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class DeepImageLevel; // // Sample count channel for a deep image level: // // Each deep image level has a number of samples channel. For each // pixel location (x,y) within the data window of the level, the sample // count channel stores a single integer, n(x,y). A deep channel, c, // in the level as the sample count channel stores n(x,y) samples at // location (x,y) if // // x % c.xSampling() == 0 and y % c.ySampling() == 0. // // The deep channel stores no samples at location (x,y) if // // x % c.xSampling() != 0 or y % c.ySampling() != 0, // class IMFUTIL_EXPORT_TYPE SampleCountChannel : public ImageChannel { public: // // The OpenEXR pixel type of this channel (HALF, FLOAT or UINT). // IMFUTIL_EXPORT virtual PixelType pixelType () const; // // Construct an OpenEXR frame buffer slice for this channel. // This function is needed reading an image from an OpenEXR // file and for saving an image in an OpenEXR file. // IMFUTIL_EXPORT Slice slice () const; // // Access to the image level to which this channel belongs. // IMFUTIL_EXPORT DeepImageLevel & deepLevel (); IMFUTIL_EXPORT const DeepImageLevel & deepLevel () const; // // Access to n(x,y), without bounds checking. Accessing a location // outside the data window of the image level results in undefined // behavior. // IMFUTIL_EXPORT const unsigned int & operator () (int x, int y) const; // // Access to n(x,y), with bounds checking. Accessing a location outside // the data window of the image level throws an Iex::ArgExc exception. // IMFUTIL_EXPORT const unsigned int & at (int x, int y) const; // // Faster access to n(x,y) for all pixels in a single horizontal row of // the channel. Rows are numbered from 0 to pixelsPerColumn()-1, and // each row contains pixelsPerRow() values. // Access is not bounds checked; accessing out of bounds rows or pixels // results in undefined behavior. // IMFUTIL_EXPORT const unsigned int * row (int r) const; // // Change the sample counts in one or more pixels: // // set(x,y,m) sets n(x,y) to m. // // set(r,m) sets n(x,y) for all pixels in row r according to the // values in array m. The array must contain pixelsPerRow() // entries, and the row number must be in the range from 0 // to pixelsPerColumn()-1. // // clear() sets n(x,y) to 0 for all pixels within the data window // of the level. // // If the sample count for a pixel is increased, then new samples are // appended at the end of the sample list of each deep channel. The // new samples are initialized to zero. If the sample count in a pixel // is decreased, then sample list of each deep channel is truncated by // discarding samples at the end of the list. // // Access is bounds-checked; attempting to set the number of samples of // a pixel outside the data window throws an Iex::ArgExc exception. // // Memory allocation for the sample lists is not particularly clever; // repeatedly increasing and decreasing the number of samples in the // pixels of a level is likely to result in serious memory fragmentation. // // Setting the number of samples for one or more pixels may cause the // program to run out of memory. If this happens, the image is resized // to zero by zero pixels and an exception is thrown. Note that the // resizing operation deletes this sample count channel and the image // level to which it belongs. // IMFUTIL_EXPORT void set(int x, int y, unsigned int newNumSamples); IMFUTIL_EXPORT void set(int r, unsigned int newNumSamples[]); IMFUTIL_EXPORT void clear(); // // OpenEXR file reading support / make sample counts editable: // // beginEdit() frees all memory that has been allocated for samples // in the deep channels, and returns a pointer to an // array of pixelsPerRow() by pixelsPerColumn() sample // counts in row-major order. // // After beginEdit() returns, application code is // free to change the values in the sample count array. // In particular, the application can fill the array by // reading the sample counts from an OpenEXR file. // // However, since memory for the samples in the deep // channels has been freed, attempting to access any // sample in a deep channel results in undefined // behavior, most likely a program crash. // // endEdit() allocates new memory for all samples in the deep // channels of the layer, according to the current // sample counts, and sets the samples to zero. // // Application code must take make sure that each call to beginEdit() // is followed by a corresponding endEdit() call, even if an // exception occurs while the sample counts are acessed. In order to // do that, application code may want to create a temporary Edit // object instead of calling beginEdit() and endEdit() directly. // // Setting the number of samples for all pixels in the image may // cause the program to run out of memory. If this happens, the image // is resized to zero by zero pixels and an exception is thrown. // Note that the resizing operation deletes this sample count channel // and the image level to which it belongs. // IMFUTIL_EXPORT unsigned int * beginEdit(); IMFUTIL_EXPORT void endEdit(); class Edit { public: // // Constructor calls level->beginEdit(), // destructor calls level->endEdit(). // IMFUTIL_EXPORT Edit (SampleCountChannel& level); IMFUTIL_EXPORT ~Edit (); Edit (const Edit& other) = delete; Edit& operator = (const Edit& other) = delete; Edit (Edit&& other) = delete; Edit& operator = (Edit&& other) = delete; // // Access to the writable sample count array. // IMFUTIL_EXPORT unsigned int * sampleCounts () const; private: SampleCountChannel & _channel; unsigned int * _sampleCounts; }; // // Functions that support the implementation of deep image channels. // IMFUTIL_EXPORT const unsigned int * numSamples () const; IMFUTIL_EXPORT const unsigned int * sampleListSizes () const; IMFUTIL_EXPORT const size_t * sampleListPositions () const; IMFUTIL_EXPORT size_t sampleBufferSize () const; private: friend class DeepImageLevel; // // The constructor and destructor are not public because // image channels exist only as parts of a deep image level. // SampleCountChannel (DeepImageLevel &level); virtual ~SampleCountChannel(); virtual void resize (); void resetBasePointer (); unsigned int * _numSamples; // Array of per-pixel sample counts unsigned int * _base; // Base pointer for faster access // to entries in _numSamples unsigned int * _sampleListSizes; // Array of allocated sizes of // per-pixel sample lists size_t * _sampleListPositions; // Array of positions of per-pixel // sample lists within sample list // buffer size_t _totalNumSamples; // Sum of all entries in the // _numSamples array size_t _totalSamplesOccupied; // Total number of samples within // sample list buffer that have // either been allocated for sample // lists or lost to fragmentation size_t _sampleBufferSize; // Size of the sample list buffer. }; //----------------------------------------------------------------------------- // Implementation of templates and inline functions //----------------------------------------------------------------------------- inline SampleCountChannel::Edit::Edit (SampleCountChannel &channel): _channel (channel), _sampleCounts (channel.beginEdit()) { // empty } inline SampleCountChannel::Edit::~Edit () { _channel.endEdit(); } inline unsigned int * SampleCountChannel::Edit::sampleCounts () const { return _sampleCounts; } inline const unsigned int * SampleCountChannel::numSamples () const { return _numSamples; } inline const unsigned int * SampleCountChannel::sampleListSizes () const { return _sampleListSizes; } inline const size_t * SampleCountChannel::sampleListPositions () const { return _sampleListPositions; } inline size_t SampleCountChannel::sampleBufferSize () const { return _sampleBufferSize; } inline const unsigned int & SampleCountChannel::operator () (int x, int y) const { return _base[y * pixelsPerRow() + x]; } inline const unsigned int & SampleCountChannel::at (int x, int y) const { boundsCheck (x, y); return _base[y * pixelsPerRow() + x]; } inline const unsigned int * SampleCountChannel::row (int n) const { return _base + n * pixelsPerRow(); } OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[~��@ @ ImfLineOrderAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_LINE_ORDER_ATTRIBUTE_H #define INCLUDED_IMF_LINE_ORDER_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class LineOrderAttribute // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" #include "ImfLineOrder.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER using LineOrderAttribute = TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::LineOrder>; #ifndef COMPILING_IMF_LINE_ORDER_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::LineOrder>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[If�o o ImfImageChannelRenaming.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_IMAGE_CHANNEL_RENAMING_H #define INCLUDED_IMF_IMAGE_CHANNEL_RENAMING_H //---------------------------------------------------------------------------- // // typedef RenamingMap, // helper functions for image channel renaming. // //---------------------------------------------------------------------------- #include "ImfNamespace.h" #include <string> #include <map> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER // // Given a map from old channel names to new channel names, // rename the channels in an image or image level. // This function assumes that the channel old-to-new-names // map has already been checked for collisions. // typedef std::map <std::string, std::string> RenamingMap; template <class ChannelMap> inline void renameChannelsInMap (const RenamingMap &oldToNewNames, ChannelMap &channels) { ChannelMap renamedChannels; for (typename ChannelMap::const_iterator i = channels.begin(); i != channels.end(); ++i) { RenamingMap::const_iterator j = oldToNewNames.find (i->first); std::string newName = (j == oldToNewNames.end())? i->first: j->second; renamedChannels[newName] = i->second; } channels = renamedChannels; } OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[ �qD� � ImfBoxAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_BOX_ATTRIBUTE_H #define INCLUDED_IMF_BOX_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class Box2iAttribute // class Box2fAttribute // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" #include <ImathBox.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER using Box2iAttribute = TypedAttribute<IMATH_NAMESPACE::Box2i>; using Box2fAttribute = TypedAttribute<IMATH_NAMESPACE::Box2f>; #ifndef COMPILING_IMF_BOX_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<IMATH_NAMESPACE::Box2i>; extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<IMATH_NAMESPACE::Box2f>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[a�� � ImfDoubleAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_DOUBLE_ATTRIBUTE_H #define INCLUDED_IMF_DOUBLE_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class DoubleAttribute // //----------------------------------------------------------------------------- #include "ImfAttribute.h" #include "ImfExport.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<double> DoubleAttribute; #ifndef COMPILING_IMF_DOUBLE_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<double>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�aD�� � ImfDeepScanLineOutputFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_DEEP_SCAN_LINE_OUTPUT_FILE_H #define INCLUDED_IMF_DEEP_SCAN_LINE_OUTPUT_FILE_H //----------------------------------------------------------------------------- // // class DeepScanLineOutputFile // //----------------------------------------------------------------------------- #include "ImfHeader.h" #include "ImfFrameBuffer.h" #include "ImfThreading.h" #include "ImfGenericOutputFile.h" #include "ImfNamespace.h" #include "ImfForward.h" #include "ImfExport.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER struct PreviewRgba; class DeepScanLineOutputFile : public GenericOutputFile { public: //----------------------------------------------------------- // Constructor -- opens the file and writes the file header. // The file header is also copied into the DeepScanLineOutputFile // object, and can later be accessed via the header() method. // Destroying this DeepScanLineOutputFile object automatically closes // the file. // // numThreads determines the number of threads that will be // used to write the file (see ImfThreading.h). //----------------------------------------------------------- IMF_EXPORT DeepScanLineOutputFile (const char fileName[], const Header &header, int numThreads = globalThreadCount()); //------------------------------------------------------------ // Constructor -- attaches the new DeepScanLineOutputFile object // to a file that has already been opened, and writes the file header. // The file header is also copied into the DeepScanLineOutputFile // object, and can later be accessed via the header() method. // Destroying this DeepScanLineOutputFile object does not automatically // close the file. // // numThreads determines the number of threads that will be // used to write the file (see ImfThreading.h). //------------------------------------------------------------ IMF_EXPORT DeepScanLineOutputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, const Header &header, int numThreads = globalThreadCount()); //------------------------------------------------- // Destructor // // Destroying the DeepScanLineOutputFile object // before writing all scan lines within the data // window results in an incomplete file. //------------------------------------------------- IMF_EXPORT virtual ~DeepScanLineOutputFile (); //------------------------ // Access to the file name //------------------------ IMF_EXPORT const char * fileName () const; //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; //------------------------------------------------------- // Set the current frame buffer -- copies the FrameBuffer // object into the OutputFile object. // // The current frame buffer is the source of the pixel // data written to the file. The current frame buffer // must be set at least once before writePixels() is // called. The current frame buffer can be changed // after each call to writePixels. //------------------------------------------------------- IMF_EXPORT void setFrameBuffer (const DeepFrameBuffer &frameBuffer); //----------------------------------- // Access to the current frame buffer //----------------------------------- IMF_EXPORT const DeepFrameBuffer & frameBuffer () const; //------------------------------------------------------------------- // Write pixel data: // // writePixels(n) retrieves the next n scan lines worth of data from // the current frame buffer, starting with the scan line indicated by // currentScanLine(), and stores the data in the output file, and // progressing in the direction indicated by header.lineOrder(). // // To produce a complete and correct file, exactly m scan lines must // be written, where m is equal to // header().dataWindow().max.y - header().dataWindow().min.y + 1. //------------------------------------------------------------------- IMF_EXPORT void writePixels (int numScanLines = 1); //------------------------------------------------------------------ // Access to the current scan line: // // currentScanLine() returns the y coordinate of the first scan line // that will be read from the current frame buffer during the next // call to writePixels(). // // If header.lineOrder() == INCREASING_Y: // // The current scan line before the first call to writePixels() // is header().dataWindow().min.y. After writing each scan line, // the current scan line is incremented by 1. // // If header.lineOrder() == DECREASING_Y: // // The current scan line before the first call to writePixels() // is header().dataWindow().max.y. After writing each scan line, // the current scan line is decremented by 1. // //------------------------------------------------------------------ IMF_EXPORT int currentScanLine () const; //-------------------------------------------------------------- // Shortcut to copy all pixels from an InputFile into this file, // without uncompressing and then recompressing the pixel data. // This file's header must be compatible with the InputFile's // header: The two header's "dataWindow", "compression", // "lineOrder" and "channels" attributes must be the same. //-------------------------------------------------------------- IMF_EXPORT void copyPixels (DeepScanLineInputFile &in); // -------------------------------------------------------------- // Shortcut to copy pixels from a given part of a multipart file // -------------------------------------------------------------- IMF_EXPORT void copyPixels (DeepScanLineInputPart &in); //-------------------------------------------------------------- // Updating the preview image: // // updatePreviewImage() supplies a new set of pixels for the // preview image attribute in the file's header. If the header // does not contain a preview image, updatePreviewImage() throws // an IEX_NAMESPACE::LogicExc. // // Note: updatePreviewImage() is necessary because images are // often stored in a file incrementally, a few scan lines at a // time, while the image is being generated. Since the preview // image is an attribute in the file's header, it gets stored in // the file as soon as the file is opened, but we may not know // what the preview image should look like until we have written // the last scan line of the main image. // //-------------------------------------------------------------- IMF_EXPORT void updatePreviewImage (const PreviewRgba newPixels[]); struct Data; private: //------------------------------------------------------------ // Constructor -- attaches the OutputStreamMutex to the // given one from MultiPartOutputFile. Set the previewPosition // and lineOffsetsPosition which have been acquired from // the constructor of MultiPartOutputFile as well. //------------------------------------------------------------ DeepScanLineOutputFile (const OutputPartData* part); DeepScanLineOutputFile (const DeepScanLineOutputFile &) = delete; DeepScanLineOutputFile & operator = (const DeepScanLineOutputFile &) = delete; DeepScanLineOutputFile (DeepScanLineOutputFile &&) = delete; DeepScanLineOutputFile & operator = (DeepScanLineOutputFile &&) = delete; void initialize (const Header &header); void initializeLineBuffer(); Data * _data; friend class MultiPartOutputFile; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[��z� � ImfIntAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_INT_ATTRIBUTE_H #define INCLUDED_IMF_INT_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class IntAttribute // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<int> IntAttribute; #ifndef COMPILING_IMF_INT_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<int>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[ � �: �: ImfXdr.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_XDR_H #define INCLUDED_IMF_XDR_H //---------------------------------------------------------------------------- // // Xdr -- routines to convert data between the machine's native // format and a machine-independent external data representation: // // write<R> (T &o, S v); converts a value, v, of type S // into a machine-independent // representation and stores the // result in an output buffer, o. // // read<R> (T &i, S &v); reads the machine-independent // representation of a value of type // S from input buffer i, converts // the value into the machine's native // representation, and stores the result // in v. // // size<S>(); returns the size, in bytes, of the // machine-independent representation // of an object of type S. // // The write() and read() routines are templates; data can be written // to and read from any output or input buffer type T for which a helper // class, R, exits. Class R must define a method to store a char array // in a T, and a method to read a char array from a T: // // struct R // { // static void // writeChars (T &o, const char c[/*n*/], int n) // { // ... // Write c[0], c[1] ... c[n-1] to output buffer o. // } // // static void // readChars (T &i, char c[/*n*/], int n) // { // ... // Read n characters from input buffer i // // and copy them to c[0], c[1] ... c[n-1]. // } // }; // // Example - writing to and reading from iostreams: // // struct CharStreamIO // { // static void // writeChars (ostream &os, const char c[], int n) // { // os.write (c, n); // } // // static void // readChars (istream &is, char c[], int n) // { // is.read (c, n); // } // }; // // ... // // Xdr::write<CharStreamIO> (os, 3); // Xdr::write<CharStreamIO> (os, 5.0); // //---------------------------------------------------------------------------- #include "ImfNamespace.h" #include "IexMathExc.h" #include <half.h> #include <limits.h> #include <cstdint> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER namespace Xdr { //------------------------------- // Write data to an output stream //------------------------------- template <class S, class T> void write (T &out, bool v); template <class S, class T> void write (T &out, char v); template <class S, class T> void write (T &out, signed char v); template <class S, class T> void write (T &out, unsigned char v); template <class S, class T> void write (T &out, signed short v); template <class S, class T> void write (T &out, unsigned short v); template <class S, class T> void write (T &out, signed int v); template <class S, class T> void write (T &out, unsigned int v); template <class S, class T> void write (T &out, int64_t v); template <class S, class T> void write (T &out, uint64_t v); template <class S, class T> void write (T &out, float v); template <class S, class T> void write (T &out, double v); template <class S, class T> void write (T &out, half v); template <class S, class T> void write (T &out, const char v[/*n*/], int n); // fixed-size char array template <class S, class T> void write (T &out, const char v[]); // zero-terminated string //----------------------------------------- // Append padding bytes to an output stream //----------------------------------------- template <class S, class T> void pad (T &out, int n); // write n padding bytes //------------------------------- // Read data from an input stream //------------------------------- template <class S, class T> void read (T &in, bool &v); template <class S, class T> void read (T &in, char &v); template <class S, class T> void read (T &in, signed char &v); template <class S, class T> void read (T &in, unsigned char &v); template <class S, class T> void read (T &in, signed short &v); template <class S, class T> void read (T &in, unsigned short &v); template <class S, class T> void read (T &in, signed int &v); template <class S, class T> void read (T &in, unsigned int &v); template <class S, class T> void read (T &in, int64_t &v); template <class S, class T> void read (T &in, uint64_t &v); template <class S, class T> void read (T &in, float &v); template <class S, class T> void read (T &in, double &v); template <class S, class T> void read (T &in, half &v); template <class S, class T> void read (T &in, char v[/*n*/], int n); // fixed-size char array template <class S, class T> void read (T &in, int n, char v[/*n*/]); // zero-terminated string //------------------------------------------- // Skip over padding bytes in an input stream //------------------------------------------- template <class S, class T> void skip (T &in, int n); // skip n padding bytes //-------------------------------------- // Size of the machine-independent // representation of an object of type S //-------------------------------------- template <class S> int size (); //--------------- // Implementation //--------------- template <class S, class T> inline void writeSignedChars (T &out, const signed char c[], int n) { S::writeChars (out, (const char *) c, n); } template <class S, class T> inline void writeUnsignedChars (T &out, const unsigned char c[], int n) { S::writeChars (out, (const char *) c, n); } template <class S, class T> inline void readSignedChars (T &in, signed char c[], int n) { S::readChars (in, (char *) c, n); } template <class S, class T> inline void readUnsignedChars (T &in, unsigned char c[], int n) { S::readChars (in, (char *) c, n); } template <class S, class T> inline void write (T &out, bool v) { char c = !!v; S::writeChars (out, &c, 1); } template <class S, class T> inline void write (T &out, char v) { S::writeChars (out, &v, 1); } template <class S, class T> inline void write (T &out, signed char v) { writeSignedChars<S> (out, &v, 1); } template <class S, class T> inline void write (T &out, unsigned char v) { writeUnsignedChars<S> (out, &v, 1); } template <class S, class T> void write (T &out, signed short v) { signed char b[2]; b[0] = (signed char) (v); b[1] = (signed char) (v >> 8); writeSignedChars<S> (out, b, 2); } template <class S, class T> void write (T &out, unsigned short v) { unsigned char b[2]; b[0] = (unsigned char) (v); b[1] = (unsigned char) (v >> 8); writeUnsignedChars<S> (out, b, 2); } template <class S, class T> void write (T &out, signed int v) { signed char b[4]; b[0] = (signed char) (v); b[1] = (signed char) (v >> 8); b[2] = (signed char) (v >> 16); b[3] = (signed char) (v >> 24); writeSignedChars<S> (out, b, 4); } template <class S, class T> void write (T &out, unsigned int v) { unsigned char b[4]; b[0] = (unsigned char) (v); b[1] = (unsigned char) (v >> 8); b[2] = (unsigned char) (v >> 16); b[3] = (unsigned char) (v >> 24); writeUnsignedChars<S> (out, b, 4); } template <class S, class T> void write (T &out, int64_t v) { signed char b[8]; b[0] = (signed char) (v); b[1] = (signed char) (v >> 8); b[2] = (signed char) (v >> 16); b[3] = (signed char) (v >> 24); b[4] = (signed char) (v >> 32); b[5] = (signed char) (v >> 40); b[6] = (signed char) (v >> 48); b[7] = (signed char) (v >> 56); writeSignedChars<S> (out, b, 8); } template <class S, class T> void write (T &out, uint64_t v) { unsigned char b[8]; b[0] = (unsigned char) (v); b[1] = (unsigned char) (v >> 8); b[2] = (unsigned char) (v >> 16); b[3] = (unsigned char) (v >> 24); b[4] = (unsigned char) (v >> 32); b[5] = (unsigned char) (v >> 40); b[6] = (unsigned char) (v >> 48); b[7] = (unsigned char) (v >> 56); writeUnsignedChars<S> (out, b, 8); } template <class S, class T> void write (T &out, float v) { union {unsigned int i; float f;} u; u.f = v; unsigned char b[4]; b[0] = (unsigned char) (u.i); b[1] = (unsigned char) (u.i >> 8); b[2] = (unsigned char) (u.i >> 16); b[3] = (unsigned char) (u.i >> 24); writeUnsignedChars<S> (out, b, 4); } template <class S, class T> void write (T &out, double v) { union {uint64_t i; double d;} u; u.d = v; unsigned char b[8]; b[0] = (unsigned char) (u.i); b[1] = (unsigned char) (u.i >> 8); b[2] = (unsigned char) (u.i >> 16); b[3] = (unsigned char) (u.i >> 24); b[4] = (unsigned char) (u.i >> 32); b[5] = (unsigned char) (u.i >> 40); b[6] = (unsigned char) (u.i >> 48); b[7] = (unsigned char) (u.i >> 56); writeUnsignedChars<S> (out, b, 8); } template <class S, class T> inline void write (T &out, half v) { unsigned char b[2]; b[0] = (unsigned char) (v.bits()); b[1] = (unsigned char) (v.bits() >> 8); writeUnsignedChars<S> (out, b, 2); } template <class S, class T> inline void write (T &out, const char v[], int n) // fixed-size char array { S::writeChars (out, v, n); } template <class S, class T> void write (T &out, const char v[]) // zero-terminated string { while (*v) { S::writeChars (out, v, 1); ++v; } S::writeChars (out, v, 1); } template <class S, class T> void pad (T &out, int n) // add n padding bytes { for (int i = 0; i < n; i++) { const char c = 0; S::writeChars (out, &c, 1); } } template <class S, class T> inline void read (T &in, bool &v) { char c; S::readChars (in, &c, 1); v = !!c; } template <class S, class T> inline void read (T &in, char &v) { S::readChars (in, &v, 1); } template <class S, class T> inline void read (T &in, signed char &v) { readSignedChars<S> (in, &v, 1); } template <class S, class T> inline void read (T &in, unsigned char &v) { readUnsignedChars<S> (in, &v, 1); } template <class S, class T> void read (T &in, signed short &v) { signed char b[2]; readSignedChars<S> (in, b, 2); v = (static_cast <unsigned char> (b[0]) & 0x00ff) | (static_cast <unsigned char> (b[1]) << 8); } template <class S, class T> void read (T &in, unsigned short &v) { unsigned char b[2]; readUnsignedChars<S> (in, b, 2); v = (b[0] & 0x00ff) | (b[1] << 8); } template <class S, class T> void read (T &in, signed int &v) { signed char b[4]; readSignedChars<S> (in, b, 4); v = (static_cast <unsigned char> (b[0]) & 0x000000ff) | ((static_cast <unsigned char> (b[1]) << 8) & 0x0000ff00) | ((static_cast <unsigned char> (b[2]) << 16) & 0x00ff0000) | (static_cast <unsigned char> (b[3]) << 24); } template <class S, class T> void read (T &in, unsigned int &v) { unsigned char b[4]; readUnsignedChars<S> (in, b, 4); v = (b[0] & 0x000000ff) | ((b[1] << 8) & 0x0000ff00) | ((b[2] << 16) & 0x00ff0000) | (b[3] << 24); } template <class S, class T> void read (T &in, int64_t &v) { signed char b[8]; readSignedChars<S> (in, b, 8); v = (static_cast <int64_t> (b[0]) & 0x00000000000000ff) | ((static_cast <int64_t> (b[1]) << 8) & 0x000000000000ff00) | ((static_cast <int64_t> (b[2]) << 16) & 0x0000000000ff0000) | ((static_cast <int64_t> (b[3]) << 24) & 0x00000000ff000000) | ((static_cast <int64_t> (b[4]) << 32) & 0x000000ff00000000) | ((static_cast <int64_t> (b[5]) << 40) & 0x0000ff0000000000) | ((static_cast <int64_t> (b[6]) << 48) & 0x00ff000000000000) | (static_cast <int64_t> (b[7]) << 56); } template <class S, class T> void read (T &in, uint64_t &v) { unsigned char b[8]; readUnsignedChars<S> (in, b, 8); v = ((uint64_t) b[0] & 0x00000000000000ffLL) | (((uint64_t) b[1] << 8) & 0x000000000000ff00LL) | (((uint64_t) b[2] << 16) & 0x0000000000ff0000LL) | (((uint64_t) b[3] << 24) & 0x00000000ff000000LL) | (((uint64_t) b[4] << 32) & 0x000000ff00000000LL) | (((uint64_t) b[5] << 40) & 0x0000ff0000000000LL) | (((uint64_t) b[6] << 48) & 0x00ff000000000000LL) | ((uint64_t) b[7] << 56); } template <class S, class T> void read (T &in, float &v) { unsigned char b[4]; readUnsignedChars<S> (in, b, 4); union {unsigned int i; float f;} u; u.i = (b[0] & 0x000000ff) | ((b[1] << 8) & 0x0000ff00) | ((b[2] << 16) & 0x00ff0000) | (b[3] << 24); v = u.f; } template <class S, class T> void read (T &in, double &v) { unsigned char b[8]; readUnsignedChars<S> (in, b, 8); union {uint64_t i; double d;} u; u.i = ((uint64_t) b[0] & 0x00000000000000ffULL) | (((uint64_t) b[1] << 8) & 0x000000000000ff00ULL) | (((uint64_t) b[2] << 16) & 0x0000000000ff0000ULL) | (((uint64_t) b[3] << 24) & 0x00000000ff000000ULL) | (((uint64_t) b[4] << 32) & 0x000000ff00000000ULL) | (((uint64_t) b[5] << 40) & 0x0000ff0000000000ULL) | (((uint64_t) b[6] << 48) & 0x00ff000000000000ULL) | ((uint64_t) b[7] << 56); v = u.d; } template <class S, class T> inline void read (T &in, half &v) { unsigned char b[2]; readUnsignedChars<S> (in, b, 2); v.setBits ((b[0] & 0x00ff) | (b[1] << 8)); } template <class S, class T> inline void read (T &in, char v[], int n) // fixed-size char array { S::readChars (in, v, n); } template <class S, class T> void read (T &in, int n, char v[]) // zero-terminated string { while (n >= 0) { S::readChars (in, v, 1); if (*v == 0) break; --n; ++v; } } template <class S, class T> void skip (T &in, int n) // skip n padding bytes { char c[1024]; while (n >= (int) sizeof (c)) { if (!S::readChars (in, c, sizeof (c))) return; n -= sizeof (c); } if (n >= 1) S::readChars (in, c, n); } template <> inline int size <bool> () {return 1;} template <> inline int size <char> () {return 1;} template <> inline int size <signed char> () {return 1;} template <> inline int size <unsigned char> () {return 1;} template <> inline int size <signed short> () {return 2;} template <> inline int size <unsigned short> () {return 2;} template <> inline int size <signed int> () {return 4;} template <> inline int size <unsigned int> () {return 4;} template <> inline int size <signed long> () {return 8;} template <> inline int size <unsigned long> () {return 8;} template <> inline int size <unsigned long long> () {return 8;} template <> inline int size <float> () {return 4;} template <> inline int size <double> () {return 8;} template <> inline int size <half> () {return 2;} } // namespace Xdr OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #if defined (OPENEXR_IMF_INTERNAL_NAMESPACE_AUTO_EXPOSE) namespace Imf{using namespace OPENEXR_IMF_INTERNAL_NAMESPACE;} #endif #endif PK rM�[z�xU�> �> ImfTiledRgbaFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_TILED_RGBA_FILE_H #define INCLUDED_IMF_TILED_RGBA_FILE_H //----------------------------------------------------------------------------- // // Simplified RGBA image I/O for tiled files // // class TiledRgbaOutputFile // class TiledRgbaInputFile // //----------------------------------------------------------------------------- #include "ImfForward.h" #include "ImfCompression.h" #include "ImfLineOrder.h" #include "ImfTileDescription.h" #include "ImfRgba.h" #include "ImfThreading.h" #include <ImathVec.h> #include <ImathBox.h> #include <half.h> #include <string> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER // // Tiled RGBA output file. // class IMF_EXPORT_TYPE TiledRgbaOutputFile { public: //--------------------------------------------------- // Constructor -- rgbaChannels, tileXSize, tileYSize, // levelMode, and levelRoundingMode overwrite the // channel list and tile description attribute in the // header that is passed as an argument to the // constructor. //--------------------------------------------------- IMF_EXPORT TiledRgbaOutputFile (const char name[], const Header &header, RgbaChannels rgbaChannels, int tileXSize, int tileYSize, LevelMode mode, LevelRoundingMode rmode = ROUND_DOWN, int numThreads = globalThreadCount ()); //--------------------------------------------------- // Constructor -- like the previous one, but the new // TiledRgbaOutputFile is attached to a file that has // already been opened by the caller. Destroying // TiledRgbaOutputFileObjects constructed with this // constructor does not automatically close the // corresponding files. //--------------------------------------------------- IMF_EXPORT TiledRgbaOutputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, const Header &header, RgbaChannels rgbaChannels, int tileXSize, int tileYSize, LevelMode mode, LevelRoundingMode rmode = ROUND_DOWN, int numThreads = globalThreadCount ()); //------------------------------------------------------ // Constructor -- header data are explicitly specified // as function call arguments (an empty dataWindow means // "same as displayWindow") //------------------------------------------------------ IMF_EXPORT TiledRgbaOutputFile (const char name[], int tileXSize, int tileYSize, LevelMode mode, LevelRoundingMode rmode, const IMATH_NAMESPACE::Box2i &displayWindow, const IMATH_NAMESPACE::Box2i &dataWindow = IMATH_NAMESPACE::Box2i(), RgbaChannels rgbaChannels = WRITE_RGBA, float pixelAspectRatio = 1, const IMATH_NAMESPACE::V2f screenWindowCenter = IMATH_NAMESPACE::V2f (0, 0), float screenWindowWidth = 1, LineOrder lineOrder = INCREASING_Y, Compression compression = ZIP_COMPRESSION, int numThreads = globalThreadCount ()); //----------------------------------------------- // Constructor -- like the previous one, but both // the display window and the data window are // Box2i (V2i (0, 0), V2i (width - 1, height -1)) //----------------------------------------------- IMF_EXPORT TiledRgbaOutputFile (const char name[], int width, int height, int tileXSize, int tileYSize, LevelMode mode, LevelRoundingMode rmode = ROUND_DOWN, RgbaChannels rgbaChannels = WRITE_RGBA, float pixelAspectRatio = 1, const IMATH_NAMESPACE::V2f screenWindowCenter = IMATH_NAMESPACE::V2f (0, 0), float screenWindowWidth = 1, LineOrder lineOrder = INCREASING_Y, Compression compression = ZIP_COMPRESSION, int numThreads = globalThreadCount ()); IMF_EXPORT virtual ~TiledRgbaOutputFile (); //------------------------------------------------ // Define a frame buffer as the pixel data source: // Pixel (x, y) is at address // // base + x * xStride + y * yStride // //------------------------------------------------ IMF_EXPORT void setFrameBuffer (const Rgba *base, size_t xStride, size_t yStride); //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; IMF_EXPORT const FrameBuffer & frameBuffer () const; IMF_EXPORT const IMATH_NAMESPACE::Box2i & displayWindow () const; IMF_EXPORT const IMATH_NAMESPACE::Box2i & dataWindow () const; IMF_EXPORT float pixelAspectRatio () const; IMF_EXPORT const IMATH_NAMESPACE::V2f screenWindowCenter () const; IMF_EXPORT float screenWindowWidth () const; IMF_EXPORT LineOrder lineOrder () const; IMF_EXPORT Compression compression () const; IMF_EXPORT RgbaChannels channels () const; //---------------------------------------------------- // Utility functions (same as in Imf::TiledOutputFile) //---------------------------------------------------- IMF_EXPORT unsigned int tileXSize () const; IMF_EXPORT unsigned int tileYSize () const; IMF_EXPORT LevelMode levelMode () const; IMF_EXPORT LevelRoundingMode levelRoundingMode () const; IMF_EXPORT int numLevels () const; IMF_EXPORT int numXLevels () const; IMF_EXPORT int numYLevels () const; IMF_EXPORT bool isValidLevel (int lx, int ly) const; IMF_EXPORT int levelWidth (int lx) const; IMF_EXPORT int levelHeight (int ly) const; IMF_EXPORT int numXTiles (int lx = 0) const; IMF_EXPORT int numYTiles (int ly = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int lx, int ly) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int lx, int ly) const; //------------------------------------------------------------------ // Write pixel data: // // writeTile(dx, dy, lx, ly) writes the tile with tile // coordinates (dx, dy), and level number (lx, ly) to // the file. // // dx must lie in the interval [0, numXTiles(lx)-1] // dy must lie in the interval [0, numYTiles(ly)-1] // // lx must lie in the interval [0, numXLevels()-1] // ly must lie in the inverval [0, numYLevels()-1] // // writeTile(dx, dy, level) is a convenience function // used for ONE_LEVEL and MIPMAP_LEVEL files. It calls // writeTile(dx, dy, level, level). // // The two writeTiles(dx1, dx2, dy1, dy2, ...) functions allow // writing multiple tiles at once. If multi-threading is used // multiple tiles are written concurrently. // // Pixels that are outside the pixel coordinate range for the tile's // level, are never accessed by writeTile(). // // Each tile in the file must be written exactly once. // //------------------------------------------------------------------ IMF_EXPORT void writeTile (int dx, int dy, int l = 0); IMF_EXPORT void writeTile (int dx, int dy, int lx, int ly); IMF_EXPORT void writeTiles (int dxMin, int dxMax, int dyMin, int dyMax, int lx, int ly); IMF_EXPORT void writeTiles (int dxMin, int dxMax, int dyMin, int dyMax, int l = 0); // ------------------------------------------------------------------------- // Update the preview image (see Imf::TiledOutputFile::updatePreviewImage()) // ------------------------------------------------------------------------- IMF_EXPORT void updatePreviewImage (const PreviewRgba[]); //------------------------------------------------ // Break a tile -- for testing and debugging only // (see Imf::TiledOutputFile::breakTile()) // // Warning: Calling this function usually results // in a broken image file. The file or parts of // it may not be readable, or the file may contain // bad data. // //------------------------------------------------ IMF_EXPORT void breakTile (int dx, int dy, int lx, int ly, int offset, int length, char c); private: // // Copy constructor and assignment are not implemented // TiledRgbaOutputFile (const TiledRgbaOutputFile &) = delete; TiledRgbaOutputFile & operator = (const TiledRgbaOutputFile &) = delete; TiledRgbaOutputFile (TiledRgbaOutputFile &&) = delete; TiledRgbaOutputFile & operator = (TiledRgbaOutputFile &&) = delete; class IMF_HIDDEN ToYa; TiledOutputFile * _outputFile; ToYa * _toYa; }; // // Tiled RGBA input file // class IMF_EXPORT_TYPE TiledRgbaInputFile { public: //-------------------------------------------------------- // Constructor -- opens the file with the specified name. // Destroying TiledRgbaInputFile objects constructed with // this constructor automatically closes the corresponding // files. //-------------------------------------------------------- IMF_EXPORT TiledRgbaInputFile (const char name[], int numThreads = globalThreadCount ()); //------------------------------------------------------- // Constructor -- attaches the new TiledRgbaInputFile // object to a file that has already been opened by the // caller. // Destroying TiledRgbaInputFile objects constructed with // this constructor does not automatically close the // corresponding files. //------------------------------------------------------- IMF_EXPORT TiledRgbaInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int numThreads = globalThreadCount ()); //------------------------------------------------------------ // Constructors -- the same as the previous two, but the names // of the red, green, blue, alpha, and luminance channels are // expected to be layerName.R, layerName.G, etc. //------------------------------------------------------------ IMF_EXPORT TiledRgbaInputFile (const char name[], const std::string &layerName, int numThreads = globalThreadCount()); IMF_EXPORT TiledRgbaInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, const std::string &layerName, int numThreads = globalThreadCount()); //----------- // Destructor //----------- IMF_EXPORT virtual ~TiledRgbaInputFile (); //----------------------------------------------------- // Define a frame buffer as the pixel data destination: // Pixel (x, y) is at address // // base + x * xStride + y * yStride // //----------------------------------------------------- IMF_EXPORT void setFrameBuffer (Rgba *base, size_t xStride, size_t yStride); //------------------------------------------------------------------- // Switch to a different layer -- subsequent calls to readTile() // and readTiles() will read channels layerName.R, layerName.G, etc. // After each call to setLayerName(), setFrameBuffer() must be called // at least once before the next call to readTile() or readTiles(). //------------------------------------------------------------------- IMF_EXPORT void setLayerName (const std::string &layerName); //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; IMF_EXPORT const FrameBuffer & frameBuffer () const; IMF_EXPORT const IMATH_NAMESPACE::Box2i & displayWindow () const; IMF_EXPORT const IMATH_NAMESPACE::Box2i & dataWindow () const; IMF_EXPORT float pixelAspectRatio () const; IMF_EXPORT const IMATH_NAMESPACE::V2f screenWindowCenter () const; IMF_EXPORT float screenWindowWidth () const; IMF_EXPORT LineOrder lineOrder () const; IMF_EXPORT Compression compression () const; IMF_EXPORT RgbaChannels channels () const; IMF_EXPORT const char * fileName () const; IMF_EXPORT bool isComplete () const; //---------------------------------- // Access to the file format version //---------------------------------- IMF_EXPORT int version () const; //--------------------------------------------------- // Utility functions (same as in Imf::TiledInputFile) //--------------------------------------------------- IMF_EXPORT unsigned int tileXSize () const; IMF_EXPORT unsigned int tileYSize () const; IMF_EXPORT LevelMode levelMode () const; IMF_EXPORT LevelRoundingMode levelRoundingMode () const; IMF_EXPORT int numLevels () const; IMF_EXPORT int numXLevels () const; IMF_EXPORT int numYLevels () const; IMF_EXPORT bool isValidLevel (int lx, int ly) const; IMF_EXPORT int levelWidth (int lx) const; IMF_EXPORT int levelHeight (int ly) const; IMF_EXPORT int numXTiles (int lx = 0) const; IMF_EXPORT int numYTiles (int ly = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int lx, int ly) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int lx, int ly) const; //---------------------------------------------------------------- // Read pixel data: // // readTile(dx, dy, lx, ly) reads the tile with tile // coordinates (dx, dy), and level number (lx, ly), // and stores it in the current frame buffer. // // dx must lie in the interval [0, numXTiles(lx)-1] // dy must lie in the interval [0, numYTiles(ly)-1] // // lx must lie in the interval [0, numXLevels()-1] // ly must lie in the inverval [0, numYLevels()-1] // // readTile(dx, dy, level) is a convenience function used // for ONE_LEVEL and MIPMAP_LEVELS files. It calls // readTile(dx, dy, level, level). // // The two readTiles(dx1, dx2, dy1, dy2, ...) functions allow // reading multiple tiles at once. If multi-threading is used // multiple tiles are read concurrently. // // Pixels that are outside the pixel coordinate range for the // tile's level, are never accessed by readTile(). // // Attempting to access a tile that is not present in the file // throws an InputExc exception. // //---------------------------------------------------------------- IMF_EXPORT void readTile (int dx, int dy, int l = 0); IMF_EXPORT void readTile (int dx, int dy, int lx, int ly); IMF_EXPORT void readTiles (int dxMin, int dxMax, int dyMin, int dyMax, int lx, int ly); IMF_EXPORT void readTiles (int dxMin, int dxMax, int dyMin, int dyMax, int l = 0); private: // // Copy constructor and assignment are not implemented // TiledRgbaInputFile (const TiledRgbaInputFile &) = delete; TiledRgbaInputFile & operator = (const TiledRgbaInputFile &) = delete; TiledRgbaInputFile (TiledRgbaInputFile &&) = delete; TiledRgbaInputFile & operator = (TiledRgbaInputFile &&) = delete; class FromYa; TiledInputFile * _inputFile; FromYa * _fromYa; std::string _channelNamePrefix; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[��.X X ImfImageDataWindow.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_IMAGE_DATA_WINDOW_H #define INCLUDED_IMF_IMAGE_DATA_WINDOW_H //---------------------------------------------------------------------------- // // enum DataWindowSource, // function dataWindowForFile() // //---------------------------------------------------------------------------- #include "ImfUtilExport.h" #include "ImfNamespace.h" #include <ImathBox.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER enum IMFUTIL_EXPORT_ENUM DataWindowSource { USE_IMAGE_DATA_WINDOW, USE_HEADER_DATA_WINDOW }; // // Given the an image, i, an OpenEXR file header, h, and a data window // source flag, d, dataWindowForFile(i,h,d) returns i.dataWindow() if d // is USE_IMAGE_DATA_WINDOW, or the intersection of i.dataWindow() and // h.dataWindow() if d is USE_HEADER_DATA_WINDOW. // class Image; class Header; IMFUTIL_EXPORT IMATH_NAMESPACE::Box2i dataWindowForFile (const Header &hdr, const Image &img, DataWindowSource dws); OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[!�W7 7 ImfVersion.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_VERSION_H #define INCLUDED_IMF_VERSION_H //----------------------------------------------------------------------------- // // Magic and version number. // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER // // The MAGIC number is stored in the first four bytes of every // OpenEXR image file. This can be used to quickly test whether // a given file is an OpenEXR image file (see isImfMagic(), below). // static const int MAGIC = 20000630; // // The second item in each OpenEXR image file, right after the // magic number, is a four-byte file version identifier. Depending // on a file's version identifier, a file reader can enable various // backwards-compatibility switches, or it can quickly reject files // that it cannot read. // // The version identifier is split into an 8-bit version number, // and a 24-bit flags field. // static const int VERSION_NUMBER_FIELD = 0x000000ff; static const int VERSION_FLAGS_FIELD = 0xffffff00; // // Value that goes into VERSION_NUMBER_FIELD. // static const int EXR_VERSION = 2; // // Flags that can go into VERSION_FLAGS_FIELD. // Flags can only occupy the 1 bits in VERSION_FLAGS_FIELD. // static const int TILED_FLAG = 0x00000200; // File is tiled static const int LONG_NAMES_FLAG = 0x00000400; // File contains long // attribute or channel // names static const int NON_IMAGE_FLAG = 0x00000800; // File has at least one part // which is not a regular // scanline image or regular tiled image // (that is, it is a deep format) static const int MULTI_PART_FILE_FLAG = 0x00001000; // File has multiple parts // // Bitwise OR of all known flags. // static const int ALL_FLAGS = TILED_FLAG | LONG_NAMES_FLAG | NON_IMAGE_FLAG | MULTI_PART_FILE_FLAG; // // Utility functions // inline bool isTiled (int version) {return !!(version & TILED_FLAG);} inline bool isMultiPart (int version) {return !!(version & MULTI_PART_FILE_FLAG); } inline bool isNonImage(int version) {return !!(version & NON_IMAGE_FLAG); } inline int makeTiled (int version) {return version | TILED_FLAG;} inline int makeNotTiled (int version) {return version & ~TILED_FLAG;} inline int getVersion (int version) {return version & VERSION_NUMBER_FIELD;} inline int getFlags (int version) {return version & VERSION_FLAGS_FIELD;} inline bool supportsFlags (int flags) {return !(flags & ~ALL_FLAGS);} // // Given the first four bytes of a file, returns true if the // file is probably an OpenEXR image file, false if not. // IMF_EXPORT bool isImfMagic (const char bytes[4]); OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[��\ \ ImfThreading.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_THREADING_H #define INCLUDED_IMF_THREADING_H #include "ImfExport.h" #include "ImfNamespace.h" //----------------------------------------------------------------------------- // // Threading support for the OpenEXR library // // The OpenEXR library uses threads to perform reading and writing // of OpenEXR files in parallel. The thread that calls the library // always performs the actual file IO (this is usually the main // application thread) whereas a several worker threads perform // data compression and decompression. The number of worker // threads can be any non-negative value (a value of zero reverts // to single-threaded operation). As long as there is at least // one worker thread, file IO and compression can potentially be // done concurrently through pinelining. If there are two or more // worker threads, then pipelining as well as concurrent compression // of multiple blocks can be performed. // // Threading in the EXR library is controllable at two granularities: // // * The functions in this file query and control the total number // of worker threads, which will be created globally for the whole // library. Regardless of how many input or output files are // opened simultaneously, the library will use at most this number // of worker threads to perform all work. The default number of // global worker threads is zero (i.e. single-threaded operation; // everything happens in the thread that calls the library). // // * Furthermore, it is possible to set the number of threads that // each input or output file should keep busy. This number can // be explicitly set for each file. The default behavior is for // each file to try to occupy all worker threads in the library's // thread pool. // //----------------------------------------------------------------------------- OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER //----------------------------------------------------------------------------- // Return the number of Imf-global worker threads used for parallel // compression and decompression of OpenEXR files. //----------------------------------------------------------------------------- IMF_EXPORT int globalThreadCount (); //----------------------------------------------------------------------------- // Change the number of Imf-global worker threads //----------------------------------------------------------------------------- IMF_EXPORT void setGlobalThreadCount (int count); OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[~(�I3 3 ImfKeyCodeAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_KEY_CODE_ATTRIBUTE_H #define INCLUDED_IMF_KEY_CODE_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class KeyCodeAttribute // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" #include "ImfKeyCode.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::KeyCode> KeyCodeAttribute; #ifndef COMPILING_IMF_KEYCODE_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::KeyCode>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[���, �, ImfCRgbaFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_C_RGBA_FILE_H #define INCLUDED_IMF_C_RGBA_FILE_H #include "ImfExport.h" #include <stdlib.h> #ifdef __cplusplus extern "C" { #endif /* ** Interpreting unsigned shorts as 16-bit floating point numbers */ typedef unsigned short ImfHalf; IMF_EXPORT void ImfFloatToHalf (float f, ImfHalf *h); IMF_EXPORT void ImfFloatToHalfArray (int n, const float f[/*n*/], ImfHalf h[/*n*/]); IMF_EXPORT float ImfHalfToFloat (ImfHalf h); IMF_EXPORT void ImfHalfToFloatArray (int n, const ImfHalf h[/*n*/], float f[/*n*/]); /* ** RGBA pixel; memory layout must be the same as struct Imf::Rgba. */ struct ImfRgba { ImfHalf r; ImfHalf g; ImfHalf b; ImfHalf a; }; typedef struct ImfRgba ImfRgba; /* ** Magic number; this must be the same as Imf::MAGIC */ #define IMF_MAGIC 20000630 /* ** Version number; this must be the same as Imf::EXR_VERSION */ #define IMF_VERSION_NUMBER 2 /* ** Line order; values must the the same as in Imf::LineOrder. */ #define IMF_INCREASING_Y 0 #define IMF_DECREASING_Y 1 #define IMF_RANDOM_Y 2 /* ** Compression types; values must be the same as in Imf::Compression. */ #define IMF_NO_COMPRESSION 0 #define IMF_RLE_COMPRESSION 1 #define IMF_ZIPS_COMPRESSION 2 #define IMF_ZIP_COMPRESSION 3 #define IMF_PIZ_COMPRESSION 4 #define IMF_PXR24_COMPRESSION 5 #define IMF_B44_COMPRESSION 6 #define IMF_B44A_COMPRESSION 7 #define IMF_DWAA_COMPRESSION 8 #define IMF_DWAB_COMPRESSION 9 /* ** Channels; values must be the same as in Imf::RgbaChannels. */ #define IMF_WRITE_R 0x01 #define IMF_WRITE_G 0x02 #define IMF_WRITE_B 0x04 #define IMF_WRITE_A 0x08 #define IMF_WRITE_Y 0x10 #define IMF_WRITE_C 0x20 #define IMF_WRITE_RGB 0x07 #define IMF_WRITE_RGBA 0x0f #define IMF_WRITE_YC 0x30 #define IMF_WRITE_YA 0x18 #define IMF_WRITE_YCA 0x38 /* ** Level modes; values must be the same as in Imf::LevelMode */ #define IMF_ONE_LEVEL 0 #define IMF_MIPMAP_LEVELS 1 #define IMF_RIPMAP_LEVELS 2 /* ** Level rounding modes; values must be the same as in Imf::LevelRoundingMode */ #define IMF_ROUND_DOWN 0 #define IMF_ROUND_UP 1 /* ** RGBA file header */ struct ImfHeader; typedef struct ImfHeader ImfHeader; IMF_EXPORT ImfHeader * ImfNewHeader (void); IMF_EXPORT void ImfDeleteHeader (ImfHeader *hdr); IMF_EXPORT ImfHeader * ImfCopyHeader (const ImfHeader *hdr); IMF_EXPORT void ImfHeaderSetDisplayWindow (ImfHeader *hdr, int xMin, int yMin, int xMax, int yMax); IMF_EXPORT void ImfHeaderDisplayWindow (const ImfHeader *hdr, int *xMin, int *yMin, int *xMax, int *yMax); IMF_EXPORT void ImfHeaderSetDataWindow (ImfHeader *hdr, int xMin, int yMin, int xMax, int yMax); IMF_EXPORT void ImfHeaderDataWindow (const ImfHeader *hdr, int *xMin, int *yMin, int *xMax, int *yMax); IMF_EXPORT void ImfHeaderSetPixelAspectRatio (ImfHeader *hdr, float pixelAspectRatio); IMF_EXPORT float ImfHeaderPixelAspectRatio (const ImfHeader *hdr); IMF_EXPORT void ImfHeaderSetScreenWindowCenter (ImfHeader *hdr, float x, float y); IMF_EXPORT void ImfHeaderScreenWindowCenter (const ImfHeader *hdr, float *x, float *y); IMF_EXPORT void ImfHeaderSetScreenWindowWidth (ImfHeader *hdr, float width); IMF_EXPORT float ImfHeaderScreenWindowWidth (const ImfHeader *hdr); IMF_EXPORT void ImfHeaderSetLineOrder (ImfHeader *hdr, int lineOrder); IMF_EXPORT int ImfHeaderLineOrder (const ImfHeader *hdr); IMF_EXPORT void ImfHeaderSetCompression (ImfHeader *hdr, int compression); IMF_EXPORT int ImfHeaderCompression (const ImfHeader *hdr); IMF_EXPORT int ImfHeaderSetIntAttribute (ImfHeader *hdr, const char name[], int value); IMF_EXPORT int ImfHeaderIntAttribute (const ImfHeader *hdr, const char name[], int *value); IMF_EXPORT int ImfHeaderSetFloatAttribute (ImfHeader *hdr, const char name[], float value); IMF_EXPORT int ImfHeaderSetDoubleAttribute (ImfHeader *hdr, const char name[], double value); IMF_EXPORT int ImfHeaderFloatAttribute (const ImfHeader *hdr, const char name[], float *value); IMF_EXPORT int ImfHeaderDoubleAttribute (const ImfHeader *hdr, const char name[], double *value); IMF_EXPORT int ImfHeaderSetStringAttribute (ImfHeader *hdr, const char name[], const char value[]); IMF_EXPORT int ImfHeaderStringAttribute (const ImfHeader *hdr, const char name[], const char **value); IMF_EXPORT int ImfHeaderSetBox2iAttribute (ImfHeader *hdr, const char name[], int xMin, int yMin, int xMax, int yMax); IMF_EXPORT int ImfHeaderBox2iAttribute (const ImfHeader *hdr, const char name[], int *xMin, int *yMin, int *xMax, int *yMax); IMF_EXPORT int ImfHeaderSetBox2fAttribute (ImfHeader *hdr, const char name[], float xMin, float yMin, float xMax, float yMax); IMF_EXPORT int ImfHeaderBox2fAttribute (const ImfHeader *hdr, const char name[], float *xMin, float *yMin, float *xMax, float *yMax); IMF_EXPORT int ImfHeaderSetV2iAttribute (ImfHeader *hdr, const char name[], int x, int y); IMF_EXPORT int ImfHeaderV2iAttribute (const ImfHeader *hdr, const char name[], int *x, int *y); IMF_EXPORT int ImfHeaderSetV2fAttribute (ImfHeader *hdr, const char name[], float x, float y); IMF_EXPORT int ImfHeaderV2fAttribute (const ImfHeader *hdr, const char name[], float *x, float *y); IMF_EXPORT int ImfHeaderSetV3iAttribute (ImfHeader *hdr, const char name[], int x, int y, int z); IMF_EXPORT int ImfHeaderV3iAttribute (const ImfHeader *hdr, const char name[], int *x, int *y, int *z); IMF_EXPORT int ImfHeaderSetV3fAttribute (ImfHeader *hdr, const char name[], float x, float y, float z); IMF_EXPORT int ImfHeaderV3fAttribute (const ImfHeader *hdr, const char name[], float *x, float *y, float *z); IMF_EXPORT int ImfHeaderSetM33fAttribute (ImfHeader *hdr, const char name[], const float m[3][3]); IMF_EXPORT int ImfHeaderM33fAttribute (const ImfHeader *hdr, const char name[], float m[3][3]); IMF_EXPORT int ImfHeaderSetM44fAttribute (ImfHeader *hdr, const char name[], const float m[4][4]); IMF_EXPORT int ImfHeaderM44fAttribute (const ImfHeader *hdr, const char name[], float m[4][4]); /* ** RGBA output file */ struct ImfOutputFile; typedef struct ImfOutputFile ImfOutputFile; IMF_EXPORT ImfOutputFile * ImfOpenOutputFile (const char name[], const ImfHeader *hdr, int channels); IMF_EXPORT int ImfCloseOutputFile (ImfOutputFile *out); IMF_EXPORT int ImfOutputSetFrameBuffer (ImfOutputFile *out, const ImfRgba *base, size_t xStride, size_t yStride); IMF_EXPORT int ImfOutputWritePixels (ImfOutputFile *out, int numScanLines); IMF_EXPORT int ImfOutputCurrentScanLine (const ImfOutputFile *out); IMF_EXPORT const ImfHeader * ImfOutputHeader (const ImfOutputFile *out); IMF_EXPORT int ImfOutputChannels (const ImfOutputFile *out); /* ** Tiled RGBA output file */ struct ImfTiledOutputFile; typedef struct ImfTiledOutputFile ImfTiledOutputFile; IMF_EXPORT ImfTiledOutputFile * ImfOpenTiledOutputFile (const char name[], const ImfHeader *hdr, int channels, int xSize, int ySize, int mode, int rmode); IMF_EXPORT int ImfCloseTiledOutputFile (ImfTiledOutputFile *out); IMF_EXPORT int ImfTiledOutputSetFrameBuffer (ImfTiledOutputFile *out, const ImfRgba *base, size_t xStride, size_t yStride); IMF_EXPORT int ImfTiledOutputWriteTile (ImfTiledOutputFile *out, int dx, int dy, int lx, int ly); IMF_EXPORT int ImfTiledOutputWriteTiles (ImfTiledOutputFile *out, int dxMin, int dxMax, int dyMin, int dyMax, int lx, int ly); IMF_EXPORT const ImfHeader * ImfTiledOutputHeader (const ImfTiledOutputFile *out); IMF_EXPORT int ImfTiledOutputChannels (const ImfTiledOutputFile *out); IMF_EXPORT int ImfTiledOutputTileXSize (const ImfTiledOutputFile *out); IMF_EXPORT int ImfTiledOutputTileYSize (const ImfTiledOutputFile *out); IMF_EXPORT int ImfTiledOutputLevelMode (const ImfTiledOutputFile *out); IMF_EXPORT int ImfTiledOutputLevelRoundingMode (const ImfTiledOutputFile *out); /* ** RGBA input file */ struct ImfInputFile; typedef struct ImfInputFile ImfInputFile; IMF_EXPORT ImfInputFile * ImfOpenInputFile (const char name[]); IMF_EXPORT int ImfCloseInputFile (ImfInputFile *in); IMF_EXPORT int ImfInputSetFrameBuffer (ImfInputFile *in, ImfRgba *base, size_t xStride, size_t yStride); IMF_EXPORT int ImfInputReadPixels (ImfInputFile *in, int scanLine1, int scanLine2); IMF_EXPORT const ImfHeader * ImfInputHeader (const ImfInputFile *in); IMF_EXPORT int ImfInputChannels (const ImfInputFile *in); IMF_EXPORT const char * ImfInputFileName (const ImfInputFile *in); /* ** Tiled RGBA input file */ struct ImfTiledInputFile; typedef struct ImfTiledInputFile ImfTiledInputFile; IMF_EXPORT ImfTiledInputFile * ImfOpenTiledInputFile (const char name[]); IMF_EXPORT int ImfCloseTiledInputFile (ImfTiledInputFile *in); IMF_EXPORT int ImfTiledInputSetFrameBuffer (ImfTiledInputFile *in, ImfRgba *base, size_t xStride, size_t yStride); IMF_EXPORT int ImfTiledInputReadTile (ImfTiledInputFile *in, int dx, int dy, int lx, int ly); IMF_EXPORT int ImfTiledInputReadTiles (ImfTiledInputFile *in, int dxMin, int dxMax, int dyMin, int dyMax, int lx, int ly); IMF_EXPORT const ImfHeader * ImfTiledInputHeader (const ImfTiledInputFile *in); IMF_EXPORT int ImfTiledInputChannels (const ImfTiledInputFile *in); IMF_EXPORT const char * ImfTiledInputFileName (const ImfTiledInputFile *in); IMF_EXPORT int ImfTiledInputTileXSize (const ImfTiledInputFile *in); IMF_EXPORT int ImfTiledInputTileYSize (const ImfTiledInputFile *in); IMF_EXPORT int ImfTiledInputLevelMode (const ImfTiledInputFile *in); IMF_EXPORT int ImfTiledInputLevelRoundingMode (const ImfTiledInputFile *in); /* ** Lookup tables */ struct ImfLut; typedef struct ImfLut ImfLut; IMF_EXPORT ImfLut * ImfNewRound12logLut (int channels); IMF_EXPORT ImfLut * ImfNewRoundNBitLut (unsigned int n, int channels); IMF_EXPORT void ImfDeleteLut (ImfLut *lut); IMF_EXPORT void ImfApplyLut (ImfLut *lut, ImfRgba *data, int nData, int stride); /* ** Most recent error message */ IMF_EXPORT const char * ImfErrorMessage (void); #ifdef __cplusplus } /* extern "C" */ #endif #endif PK rM�[���^ ^ ImfFlatImageChannel.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_FLAT_IMAGE_CHANNEL_H #define INCLUDED_IMF_FLAT_IMAGE_CHANNEL_H //---------------------------------------------------------------------------- // // class FlatImageChannel, // template class TypedFlatImageChannel<T> // // For an explanation of images, levels and channels, // see the comments in header file Image.h. // //---------------------------------------------------------------------------- #include "ImfImageChannel.h" #include "ImfUtilExport.h" #include "ImfImageLevel.h" #include "ImfPixelType.h" #include "ImfFrameBuffer.h" #include <ImathBox.h> #include <half.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class FlatImageLevel; // // Image channels: // // A TypedFlatImageChannel<T> holds the pixel data for a single channel // of one level of a flat image. The pixels in the channel are of type T, // where T is either half, float or unsigned int. Storage is allocated // only for pixels within the data window of the level. // class IMFUTIL_EXPORT_TYPE FlatImageChannel: public ImageChannel { public: // // Construct an OpenEXR frame buffer slice for this channel. // This function is needed reading an image from an OpenEXR // file and for saving an image in an OpenEXR file. // virtual Slice slice () const = 0; // // Access to the flat image level to which this channel belongs. // IMFUTIL_EXPORT FlatImageLevel & flatLevel (); IMFUTIL_EXPORT const FlatImageLevel & flatLevel () const; protected: friend class FlatImageLevel; IMFUTIL_EXPORT FlatImageChannel (FlatImageLevel &level, int xSampling, int ySampling, bool pLinear); IMFUTIL_EXPORT virtual ~FlatImageChannel(); FlatImageChannel (const FlatImageChannel& other) = delete; FlatImageChannel& operator = (const FlatImageChannel& other) = delete; FlatImageChannel (FlatImageChannel&& other) = delete; FlatImageChannel& operator = (FlatImageChannel&& other) = delete; IMFUTIL_EXPORT virtual void resize (); virtual void resetBasePointer () = 0; }; template <class T> class IMFUTIL_EXPORT_TEMPLATE_TYPE TypedFlatImageChannel: public FlatImageChannel { public: // // The OpenEXR pixel type of this channel (HALF, FLOAT or UINT). // virtual PixelType pixelType () const; // // Construct an OpenEXR frame buffer slice for this channel. // virtual Slice slice () const; // // Access to the pixel at pixel space location (x, y), without // bounds checking. Accessing a location outside the data window // of the image level results in undefined behavior. // T & operator () (int x, int y); const T & operator () (int x, int y) const; // // Access to the pixel at pixel space location (x, y), with bounds // checking. Accessing a location outside the data window of the // image level throws an Iex::ArgExc exception. // T & at (int x, int y); const T & at (int x, int y) const; // // Faster access to all pixels in a single horizontal row of the // channel. Rows are numbered from 0 to pixelsPerColumn()-1, and // each row contains pixelsPerRow() values. // Access is not bounds checked; accessing out of bounds rows or // pixels results in undefined behavior. // T * row (int r); const T * row (int r) const; private: friend class FlatImageLevel; // // The constructor and destructor are not public because flat // image channels exist only as parts of a flat image level. // IMFUTIL_HIDDEN TypedFlatImageChannel (FlatImageLevel &level, int xSampling, int ySampling, bool pLinear); IMFUTIL_HIDDEN virtual ~TypedFlatImageChannel (); TypedFlatImageChannel (const TypedFlatImageChannel& other) = delete; TypedFlatImageChannel& operator = (const TypedFlatImageChannel& other) = delete; TypedFlatImageChannel (TypedFlatImageChannel&& other) = delete; TypedFlatImageChannel& operator = (TypedFlatImageChannel&& other) = delete; IMFUTIL_HIDDEN virtual void resize (); IMFUTIL_HIDDEN virtual void resetBasePointer (); T * _pixels; // Pointer to allocated storage T * _base; // Base pointer for faster pixel access }; // // Channel typedefs for the pixel data types supported by OpenEXR. // typedef TypedFlatImageChannel<half> FlatHalfChannel; typedef TypedFlatImageChannel<float> FlatFloatChannel; typedef TypedFlatImageChannel<unsigned int> FlatUIntChannel; //----------------------------------------------------------------------------- // Implementation of templates and inline functions //----------------------------------------------------------------------------- template <class T> inline T & TypedFlatImageChannel<T>::operator () (int x, int y) { return _base[(y / ySampling()) * pixelsPerRow() + (x / xSampling())]; } template <class T> inline const T & TypedFlatImageChannel<T>::operator () (int x, int y) const { return _base[(y / ySampling()) * pixelsPerRow() + (x / xSampling())]; } template <class T> inline T & TypedFlatImageChannel<T>::at (int x, int y) { boundsCheck (x, y); return _base[(y / ySampling()) * pixelsPerRow() + (x / xSampling())]; } template <class T> inline const T & TypedFlatImageChannel<T>::at (int x, int y) const { boundsCheck (x, y); return _base[(y / ySampling()) * pixelsPerRow() + (x / xSampling())]; } template <class T> inline T * TypedFlatImageChannel<T>::row (int r) { return _base + r * pixelsPerRow(); } template <class T> inline const T * TypedFlatImageChannel<T>::row (int n) const { return _base + n * pixelsPerRow(); } #ifndef COMPILING_IMF_FLAT_IMAGE_CHANNEL extern template class IMFUTIL_EXPORT_EXTERN_TEMPLATE TypedFlatImageChannel<half>; extern template class IMFUTIL_EXPORT_EXTERN_TEMPLATE TypedFlatImageChannel<float>; extern template class IMFUTIL_EXPORT_EXTERN_TEMPLATE TypedFlatImageChannel<unsigned int>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�[��� � ImfConvert.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_CONVERT_H #define INCLUDED_IMF_CONVERT_H //----------------------------------------------------------------------------- // // Routines for converting between pixel data types, // with well-defined behavior for exceptional cases, // without depending on how hardware and operating // system handle integer overflows and floating-point // exceptions. // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include <half.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER //--------------------------------------------------------- // Conversion from half or float to unsigned int: // // input result // --------------------------------------------------- // // finite, >= 0 input, cast to unsigned int // (rounds towards zero) // // finite, < 0 0 // // NaN 0 // // +infinity UINT_MAX // // -infinity 0 // //--------------------------------------------------------- IMF_EXPORT unsigned int halfToUint (half h); IMF_EXPORT unsigned int floatToUint (float f); //--------------------------------------------------------- // Conversion from unsigned int or float to half: // // input result // --------------------------------------------------- // // finite, closest possible half // magnitude <= HALF_MAX // // finite, > HALF_MAX +infinity // // finite, < -HALF_MAX -infinity // // NaN NaN // // +infinity +infinity // // -infinity -infinity // //--------------------------------------------------------- IMF_EXPORT half uintToHalf (unsigned int ui); IMF_EXPORT half floatToHalf (float f); OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[;��-Y Y ImfPreviewImageAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_PREVIEW_IMAGE_ATTRIBUTE_H #define INCLUDED_IMF_PREVIEW_IMAGE_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class PreviewImageAttribute // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" #include "ImfPreviewImage.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::PreviewImage> PreviewImageAttribute; #ifndef COMPILING_IMF_PREVIEW_IMAGE_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::PreviewImage>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�w�Q ImfPartType.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef IMFPARTTYPE_H_ #define IMFPARTTYPE_H_ #include "ImfExport.h" #include "ImfNamespace.h" #include <string> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER static const std::string SCANLINEIMAGE = "scanlineimage"; static const std::string TILEDIMAGE = "tiledimage"; static const std::string DEEPSCANLINE = "deepscanline"; static const std::string DEEPTILE = "deeptile"; IMF_EXPORT bool isImage(const std::string& name); IMF_EXPORT bool isTiled(const std::string& name); IMF_EXPORT bool isDeepData(const std::string& name); IMF_EXPORT bool isSupportedType(const std::string& name); OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif /* IMFPARTTYPE_H_ */ PK rM�[o>�# �# ImfFlatImageLevel.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_FLAT_IMAGE_LEVEL_H #define INCLUDED_IMF_FLAT_IMAGE_LEVEL_H //---------------------------------------------------------------------------- // // class FlatImageLevel // class FlatImageLevel::Iterator // class FlatImageLevel::ConstIterator // // For an explanation of images, levels and channels, // see the comments in header file Image.h. // //---------------------------------------------------------------------------- #include "ImfFlatImageChannel.h" #include "ImfImageLevel.h" #include <ImathBox.h> #include <string> #include <map> #include "ImfUtilExport.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class FlatImage; class IMFUTIL_EXPORT_TYPE FlatImageLevel : public ImageLevel { public: // // Access to the flat image to which the level belongs. // IMFUTIL_EXPORT FlatImage & flatImage(); IMFUTIL_EXPORT const FlatImage & flatImage() const; // // Accessing channels by name: // // findChannel(n) returns a pointer to the image channel with // name n, or 0 if no such channel exists. // // channel(n) returns a reference to the image channel with // name n, or throws an Iex::ArgExc exception if // no such channel exists. // // findTypedChannel<T>(n) returns a pointer to the image channel with // name n and type T, or 0 if no such channel // exists. // // typedChannel(n) returns a reference to the image channel with // name n and type T, or throws an Iex::ArgExc // exception if no such channel exists. // IMFUTIL_EXPORT FlatImageChannel * findChannel (const std::string& name); IMFUTIL_EXPORT const FlatImageChannel * findChannel (const std::string& name) const; IMFUTIL_EXPORT FlatImageChannel & channel (const std::string& name); IMFUTIL_EXPORT const FlatImageChannel & channel (const std::string& name) const; template <class T> TypedFlatImageChannel<T> * findTypedChannel (const std::string& name); template <class T> const TypedFlatImageChannel<T> * findTypedChannel (const std::string& name) const; template <class T> TypedFlatImageChannel<T> & typedChannel (const std::string& name); template <class T> const TypedFlatImageChannel<T> & typedChannel (const std::string& name) const; // // Iterator-style access to channels // typedef std::map <std::string, FlatImageChannel *> ChannelMap; class Iterator; class ConstIterator; IMFUTIL_EXPORT Iterator begin(); IMFUTIL_EXPORT ConstIterator begin() const; IMFUTIL_EXPORT Iterator end(); IMFUTIL_EXPORT ConstIterator end() const; private: friend class FlatImage; // // The constructor and destructor are private. // Image levels exist only as part of an image. // IMFUTIL_HIDDEN FlatImageLevel (FlatImage& image, int xLevelNumber, int yLevelNumber, const IMATH_NAMESPACE::Box2i& dataWindow); IMFUTIL_HIDDEN virtual ~FlatImageLevel (); IMFUTIL_HIDDEN virtual void resize (const IMATH_NAMESPACE::Box2i& dataWindow); IMFUTIL_HIDDEN virtual void shiftPixels (int dx, int dy); IMFUTIL_HIDDEN virtual void insertChannel (const std::string& name, PixelType type, int xSampling, int ySampling, bool pLinear); IMFUTIL_HIDDEN virtual void eraseChannel (const std::string& name); IMFUTIL_HIDDEN virtual void clearChannels (); IMFUTIL_HIDDEN virtual void renameChannel (const std::string &oldName, const std::string &newName); IMFUTIL_HIDDEN virtual void renameChannels (const RenamingMap &oldToNewNames); ChannelMap _channels; }; class IMFUTIL_EXPORT_TYPE FlatImageLevel::Iterator { public: IMFUTIL_EXPORT Iterator (); IMFUTIL_EXPORT Iterator (const FlatImageLevel::ChannelMap::iterator& i); // // Advance the iterator // IMFUTIL_EXPORT Iterator & operator ++ (); IMFUTIL_EXPORT Iterator operator ++ (int); // // Access to the channel to which the iterator points, // and to the name of that channel. // IMFUTIL_EXPORT const std::string & name () const; IMFUTIL_EXPORT FlatImageChannel & channel () const; private: friend class FlatImageLevel::ConstIterator; FlatImageLevel::ChannelMap::iterator _i; }; class IMFUTIL_EXPORT_TYPE FlatImageLevel::ConstIterator { public: IMFUTIL_EXPORT ConstIterator (); IMFUTIL_EXPORT ConstIterator (const FlatImageLevel::ChannelMap::const_iterator& i); IMFUTIL_EXPORT ConstIterator (const FlatImageLevel::Iterator& other); // // Advance the iterator // IMFUTIL_EXPORT ConstIterator & operator ++ (); IMFUTIL_EXPORT ConstIterator operator ++ (int); // // Access to the channel to which the iterator points, // and to the name of that channel. // IMFUTIL_EXPORT const std::string & name () const; IMFUTIL_EXPORT const FlatImageChannel & channel () const; private: friend bool operator == (const ConstIterator &, const ConstIterator &); friend bool operator != (const ConstIterator &, const ConstIterator &); FlatImageLevel::ChannelMap::const_iterator _i; }; //----------------------------------------------------------------------------- // Implementation of templates and inline functions //----------------------------------------------------------------------------- template <class T> TypedFlatImageChannel<T> * FlatImageLevel::findTypedChannel (const std::string& name) { return dynamic_cast <TypedFlatImageChannel<T> *> (findChannel (name)); } template <class T> const TypedFlatImageChannel<T> * FlatImageLevel::findTypedChannel (const std::string& name) const { return dynamic_cast <const TypedFlatImageChannel<T> *> (findChannel (name)); } template <class T> TypedFlatImageChannel<T> & FlatImageLevel::typedChannel (const std::string& name) { TypedFlatImageChannel<T> * ptr = findTypedChannel<T> (name); if (ptr == 0) throwBadChannelNameOrType (name); return *ptr; } template <class T> const TypedFlatImageChannel<T> & FlatImageLevel::typedChannel (const std::string& name) const { const TypedFlatImageChannel<T> * ptr = findTypedChannel<T> (name); if (ptr == 0) throwBadChannelNameOrType (name); return *ptr; } inline FlatImageLevel::Iterator::Iterator (): _i() { // empty } inline FlatImageLevel::Iterator::Iterator (const FlatImageLevel::ChannelMap::iterator& i): _i (i) { // empty } inline FlatImageLevel::Iterator & FlatImageLevel::Iterator::operator ++ () { ++_i; return *this; } inline FlatImageLevel::Iterator FlatImageLevel::Iterator::operator ++ (int) { Iterator tmp = *this; ++_i; return tmp; } inline const std::string & FlatImageLevel::Iterator::name () const { return _i->first; } inline FlatImageChannel & FlatImageLevel::Iterator::channel () const { return *_i->second; } inline FlatImageLevel::ConstIterator::ConstIterator (): _i() { // empty } inline FlatImageLevel::ConstIterator::ConstIterator (const FlatImageLevel::ChannelMap::const_iterator& i): _i (i) { // empty } inline FlatImageLevel::ConstIterator::ConstIterator (const FlatImageLevel::Iterator& other): _i (other._i) { // empty } inline FlatImageLevel::ConstIterator & FlatImageLevel::ConstIterator::operator ++ () { ++_i; return *this; } inline FlatImageLevel::ConstIterator FlatImageLevel::ConstIterator::operator ++ (int) { ConstIterator tmp = *this; ++_i; return tmp; } inline const std::string & FlatImageLevel::ConstIterator::name () const { return _i->first; } inline const FlatImageChannel & FlatImageLevel::ConstIterator::channel () const { return *_i->second; } inline bool operator == (const FlatImageLevel::ConstIterator& x, const FlatImageLevel::ConstIterator& y) { return x._i == y._i; } inline bool operator != (const FlatImageLevel::ConstIterator& x, const FlatImageLevel::ConstIterator& y) { return !(x == y); } OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[��=1� � ImfMatrixAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_MATRIX_ATTRIBUTE_H #define INCLUDED_IMF_MATRIX_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class M33fAttribute // class M33dAttribute // class M44fAttribute // class M44dAttribute // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" #include <ImathMatrix.h> #if defined(_MSC_VER) // suppress warning about non-exported base classes #pragma warning (push) #pragma warning (disable : 4251) #pragma warning (disable : 4275) #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<IMATH_NAMESPACE::M33f> M33fAttribute; typedef TypedAttribute<IMATH_NAMESPACE::M33d> M33dAttribute; typedef TypedAttribute<IMATH_NAMESPACE::M44f> M44fAttribute; typedef TypedAttribute<IMATH_NAMESPACE::M44d> M44dAttribute; #ifndef COMPILING_IMF_MATRIX_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<IMATH_NAMESPACE::M33f>; extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<IMATH_NAMESPACE::M33d>; extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<IMATH_NAMESPACE::M44f>; extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<IMATH_NAMESPACE::M44d>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #if defined(_MSC_VER) #pragma warning(pop) #endif #endif PK rM�[^}��D D ImfCompositeDeepScanLine.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Weta Digital, Ltd and Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_COMPOSITEDEEPSCANLINE_H #define INCLUDED_IMF_COMPOSITEDEEPSCANLINE_H //----------------------------------------------------------------------------- // // Class to composite deep samples into a frame buffer // Initialise with a deep input part or deep inputfile // (also supports multiple files and parts, and will // composite them together, as long as their sizes and channelmaps agree) // // Then call setFrameBuffer, and readPixels, exactly as for reading // regular scanline images. // // Restrictions - source file(s) must contain at least Z and alpha channels // - if multiple files/parts are provided, sizes must match // - all requested channels will be composited as premultiplied // - only half and float channels can be requested // // This object should not be considered threadsafe // // The default compositing engine will give spurious results with overlapping // volumetric samples - you may derive from DeepCompositing class, override the // sort_pixel() and composite_pixel() functions, and pass an instance to // setCompositing(). // //----------------------------------------------------------------------------- #include "ImfForward.h" #include <ImathBox.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE CompositeDeepScanLine { public: IMF_EXPORT CompositeDeepScanLine(); IMF_EXPORT virtual ~CompositeDeepScanLine(); /// set the source data as a part ///@note all parts must remain valid until after last interaction with DeepComp IMF_EXPORT void addSource(DeepScanLineInputPart * part); /// set the source data as a file ///@note all file must remain valid until after last interaction with DeepComp IMF_EXPORT void addSource(DeepScanLineInputFile * file); ///////////////////////////////////////// // // set the frame buffer for output values // the buffers specified must be large enough // to handle the dataWindow() // ///////////////////////////////////////// IMF_EXPORT void setFrameBuffer(const FrameBuffer & fr); ///////////////////////////////////////// // // retrieve frameBuffer // //////////////////////////////////////// IMF_EXPORT const FrameBuffer & frameBuffer() const; ////////////////////////////////////////////////// // // read scanlines start to end from the source(s) // storing the result in the frame buffer provided // ////////////////////////////////////////////////// IMF_EXPORT void readPixels(int start,int end); IMF_EXPORT int sources() const; // return number of sources ///////////////////////////////////////////////// // // retrieve the datawindow // If multiple parts are specified, this will // be the union of the dataWindow of all parts // //////////////////////////////////////////////// IMF_EXPORT const IMATH_NAMESPACE::Box2i & dataWindow() const; // // override default sorting/compositing operation // (otherwise an instance of the base class will be used) // IMF_EXPORT void setCompositing(DeepCompositing *); struct IMF_HIDDEN Data; private : struct Data *_Data; CompositeDeepScanLine(const CompositeDeepScanLine &) = delete; CompositeDeepScanLine & operator=(const CompositeDeepScanLine &) = delete; CompositeDeepScanLine(CompositeDeepScanLine &&) = delete; CompositeDeepScanLine & operator=(CompositeDeepScanLine &&) = delete; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[��'�C �C ImfDeepTiledOutputFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_DEEP_TILED_OUTPUT_FILE_H #define INCLUDED_IMF_DEEP_TILED_OUTPUT_FILE_H //----------------------------------------------------------------------------- // // class DeepTiledOutputFile // //----------------------------------------------------------------------------- #include "ImfForward.h" #include "ImfThreading.h" #include "ImfGenericOutputFile.h" #include "ImfTileDescription.h" #include <ImathBox.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE DeepTiledOutputFile : public GenericOutputFile { public: //------------------------------------------------------------------- // A constructor that opens the file with the specified name, and // writes the file header. The file header is also copied into the // TiledOutputFile object, and can later be accessed via the header() // method. // // Destroying TiledOutputFile constructed with this constructor // automatically closes the corresponding files. // // The header must contain a TileDescriptionAttribute called "tiles". // // The x and y subsampling factors for all image channels must be 1; // subsampling is not supported. // // Tiles can be written to the file in arbitrary order. The line // order attribute can be used to cause the tiles to be sorted in // the file. When the file is read later, reading the tiles in the // same order as they are in the file tends to be significantly // faster than reading the tiles in random order (see writeTile, // below). //------------------------------------------------------------------- IMF_EXPORT DeepTiledOutputFile (const char fileName[], const Header &header, int numThreads = globalThreadCount ()); // ---------------------------------------------------------------- // A constructor that attaches the new TiledOutputFile object to // a file that has already been opened. Destroying TiledOutputFile // objects constructed with this constructor does not automatically // close the corresponding files. // ---------------------------------------------------------------- IMF_EXPORT DeepTiledOutputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, const Header &header, int numThreads = globalThreadCount ()); //----------------------------------------------------- // Destructor // // Destroying a TiledOutputFile object before all tiles // have been written results in an incomplete file. //----------------------------------------------------- IMF_EXPORT virtual ~DeepTiledOutputFile (); //------------------------ // Access to the file name //------------------------ IMF_EXPORT const char * fileName () const; //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; //------------------------------------------------------- // Set the current frame buffer -- copies the FrameBuffer // object into the TiledOutputFile object. // // The current frame buffer is the source of the pixel // data written to the file. The current frame buffer // must be set at least once before writeTile() is // called. The current frame buffer can be changed // after each call to writeTile(). //------------------------------------------------------- IMF_EXPORT void setFrameBuffer (const DeepFrameBuffer &frameBuffer); //----------------------------------- // Access to the current frame buffer //----------------------------------- IMF_EXPORT const DeepFrameBuffer & frameBuffer () const; //------------------- // Utility functions: //------------------- //--------------------------------------------------------- // Multiresolution mode and tile size: // The following functions return the xSize, ySize and mode // fields of the file header's TileDescriptionAttribute. //--------------------------------------------------------- IMF_EXPORT unsigned int tileXSize () const; IMF_EXPORT unsigned int tileYSize () const; IMF_EXPORT LevelMode levelMode () const; IMF_EXPORT LevelRoundingMode levelRoundingMode () const; //-------------------------------------------------------------------- // Number of levels: // // numXLevels() returns the file's number of levels in x direction. // // if levelMode() == ONE_LEVEL: // return value is: 1 // // if levelMode() == MIPMAP_LEVELS: // return value is: rfunc (log (max (w, h)) / log (2)) + 1 // // if levelMode() == RIPMAP_LEVELS: // return value is: rfunc (log (w) / log (2)) + 1 // // where // w is the width of the image's data window, max.x - min.x + 1, // y is the height of the image's data window, max.y - min.y + 1, // and rfunc(x) is either floor(x), or ceil(x), depending on // whether levelRoundingMode() returns ROUND_DOWN or ROUND_UP. // // numYLevels() returns the file's number of levels in y direction. // // if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS: // return value is the same as for numXLevels() // // if levelMode() == RIPMAP_LEVELS: // return value is: rfunc (log (h) / log (2)) + 1 // // // numLevels() is a convenience function for use with MIPMAP_LEVELS // files. // // if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS: // return value is the same as for numXLevels() // // if levelMode() == RIPMAP_LEVELS: // an IEX_NAMESPACE::LogicExc exception is thrown // // isValidLevel(lx, ly) returns true if the file contains // a level with level number (lx, ly), false if not. // //-------------------------------------------------------------------- IMF_EXPORT int numLevels () const; IMF_EXPORT int numXLevels () const; IMF_EXPORT int numYLevels () const; IMF_EXPORT bool isValidLevel (int lx, int ly) const; //--------------------------------------------------------- // Dimensions of a level: // // levelWidth(lx) returns the width of a level with level // number (lx, *), where * is any number. // // return value is: // max (1, rfunc (w / pow (2, lx))) // // // levelHeight(ly) returns the height of a level with level // number (*, ly), where * is any number. // // return value is: // max (1, rfunc (h / pow (2, ly))) // //--------------------------------------------------------- IMF_EXPORT int levelWidth (int lx) const; IMF_EXPORT int levelHeight (int ly) const; //---------------------------------------------------------- // Number of tiles: // // numXTiles(lx) returns the number of tiles in x direction // that cover a level with level number (lx, *), where * is // any number. // // return value is: // (levelWidth(lx) + tileXSize() - 1) / tileXSize() // // // numYTiles(ly) returns the number of tiles in y direction // that cover a level with level number (*, ly), where * is // any number. // // return value is: // (levelHeight(ly) + tileXSize() - 1) / tileXSize() // //---------------------------------------------------------- IMF_EXPORT int numXTiles (int lx = 0) const; IMF_EXPORT int numYTiles (int ly = 0) const; //--------------------------------------------------------- // Level pixel ranges: // // dataWindowForLevel(lx, ly) returns a 2-dimensional // region of valid pixel coordinates for a level with // level number (lx, ly) // // return value is a Box2i with min value: // (dataWindow.min.x, dataWindow.min.y) // // and max value: // (dataWindow.min.x + levelWidth(lx) - 1, // dataWindow.min.y + levelHeight(ly) - 1) // // dataWindowForLevel(level) is a convenience function used // for ONE_LEVEL and MIPMAP_LEVELS files. It returns // dataWindowForLevel(level, level). // //--------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int lx, int ly) const; //------------------------------------------------------------------- // Tile pixel ranges: // // dataWindowForTile(dx, dy, lx, ly) returns a 2-dimensional // region of valid pixel coordinates for a tile with tile coordinates // (dx,dy) and level number (lx, ly). // // return value is a Box2i with min value: // (dataWindow.min.x + dx * tileXSize(), // dataWindow.min.y + dy * tileYSize()) // // and max value: // (dataWindow.min.x + (dx + 1) * tileXSize() - 1, // dataWindow.min.y + (dy + 1) * tileYSize() - 1) // // dataWindowForTile(dx, dy, level) is a convenience function // used for ONE_LEVEL and MIPMAP_LEVELS files. It returns // dataWindowForTile(dx, dy, level, level). // //------------------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int lx, int ly) const; //------------------------------------------------------------------ // Write pixel data: // // writeTile(dx, dy, lx, ly) writes the tile with tile // coordinates (dx, dy), and level number (lx, ly) to // the file. // // dx must lie in the interval [0, numXTiles(lx) - 1] // dy must lie in the interval [0, numYTiles(ly) - 1] // // lx must lie in the interval [0, numXLevels() - 1] // ly must lie in the inverval [0, numYLevels() - 1] // // writeTile(dx, dy, level) is a convenience function // used for ONE_LEVEL and MIPMAP_LEVEL files. It calls // writeTile(dx, dy, level, level). // // The two writeTiles(dx1, dx2, dy1, dy2, ...) functions allow // writing multiple tiles at once. If multi-threading is used // multiple tiles are written concurrently. The tile coordinates, // dx1, dx2 and dy1, dy2, specify inclusive ranges of tile // coordinates. It is valid for dx1 < dx2 or dy1 < dy2; the // tiles are always written in the order specified by the line // order attribute. Hence, it is not possible to specify an // "invalid" or empty tile range. // // Pixels that are outside the pixel coordinate range for the tile's // level, are never accessed by writeTile(). // // Each tile in the file must be written exactly once. // // The file's line order attribute determines the order of the tiles // in the file: // // INCREASING_Y In the file, the tiles for each level are stored // in a contiguous block. The levels are ordered // like this: // // (0, 0) (1, 0) ... (nx-1, 0) // (0, 1) (1, 1) ... (nx-1, 1) // ... // (0,ny-1) (1,ny-1) ... (nx-1,ny-1) // // where nx = numXLevels(), and ny = numYLevels(). // In an individual level, (lx, ly), the tiles // are stored in the following order: // // (0, 0) (1, 0) ... (tx-1, 0) // (0, 1) (1, 1) ... (tx-1, 1) // ... // (0,ty-1) (1,ty-1) ... (tx-1,ty-1) // // where tx = numXTiles(lx), // and ty = numYTiles(ly). // // DECREASING_Y As for INCREASING_Y, the tiles for each level // are stored in a contiguous block. The levels // are ordered the same way as for INCREASING_Y, // but within an individual level, the tiles // are stored in this order: // // (0,ty-1) (1,ty-1) ... (tx-1,ty-1) // ... // (0, 1) (1, 1) ... (tx-1, 1) // (0, 0) (1, 0) ... (tx-1, 0) // // // RANDOM_Y The order of the calls to writeTile() determines // the order of the tiles in the file. // //------------------------------------------------------------------ IMF_EXPORT void writeTile (int dx, int dy, int l = 0); IMF_EXPORT void writeTile (int dx, int dy, int lx, int ly); IMF_EXPORT void writeTiles (int dx1, int dx2, int dy1, int dy2, int lx, int ly); IMF_EXPORT void writeTiles (int dx1, int dx2, int dy1, int dy2, int l = 0); //------------------------------------------------------------------ // Shortcut to copy all pixels from a TiledInputFile into this file, // without uncompressing and then recompressing the pixel data. // This file's header must be compatible with the TiledInputFile's // header: The two header's "dataWindow", "compression", // "lineOrder", "channels", and "tiles" attributes must be the same. //------------------------------------------------------------------ IMF_EXPORT void copyPixels (DeepTiledInputFile &in); IMF_EXPORT void copyPixels (DeepTiledInputPart &in); //-------------------------------------------------------------- // Updating the preview image: // // updatePreviewImage() supplies a new set of pixels for the // preview image attribute in the file's header. If the header // does not contain a preview image, updatePreviewImage() throws // an IEX_NAMESPACE::LogicExc. // // Note: updatePreviewImage() is necessary because images are // often stored in a file incrementally, a few tiles at a time, // while the image is being generated. Since the preview image // is an attribute in the file's header, it gets stored in the // file as soon as the file is opened, but we may not know what // the preview image should look like until we have written the // last tile of the main image. // //-------------------------------------------------------------- IMF_EXPORT void updatePreviewImage (const PreviewRgba newPixels[]); //------------------------------------------------------------- // Break a tile -- for testing and debugging only: // // breakTile(dx,dy,lx,ly,p,n,c) introduces an error into the // output file by writing n copies of character c, starting // p bytes from the beginning of the tile with tile coordinates // (dx, dy) and level number (lx, ly). // // Warning: Calling this function usually results in a broken // image file. The file or parts of it may not be readable, // or the file may contain bad data. // //------------------------------------------------------------- IMF_EXPORT void breakTile (int dx, int dy, int lx, int ly, int offset, int length, char c); struct Data; private: // ---------------------------------------------------------------- // A constructor attaches the OutputStreamMutex to the // given one from MultiPartOutputFile. Set the previewPosition // and lineOffsetsPosition which have been acquired from // the constructor of MultiPartOutputFile as well. // ---------------------------------------------------------------- DeepTiledOutputFile (const OutputPartData* part); DeepTiledOutputFile (const DeepTiledOutputFile &) = delete; DeepTiledOutputFile & operator = (const DeepTiledOutputFile &) = delete; DeepTiledOutputFile (DeepTiledOutputFile &&) = delete; DeepTiledOutputFile & operator = (DeepTiledOutputFile &&) = delete; void initialize (const Header &header); bool isValidTile (int dx, int dy, int lx, int ly) const; size_t bytesPerLineForTile (int dx, int dy, int lx, int ly) const; Data * _data; friend class MultiPartOutputFile; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[i�9 ImfKeyCode.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_KEY_CODE_H #define INCLUDED_IMF_KEY_CODE_H //----------------------------------------------------------------------------- // // class KeyCode // // A KeyCode object uniquely identifies a motion picture film frame. // The following fields specifiy film manufacturer, film type, film // roll and the frame's position within the roll: // // filmMfcCode film manufacturer code // range: 0 - 99 // // filmType film type code // range: 0 - 99 // // prefix prefix to identify film roll // range: 0 - 999999 // // count count, increments once every perfsPerCount // perforations (see below) // range: 0 - 9999 // // perfOffset offset of frame, in perforations from // zero-frame reference mark // range: 0 - 119 // // perfsPerFrame number of perforations per frame // range: 1 - 15 // // typical values: // // 1 for 16mm film // 3, 4, or 8 for 35mm film // 5, 8 or 15 for 65mm film // // perfsPerCount number of perforations per count // range: 20 - 120 // // typical values: // // 20 for 16mm film // 64 for 35mm film // 80 or 120 for 65mm film // // For more information about the interpretation of those fields see // the following standards and recommended practice publications: // // SMPTE 254 Motion-Picture Film (35-mm) - Manufacturer-Printed // Latent Image Identification Information // // SMPTE 268M File Format for Digital Moving-Picture Exchange (DPX) // (section 6.1) // // SMPTE 270 Motion-Picture Film (65-mm) - Manufacturer- Printed // Latent Image Identification Information // // SMPTE 271 Motion-Picture Film (16-mm) - Manufacturer- Printed // Latent Image Identification Information // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE KeyCode { public: //------------------------------------- // Constructors and assignment operator //------------------------------------- IMF_EXPORT KeyCode (int filmMfcCode = 0, int filmType = 0, int prefix = 0, int count = 0, int perfOffset = 0, int perfsPerFrame = 4, int perfsPerCount = 64); IMF_EXPORT KeyCode (const KeyCode &other); ~KeyCode() = default; IMF_EXPORT KeyCode & operator = (const KeyCode &other); //---------------------------- // Access to individual fields //---------------------------- IMF_EXPORT int filmMfcCode () const; IMF_EXPORT void setFilmMfcCode (int filmMfcCode); IMF_EXPORT int filmType () const; IMF_EXPORT void setFilmType (int filmType); IMF_EXPORT int prefix () const; IMF_EXPORT void setPrefix (int prefix); IMF_EXPORT int count () const; IMF_EXPORT void setCount (int count); IMF_EXPORT int perfOffset () const; IMF_EXPORT void setPerfOffset (int perfOffset); IMF_EXPORT int perfsPerFrame () const; IMF_EXPORT void setPerfsPerFrame (int perfsPerFrame); IMF_EXPORT int perfsPerCount () const; IMF_EXPORT void setPerfsPerCount (int perfsPerCount); private: int _filmMfcCode; int _filmType; int _prefix; int _count; int _perfOffset; int _perfsPerFrame; int _perfsPerCount; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�]�~� � ImfLut.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_LUT_H #define INCLUDED_IMF_LUT_H //----------------------------------------------------------------------------- // // Lookup tables for efficient application // of half --> half functions to pixel data, // and some commonly applied functions. // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfRgbaFile.h" #include <ImathBox.h> #include <halfFunction.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER // // Lookup table for individual half channels. // class HalfLut { public: //------------ // Constructor //------------ template <class Function> HalfLut (Function f); //---------------------------------------------------------------------- // Apply the table to data[0], data[stride] ... data[(nData-1) * stride] //---------------------------------------------------------------------- IMF_EXPORT void apply (half *data, int nData, int stride = 1) const; //--------------------------------------------------------------- // Apply the table to a frame buffer slice (see ImfFrameBuffer.h) //--------------------------------------------------------------- IMF_EXPORT void apply (const Slice &data, const IMATH_NAMESPACE::Box2i &dataWindow) const; private: halfFunction <half> _lut; }; // // Lookup table for combined RGBA data. // class RgbaLut { public: //------------ // Constructor //------------ template <class Function> RgbaLut (Function f, RgbaChannels chn = WRITE_RGB); //---------------------------------------------------------------------- // Apply the table to data[0], data[stride] ... data[(nData-1) * stride] //---------------------------------------------------------------------- IMF_EXPORT void apply (Rgba *data, int nData, int stride = 1) const; //----------------------------------------------------------------------- // Apply the table to a frame buffer (see RgbaOutpuFile.setFrameBuffer()) //----------------------------------------------------------------------- IMF_EXPORT void apply (Rgba *base, int xStride, int yStride, const IMATH_NAMESPACE::Box2i &dataWindow) const; private: halfFunction <half> _lut; RgbaChannels _chn; }; // // 12bit log rounding reduces data to 20 stops with 200 steps per stop. // That makes 4000 numbers. An extra 96 just come along for the ride. // Zero explicitly remains zero. The first non-zero half will map to 1 // in the 0-4095 12log space. A nice power of two number is placed at // the center [2000] and that number is near 0.18. // IMF_EXPORT half round12log (half x); // // Round to n-bit precision (n should be between 0 and 10). // After rounding, the significand's 10-n least significant // bits will be zero. // struct roundNBit { roundNBit (int n): n(n) {} half operator () (half x) {return x.round(n);} int n; }; // // Template definitions // template <class Function> HalfLut::HalfLut (Function f): _lut(f, -HALF_MAX, HALF_MAX, half (0), half::posInf(), half::negInf(), half::qNan()) { // empty } template <class Function> RgbaLut::RgbaLut (Function f, RgbaChannels chn): _lut(f, -HALF_MAX, HALF_MAX, half (0), half::posInf(), half::negInf(), half::qNan()), _chn(chn) { // empty } OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[R&ޮ� � ImfStringAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_STRING_ATTRIBUTE_H #define INCLUDED_IMF_STRING_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class StringAttribute // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" #include <string> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<std::string> StringAttribute; #ifndef COMPILING_IMF_STRING_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<std::string>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�c� � ImfOutputFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_OUTPUT_FILE_H #define INCLUDED_IMF_OUTPUT_FILE_H //----------------------------------------------------------------------------- // // class OutputFile // //----------------------------------------------------------------------------- #include "ImfForward.h" #include "ImfGenericOutputFile.h" #include "ImfThreading.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE OutputFile : public GenericOutputFile { public: //----------------------------------------------------------- // Constructor -- opens the file and writes the file header. // The file header is also copied into the OutputFile object, // and can later be accessed via the header() method. // Destroying this OutputFile object automatically closes // the file. // // numThreads determines the number of threads that will be // used to write the file (see ImfThreading.h). //----------------------------------------------------------- IMF_EXPORT OutputFile (const char fileName[], const Header &header, int numThreads = globalThreadCount()); //------------------------------------------------------------ // Constructor -- attaches the new OutputFile object to a file // that has already been opened, and writes the file header. // The file header is also copied into the OutputFile object, // and can later be accessed via the header() method. // Destroying this OutputFile object does not automatically // close the file. // // numThreads determines the number of threads that will be // used to write the file (see ImfThreading.h). //------------------------------------------------------------ IMF_EXPORT OutputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, const Header &header, int numThreads = globalThreadCount()); //------------------------------------------------- // Destructor // // Destroying the OutputFile object before writing // all scan lines within the data window results in // an incomplete file. //------------------------------------------------- IMF_EXPORT virtual ~OutputFile (); //------------------------ // Access to the file name //------------------------ IMF_EXPORT const char * fileName () const; //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; //------------------------------------------------------- // Set the current frame buffer -- copies the FrameBuffer // object into the OutputFile object. // // The current frame buffer is the source of the pixel // data written to the file. The current frame buffer // must be set at least once before writePixels() is // called. The current frame buffer can be changed // after each call to writePixels. //------------------------------------------------------- IMF_EXPORT void setFrameBuffer (const FrameBuffer &frameBuffer); //----------------------------------- // Access to the current frame buffer //----------------------------------- IMF_EXPORT const FrameBuffer & frameBuffer () const; //------------------------------------------------------------------- // Write pixel data: // // writePixels(n) retrieves the next n scan lines worth of data from // the current frame buffer, starting with the scan line indicated by // currentScanLine(), and stores the data in the output file, and // progressing in the direction indicated by header.lineOrder(). // // To produce a complete and correct file, exactly m scan lines must // be written, where m is equal to // header().dataWindow().max.y - header().dataWindow().min.y + 1. //------------------------------------------------------------------- IMF_EXPORT void writePixels (int numScanLines = 1); //------------------------------------------------------------------ // Access to the current scan line: // // currentScanLine() returns the y coordinate of the first scan line // that will be read from the current frame buffer during the next // call to writePixels(). // // If header.lineOrder() == INCREASING_Y: // // The current scan line before the first call to writePixels() // is header().dataWindow().min.y. After writing each scan line, // the current scan line is incremented by 1. // // If header.lineOrder() == DECREASING_Y: // // The current scan line before the first call to writePixels() // is header().dataWindow().max.y. After writing each scan line, // the current scan line is decremented by 1. // //------------------------------------------------------------------ IMF_EXPORT int currentScanLine () const; //-------------------------------------------------------------- // Shortcut to copy all pixels from an InputFile into this file, // without uncompressing and then recompressing the pixel data. // This file's header must be compatible with the InputFile's // header: The two header's "dataWindow", "compression", // "lineOrder" and "channels" attributes must be the same. //-------------------------------------------------------------- IMF_EXPORT void copyPixels (InputFile &in); //------------------------------------------------------------- // Shortcut to copy all pixels from an InputPart into this file // - equivalent to copyPixel(InputFile &in) but for multipart files //--------------------------------------------------------------- IMF_EXPORT void copyPixels (InputPart &in); //-------------------------------------------------------------- // Updating the preview image: // // updatePreviewImage() supplies a new set of pixels for the // preview image attribute in the file's header. If the header // does not contain a preview image, updatePreviewImage() throws // an IEX_NAMESPACE::LogicExc. // // Note: updatePreviewImage() is necessary because images are // often stored in a file incrementally, a few scan lines at a // time, while the image is being generated. Since the preview // image is an attribute in the file's header, it gets stored in // the file as soon as the file is opened, but we may not know // what the preview image should look like until we have written // the last scan line of the main image. // //-------------------------------------------------------------- IMF_EXPORT void updatePreviewImage (const PreviewRgba newPixels[]); //--------------------------------------------------------- // Break a scan line -- for testing and debugging only: // // breakScanLine(y,p,n,c) introduces an error into the // output file by writing n copies of character c, starting // p bytes from the beginning of the pixel data block that // contains scan line y. // // Warning: Calling this function usually results in a // broken image file. The file or parts of it may not // be readable, or the file may contain bad data. // //--------------------------------------------------------- IMF_EXPORT void breakScanLine (int y, int offset, int length, char c); struct IMF_HIDDEN Data; private: //------------------------------------------------------------ // Constructor -- attaches the OutputStreamMutex to the // given one from MultiPartOutputFile. Set the previewPosition // and lineOffsetsPosition which have been acquired from // the constructor of MultiPartOutputFile as well. //------------------------------------------------------------ IMF_HIDDEN OutputFile (const OutputPartData* part); OutputFile (const OutputFile &) = delete; OutputFile & operator = (const OutputFile &) = delete; OutputFile (OutputFile &&) = delete; OutputFile & operator = (OutputFile &&) = delete; void initialize (const Header &header); Data * _data; friend class MultiPartOutputFile; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[}+� � ImfDeepCompositing.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Weta Digital, Ltd and Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_DEEPCOMPOSITING_H #define INCLUDED_IMF_DEEPCOMPOSITING_H //----------------------------------------------------------------------------- // // Class to sort and composite deep samples into a frame buffer // You may derive from this class to change the way that CompositeDeepScanLine // and CompositeDeepTile combine samples together - pass an instance of your derived // class to the compositing engine // //----------------------------------------------------------------------------- #include "ImfForward.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE DeepCompositing { public: IMF_EXPORT DeepCompositing(); IMF_EXPORT virtual ~DeepCompositing(); ////////////////////////////////////////////// /// /// composite together the given channels /// /// @param outputs - return array of pixel values - /// @param inputs - arrays of input sample /// @param channel_names - array of channel names for corresponding channels /// @param num_channels - number of active channels (3 or greater) /// @param num_samples - number of values in all input arrays /// @param sources - number of different sources /// /// each array input has num_channels entries: outputs[n] should be the composited /// values in array inputs[n], whose name will be given by channel_names[n] /// /// The channel ordering shall be as follows: /// Position Channel /// 0 Z /// 1 ZBack (if no ZBack, then inputs[1]==inputs[0] and channel_names[1]==channel_names[0]) /// 2 A (alpha channel) /// 3-n other channels - only channels in the frame buffer will appear here /// /// since a Z and Alpha channel is required, and channel[1] is ZBack or another copy of Z /// there will always be 3 or more channels. /// /// The default implementation calls sort() if and only if more than one source is active, /// composites all samples together using the Over operator from front to back, /// stopping as soon as a sample with alpha=1 is found /// It also blanks all outputs if num_samples==0 /// /// note - multiple threads may call composite_pixel simultaneously for different pixels /// /// ////////////////////////////////////////////// IMF_EXPORT virtual void composite_pixel(float outputs[], const float * inputs[], const char * channel_names[], int num_channels, int num_samples, int sources ); //////////////////////////////////////////////////////////////// /// /// find the depth order for samples with given channel values /// does not sort the values in-place. Instead it populates /// array 'order' with the desired sorting order /// /// the default operation sorts samples from front to back according to their Z channel /// /// @param order - required output order. order[n] shall be the nth closest sample /// @param inputs - arrays of input samples, one array per channel_name /// @param channel_names - array of channel names for corresponding channels /// @param num_channels - number of channels (3 or greater) /// @param num_samples - number of samples in each array /// @param sources - number of different sources the data arises from /// /// the channel layout is identical to composite_pixel() /// /////////////////////////////////////////////////////////////// IMF_EXPORT virtual void sort(int order[], const float * inputs[], const char * channel_names[], int num_channels, int num_samples, int sources); }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[ �B�� � IlmThread.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_ILM_THREAD_H #define INCLUDED_ILM_THREAD_H //----------------------------------------------------------------------------- // // class Thread // // Class Thread is a portable interface to a system-dependent thread // primitive. In order to make a thread actually do something useful, // you must derive a subclass from class Thread and implement the // run() function. If the operating system supports threading then // the run() function will be executed int a new thread. // // The actual creation of the thread is done by the start() routine // which then calls the run() function. In general the start() // routine should be called from the constructor of the derived class. // // The base-class thread destructor will join/destroy the thread. // // IMPORTANT: Due to the mechanisms that encapsulate the low-level // threading primitives in a C++ class there is a race condition // with code resembling the following: // // { // WorkerThread myThread; // } // myThread goes out of scope, is destroyed // // and the thread is joined // // The race is between the parent thread joining the child thread // in the destructor of myThread, and the run() function in the // child thread. If the destructor gets executed first then run() // will be called with an invalid "this" pointer. // // This issue can be fixed by using a Semaphore to keep track of // whether the run() function has already been called. You can // include a Semaphore member variable within your derived class // which you post() on in the run() function, and wait() on in the // destructor before the thread is joined. Alternatively you could // do something like this: // // Semaphore runStarted; // // void WorkerThread::run () // { // runStarted.post() // // do some work // ... // } // // { // WorkerThread myThread; // runStarted.wait (); // ensure that we have started // // the run function // } // myThread goes out of scope, is destroyed // // and the thread is joined // //----------------------------------------------------------------------------- #include "IlmThreadConfig.h" #include "IlmThreadExport.h" #include "IlmThreadNamespace.h" #if ILMTHREAD_THREADING_ENABLED #include <thread> #endif ILMTHREAD_INTERNAL_NAMESPACE_HEADER_ENTER // // Query function to determine if the current platform supports // threads AND this library was compiled with threading enabled. // ILMTHREAD_EXPORT bool supportsThreads (); class ILMTHREAD_EXPORT_TYPE Thread { public: ILMTHREAD_EXPORT Thread (); ILMTHREAD_EXPORT virtual ~Thread (); ILMTHREAD_EXPORT void start (); virtual void run () = 0; // // wait for thread to exit - must be called before deleting thread // ILMTHREAD_EXPORT void join(); ILMTHREAD_EXPORT bool joinable() const; private: #if ILMTHREAD_THREADING_ENABLED std::thread _thread; #endif Thread &operator= (const Thread& t) = delete; Thread &operator= (Thread&& t) = delete; Thread (const Thread& t) = delete; Thread (Thread&& t) = delete; }; ILMTHREAD_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_ILM_THREAD_H PK rM�[ ��<E E ImfPartHelper.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Weta Digital, Ltd and Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_PARTHELPER_H #define INCLUDED_IMF_PARTHELPER_H //----------------------------------------------------------------------------- // // Functions to help split channels into separate parts: provide a list of // channels, with desired views. call SplitChannels to assign a part to each // layer, or correct the name of the channel. // Also can enumerate the parts in a file and list which parts channels are in // // This is a good way to offer a 'create Multipart file' checkbox to the user in a // write dialog box: Populate a list of MultiViewChannelName objects, // call SplitChannels with whether single or multipart files are required. // Then write the number of parts it specifies, using internal_name for the channel // names in the ChannelList and FrameBuffer objects. There should be no need // for different codepaths for single part and multipart files // // Similarly, on reading a file as a MultiPartInputFile, use GetChannelsInMultiPartFile to // enumerate all channels in the file, using internal_name in FrameBuffer objects // to read the channel // // //----------------------------------------------------------------------------- #include "ImfForward.h" #include "ImfNamespace.h" #include "ImfExport.h" #include "ImfMultiPartInputFile.h" #include "ImfChannelList.h" #include "ImfStringVectorAttribute.h" #include "ImfStandardAttributes.h" #include "ImfMultiView.h" #include <string> #include <map> #include <set> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER struct MultiViewChannelName{ public: std::string name; ///< name of channel std::string view; ///< view for channel int part_number; ///< part number: updated by SplitChannels std::string internal_name;///< name used in headers: in singlepart mode, may contain viewname //return layer for this channel, or "" if no layer std::string getLayer() const { std::size_t q=name.rfind('.'); if( q==name.npos ) { return ""; } return name.substr(0,q); } std::string getSuffix() const { std::size_t q=name.rfind('.'); if( q==name.npos ) { return name; } return name.substr(q+1); } }; // ///\brief assigns individual channels to different parts based on their layer and view name /// input is an array, list, vector etc of MultiViewChannelName objects /// on entry, each MultiViewChannelName name/view must be set (view can be empty if not multiview) /// /// if singlepart set, then on exit part_number will be zero, and internal_name will have view name inserted /// otherwise, each channel will be assigned to a different part based on its layer name and view name /// /// @param begin pointer to first MultiViewChannelName item /// @param end pointer to end of MultiViewChannelName item array /// @return total number of parts required // template<typename T> inline int SplitChannels(const T & begin,const T & end,bool multipart=true,const std::string & heroView=std::string()) { if(!multipart) { for(T i=begin;i!=end;i++) { i->part_number=0; //does this have a view name set? if(i->view=="") { i->internal_name=i->name; }else{ std::string lname = i->getLayer(); // no layer, only non-hero views get view name in layer name if(lname=="") { if(i->view==heroView) { i->internal_name = i->name; }else{ i->internal_name = i->view+"."+i->name; } }else{ i->internal_name = lname+"."+i->view+"."+i->getSuffix(); } } } // single part created return 1; }else{ // step 1: extract individual layers and parts // for each layer, enumerate which views are active std::map< std::string , std::set< std::string > > viewsInLayers; for(T i=begin;i!=end;i++) { viewsInLayers[i->getLayer()].insert(i->view); } // step 2: assign a part number to each layer/view std::map< std::pair<std::string,std::string> , int > layerToPart; int partCount=0; for(std::map< std::string , std::set< std::string > >::const_iterator layer=viewsInLayers.begin(); layer!=viewsInLayers.end();layer++) { // if this layer has a heroView, insert that first bool layer_has_hero = layer->second.find(heroView)!=layer->second.end(); if( layer_has_hero ) { layerToPart[ std::make_pair(layer->first,heroView) ] = partCount++; } // insert other layers which aren't the hero view for(std::set< std::string >::const_iterator view=layer->second.begin(); view!=layer->second.end();view++) { if(*view!=heroView) { layerToPart[ std::make_pair(layer->first,*view) ] = partCount++; } } } // step 3: update part number of each provided channel for( T i=begin;i!=end;i++) { i->internal_name=i->name; i->part_number = layerToPart[ std::make_pair(i->getLayer(),i->view) ]; } // return number of parts created return partCount; } } // // populate the chans vector<MultiViewChannelName> with a list of channels in the file // and their corresponding part number // template<class T> inline void GetChannelsInMultiPartFile(const MultiPartInputFile & file,T & chans) { bool has_multiview=false; StringVector mview; if(file.parts()==1) { if(hasMultiView(file.header(0))) { mview=multiView(file.header(0)); has_multiview=true; } } for(int p=0;p<file.parts();p++) { const ChannelList & c=file.header(p).channels(); std::string view=""; if(file.header(p).hasView()) { view=file.header(p).view(); } for(ChannelList::ConstIterator i=c.begin();i!=c.end();i++) { MultiViewChannelName m; m.name=std::string(i.name()); m.internal_name=m.name; if(has_multiview) { m.view=viewFromChannelName(m.name,mview); m.name=removeViewName(m.internal_name,m.view); }else{ m.view=view; } m.part_number=p; chans.push_back(m); } } } OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[b��a a IexMacros.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IEXMACROS_H #define INCLUDED_IEXMACROS_H //-------------------------------------------------------------------- // // Macros which make throwing exceptions more convenient // //-------------------------------------------------------------------- #include <sstream> //---------------------------------------------------------------------------- // A macro to throw exceptions whose text is assembled using stringstreams. // // Example: // // THROW (InputExc, "Syntax error in line " << line ", " << file << "."); // //---------------------------------------------------------------------------- #include "IexExport.h" #include "IexForward.h" IEX_EXPORT void iex_debugTrap(); #define THROW(type, text) \ do \ { \ iex_debugTrap(); \ std::stringstream _iex_throw_s; \ _iex_throw_s << text; \ throw type (_iex_throw_s); \ } \ while (0) //---------------------------------------------------------------------------- // Macros to add to or to replace the text of an exception. // The new text is assembled using stringstreams. // // Examples: // // Append to end of an exception's text: // // catch (BaseExc &e) // { // APPEND_EXC (e, " Directory " << name << " does not exist."); // throw; // } // // Replace an exception's text: // // catch (BaseExc &e) // { // REPLACE_EXC (e, "Directory " << name << " does not exist. " << e); // throw; // } //---------------------------------------------------------------------------- #define APPEND_EXC(exc, text) \ do \ { \ std::stringstream _iex_append_s; \ _iex_append_s << text; \ exc.append (_iex_append_s); \ } \ while (0) #define REPLACE_EXC(exc, text) \ do \ { \ std::stringstream _iex_replace_s; \ _iex_replace_s << text; \ exc.assign (_iex_replace_s); \ } \ while (0) //------------------------------------------------------------- // A macro to throw ErrnoExc exceptions whose text is assembled // using stringstreams: // // Example: // // THROW_ERRNO ("Cannot open file " << name << " (%T)."); // //------------------------------------------------------------- #define THROW_ERRNO(text) \ do \ { \ std::stringstream _iex_throw_errno_s; \ _iex_throw_errno_s << text; \ ::IEX_NAMESPACE::throwErrnoExc (_iex_throw_errno_s.str()); \ } \ while (0) //------------------------------------------------------------- // A macro to throw exceptions if an assertion is false. // // Example: // // ASSERT (ptr != 0, NullExc, "Null pointer" ); // //------------------------------------------------------------- #define ASSERT(assertion, type, text) \ do \ { \ if( bool(assertion) == false ) \ { \ THROW( type, text ); \ } \ } \ while (0) //------------------------------------------------------------- // A macro to throw an IEX_NAMESPACE::LogicExc if an assertion is false, // with the text composed from the source code file, line number, // and assertion argument text. // // Example: // // LOGIC_ASSERT (i < n); // //------------------------------------------------------------- #define LOGIC_ASSERT(assertion) \ ASSERT(assertion, \ IEX_NAMESPACE::LogicExc, \ __FILE__ << "(" << __LINE__ << "): logical assertion failed: " << #assertion ) #endif PK rM�[e��K�0 �0 openexr_encode.hnu �[��� /* ** SPDX-License-Identifier: BSD-3-Clause ** Copyright Contributors to the OpenEXR Project. */ #ifndef OPENEXR_CORE_ENCODE_H #define OPENEXR_CORE_ENCODE_H #include "openexr_chunkio.h" #include "openexr_coding.h" #ifdef __cplusplus extern "C" { #endif /** Can be bit-wise or'ed into the decode_flags in the decode pipeline. * * Indicates that the sample count table should be encoded from an * individual sample count list (n, m, o, ...), meaning it will have * to compute the cumulative counts on the fly. * * Without this (i.e. a value of 0 in that bit), indicates the sample * count table is already a cumulative list (n, n+m, n+m+o, ...), * which is the on-disk representation */ #define EXR_ENCODE_DATA_SAMPLE_COUNTS_ARE_INDIVIDUAL ((uint16_t) (1 << 0)) /** Can be bit-wise or'ed into the decode_flags in the decode pipeline. * * Indicates that the data in the channel pointers to encode from is not * a direct pointer, but instead is a pointer-to-pointers. In this * mode, the user_pixel_stride and user_line_stride are used to * advance the pointer offsets for each pixel in the output, but the * user_bytes_per_element and user_data_type are used to put * (successive) entries into each destination. * * So each channel pointer must then point to an array of * chunk.width * chunk.height pointers. If an entry is * NULL, 0 samples will be placed in the output. * * If this is NOT set (0), the default packing routine assumes the * data will be planar and contiguous (each channel is a separate * memory block), ignoring user_line_stride and user_pixel_stride and * advancing only by the sample counts and bytes per element */ #define EXR_ENCODE_NON_IMAGE_DATA_AS_POINTERS ((uint16_t) (1 << 1)) /** * Structure meant to be used on a per-thread basis for writing exr data * * As should be obvious, this structure is NOT thread safe, but rather * meant to be used by separate threads, which can all be accessing * the same context concurrently. */ typedef struct _exr_encode_pipeline { /** the output channel information for this chunk * * User is expected to fill the channel pointers for the input * channels. For writing, all channels must be initialized prior * to using \ref exr_choose_pack_routine. If a custom pack routine * is written, that is up to the implementor. * * Describes the channel information. This information is * allocated dynamically during \ref exr_initialize_encoding */ exr_coding_channel_info_t* channels; int16_t channel_count; /** Encode flags to control the behavior*/ uint16_t encode_flags; /** copy of the parameters given to the initialize / update for convenience */ int part_index; exr_const_context_t context; exr_chunk_info_t chunk; /** * can be used by the user to pass custom context data through * the encode pipeline */ void* encoding_user_data; /** the packed buffer where individual channels have been put into here. * * If null, will be allocated during the run of the pipeline. * * If the caller wishes to take control of the buffer, simple * adopt the pointer and set it to null here. Be cognizant of any * custom allocators. */ void* packed_buffer; /** differing from the allocation size, the number of actual bytes */ uint64_t packed_bytes; /** used when re-using the same encode pipeline struct to know if * chunk is changed size whether current buffer is large enough * * If null, will be allocated during the run of the pipeline. * * If the caller wishes to take control of the buffer, simple * adopt the pointer and set it to null here. Be cognizant of any * custom allocators. */ size_t packed_alloc_size; /** for deep data. NB: the members NOT const because we need to * temporarily swap it to xdr order and restore it (to avoid a * duplicate buffer allocation) * * Depending on the flag set above, will be treated either as a * cumulative list (n, n+m, n+m+o, ...), or an individual table * (n, m, o, ...). */ int32_t* sample_count_table; /** allocated table size (to avoid re-allocations). Number of * samples must always be width * height for the chunk */ size_t sample_count_alloc_size; /** packed sample table (i.e. compressed, raw on disk * representation) for deep or other non-image data */ void* packed_sample_count_table; /** Number of bytes to write (actual size) for the * packed_sample_count_table */ size_t packed_sample_count_bytes; /** Allocated size (to avoid re-allocations) for the * packed_sample_count_table */ size_t packed_sample_count_alloc_size; /** the compressed buffer, only needed for * compressed files * * If null, will be allocated during the run of the pipeline when * needed. * * If the caller wishes to take control of the buffer, simple * adopt the pointer and set it to null here. Be cognizant of any * custom allocators. */ void* compressed_buffer; /** must be filled in as the pipeline runs to inform the writing * software about the compressed size of the chunk (if it is an * uncompressed file or the compression would make the file * larger, it is expected to be the packed_buffer) * * If the caller wishes to take control of the buffer, simple * adopt the pointer and set it to zero here. Be cognizant of any * custom allocators. */ size_t compressed_bytes; /** used when re-using the same encode pipeline struct to know if * chunk is changed size whether current buffer is large enough * * If null, will be allocated during the run of the pipeline when * needed. * * If the caller wishes to take control of the buffer, simple * adopt the pointer and set it to zero here. Be cognizant of any * custom allocators. */ size_t compressed_alloc_size; /** a scratch buffer for intermediate results * * If null, will be allocated during the run of the pipeline when * needed. * * If the caller wishes to take control of the buffer, simple * adopt the pointer and set it to null here. Be cognizant of any * custom allocators. */ void* scratch_buffer_1; /** used when re-using the same encode pipeline struct to know if * chunk is changed size whether current buffer is large enough * * If null, will be allocated during the run of the pipeline when * needed. * * If the caller wishes to take control of the buffer, simple * adopt the pointer and set it to null here. Be cognizant of any * custom allocators. */ size_t scratch_alloc_size_1; /** some compression routines may need a second scratch buffer * * If null, will be allocated during the run of the pipeline when * needed. * * If the caller wishes to take control of the buffer, simple * adopt the pointer and set it to null here. Be cognizant of any * custom allocators. */ void* scratch_buffer_2; /** used when re-using the same encode pipeline struct to know if * chunk is changed size whether current buffer is large enough */ size_t scratch_alloc_size_2; /** * enables a custom allocator for the different buffers (i.e. if * encoding on a GPU). If NULL, will use the allocator from the * context */ void* (*alloc_fn) (enum transcoding_pipeline_buffer_id, size_t); /** * enables a custom allocator for the different buffers (i.e. if * encoding on a GPU). If NULL, will use the allocator from the * context */ void (*free_fn) (enum transcoding_pipeline_buffer_id, void*); /** * Function chosen based on the output layout of the channels of the part to * decompress data. * * If the user has a custom method for the * compression on this part, this can be changed after * initialization. */ exr_result_t (*convert_and_pack_fn) (struct _exr_encode_pipeline* pipeline); /** * Function chosen based on the compression type of the part to * compress data. * * If the user has a custom compression method for the compression * type on this part, this can be changed after initialization. */ exr_result_t (*compress_fn) (struct _exr_encode_pipeline* pipeline); /** * This routine is used when waiting for other threads to finish * writing previous chunks such that this thread can write this * chunk. This is used for parts which have a specified chunk * ordering (increasing / decreasing y) and the chunks can not be * written randomly (as could be true for uncompressed). * * This enables the calling application to contribute thread time * to other computation as needed, or just use something like * pthread_yield(). * * By default, this routine will be assigned to a function which * returns an error, failing the encode immediately. In this way, * it assumes that there is only one thread being used for * writing. * * It is up to the user to provide an appropriate routine if * performing multi-threaded writing. */ exr_result_t (*yield_until_ready_fn) ( struct _exr_encode_pipeline* pipeline); /** * Function chosen to write chunk data to the context. * * This is allowed to be overridden, but probably is not necessary * in most scenarios */ exr_result_t (*write_fn) (struct _exr_encode_pipeline* pipeline); /** * Small stash of channel info values. This is faster than calling * malloc when the channel count in the part is small (RGBAZ), * which is super common, however if there are a large number of * channels, it will allocate space for that, so do not rely on * this being used */ exr_coding_channel_info_t _quick_chan_store[5]; } exr_encode_pipeline_t; /** @brief simple macro to initialize an empty decode pipeline */ #define EXR_ENCODE_PIPELINE_INITIALIZER \ { \ 0 \ } /** Initialize the encoding pipeline structure with the channel info * for the specified part based on the chunk to be written * * NB: The \ref pack_and_convert_fn will be NULL after this. If that * stage is desired, initialize the channel output information and * call \ref exr_choose_unpack_routine */ EXR_EXPORT exr_result_t exr_encoding_initialize ( exr_const_context_t ctxt, int part_index, const exr_chunk_info_t* cinfo, exr_encode_pipeline_t* encode_pipe); /** Given an initialized encode pipeline, find an appropriate * function to shuffle and convert data into the defined channel * outputs * * Calling this is not required if a custom routine will be used, or * if just the raw decompressed data is desired. */ EXR_EXPORT exr_result_t exr_encoding_choose_default_routines ( exr_const_context_t ctxt, int part_index, exr_encode_pipeline_t* encode_pipe); /** Given a encode pipeline previously initialized, update it for the * new chunk to be written. * * In this manner, memory buffers can be re-used to avoid continual * malloc / free calls. Further, it allows the previous choices for * the various functions to be quickly re-used. */ EXR_EXPORT exr_result_t exr_encoding_update ( exr_const_context_t ctxt, int part_index, const exr_chunk_info_t* cinfo, exr_encode_pipeline_t* encode_pipe); /** Execute the encoding pipeline */ EXR_EXPORT exr_result_t exr_encoding_run ( exr_const_context_t ctxt, int part_index, exr_encode_pipeline_t* encode_pipe); /** Free any intermediate memory in the encoding pipeline * * This does NOT free any pointers referred to in the channel info * areas, but rather only the intermediate buffers and memory needed * for the structure itself. */ EXR_EXPORT exr_result_t exr_encoding_destroy ( exr_const_context_t ctxt, exr_encode_pipeline_t* encode_pipe); #ifdef __cplusplus } /* extern "C" */ #endif #endif /* OPENEXR_CORE_ENCODE_H */ PK rM�[e)e� ImfMultiPartInputFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef IMFMULTIPARTINPUTFILE_H_ #define IMFMULTIPARTINPUTFILE_H_ #include "ImfForward.h" #include "ImfGenericInputFile.h" #include "ImfThreading.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE MultiPartInputFile : public GenericInputFile { public: IMF_EXPORT MultiPartInputFile(const char fileName[], int numThreads = globalThreadCount(), bool reconstructChunkOffsetTable = true); IMF_EXPORT MultiPartInputFile(IStream& is, int numThreads = globalThreadCount(), bool reconstructChunkOffsetTable = true); IMF_EXPORT virtual ~MultiPartInputFile(); // ---------------------- // Count of number of parts in file // --------------------- IMF_EXPORT int parts() const; //---------------------- // Access to the headers //---------------------- IMF_EXPORT const Header & header(int n) const; //---------------------------------- // Access to the file format version //---------------------------------- IMF_EXPORT int version () const; // =---------------------------------------- // Check whether the entire chunk offset // table for the part is written correctly // ----------------------------------------- IMF_EXPORT bool partComplete(int part) const; // ---------------------------------------- // Flush internal part cache // Invalidates all 'Part' types previously // constructed from this file // Intended for test purposes, but can be // used to temporarily reduce memory overhead, // or to switch between types (e.g. TiledInputPart // or DeepScanLineInputPart to InputPart) // ---------------------------------------- IMF_EXPORT void flushPartCache(); struct IMF_HIDDEN Data; private: Data* _data; MultiPartInputFile(const MultiPartInputFile &) = delete; MultiPartInputFile& operator = (const MultiPartInputFile &) = delete; MultiPartInputFile(MultiPartInputFile &&) = delete; MultiPartInputFile& operator = (MultiPartInputFile &&) = delete; // // used internally by 'Part' types to access individual parts of the multipart file // template<class T> IMF_HIDDEN T* getInputPart(int partNumber); IMF_HIDDEN InputPartData* getPart(int); IMF_HIDDEN void initialize(); friend class InputPart; friend class ScanLineInputPart; friend class TiledInputPart; friend class DeepScanLineInputPart; friend class DeepTiledInputPart; // // For backward compatibility. // friend class InputFile; friend class TiledInputFile; friend class ScanLineInputFile; friend class DeepScanLineInputFile; friend class DeepTiledInputFile; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif /* IMFMULTIPARTINPUTFILE_H_ */ PK rM�[�)�=k k ImfTiledOutputPart.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef IMFTILEDOUTPUTPART_H_ #define IMFTILEDOUTPUTPART_H_ #include "ImfForward.h" #include "ImfTileDescription.h" #include <ImathBox.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER //------------------------------------------------------------------------------- // class TiledOutputPart: // // Same interface as TiledOutputFile. Please have a reference to TiledOutputFile. //------------------------------------------------------------------------------- class TiledOutputPart { public: IMF_EXPORT TiledOutputPart(MultiPartOutputFile& multiPartFile, int partNumber); IMF_EXPORT const char * fileName () const; IMF_EXPORT const Header & header () const; IMF_EXPORT void setFrameBuffer (const FrameBuffer &frameBuffer); IMF_EXPORT const FrameBuffer & frameBuffer () const; IMF_EXPORT unsigned int tileXSize () const; IMF_EXPORT unsigned int tileYSize () const; IMF_EXPORT LevelMode levelMode () const; IMF_EXPORT LevelRoundingMode levelRoundingMode () const; IMF_EXPORT int numLevels () const; IMF_EXPORT int numXLevels () const; IMF_EXPORT int numYLevels () const; IMF_EXPORT bool isValidLevel (int lx, int ly) const; IMF_EXPORT int levelWidth (int lx) const; IMF_EXPORT int levelHeight (int ly) const; IMF_EXPORT int numXTiles (int lx = 0) const; IMF_EXPORT int numYTiles (int ly = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int lx, int ly) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int lx, int ly) const; IMF_EXPORT void writeTile (int dx, int dy, int l = 0); IMF_EXPORT void writeTile (int dx, int dy, int lx, int ly); IMF_EXPORT void writeTiles (int dx1, int dx2, int dy1, int dy2, int lx, int ly); IMF_EXPORT void writeTiles (int dx1, int dx2, int dy1, int dy2, int l = 0); IMF_EXPORT void copyPixels (TiledInputFile &in); IMF_EXPORT void copyPixels (InputFile &in); IMF_EXPORT void copyPixels (TiledInputPart &in); IMF_EXPORT void copyPixels (InputPart &in); IMF_EXPORT void updatePreviewImage (const PreviewRgba newPixels[]); IMF_EXPORT void breakTile (int dx, int dy, int lx, int ly, int offset, int length, char c); private: TiledOutputFile* file; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif /* IMFTILEDOUTPUTPART_H_ */ PK rM�[�1��� � ImfFlatImage.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_FLAT_IMAGE_H #define INCLUDED_IMF_FLAT_IMAGE_H //---------------------------------------------------------------------------- // // class FlatImage // // For an explanation of images, levels and channels, // see the comments in header file Image.h. // //---------------------------------------------------------------------------- #include "ImfFlatImageLevel.h" #include "ImfImage.h" #include "ImfUtilExport.h" #include "ImfTileDescription.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMFUTIL_EXPORT_TYPE FlatImage : public Image { public: // // Constructors and destructor. // The default constructor constructs an image with an empty data // window level mode ONE_LEVEL and level rounding mode ROUND_DOWN. // IMFUTIL_EXPORT FlatImage(); IMFUTIL_EXPORT FlatImage(const IMATH_NAMESPACE::Box2i &dataWindow, LevelMode levelMode = ONE_LEVEL, LevelRoundingMode levelRoundingMode = ROUND_DOWN); IMFUTIL_EXPORT virtual ~FlatImage(); // // Accessing image levels by level number // IMFUTIL_EXPORT virtual FlatImageLevel & level(int l = 0); IMFUTIL_EXPORT virtual const FlatImageLevel & level(int l = 0) const; IMFUTIL_EXPORT virtual FlatImageLevel & level(int lx, int ly); IMFUTIL_EXPORT virtual const FlatImageLevel & level(int lx, int ly) const; protected: IMFUTIL_EXPORT virtual FlatImageLevel * newLevel (int lx, int ly, const IMATH_NAMESPACE::Box2i &dataWindow); }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[Z��� � IlmThreadConfig.hnu �[��� // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // This file is auto-generated by the cmake configure step #ifndef INCLUDED_ILMTHREAD_CONFIG_H #define INCLUDED_ILMTHREAD_CONFIG_H 1 #pragma once // // // C++ namespace configuration / options #define ILMTHREAD_THREADING_ENABLED 1 #define ILMTHREAD_HAVE_POSIX_SEMAPHORES 1 // // Current internal library namepace name // #define ILMTHREAD_INTERNAL_NAMESPACE_CUSTOM 0 #define ILMTHREAD_INTERNAL_NAMESPACE IlmThread_3_1 // // Current public user namepace name // #define ILMTHREAD_NAMESPACE_CUSTOM 0 #define ILMTHREAD_NAMESPACE IlmThread #if defined(__cplusplus) && (__cplusplus >= 201402L) # define ILMTHREAD_DEPRECATED(msg) [[deprecated(msg)]] #endif #ifndef ILMTHREAD_DEPRECATED # ifdef _MSC_VER # define ILMTHREAD_DEPRECATED(msg) __declspec(deprecated(msg)) # else # define ILMTHREAD_DEPRECATED(msg) __attribute__((deprecated(msg))) # endif #endif #endif // INCLUDED_ILMTHREAD_CONFIG_H PK rM�[�/�cZ Z ImfDeepScanLineInputPart.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef IMFDEEPSCANLINEINPUTPART_H_ #define IMFDEEPSCANLINEINPUTPART_H_ #include "ImfForward.h" #include <cstdint> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE DeepScanLineInputPart { public: IMF_EXPORT DeepScanLineInputPart(MultiPartInputFile& file, int partNumber); //------------------------ // Access to the file name //------------------------ IMF_EXPORT const char * fileName () const; //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; //---------------------------------- // Access to the file format version //---------------------------------- IMF_EXPORT int version () const; //----------------------------------------------------------- // Set the current frame buffer -- copies the FrameBuffer // object into the InputFile object. // // The current frame buffer is the destination for the pixel // data read from the file. The current frame buffer must be // set at least once before readPixels() is called. // The current frame buffer can be changed after each call // to readPixels(). //----------------------------------------------------------- IMF_EXPORT void setFrameBuffer (const DeepFrameBuffer &frameBuffer); //----------------------------------- // Access to the current frame buffer //----------------------------------- IMF_EXPORT const DeepFrameBuffer & frameBuffer () const; //--------------------------------------------------------------- // Check if the file is complete: // // isComplete() returns true if all pixels in the data window are // present in the input file, or false if any pixels are missing. // (Another program may still be busy writing the file, or file // writing may have been aborted prematurely.) //--------------------------------------------------------------- IMF_EXPORT bool isComplete () const; //--------------------------------------------------------------- // Read pixel data: // // readPixels(s1,s2) reads all scan lines with y coordinates // in the interval [min (s1, s2), max (s1, s2)] from the file, // and stores them in the current frame buffer. // // Both s1 and s2 must be within the interval // [header().dataWindow().min.y, header.dataWindow().max.y] // // The scan lines can be read from the file in random order, and // individual scan lines may be skipped or read multiple times. // For maximum efficiency, the scan lines should be read in the // order in which they were written to the file. // // readPixels(s) calls readPixels(s,s). // // If threading is enabled, readPixels (s1, s2) tries to perform // decopmression of multiple scanlines in parallel. // //--------------------------------------------------------------- IMF_EXPORT void readPixels (int scanLine1, int scanLine2); IMF_EXPORT void readPixels (int scanLine); IMF_EXPORT void readPixels (const char * rawPixelData,const DeepFrameBuffer & frameBuffer, int scanLine1,int scanLine2) const; //---------------------------------------------- // Read a block of raw pixel data from the file, // without uncompressing it (this function is // used to implement OutputFile::copyPixels()). //---------------------------------------------- IMF_EXPORT void rawPixelData (int firstScanLine, char * pixelData, uint64_t &pixelDataSize); //----------------------------------------------------------- // Read pixel sample counts into a slice in the frame buffer. // // readPixelSampleCounts(s1, s2) reads all the counts of // pixel samples with y coordinates in the interval // [min (s1, s2), max (s1, s2)] from the file, and stores // them in the slice naming "sample count". // // Both s1 and s2 must be within the interval // [header().dataWindow().min.y, header.dataWindow().max.y] // // readPixelSampleCounts(s) calls readPixelSampleCounts(s,s). //----------------------------------------------------------- IMF_EXPORT void readPixelSampleCounts(int scanline1, int scanline2); IMF_EXPORT void readPixelSampleCounts(int scanline); IMF_EXPORT void readPixelSampleCounts( const char * rawdata , const DeepFrameBuffer & frameBuffer, int scanLine1 , int scanLine2) const; IMF_EXPORT int firstScanLineInChunk(int y) const; IMF_EXPORT int lastScanLineInChunk (int y) const; private: DeepScanLineInputFile *file; // needed for copyPixels friend class DeepScanLineOutputFile; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif /* IMFDEEPSCANLINEINPUTPART_H_ */ PK rM�[o7?C C ImfRgba.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_RGBA_H #define INCLUDED_IMF_RGBA_H //----------------------------------------------------------------------------- // // class Rgba // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include <half.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER // // RGBA pixel // struct Rgba { half r; half g; half b; half a; Rgba () {} Rgba (half r, half g, half b, half a = 1.f): r (r), g (g), b (b), a (a) {} }; // // Channels in an RGBA file // enum IMF_EXPORT_ENUM RgbaChannels { WRITE_R = 0x01, // Red WRITE_G = 0x02, // Green WRITE_B = 0x04, // Blue WRITE_A = 0x08, // Alpha WRITE_Y = 0x10, // Luminance, for black-and-white images, // or in combination with chroma WRITE_C = 0x20, // Chroma (two subsampled channels, RY and BY, // supported only for scanline-based files) WRITE_RGB = 0x07, // Red, green, blue WRITE_RGBA = 0x0f, // Red, green, blue, alpha WRITE_YC = 0x30, // Luminance, chroma WRITE_YA = 0x18, // Luminance, alpha WRITE_YCA = 0x38 // Luminance, chroma, alpha }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�G�� � IexThrowErrnoExc.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IEXTHROWERRNOEXC_H #define INCLUDED_IEXTHROWERRNOEXC_H //---------------------------------------------------------- // // A function which throws ExcErrno exceptions // //---------------------------------------------------------- #include "IexBaseExc.h" #include "IexExport.h" IEX_INTERNAL_NAMESPACE_HEADER_ENTER //-------------------------------------------------------------------------- // // Function throwErrnoExc() throws an exception which corresponds to // error code errnum. The exception text is initialized with a copy // of the string passed to throwErrnoExc(), where all occurrences of // "%T" have been replaced with the output of strerror(oserror()). // // Example: // // If opening file /tmp/output failed with an ENOENT error code, // calling // // throwErrnoExc (); // // or // // throwErrnoExc ("%T."); // // will throw an EnoentExc whose text reads // // No such file or directory. // // More detailed messages can be assembled using stringstreams: // // std::stringstream s; // s << "Cannot open file " << name << " (%T)."; // throwErrnoExc (s); // // The resulting exception contains the following text: // // Cannot open file /tmp/output (No such file or directory). // // Alternatively, you may want to use the THROW_ERRNO macro defined // in IexMacros.h: // // THROW_ERRNO ("Cannot open file " << name << " (%T).") // //-------------------------------------------------------------------------- IEX_EXPORT void throwErrnoExc(const std::string &txt, int errnum); IEX_EXPORT void throwErrnoExc(const std::string &txt); IEX_EXPORT void throwErrnoExc(); IEX_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IEXTHROWERRNOEXC_H PK rM�[�J�F� � ImfRgbaYca.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_RGBA_YCA_H #define INCLUDED_IMF_RGBA_YCA_H //----------------------------------------------------------------------------- // // Conversion between RGBA (red, green, blue alpha) // and YCA (luminance, subsampled chroma, alpha) data: // // Luminance, Y, is computed as a weighted sum of R, G, and B: // // Y = yw.x * R + yw.y * G + yw.z * B // // Function computeYw() computes a set of RGB-to-Y weights, yw, // from a set of primary and white point chromaticities. // // Chroma, C, consists of two components, RY and BY: // // RY = (R - Y) / Y // BY = (B - Y) / Y // // For efficiency, the x and y subsampling rates for chroma are // hardwired to 2, and the chroma subsampling and reconstruction // filters are fixed 27-pixel wide windowed sinc functions. // // Starting with an image that has RGBA data for all pixels, // // RGBA RGBA RGBA RGBA ... RGBA RGBA // RGBA RGBA RGBA RGBA ... RGBA RGBA // RGBA RGBA RGBA RGBA ... RGBA RGBA // RGBA RGBA RGBA RGBA ... RGBA RGBA // ... // RGBA RGBA RGBA RGBA ... RGBA RGBA // RGBA RGBA RGBA RGBA ... RGBA RGBA // // function RGBAtoYCA() converts the pixels to YCA format: // // YCA YCA YCA YCA ... YCA YCA // YCA YCA YCA YCA ... YCA YCA // YCA YCA YCA YCA ... YCA YCA // YCA YCA YCA YCA ... YCA YCA // ... // YCA YCA YCA YCA ... YCA YCA // YCA YCA YCA YCA ... YCA YCA // // Next, decimateChomaHoriz() eliminates the chroma values from // the odd-numbered pixels in every scan line: // // YCA YA YCA YA ... YCA YA // YCA YA YCA YA ... YCA YA // YCA YA YCA YA ... YCA YA // YCA YA YCA YA ... YCA YA // ... // YCA YA YCA YA ... YCA YA // YCA YA YCA YA ... YCA YA // // decimateChromaVert() eliminates all chroma values from the // odd-numbered scan lines: // // YCA YA YCA YA ... YCA YA // YA YA YA YA ... YA YA // YCA YA YCA YA ... YCA YA // YA YA YA YA ... YA YA // ... // YCA YA YCA YA ... YCA YA // YA YA YA YA ... YA YA // // Finally, roundYCA() reduces the precision of the luminance // and chroma values so that the pixel data shrink more when // they are saved in a compressed file. // // The output of roundYCA() can be converted back to a set // of RGBA pixel data that is visually very similar to the // original RGBA image, by calling reconstructChromaHoriz(), // reconstructChromaVert(), YCAtoRGBA(), and finally // fixSaturation(). // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfRgba.h" #include "ImfChromaticities.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER namespace RgbaYca { // // Width of the chroma subsampling and reconstruction filters // static const int N = 27; static const int N2 = N / 2; // // Convert a set of primary chromaticities into a set of weighting // factors for computing a pixels's luminance, Y, from R, G and B // IMF_EXPORT IMATH_NAMESPACE::V3f computeYw (const Chromaticities &cr); // // Convert an array of n RGBA pixels, rgbaIn, to YCA (luminance/chroma/alpha): // // ycaOut[i].g = Y (rgbaIn[i]); // ycaOut[i].r = RY (rgbaIn[i]); // ycaOut[i].b = BY (rgbaIn[i]); // ycaOut[i].a = aIsValid? rgbaIn[i].a: 1 // // yw is a set of RGB-to-Y weighting factors, as computed by computeYw(). // IMF_EXPORT void RGBAtoYCA (const IMATH_NAMESPACE::V3f &yw, int n, bool aIsValid, const Rgba rgbaIn[/*n*/], Rgba ycaOut[/*n*/]); // // Perform horizontal low-pass filtering and subsampling of // the chroma channels of an array of n pixels. In order // to avoid indexing off the ends of the input array during // low-pass filtering, ycaIn must have N2 extra pixels at // both ends. Before calling decimateChromaHoriz(), the extra // pixels should be filled with copies of the first and last // "real" input pixel. // IMF_EXPORT void decimateChromaHoriz (int n, const Rgba ycaIn[/*n+N-1*/], Rgba ycaOut[/*n*/]); // // Perform vertical chroma channel low-pass filtering and subsampling. // N scan lines of input pixels are combined into a single scan line // of output pixels. // IMF_EXPORT void decimateChromaVert (int n, const Rgba * const ycaIn[N], Rgba ycaOut[/*n*/]); // // Round the luminance and chroma channels of an array of YCA // pixels that has already been filtered and subsampled. // The signifcands of the pixels' luminance and chroma values // are rounded to roundY and roundC bits respectively. // IMF_EXPORT void roundYCA (int n, unsigned int roundY, unsigned int roundC, const Rgba ycaIn[/*n*/], Rgba ycaOut[/*n*/]); // // For a scan line that has valid chroma data only for every other pixel, // reconstruct the missing chroma values. // IMF_EXPORT void reconstructChromaHoriz (int n, const Rgba ycaIn[/*n+N-1*/], Rgba ycaOut[/*n*/]); // // For a scan line that has only luminance and no valid chroma data, // reconstruct chroma from the surronding N scan lines. // IMF_EXPORT void reconstructChromaVert (int n, const Rgba * const ycaIn[N], Rgba ycaOut[/*n*/]); // // Convert an array of n YCA (luminance/chroma/alpha) pixels to RGBA. // This function is the inverse of RGBAtoYCA(). // yw is a set of RGB-to-Y weighting factors, as computed by computeYw(). // IMF_EXPORT void YCAtoRGBA (const IMATH_NAMESPACE::V3f &yw, int n, const Rgba ycaIn[/*n*/], Rgba rgbaOut[/*n*/]); // // Eliminate super-saturated pixels: // // Converting an image from RGBA to YCA, low-pass filtering chroma, // and converting the result back to RGBA can produce pixels with // super-saturated colors, where one or two of the RGB components // become zero or negative. (The low-pass and reconstruction filters // introduce some amount of ringing into the chroma components. // This can lead to negative RGB values near high-contrast edges.) // // The fixSaturation() function finds super-saturated pixels and // corrects them by desaturating their colors while maintaining // their luminance. fixSaturation() takes three adjacent input // scan lines, rgbaIn[0], rgbaIn[1], rgbaIn[2], adjusts the // saturation of rgbaIn[1], and stores the result in rgbaOut. // IMF_EXPORT void fixSaturation (const IMATH_NAMESPACE::V3f &yw, int n, const Rgba * const rgbaIn[3], Rgba rgbaOut[/*n*/]); } // namespace RgbaYca OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[q�n n IlmThreadPool.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_ILM_THREAD_POOL_H #define INCLUDED_ILM_THREAD_POOL_H //----------------------------------------------------------------------------- // // class Task, class ThreadPool, class TaskGroup // // Class ThreadPool manages a set of worker threads and accepts // tasks for processing. Tasks added to the thread pool are // executed concurrently by the worker threads. // // Class Task provides an abstract interface for a task which // a ThreadPool works on. Derived classes need to implement the // execute() function which performs the actual task. // // Class TaskGroup allows synchronization on the completion of a set // of tasks. Every task that is added to a ThreadPool belongs to a // single TaskGroup. The destructor of the TaskGroup waits for all // tasks in the group to finish. // // Note: if you plan to use the ThreadPool interface in your own // applications note that the implementation of the ThreadPool calls // operator delete on tasks as they complete. If you define a custom // operator new for your tasks, for instance to use a custom heap, // then you must also write an appropriate operator delete. // //----------------------------------------------------------------------------- #include "IlmThreadNamespace.h" #include "IlmThreadExport.h" #include "IlmThreadConfig.h" ILMTHREAD_INTERNAL_NAMESPACE_HEADER_ENTER class TaskGroup; class Task; //------------------------------------------------------- // ThreadPoolProvider -- this is a pure virtual interface // enabling custom overloading of the threads used and how // the implementation of the processing of tasks // is implemented //------------------------------------------------------- class ILMTHREAD_EXPORT_TYPE ThreadPoolProvider { public: ILMTHREAD_EXPORT ThreadPoolProvider(); ILMTHREAD_EXPORT virtual ~ThreadPoolProvider(); // as in ThreadPool below virtual int numThreads () const = 0; // as in ThreadPool below virtual void setNumThreads (int count) = 0; // as in ThreadPool below virtual void addTask (Task* task) = 0; // Ensure that all tasks in this set are finished // and threads shutdown virtual void finish () = 0; // Make the provider non-copyable ThreadPoolProvider (const ThreadPoolProvider &) = delete; ThreadPoolProvider &operator= (const ThreadPoolProvider &) = delete; ThreadPoolProvider (ThreadPoolProvider &&) = delete; ThreadPoolProvider &operator= (ThreadPoolProvider &&) = delete; }; class ILMTHREAD_EXPORT_TYPE ThreadPool { public: //------------------------------------------------------- // static routine to query how many processors should be // used for processing exr files. The user of ThreadPool // is free to use std::thread::hardware_concurrency or // whatever number of threads is appropriate based on the // application. However, this routine exists such that // in the future, if core counts expand faster than // memory bandwidth, or higher order NUMA machines are built // that we can query, this routine gives a place where we // can centralize that logic //------------------------------------------------------- ILMTHREAD_EXPORT static unsigned estimateThreadCountForFileIO (); //------------------------------------------------------- // Constructor -- creates numThreads worker threads which // wait until a task is available, // using a default ThreadPoolProvider //------------------------------------------------------- ILMTHREAD_EXPORT ThreadPool (unsigned numThreads = 0); //----------------------------------------------------------- // Destructor -- waits for all tasks to complete, joins all // the threads to the calling thread, and then destroys them. //----------------------------------------------------------- ILMTHREAD_EXPORT virtual ~ThreadPool (); ThreadPool (const ThreadPool&) = delete; ThreadPool& operator= (const ThreadPool&) = delete; ThreadPool (ThreadPool&&) = delete; ThreadPool& operator= (ThreadPool&&) = delete; //-------------------------------------------------------- // Query and set the number of worker threads in the pool. // // Warning: never call setNumThreads from within a worker // thread as this will almost certainly cause a deadlock // or crash. //-------------------------------------------------------- ILMTHREAD_EXPORT int numThreads () const; ILMTHREAD_EXPORT void setNumThreads (int count); //-------------------------------------------------------- // Set the thread provider for the pool. // // The ThreadPool takes ownership of the ThreadPoolProvider // and will call delete on it when it is finished or when // it is changed // // Warning: never call setThreadProvider from within a worker // thread as this will almost certainly cause a deadlock // or crash. //-------------------------------------------------------- ILMTHREAD_EXPORT void setThreadProvider (ThreadPoolProvider *provider); //------------------------------------------------------------ // Add a task for processing. The ThreadPool can handle any // number of tasks regardless of the number of worker threads. // The tasks are first added onto a queue, and are executed // by threads as they become available, in FIFO order. //------------------------------------------------------------ ILMTHREAD_EXPORT void addTask (Task* task); //------------------------------------------- // Access functions for the global threadpool //------------------------------------------- ILMTHREAD_EXPORT static ThreadPool& globalThreadPool (); ILMTHREAD_EXPORT static void addGlobalTask (Task* task); struct ILMTHREAD_HIDDEN Data; protected: Data * _data; }; class ILMTHREAD_EXPORT_TYPE Task { public: ILMTHREAD_EXPORT Task (TaskGroup* g); ILMTHREAD_EXPORT virtual ~Task (); Task (const Task&) = delete; Task &operator= (const Task&) = delete; Task (Task&&) = delete; Task& operator= (Task&&) = delete; virtual void execute () = 0; ILMTHREAD_EXPORT TaskGroup * group(); protected: TaskGroup * _group; }; class ILMTHREAD_EXPORT_TYPE TaskGroup { public: ILMTHREAD_EXPORT TaskGroup(); ILMTHREAD_EXPORT ~TaskGroup(); TaskGroup (const TaskGroup& other) = delete; TaskGroup& operator = (const TaskGroup& other) = delete; TaskGroup (TaskGroup&& other) = delete; TaskGroup& operator = (TaskGroup&& other) = delete; // marks one task as finished // should be used by the thread pool provider to notify // as it finishes tasks ILMTHREAD_EXPORT void finishOneTask (); struct ILMTHREAD_HIDDEN Data; Data* const _data; }; ILMTHREAD_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_ILM_THREAD_POOL_H PK rM�[[�W=� � ImfMultiView.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Weta Digital, Ltd and Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_MULTIVIEW_H #define INCLUDED_IMF_MULTIVIEW_H #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfChannelList.h" #include "ImfStringVectorAttribute.h" //----------------------------------------------------------------------------- // // Functions related to accessing channels and views in multi-view // OpenEXR files. // // A multi-view image file contains two or more views of the same // scene, as seen from different viewpoints, for example, a left-eye // and a right-eye view for stereo displays. Each view has its own // set of image channels. A naming convention identifies the channels // that belong to a given view. // // A "multiView" attribute in the file header lists the names of the // views in an image (see ImfStandardAttributes.h), and channel names // of the form // // layer.view.channel // // allow channels to be matched with views. // // For compatibility with singe-view images, the first view listed in // the multiView attribute is the "default view", and channels that // have no periods in their names are considered part of the default // view. // // For example, if a file's multiView attribute lists the views // "left" and "right", in that order, then "left" is the default // view. Channels // // "R", "left.Z", "diffuse.left.R" // // are part of the "left" view; channels // // "right.R", "right.Z", "diffuse.right.R" // // are part of the "right" view; and channels // // "tmp.R", "right.diffuse.R", "diffuse.tmp.R" // // belong to no view at all. // //----------------------------------------------------------------------------- OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER // // Return the name of the default view given a multi-view string vector, // that is, return the first element of the string vector. If the string // vector is empty, return "". // IMF_EXPORT std::string defaultViewName (const StringVector &multiView); // // Given the name of a channel, return the name of the view to // which it belongs. Returns the empty string ("") if the channel // is not a member of any named view. // IMF_EXPORT std::string viewFromChannelName (const std::string &channel, const StringVector &multiView); // // Return whether channel1 and channel2 are the same channel but // viewed in different views. (Return false if either channel // belongs to no view or if both channels belong to the same view.) // IMF_EXPORT bool areCounterparts (const std::string &channel1, const std::string &channel2, const StringVector &multiView); // // Return a list of all channels belonging to view viewName. // IMF_EXPORT ChannelList channelsInView (const std::string &viewName, const ChannelList &channelList, const StringVector &multiView); // // Return a list of channels not associated with any view. // IMF_EXPORT ChannelList channelsInNoView (const ChannelList &channelList, const StringVector &multiView); // // Given the name of a channel, return a list of the same channel // in all views (for example, given X.left.Y return X.left.Y, // X.right.Y, X.centre.Y, etc.). // IMF_EXPORT ChannelList channelInAllViews (const std::string &channame, const ChannelList &channelList, const StringVector &multiView); // // Given the name of a channel in one view, return the corresponding // channel name for view otherViewName. Return "" if no corresponding // channel exists in view otherViewName, or if view otherViewName doesn't // exist. // IMF_EXPORT std::string channelInOtherView (const std::string &channel, const ChannelList &channelList, const StringVector &multiView, const std::string &otherViewName); // // Given a channel name that does not include a view name, insert // multiView[i] into the channel name at the appropriate location. // If i is zero and the channel name contains no periods, then do // not insert the view name. // IMF_EXPORT std::string insertViewName (const std::string &channel, const StringVector &multiView, int i); // // Given a channel name that does may include a view name, return // string without the view name. If the string does not contain // the view name, return the string unaltered. // (Will only remove the viewname if it is in the correct position // in the string) // IMF_EXPORT std::string removeViewName (const std::string &channel, const std::string &view); OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[��=T T IlmThreadMutex.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_ILM_THREAD_MUTEX_H #define INCLUDED_ILM_THREAD_MUTEX_H //----------------------------------------------------------------------------- // // NB: Maintained for backward compatibility with header files only. This // has been entirely replaced by c++11 and the std::mutex layer // //----------------------------------------------------------------------------- #include "IlmThreadExport.h" #include "IlmThreadConfig.h" #include "IlmThreadNamespace.h" #if ILMTHREAD_THREADING_ENABLED #include <mutex> #endif ILMTHREAD_INTERNAL_NAMESPACE_HEADER_ENTER #if ILMTHREAD_THREADING_ENABLED using Mutex ILMTHREAD_DEPRECATED ("replace with std::mutex") = std::mutex; // unfortunately we can't use std::unique_lock as a replacement for Lock since // they have different API. Let us deprecate for now and give people a chance // to clean up their code. class Lock { public: ILMTHREAD_DEPRECATED ("replace with std::lock_guard or std::unique_lock") Lock (const Mutex& m, bool autoLock = true): _mutex (const_cast<Mutex &>(m)), _locked (false) { if (autoLock) { _mutex.lock(); _locked = true; } } ~Lock () { if (_locked) _mutex.unlock(); } Lock (const Lock&) = delete; Lock &operator= (const Lock&) = delete; Lock (Lock&&) = delete; Lock& operator= (Lock&&) = delete; void acquire () { _mutex.lock(); _locked = true; } void release () { _locked = false; _mutex.unlock(); } bool locked () { return _locked; } private: Mutex & _mutex; bool _locked; }; #endif ILMTHREAD_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_ILM_THREAD_MUTEX_H PK rM�[���� � ImfInt64.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_INT64_H #define INCLUDED_IMF_INT64_H //---------------------------------------------------------------------------- // // Deprecated Int64/SInt64 unsigned 64-bit integer type. // Use int64_t and uint64_t instead. // //---------------------------------------------------------------------------- #include "ImathInt64.h" #include "ImfNamespace.h" #include <stdint.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER IMATH_DEPRECATED("use uint64_t") typedef IMATH_NAMESPACE::Int64 Int64; IMATH_DEPRECATED("use int64_t") typedef IMATH_NAMESPACE::SInt64 SInt64; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMF_INT64_H PK rM�[:5�@%0 %0 ImfDeepTiledInputPart.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef IMFDEEPTILEDINPUTPART_H_ #define IMFDEEPTILEDINPUTPART_H_ #include "ImfForward.h" #include "ImfTileDescription.h" #include <ImathBox.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE DeepTiledInputPart { public: IMF_EXPORT DeepTiledInputPart(MultiPartInputFile& multiPartFile, int partNumber); //------------------------ // Access to the file name //------------------------ IMF_EXPORT const char * fileName () const; //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; //---------------------------------- // Access to the file format version //---------------------------------- IMF_EXPORT int version () const; //----------------------------------------------------------- // Set the current frame buffer -- copies the FrameBuffer // object into the TiledInputFile object. // // The current frame buffer is the destination for the pixel // data read from the file. The current frame buffer must be // set at least once before readTile() is called. // The current frame buffer can be changed after each call // to readTile(). //----------------------------------------------------------- IMF_EXPORT void setFrameBuffer (const DeepFrameBuffer &frameBuffer); //----------------------------------- // Access to the current frame buffer //----------------------------------- IMF_EXPORT const DeepFrameBuffer & frameBuffer () const; //------------------------------------------------------------ // Check if the file is complete: // // isComplete() returns true if all pixels in the data window // (in all levels) are present in the input file, or false if // any pixels are missing. (Another program may still be busy // writing the file, or file writing may have been aborted // prematurely.) //------------------------------------------------------------ IMF_EXPORT bool isComplete () const; //-------------------------------------------------- // Utility functions: //-------------------------------------------------- //--------------------------------------------------------- // Multiresolution mode and tile size: // The following functions return the xSize, ySize and mode // fields of the file header's TileDescriptionAttribute. //--------------------------------------------------------- IMF_EXPORT unsigned int tileXSize () const; IMF_EXPORT unsigned int tileYSize () const; IMF_EXPORT LevelMode levelMode () const; IMF_EXPORT LevelRoundingMode levelRoundingMode () const; //-------------------------------------------------------------------- // Number of levels: // // numXLevels() returns the file's number of levels in x direction. // // if levelMode() == ONE_LEVEL: // return value is: 1 // // if levelMode() == MIPMAP_LEVELS: // return value is: rfunc (log (max (w, h)) / log (2)) + 1 // // if levelMode() == RIPMAP_LEVELS: // return value is: rfunc (log (w) / log (2)) + 1 // // where // w is the width of the image's data window, max.x - min.x + 1, // y is the height of the image's data window, max.y - min.y + 1, // and rfunc(x) is either floor(x), or ceil(x), depending on // whether levelRoundingMode() returns ROUND_DOWN or ROUND_UP. // // numYLevels() returns the file's number of levels in y direction. // // if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS: // return value is the same as for numXLevels() // // if levelMode() == RIPMAP_LEVELS: // return value is: rfunc (log (h) / log (2)) + 1 // // // numLevels() is a convenience function for use with // MIPMAP_LEVELS files. // // if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS: // return value is the same as for numXLevels() // // if levelMode() == RIPMAP_LEVELS: // an IEX_NAMESPACE::LogicExc exception is thrown // // isValidLevel(lx, ly) returns true if the file contains // a level with level number (lx, ly), false if not. // //-------------------------------------------------------------------- IMF_EXPORT int numLevels () const; IMF_EXPORT int numXLevels () const; IMF_EXPORT int numYLevels () const; IMF_EXPORT bool isValidLevel (int lx, int ly) const; //---------------------------------------------------------- // Dimensions of a level: // // levelWidth(lx) returns the width of a level with level // number (lx, *), where * is any number. // // return value is: // max (1, rfunc (w / pow (2, lx))) // // // levelHeight(ly) returns the height of a level with level // number (*, ly), where * is any number. // // return value is: // max (1, rfunc (h / pow (2, ly))) // //---------------------------------------------------------- IMF_EXPORT int levelWidth (int lx) const; IMF_EXPORT int levelHeight (int ly) const; //-------------------------------------------------------------- // Number of tiles: // // numXTiles(lx) returns the number of tiles in x direction // that cover a level with level number (lx, *), where * is // any number. // // return value is: // (levelWidth(lx) + tileXSize() - 1) / tileXSize() // // // numYTiles(ly) returns the number of tiles in y direction // that cover a level with level number (*, ly), where * is // any number. // // return value is: // (levelHeight(ly) + tileXSize() - 1) / tileXSize() // //-------------------------------------------------------------- IMF_EXPORT int numXTiles (int lx = 0) const; IMF_EXPORT int numYTiles (int ly = 0) const; //--------------------------------------------------------------- // Level pixel ranges: // // dataWindowForLevel(lx, ly) returns a 2-dimensional region of // valid pixel coordinates for a level with level number (lx, ly) // // return value is a Box2i with min value: // (dataWindow.min.x, dataWindow.min.y) // // and max value: // (dataWindow.min.x + levelWidth(lx) - 1, // dataWindow.min.y + levelHeight(ly) - 1) // // dataWindowForLevel(level) is a convenience function used // for ONE_LEVEL and MIPMAP_LEVELS files. It returns // dataWindowForLevel(level, level). // //--------------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int lx, int ly) const; //------------------------------------------------------------------- // Tile pixel ranges: // // dataWindowForTile(dx, dy, lx, ly) returns a 2-dimensional // region of valid pixel coordinates for a tile with tile coordinates // (dx,dy) and level number (lx, ly). // // return value is a Box2i with min value: // (dataWindow.min.x + dx * tileXSize(), // dataWindow.min.y + dy * tileYSize()) // // and max value: // (dataWindow.min.x + (dx + 1) * tileXSize() - 1, // dataWindow.min.y + (dy + 1) * tileYSize() - 1) // // dataWindowForTile(dx, dy, level) is a convenience function // used for ONE_LEVEL and MIPMAP_LEVELS files. It returns // dataWindowForTile(dx, dy, level, level). // //------------------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int lx, int ly) const; //------------------------------------------------------------ // Read pixel data: // // readTile(dx, dy, lx, ly) reads the tile with tile // coordinates (dx, dy), and level number (lx, ly), // and stores it in the current frame buffer. // // dx must lie in the interval [0, numXTiles(lx)-1] // dy must lie in the interval [0, numYTiles(ly)-1] // // lx must lie in the interval [0, numXLevels()-1] // ly must lie in the inverval [0, numYLevels()-1] // // readTile(dx, dy, level) is a convenience function used // for ONE_LEVEL and MIPMAP_LEVELS files. It calls // readTile(dx, dy, level, level). // // The two readTiles(dx1, dx2, dy1, dy2, ...) functions allow // reading multiple tiles at once. If multi-threading is used // the multiple tiles are read concurrently. // // Pixels that are outside the pixel coordinate range for the // tile's level, are never accessed by readTile(). // // Attempting to access a tile that is not present in the file // throws an InputExc exception. // //------------------------------------------------------------ IMF_EXPORT void readTile (int dx, int dy, int l = 0); IMF_EXPORT void readTile (int dx, int dy, int lx, int ly); IMF_EXPORT void readTiles (int dx1, int dx2, int dy1, int dy2, int lx, int ly); IMF_EXPORT void readTiles (int dx1, int dx2, int dy1, int dy2, int l = 0); //-------------------------------------------------- // Read a tile of raw pixel data from the file, // without uncompressing it (this function is // used to implement TiledOutputFile::copyPixels()). //-------------------------------------------------- IMF_EXPORT void rawTileData (int &dx, int &dy, int &lx, int &ly, char *data, uint64_t &dataSize ) const; //------------------------------------------------------------------ // Read pixel sample counts into a slice in the frame buffer. // // readPixelSampleCount(dx, dy, lx, ly) reads the sample counts // for tile (dx, dy) in level (lx, ly). // // readPixelSampleCount(dx, dy, l) calls // readPixelSampleCount(dx, dy, lx = l, ly = l) // // dx must lie in the interval [0, numXTiles(lx)-1] // dy must lie in the interval [0, numYTiles(ly)-1] // // lx must lie in the interval [0, numXLevels()-1] // ly must lie in the inverval [0, numYLevels()-1] // // readPixelSampleCounts(dx1, dx2, dy1, dy2, lx, ly) reads all // the sample counts for tiles within range // [(min(dx1, dx2), min(dy1, dy2))...(max(dx1, dx2), max(dy1, dy2)], // and on level (lx, ly) // // readPixelSampleCounts(dx1, dx2, dy1, dy2, l) calls // readPixelSampleCounts(dx1, dx2, dy1, dy2, lx = l, ly = l). //------------------------------------------------------------------ IMF_EXPORT void readPixelSampleCount (int dx, int dy, int l = 0); IMF_EXPORT void readPixelSampleCount (int dx, int dy, int lx, int ly); IMF_EXPORT void readPixelSampleCounts (int dx1, int dx2, int dy1, int dy2, int lx, int ly); IMF_EXPORT void readPixelSampleCounts (int dx1, int dx2, int dy1, int dy2, int l = 0); private: DeepTiledInputFile* file; friend class DeepTiledOutputFile; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif /* IMFDEEPTILEDINPUTPART_H_ */ PK rM�[a�x�( �( ImfChannelList.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_CHANNEL_LIST_H #define INCLUDED_IMF_CHANNEL_LIST_H //----------------------------------------------------------------------------- // // class Channel // class ChannelList // //----------------------------------------------------------------------------- #include "ImfForward.h" #include "ImfName.h" #include "ImfPixelType.h" #include <map> #include <set> #include <string> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER struct IMF_EXPORT_TYPE Channel { //------------------------------ // Data type; see ImfPixelType.h //------------------------------ PixelType type; //-------------------------------------------- // Subsampling: pixel (x, y) is present in the // channel only if // // x % xSampling == 0 && y % ySampling == 0 // //-------------------------------------------- int xSampling; int ySampling; //-------------------------------------------------------------- // Hint to lossy compression methods that indicates whether // human perception of the quantity represented by this channel // is closer to linear or closer to logarithmic. Compression // methods may optimize image quality by adjusting pixel data // quantization acording to this hint. // For example, perception of red, green, blue and luminance is // approximately logarithmic; the difference between 0.1 and 0.2 // is perceived to be roughly the same as the difference between // 1.0 and 2.0. Perception of chroma coordinates tends to be // closer to linear than logarithmic; the difference between 0.1 // and 0.2 is perceived to be roughly the same as the difference // between 1.0 and 1.1. //-------------------------------------------------------------- bool pLinear; //------------ // Constructor //------------ IMF_EXPORT Channel (PixelType type = HALF, int xSampling = 1, int ySampling = 1, bool pLinear = false); //------------ // Operator == //------------ IMF_EXPORT bool operator == (const Channel &other) const; }; class IMF_EXPORT_TYPE ChannelList { public: //-------------- // Add a channel //-------------- IMF_EXPORT void insert (const char name[], const Channel &channel); IMF_EXPORT void insert (const std::string &name, const Channel &channel); //------------------------------------------------------------------ // Access to existing channels: // // [n] Returns a reference to the channel with name n. // If no channel with name n exists, an IEX_NAMESPACE::ArgExc // is thrown. // // findChannel(n) Returns a pointer to the channel with name n, // or 0 if no channel with name n exists. // //------------------------------------------------------------------ IMF_EXPORT Channel & operator [] (const char name[]); IMF_EXPORT const Channel & operator [] (const char name[]) const; IMF_EXPORT Channel & operator [] (const std::string &name); IMF_EXPORT const Channel & operator [] (const std::string &name) const; IMF_EXPORT Channel * findChannel (const char name[]); IMF_EXPORT const Channel * findChannel (const char name[]) const; IMF_EXPORT Channel * findChannel (const std::string &name); IMF_EXPORT const Channel * findChannel (const std::string &name) const; //------------------------------------------- // Iterator-style access to existing channels //------------------------------------------- typedef std::map <Name, Channel> ChannelMap; class Iterator; class ConstIterator; IMF_EXPORT Iterator begin (); IMF_EXPORT ConstIterator begin () const; IMF_EXPORT Iterator end (); IMF_EXPORT ConstIterator end () const; IMF_EXPORT Iterator find (const char name[]); IMF_EXPORT ConstIterator find (const char name[]) const; IMF_EXPORT Iterator find (const std::string &name); IMF_EXPORT ConstIterator find (const std::string &name) const; //----------------------------------------------------------------- // Support for image layers: // // In an image file with many channels it is sometimes useful to // group the channels into "layers", that is, into sets of channels // that logically belong together. Grouping channels into layers // is done using a naming convention: channel C in layer L is // called "L.C". // // For example, a computer graphic image may contain separate // R, G and B channels for light that originated at each of // several different virtual light sources. The channels in // this image might be called "light1.R", "light1.G", "light1.B", // "light2.R", "light2.G", "light2.B", etc. // // Note that this naming convention allows layers to be nested; // for example, "light1.specular.R" identifies the "R" channel // in the "specular" sub-layer of layer "light1". // // Channel names that don't contain a "." or that contain a // "." only at the beginning or at the end are not considered // to be part of any layer. // // layers(lns) sorts the channels in this ChannelList // into layers and stores the names of // all layers, sorted alphabetically, // into string set lns. // // channelsInLayer(ln,f,l) stores a pair of iterators in f and l // such that the loop // // for (ConstIterator i = f; i != l; ++i) // ... // // iterates over all channels in layer ln. // channelsInLayer (ln, l, p) calls // channelsWithPrefix (ln + ".", l, p). // //----------------------------------------------------------------- IMF_EXPORT void layers (std::set <std::string> &layerNames) const; IMF_EXPORT void channelsInLayer (const std::string &layerName, Iterator &first, Iterator &last); IMF_EXPORT void channelsInLayer (const std::string &layerName, ConstIterator &first, ConstIterator &last) const; //------------------------------------------------------------------- // Find all channels whose name begins with a given prefix: // // channelsWithPrefix(p,f,l) stores a pair of iterators in f and l // such that the following loop iterates over all channels whose name // begins with string p: // // for (ConstIterator i = f; i != l; ++i) // ... // //------------------------------------------------------------------- IMF_EXPORT void channelsWithPrefix (const char prefix[], Iterator &first, Iterator &last); IMF_EXPORT void channelsWithPrefix (const char prefix[], ConstIterator &first, ConstIterator &last) const; IMF_EXPORT void channelsWithPrefix (const std::string &prefix, Iterator &first, Iterator &last); IMF_EXPORT void channelsWithPrefix (const std::string &prefix, ConstIterator &first, ConstIterator &last) const; //------------ // Operator == //------------ IMF_EXPORT bool operator == (const ChannelList &other) const; private: ChannelMap _map; }; //---------- // Iterators //---------- class IMF_EXPORT_TYPE ChannelList::Iterator { public: IMF_EXPORT Iterator (); IMF_EXPORT Iterator (const ChannelList::ChannelMap::iterator &i); IMF_EXPORT Iterator & operator ++ (); IMF_EXPORT Iterator operator ++ (int); IMF_EXPORT const char * name () const; IMF_EXPORT Channel & channel () const; private: friend class ChannelList::ConstIterator; ChannelList::ChannelMap::iterator _i; }; class IMF_EXPORT_TYPE ChannelList::ConstIterator { public: IMF_EXPORT ConstIterator (); IMF_EXPORT ConstIterator (const ChannelList::ChannelMap::const_iterator &i); IMF_EXPORT ConstIterator (const ChannelList::Iterator &other); IMF_EXPORT ConstIterator & operator ++ (); IMF_EXPORT ConstIterator operator ++ (int); IMF_EXPORT const char * name () const; IMF_EXPORT const Channel & channel () const; private: friend bool operator == (const ConstIterator &, const ConstIterator &); friend bool operator != (const ConstIterator &, const ConstIterator &); ChannelList::ChannelMap::const_iterator _i; }; //----------------- // Inline Functions //----------------- inline ChannelList::Iterator::Iterator (): _i() { // empty } inline ChannelList::Iterator::Iterator (const ChannelList::ChannelMap::iterator &i): _i (i) { // empty } inline ChannelList::Iterator & ChannelList::Iterator::operator ++ () { ++_i; return *this; } inline ChannelList::Iterator ChannelList::Iterator::operator ++ (int) { Iterator tmp = *this; ++_i; return tmp; } inline const char * ChannelList::Iterator::name () const { return *_i->first; } inline Channel & ChannelList::Iterator::channel () const { return _i->second; } inline ChannelList::ConstIterator::ConstIterator (): _i() { // empty } inline ChannelList::ConstIterator::ConstIterator (const ChannelList::ChannelMap::const_iterator &i): _i (i) { // empty } inline ChannelList::ConstIterator::ConstIterator (const ChannelList::Iterator &other): _i (other._i) { // empty } inline ChannelList::ConstIterator & ChannelList::ConstIterator::operator ++ () { ++_i; return *this; } inline ChannelList::ConstIterator ChannelList::ConstIterator::operator ++ (int) { ConstIterator tmp = *this; ++_i; return tmp; } inline const char * ChannelList::ConstIterator::name () const { return *_i->first; } inline const Channel & ChannelList::ConstIterator::channel () const { return _i->second; } inline bool operator == (const ChannelList::ConstIterator &x, const ChannelList::ConstIterator &y) { return x._i == y._i; } inline bool operator != (const ChannelList::ConstIterator &x, const ChannelList::ConstIterator &y) { return !(x == y); } OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[ �T� � Iex.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IEX_H #define INCLUDED_IEX_H //-------------------------------- // // Exception handling // //-------------------------------- #include "IexMacros.h" #include "IexBaseExc.h" #include "IexMathExc.h" #include "IexThrowErrnoExc.h" // Note that we do not include file IexErrnoExc.h here. That file // defines over 150 classes and significantly slows down compilation. // If you throw ErrnoExc exceptions using the throwErrnoExc() function, // you don't need IexErrnoExc.h. You have to include IexErrnoExc.h // only if you want to catch specific subclasses of ErrnoExc. #endif PK rM�[<�C�� � IlmThreadNamespace.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_ILMTHREADNAMESPACE_H #define INCLUDED_ILMTHREADNAMESPACE_H // // The purpose of this file is to make it possible to specify an // ILMTHREAD_INTERNAL_NAMESPACE as a preprocessor definition and have all of // the IlmThread symbols defined within that namespace rather than the // standard IlmThread namespace. Those symbols are made available to client // code through the ILMTHREAD_NAMESPACE in addition to the // ILMTHREAD_INTERNAL_NAMESPACE. // // To ensure source code compatibility, the ILMTHREAD_NAMESPACE defaults to // IlmThread and then "using namespace ILMTHREAD_INTERNAL_NAMESPACE;" brings // all of the declarations from the ILMTHREAD_INTERNAL_NAMESPACE into the // ILMTHREAD_NAMESPACE. This means that client code can continue to use // syntax like IlmThread::Thread, but at link time it will resolve to a // mangled symbol based on the ILMTHREAD_INTERNAL_NAMESPACE. // // As an example, if one needed to build against a newer version of IlmThread // and have it run alongside an older version in the same application, it is // now possible to use an internal namespace to prevent collisions between // the older versions of IlmThread symbols and the newer ones. To do this, // the following could be defined at build time: // // ILMTHREAD_INTERNAL_NAMESPACE = IlmThread_v2 // // This means that declarations inside IlmThread headers look like this // (after the preprocessor has done its work): // // namespace IlmThread_v2 { // ... // class declarations // ... // } // // namespace IlmThread { // using namespace IlmThread_v2; // } // // // Open Source version of this file pulls in the IlmThreadConfig.h file // for the configure time options. // #include "IlmThreadConfig.h" #ifndef ILMTHREAD_NAMESPACE #define ILMTHREAD_NAMESPACE IlmThread #endif #ifndef ILMTHREAD_INTERNAL_NAMESPACE #define ILMTHREAD_INTERNAL_NAMESPACE ILMTHREAD_NAMESPACE #endif // // We need to be sure that we import the internal namespace into the public one. // To do this, we use the small bit of code below which initially defines // ILMTHREAD_INTERNAL_NAMESPACE (so it can be referenced) and then defines // ILMTHREAD_NAMESPACE and pulls the internal symbols into the public // namespace. // namespace ILMTHREAD_INTERNAL_NAMESPACE {} namespace ILMTHREAD_NAMESPACE { using namespace ILMTHREAD_INTERNAL_NAMESPACE; } // // There are identical pairs of HEADER/SOURCE ENTER/EXIT macros so that // future extension to the namespace mechanism is possible without changing // project source code. // #define ILMTHREAD_INTERNAL_NAMESPACE_HEADER_ENTER namespace ILMTHREAD_INTERNAL_NAMESPACE { #define ILMTHREAD_INTERNAL_NAMESPACE_HEADER_EXIT } #define ILMTHREAD_INTERNAL_NAMESPACE_SOURCE_ENTER namespace ILMTHREAD_INTERNAL_NAMESPACE { #define ILMTHREAD_INTERNAL_NAMESPACE_SOURCE_EXIT } #endif // INCLUDED_ILMTHREADNAMESPACE_H PK rM�[� -J J ImfWav.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_WAV_H #define INCLUDED_IMF_WAV_H //----------------------------------------------------------------------------- // // 16-bit Haar Wavelet encoding and decoding // //----------------------------------------------------------------------------- #include "ImfNamespace.h" #include "ImfExport.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER IMF_EXPORT void wav2Encode (unsigned short *in, // io: values in[y][x] are transformed in place int nx, // i : x size int ox, // i : x offset int ny, // i : y size int oy, // i : y offset unsigned short mx); // i : maximum in[x][y] value IMF_EXPORT void wav2Decode (unsigned short *in, // io: values in[y][x] are transformed in place int nx, // i : x size int ox, // i : x offset int ny, // i : y size int oy, // i : y offset unsigned short mx); // i : maximum in[x][y] value OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[2��*� � ImfPixelType.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_PIXEL_TYPE_H #define INCLUDED_IMF_PIXEL_TYPE_H //----------------------------------------------------------------------------- // // enum PixelType // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER enum IMF_EXPORT_ENUM PixelType { UINT = 0, // unsigned int (32 bit) HALF = 1, // half (16 bit floating point) FLOAT = 2, // float (32 bit floating point) NUM_PIXELTYPES // number of different pixel types }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[ ,dm� � ImfCheckFile.hnu �[��� // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. #ifndef INCLUDED_IMF_CHECKFILE_H #define INCLUDED_IMF_CHECKFILE_H #include "ImfUtilExport.h" #include "ImfNamespace.h" #include <cstddef> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER // // attempt to read the given file as an OpenEXR, using various OpenEXR read paths. // This can be used to validate correctness of the library, when running the library // with a sanitizer or memory checker, as well as checking that a file is a correct OpenEXR // // returns true if the file reads correctly using expected API calls, or false // if an exception was thrown that indicates the file is invalid // // if reduceMemory is true, will avoid tests or inputs that are known to // take large amounts of memory. This may hide errors within the file or library. // // if reduceTime is true and an error is found within the file, then future tests are reduced for speed. // This may hide errors within the library. // // IMFUTIL_EXPORT bool checkOpenEXRFile(const char* fileName, bool reduceMemory = false, bool reduceTime = false ); // // overloaded version of checkOpenEXRFile that takes a pointer to in-memory data // IMFUTIL_EXPORT bool checkOpenEXRFile(const char* data, size_t numBytes, bool reduceMemory = false, bool reduceTime = false ); OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[b%-� � ImfInputPart.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef IMFINPUTPART_H_ #define IMFINPUTPART_H_ #include "ImfForward.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER //------------------------------------------------------------------- // class InputPart: // // Same interface as InputFile. Please refer to InputFile. //------------------------------------------------------------------- class IMF_EXPORT_TYPE InputPart { public: IMF_EXPORT InputPart(MultiPartInputFile& multiPartFile, int partNumber); IMF_EXPORT const char * fileName () const; IMF_EXPORT const Header & header () const; IMF_EXPORT int version () const; IMF_EXPORT void setFrameBuffer (const FrameBuffer &frameBuffer); IMF_EXPORT const FrameBuffer & frameBuffer () const; IMF_EXPORT bool isComplete () const; IMF_EXPORT bool isOptimizationEnabled () const; IMF_EXPORT void readPixels (int scanLine1, int scanLine2); IMF_EXPORT void readPixels (int scanLine); IMF_EXPORT void rawPixelData (int firstScanLine, const char *&pixelData, int &pixelDataSize); IMF_EXPORT void rawPixelDataToBuffer (int scanLine, char *pixelData, int &pixelDataSize) const; IMF_EXPORT void rawTileData (int &dx, int &dy, int &lx, int &ly, const char *&pixelData, int &pixelDataSize); private: InputFile* file; // for internal use - give OutputFile and TiledOutputFile access to file for copyPixels friend class OutputFile; friend class TiledOutputFile; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif /* IMFINPUTPART_H_ */ PK rM�[��O� � IexMathIeeeExc.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IEXMATHIEEE_EXC_H #define INCLUDED_IEXMATHIEEE_EXC_H //--------------------------------------------------------------------------- // // Names for the loating point exceptions defined by IEEE standard 754 // //--------------------------------------------------------------------------- #include "IexExport.h" #include "IexNamespace.h" IEX_INTERNAL_NAMESPACE_HEADER_ENTER enum IEX_EXPORT_ENUM IeeeExcType { IEEE_OVERFLOW = 1, IEEE_UNDERFLOW = 2, IEEE_DIVZERO = 4, IEEE_INEXACT = 8, IEEE_INVALID = 16 }; IEX_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[��" " ImfRational.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_RATIONAL_H #define INCLUDED_IMF_RATIONAL_H #include "ImfExport.h" #include "ImfNamespace.h" //----------------------------------------------------------------------------- // // Rational numbers // // A rational number is represented as pair of integers, n and d. // The value of of the rational number is // // n/d for d > 0 // positive infinity for n > 0, d == 0 // negative infinity for n < 0, d == 0 // not a number (NaN) for n == 0, d == 0 // //----------------------------------------------------------------------------- OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE Rational { public: int n; // numerator unsigned int d; // denominator //---------------------------------------- // Default constructor, sets value to zero //---------------------------------------- Rational (): n (0), d (1) {} //------------------------------------- // Constructor, explicitly sets n and d //------------------------------------- Rational (int n, int d): n (n), d (d) {} //---------------------------- // Constructor, approximates x //---------------------------- IMF_EXPORT explicit Rational (double x); //--------------------------------- // Approximate conversion to double //--------------------------------- operator double () const {return double (n) / double (d);} }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�f IexConfig.hnu �[��� // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // This file is auto-generated by the cmake configure step #ifndef INCLUDED_IEX_CONFIG_H #define INCLUDED_IEX_CONFIG_H 1 #pragma once // // // C++ namespace configuration / options // // Current internal library namepace name // #define IEX_INTERNAL_NAMESPACE_CUSTOM 0 #define IEX_INTERNAL_NAMESPACE Iex_3_1 // // Current public user namepace name // #define IEX_NAMESPACE_CUSTOM 0 #define IEX_NAMESPACE Iex #endif // INCLUDED_IEX_CONFIG_H PK rM�[��x�^ ^ ImfMultiPartOutputFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef MULTIPARTOUTPUTFILE_H_ #define MULTIPARTOUTPUTFILE_H_ #include "ImfForward.h" #include "ImfGenericOutputFile.h" #include "ImfThreading.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER // // Class responsible for handling the writing of multipart images. // // Note: Certain attributes are 'common' to all parts. Notably: // * Display Window // * Pixel Aspect Ratio // * Time Code // * Chromaticities // The first header forms the basis for the set of attributes that are shared // across the constituent parts. // // Parameters // headers - pointer to array of headers; one for each part of the image file // parts - count of number of parts // overrideSharedAttributes - toggle for the handling of shared attributes. // set false to check for inconsistencies, true // to copy the values over from the first header. // numThreads - number of threads that should be used in encoding the data. // class IMF_EXPORT_TYPE MultiPartOutputFile : public GenericOutputFile { public: IMF_EXPORT MultiPartOutputFile(const char fileName[], const Header * headers, int parts, bool overrideSharedAttributes = false, int numThreads = globalThreadCount()); IMF_EXPORT MultiPartOutputFile(OStream & os, const Header * headers, int parts, bool overrideSharedAttributes = false, int numThreads = globalThreadCount()); // // return number of parts in file // IMF_EXPORT int parts() const; // // return header for part n // (note: may have additional attributes compared to that passed to constructor) // IMF_EXPORT const Header & header(int n) const; IMF_EXPORT ~MultiPartOutputFile(); MultiPartOutputFile(const MultiPartOutputFile& other) = delete; MultiPartOutputFile& operator = (const MultiPartOutputFile& other) = delete; MultiPartOutputFile(MultiPartOutputFile&& other) = delete; MultiPartOutputFile& operator = (MultiPartOutputFile&& other) = delete; struct IMF_HIDDEN Data; private: Data* _data; template<class T> IMF_HIDDEN T* getOutputPart(int partNumber); friend class OutputPart; friend class TiledOutputPart; friend class DeepScanLineOutputPart; friend class DeepTiledOutputPart; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif /* MULTIPARTOUTPUTFILE_H_ */ PK rM�[!����K �K ImfHeader.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_HEADER_H #define INCLUDED_IMF_HEADER_H //----------------------------------------------------------------------------- // // class Header // //----------------------------------------------------------------------------- #include "ImfForward.h" #include "ImfLineOrder.h" #include "ImfCompression.h" #include "ImfName.h" #include "ImfTileDescription.h" #include "ImathVec.h" #include "ImathBox.h" #include "IexBaseExc.h" #include "ImfAttribute.h" #include <map> #include <iosfwd> #include <string> #include <cstdint> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER using std::string; class IMF_EXPORT_TYPE Header { public: //---------------------------------------------------------------- // Default constructor -- the display window and the data window // are both set to Box2i (V2i (0, 0), V2i (width-1, height-1). //---------------------------------------------------------------- IMF_EXPORT Header (int width = 64, int height = 64, float pixelAspectRatio = 1, const IMATH_NAMESPACE::V2f &screenWindowCenter = IMATH_NAMESPACE::V2f (0, 0), float screenWindowWidth = 1, LineOrder lineOrder = INCREASING_Y, Compression = ZIP_COMPRESSION); //-------------------------------------------------------------------- // Constructor -- the data window is specified explicitly; the display // window is set to Box2i (V2i (0, 0), V2i (width-1, height-1). //-------------------------------------------------------------------- IMF_EXPORT Header (int width, int height, const IMATH_NAMESPACE::Box2i &dataWindow, float pixelAspectRatio = 1, const IMATH_NAMESPACE::V2f &screenWindowCenter = IMATH_NAMESPACE::V2f (0, 0), float screenWindowWidth = 1, LineOrder lineOrder = INCREASING_Y, Compression = ZIP_COMPRESSION); //---------------------------------------------------------- // Constructor -- the display window and the data window are // both specified explicitly. //---------------------------------------------------------- IMF_EXPORT Header (const IMATH_NAMESPACE::Box2i &displayWindow, const IMATH_NAMESPACE::Box2i &dataWindow, float pixelAspectRatio = 1, const IMATH_NAMESPACE::V2f &screenWindowCenter = IMATH_NAMESPACE::V2f (0, 0), float screenWindowWidth = 1, LineOrder lineOrder = INCREASING_Y, Compression = ZIP_COMPRESSION); //----------------- // Copy constructor //----------------- IMF_EXPORT Header (const Header &other); //----------- // Destructor //----------- IMF_EXPORT ~Header (); //----------- // Assignment //----------- IMF_EXPORT Header & operator = (const Header &other); //--------------------------------------------------------------- // Add an attribute: // // insert(n,attr) If no attribute with name n exists, a new // attribute with name n, and the same type as // attr, is added, and the value of attr is // copied into the new attribute. // // If an attribute with name n exists, and its // type is the same as attr, the value of attr // is copied into this attribute. // // If an attribute with name n exists, and its // type is different from attr, an IEX_NAMESPACE::TypeExc // is thrown. // //--------------------------------------------------------------- IMF_EXPORT void insert (const char name[], const Attribute &attribute); IMF_EXPORT void insert (const std::string &name, const Attribute &attribute); //--------------------------------------------------------------- // Remove an attribute: // // remove(n) If an attribute with name n exists, then it // is removed from the map of present attributes. // // If no attribute with name n exists, then this // functions becomes a 'no-op' // //--------------------------------------------------------------- IMF_EXPORT void erase (const char name[]); IMF_EXPORT void erase (const std::string &name); //------------------------------------------------------------------ // Access to existing attributes: // // [n] Returns a reference to the attribute // with name n. If no attribute with // name n exists, an IEX_NAMESPACE::ArgExc is thrown. // // typedAttribute<T>(n) Returns a reference to the attribute // with name n and type T. If no attribute // with name n exists, an IEX_NAMESPACE::ArgExc is // thrown. If an attribute with name n // exists, but its type is not T, an // IEX_NAMESPACE::TypeExc is thrown. // // findTypedAttribute<T>(n) Returns a pointer to the attribute with // name n and type T, or 0 if no attribute // with name n and type T exists. // //------------------------------------------------------------------ IMF_EXPORT Attribute & operator [] (const char name[]); IMF_EXPORT const Attribute & operator [] (const char name[]) const; IMF_EXPORT Attribute & operator [] (const std::string &name); IMF_EXPORT const Attribute & operator [] (const std::string &name) const; template <class T> T& typedAttribute (const char name[]); template <class T> const T& typedAttribute (const char name[]) const; template <class T> T& typedAttribute (const std::string &name); template <class T> const T& typedAttribute (const std::string &name) const; template <class T> T* findTypedAttribute (const char name[]); template <class T> const T* findTypedAttribute (const char name[]) const; template <class T> T* findTypedAttribute (const std::string &name); template <class T> const T* findTypedAttribute (const std::string &name) const; //--------------------------------------------- // Iterator-style access to existing attributes //--------------------------------------------- typedef std::map <Name, Attribute *> AttributeMap; class Iterator; class ConstIterator; IMF_EXPORT Iterator begin (); IMF_EXPORT ConstIterator begin () const; IMF_EXPORT Iterator end (); IMF_EXPORT ConstIterator end () const; IMF_EXPORT Iterator find (const char name[]); IMF_EXPORT ConstIterator find (const char name[]) const; IMF_EXPORT Iterator find (const std::string &name); IMF_EXPORT ConstIterator find (const std::string &name) const; //-------------------------------- // Access to predefined attributes //-------------------------------- IMF_EXPORT IMATH_NAMESPACE::Box2i & displayWindow (); IMF_EXPORT const IMATH_NAMESPACE::Box2i & displayWindow () const; IMF_EXPORT IMATH_NAMESPACE::Box2i & dataWindow (); IMF_EXPORT const IMATH_NAMESPACE::Box2i & dataWindow () const; IMF_EXPORT float & pixelAspectRatio (); IMF_EXPORT const float & pixelAspectRatio () const; IMF_EXPORT IMATH_NAMESPACE::V2f & screenWindowCenter (); IMF_EXPORT const IMATH_NAMESPACE::V2f & screenWindowCenter () const; IMF_EXPORT float & screenWindowWidth (); IMF_EXPORT const float & screenWindowWidth () const; IMF_EXPORT ChannelList & channels (); IMF_EXPORT const ChannelList & channels () const; IMF_EXPORT LineOrder & lineOrder (); IMF_EXPORT const LineOrder & lineOrder () const; IMF_EXPORT Compression & compression (); IMF_EXPORT const Compression & compression () const; //----------------------------------------------------- // Access to required attributes for multipart files // They are optional to non-multipart files and mandatory // for multipart files. //----------------------------------------------------- IMF_EXPORT void setName (const string& name); IMF_EXPORT string& name(); IMF_EXPORT const string& name() const; IMF_EXPORT bool hasName() const; IMF_EXPORT void setType (const string& Type); IMF_EXPORT string& type(); IMF_EXPORT const string& type() const; IMF_EXPORT bool hasType() const; IMF_EXPORT void setVersion (const int version); IMF_EXPORT int& version(); IMF_EXPORT const int& version() const; IMF_EXPORT bool hasVersion() const; // // the chunkCount attribute is set automatically when a file is written. // There is no need to set it manually // IMF_EXPORT void setChunkCount(int chunks); IMF_EXPORT bool hasChunkCount() const; IMF_EXPORT const int & chunkCount() const; IMF_EXPORT int & chunkCount(); // // for multipart files, return whether the file has a view string attribute // (for the deprecated single part multiview format EXR, see ImfMultiView.h) // IMF_EXPORT void setView(const string & view); IMF_EXPORT bool hasView() const; IMF_EXPORT string & view(); IMF_EXPORT const string & view() const; //---------------------------------------------------------------------- // Tile Description: // // The tile description is a TileDescriptionAttribute whose name // is "tiles". The "tiles" attribute must be present in any tiled // image file. When present, it describes various properties of the // tiles that make up the file. // // Convenience functions: // // setTileDescription(td) // calls insert ("tiles", TileDescriptionAttribute (td)) // // tileDescription() // returns typedAttribute<TileDescriptionAttribute>("tiles").value() // // hasTileDescription() // return findTypedAttribute<TileDescriptionAttribute>("tiles") != 0 // //---------------------------------------------------------------------- IMF_EXPORT void setTileDescription (const TileDescription & td); IMF_EXPORT TileDescription & tileDescription (); IMF_EXPORT const TileDescription & tileDescription () const; IMF_EXPORT bool hasTileDescription() const; //---------------------------------------------------------------------- // Preview image: // // The preview image is a PreviewImageAttribute whose name is "preview". // This attribute is special -- while an image file is being written, // the pixels of the preview image can be changed repeatedly by calling // OutputFile::updatePreviewImage(). // // Convenience functions: // // setPreviewImage(p) // calls insert ("preview", PreviewImageAttribute (p)) // // previewImage() // returns typedAttribute<PreviewImageAttribute>("preview").value() // // hasPreviewImage() // return findTypedAttribute<PreviewImageAttribute>("preview") != 0 // //---------------------------------------------------------------------- IMF_EXPORT void setPreviewImage (const PreviewImage &p); IMF_EXPORT PreviewImage & previewImage (); IMF_EXPORT const PreviewImage & previewImage () const; IMF_EXPORT bool hasPreviewImage () const; //------------------------------------------------------------- // Sanity check -- examines the header, and throws an exception // if it finds something wrong (empty display window, negative // pixel aspect ratio, unknown compression sceme etc.) // // set isTiled to true if you are checking a tiled/multi-res // header //------------------------------------------------------------- IMF_EXPORT void sanityCheck (bool isTiled = false, bool isMultipartFile = false) const; //---------------------------------------------------------------- // Maximum image size and maximim tile size: // // sanityCheck() will throw an exception if the width or height of // the data window exceeds the maximum image width or height, or // if the size of a tile exceeds the maximum tile width or height. // // At program startup the maximum image and tile width and height // are set to zero, meaning that width and height are unlimited. // // Limiting image and tile width and height limits how much memory // will be allocated when a file is opened. This can help protect // applications from running out of memory while trying to read // a damaged image file. //---------------------------------------------------------------- IMF_EXPORT static void setMaxImageSize (int maxWidth, int maxHeight); IMF_EXPORT static void setMaxTileSize (int maxWidth, int maxHeight); // // Check if the header reads nothing. // IMF_EXPORT bool readsNothing(); //------------------------------------------------------------------ // Input and output: // // If the header contains a preview image attribute, then writeTo() // returns the position of that attribute in the output stream; this // information is used by OutputFile::updatePreviewImage(). // If the header contains no preview image attribute, then writeTo() // returns 0. //------------------------------------------------------------------ IMF_EXPORT uint64_t writeTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, bool isTiled = false) const; IMF_EXPORT void readFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int &version); private: AttributeMap _map; bool _readsNothing; }; //---------- // Iterators //---------- class IMF_EXPORT_TYPE Header::Iterator { public: IMF_EXPORT Iterator (); IMF_EXPORT Iterator (const Header::AttributeMap::iterator &i); IMF_EXPORT Iterator & operator ++ (); IMF_EXPORT Iterator operator ++ (int); IMF_EXPORT const char * name () const; IMF_EXPORT Attribute & attribute () const; private: friend class Header::ConstIterator; Header::AttributeMap::iterator _i; }; class IMF_EXPORT_TYPE Header::ConstIterator { public: IMF_EXPORT ConstIterator (); IMF_EXPORT ConstIterator (const Header::AttributeMap::const_iterator &i); IMF_EXPORT ConstIterator (const Header::Iterator &other); IMF_EXPORT ConstIterator & operator ++ (); IMF_EXPORT ConstIterator operator ++ (int); IMF_EXPORT const char * name () const; IMF_EXPORT const Attribute & attribute () const; private: friend bool operator == (const ConstIterator &, const ConstIterator &); friend bool operator != (const ConstIterator &, const ConstIterator &); Header::AttributeMap::const_iterator _i; }; //------------------------------------------------------------------------ // Library initialization: // // In a multithreaded program, staticInitialize() must be called once // during startup, before the program accesses any other functions or // classes in the OpenEXR library. Calling staticInitialize() in this // way avoids races during initialization of the library's global // variables. // // Single-threaded programs are not required to call staticInitialize(); // initialization of the library's global variables happens automatically. // //------------------------------------------------------------------------ IMF_EXPORT void staticInitialize (); //----------------- // Inline Functions //----------------- inline Header::Iterator::Iterator (): _i() { // empty } inline Header::Iterator::Iterator (const Header::AttributeMap::iterator &i): _i (i) { // empty } inline Header::Iterator & Header::Iterator::operator ++ () { ++_i; return *this; } inline Header::Iterator Header::Iterator::operator ++ (int) { Iterator tmp = *this; ++_i; return tmp; } inline const char * Header::Iterator::name () const { return *_i->first; } inline Attribute & Header::Iterator::attribute () const { return *_i->second; } inline Header::ConstIterator::ConstIterator (): _i() { // empty } inline Header::ConstIterator::ConstIterator (const Header::AttributeMap::const_iterator &i): _i (i) { // empty } inline Header::ConstIterator::ConstIterator (const Header::Iterator &other): _i (other._i) { // empty } inline Header::ConstIterator & Header::ConstIterator::operator ++ () { ++_i; return *this; } inline Header::ConstIterator Header::ConstIterator::operator ++ (int) { ConstIterator tmp = *this; ++_i; return tmp; } inline const char * Header::ConstIterator::name () const { return *_i->first; } inline const Attribute & Header::ConstIterator::attribute () const { return *_i->second; } inline bool operator == (const Header::ConstIterator &x, const Header::ConstIterator &y) { return x._i == y._i; } inline bool operator != (const Header::ConstIterator &x, const Header::ConstIterator &y) { return !(x == y); } //--------------------- // Template definitions //--------------------- template <class T> T & Header::typedAttribute (const char name[]) { Attribute *attr = &(*this)[name]; T *tattr = dynamic_cast <T *> (attr); if (tattr == 0) throw IEX_NAMESPACE::TypeExc ("Unexpected attribute type."); return *tattr; } template <class T> const T & Header::typedAttribute (const char name[]) const { const Attribute *attr = &(*this)[name]; const T *tattr = dynamic_cast <const T *> (attr); if (tattr == 0) throw IEX_NAMESPACE::TypeExc ("Unexpected attribute type."); return *tattr; } template <class T> T & Header::typedAttribute (const std::string &name) { return typedAttribute<T> (name.c_str()); } template <class T> const T & Header::typedAttribute (const std::string &name) const { return typedAttribute<T> (name.c_str()); } template <class T> T * Header::findTypedAttribute (const char name[]) { AttributeMap::iterator i = _map.find (name); return (i == _map.end())? 0: dynamic_cast <T *> (i->second); } template <class T> const T * Header::findTypedAttribute (const char name[]) const { AttributeMap::const_iterator i = _map.find (name); return (i == _map.end())? 0: dynamic_cast <const T *> (i->second); } template <class T> T * Header::findTypedAttribute (const std::string &name) { return findTypedAttribute<T> (name.c_str()); } template <class T> const T * Header::findTypedAttribute (const std::string &name) const { return findTypedAttribute<T> (name.c_str()); } OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[G�L�� � openexr_debug.hnu �[��� /* ** SPDX-License-Identifier: BSD-3-Clause ** Copyright Contributors to the OpenEXR Project. */ #ifndef OPENEXR_DEBUG_H #define OPENEXR_DEBUG_H #include "openexr_context.h" #ifdef __cplusplus extern "C" { #endif /** Debug function: print to stdout the parts and attributes of the * context @p c */ EXR_EXPORT exr_result_t exr_print_context_info( exr_const_context_t c, int verbose ); #ifdef __cplusplus } /* extern "C" */ #endif #endif /* OPENEXR_DEBUG_H */ PK rM�[j���H �H openexr_context.hnu �[��� /* ** SPDX-License-Identifier: BSD-3-Clause ** Copyright Contributors to the OpenEXR Project. */ #ifndef OPENEXR_CONTEXT_H #define OPENEXR_CONTEXT_H #include "openexr_errors.h" #include "openexr_base.h" #include <stddef.h> #include <stdint.h> #ifdef __cplusplus extern "C" { #endif /** * @defgroup Context Context related definitions * * A context is a single instance of an OpenEXR file or stream. Beyond * a particular file or stream handle, it also has separate controls * for error handling and memory allocation. This is done to enable * encoding or decoding on mixed hardware. * * @{ */ /** Opaque context handle * * The implementation of this is partly opaque to provide better * version portability, and all accesses to relevant data should * happen using provided functions. This handle serves as a container * and identifier for all the metadata and parts associated with a * file and/or stream */ typedef struct _priv_exr_context_t* exr_context_t; typedef const struct _priv_exr_context_t* exr_const_context_t; /** * @defgroup ContextFunctions OpenEXR Context Stream / File Functions * * @brief These are a group of function interfaces used to customize * the error handling, memory allocations, or I/O behavior of an * OpenEXR context. * * @{ */ /** @brief Stream error notifier * * This function pointer is provided to the stream functions by the * library such that they can provide a nice error message to the * user during stream operations. */ typedef exr_result_t (*exr_stream_error_func_ptr_t) ( exr_const_context_t ctxt, exr_result_t code, const char* fmt, ...) EXR_PRINTF_FUNC_ATTRIBUTE; /** @brief Error callback function * * Because a file can be read from using many threads at once, it is * difficult to store an error message for later retrieval. As such, * when a file is constructed, a callback function can be provided * which delivers an error message for the calling application to * handle. This will then be delivered on the same thread causing the * error. */ typedef void (*exr_error_handler_cb_t) ( exr_const_context_t ctxt, exr_result_t code, const char* msg); /** Destroy custom stream function pointer * * Generic callback to clean up user data for custom streams. * This is called when the file is closed and expected not to * error * * @param failed - indicates the write operation failed, the * implementor may wish to cleanup temporary * files */ typedef void (*exr_destroy_stream_func_ptr_t) ( exr_const_context_t ctxt, void* userdata, int failed); /** Query stream size function pointer * * Used to query the size of the file, or amount of data representing * the openexr file in the data stream. * * This is used to validate requests against the file. If the size is * unavailable, return -1, which will disable these validation steps * for this file, although appropriate memory safeguards must be in * place in the calling application. */ typedef int64_t (*exr_query_size_func_ptr_t) ( exr_const_context_t ctxt, void* userdata); /** @brief Read custom function pointer * * Used to read data from a custom output. Expects similar semantics to * pread or ReadFile with overlapped data under win32 * * It is required that this provides thread-safe concurrent access to * the same file. If the stream / input layer you are providing does * not have this guarantee, your are responsible for providing * appropriate serialization of requests. * * A file should be expected to be accessed in the following pattern: * - upon open, the header and part information attributes will be read * - upon the first image read request, the offset tables will be read * multiple threads accessing this concurrently may actually read * these values at the same time * - chunks can then be read in any order as preferred by the * application * * While this should mean that the header will be read in 'stream' * order (no seeks required), no guarantee is made beyond that to * retrieve image / deep data in order. So if the backing file is * truly a stream, it is up to the provider to implement appropriate * caching of data to give the appearance of being able to seek / read * atomically. */ typedef int64_t (*exr_read_func_ptr_t) ( exr_const_context_t ctxt, void* userdata, void* buffer, uint64_t sz, uint64_t offset, exr_stream_error_func_ptr_t error_cb); /** Write custom function pointer * * Used to write data to a custom output. Expects similar semantics to * pwrite or WriteFile with overlapped data under win32 * * It is required that this provides thread-safe concurrent access to * the same file. While it is unlikely that multiple threads will * be used to write data for compressed forms, it is possible. * * A file should be expected to be accessed in the following pattern: * - upon open, the header and part information attributes is constructed * * - when the write_header routine is called, the header becomes immutable * and is written to the file. This computes the space to store the chunk * offsets, but does not yet write the values * * - Image chunks are written to the file, and appear in the order * they are written, not in the ordering that is required by the * chunk offset table (unless written in that order). This may vary * slightly if the size of the chunks is not directly known and * tight packing of data is necessary * * - at file close, the chunk offset tables are written to the file */ typedef int64_t (*exr_write_func_ptr_t) ( exr_const_context_t ctxt, void* userdata, const void* buffer, uint64_t sz, uint64_t offset, exr_stream_error_func_ptr_t error_cb); /** @brief struct used to pass function pointers into the context * initialization routines. * * This partly exists to avoid the chicken and egg issue around creating the storage needed for the context on systems which want to override the malloc / free routines. * * However, it also serves to make a tidier / simpler set of functions * to create and start processing exr files. * * The size member is required for version portability * * It can be initialized using \ref EXR_DEFAULT_CONTEXT_INITIALIZER * * \code{.c} * exr_context_initializer_t myctxtinit = DEFAULT_CONTEXT_INITIALIZER; * myctxtinit.error_cb = &my_super_cool_error_callback_function; * ... * \endcode * */ typedef struct _exr_context_initializer { /** @brief size member to tag initializer for version stability. * * This should be initialized to the size of the current * structure. This allows EXR to add functions or other * initializers in the future, and retain version compatibility */ size_t size; /** @brief Error callback function pointer * * The error callback is allowed to be null, and will use a default print which outputs to stderr * * @sa exr_error_handler_cb_t */ exr_error_handler_cb_t error_handler_fn; /** custom allocator, if null, will use malloc. @sa exr_memory_allocation_func_t */ exr_memory_allocation_func_t alloc_fn; /** custom deallocator, if null, will use free. @sa exr_memory_free_func_t */ exr_memory_free_func_t free_fn; /** passed to custom read, size, write, destroy functions below. Up to user to manage this pointer */ void* user_data; /** @brief custom read routine. * * This is only used during read or update contexts. If this is * provided, it is expected that the caller has previously made * the stream available, and placed whatever stream / file data * into \ref user_data above. * * If this is NULL, and the context requested is for reading an * exr file, an internal implementation is provided for reading * from normal filesystem files, and the filename provided is * attempted to be opened as such. * * Expected to be NULL for a write-only operation, but is ignored * if it is provided. * * For update contexts, both read and write functions must be * provided if either is. * * @sa exr_read_func_ptr_t */ exr_read_func_ptr_t read_fn; /** @brief custom size query routine. * * Used to provide validation when reading header values. If this * is not provided, but a custom read routine is provided, this * will disable some of the validation checks when parsing the * image header. * * Expected to be NULL for a write-only operation, but is ignored * if it is provided. * * @sa exr_query_size_func_ptr_t */ exr_query_size_func_ptr_t size_fn; /** @brief custom write routine. * * This is only used during write or update contexts. If this is * provided, it is expected that the caller has previously made * the stream available, and placed whatever stream / file data * into \ref user_data above. * * If this is NULL, and the context requested is for writing an * exr file, an internal implementation is provided for reading * from normal filesystem files, and the filename provided is * attempted to be opened as such. * * For update contexts, both read and write functions must be * provided if either is. * * @sa exr_write_func_ptr_t */ exr_write_func_ptr_t write_fn; /** @brief optional function to destroy the user data block of a custom stream * * Allows one to free any user allocated data, and close any handles. * * @sa exr_destroy_stream_func_ptr_t * */ exr_destroy_stream_func_ptr_t destroy_fn; /** initializes a field specifying what the maximum image width * allowed by the context is. See \ref exr_set_default_maximum_image_size to * understand how this interacts with global defaults */ int max_image_width; /** initializes a field specifying what the maximum image height * allowed by the context is. See \ref exr_set_default_maximum_image_size to * understand how this interacts with global defaults */ int max_image_height; /** initializes a field specifying what the maximum tile width * allowed by the context is. See \ref exr_set_default_maximum_tile_size to * understand how this interacts with global defaults */ int max_tile_width; /** initializes a field specifying what the maximum tile height * allowed by the context is. See \ref exr_set_default_maximum_tile_size to * understand how this interacts with global defaults */ int max_tile_height; } exr_context_initializer_t; /** @brief simple macro to initialize the context initializer with default values */ #define EXR_DEFAULT_CONTEXT_INITIALIZER \ { \ sizeof (exr_context_initializer_t), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 \ } /** @} */ /* context function pointer declarations */ /** @brief Check the magic number of the file and report * `EXR_ERR_SUCCESS` if the file appears to be a valid file (or at least * has the correct magic number and can be read) */ EXR_EXPORT exr_result_t exr_test_file_header ( const char* filename, const exr_context_initializer_t* ctxtdata); /** @brief Close and free any internally allocated memory, * calling any provided destroy function for custom streams * * If the file was opened for write, first save the chunk offsets * or any other unwritten data. */ EXR_EXPORT exr_result_t exr_finish (exr_context_t* ctxt); /** @brief Create and initialize a read-only exr read context * * If a custom read function is provided, the filename is for * informational purposes only, the system assumes the user has * previously opened a stream, file, or whatever and placed relevant * data in userdata to access that. * * One notable attribute of the context is that once it has been * created and returned a successful code, it has parsed all the * header data. This is done as one step such that it is easier to * provide a safe context for multiple threads to request data from * the same context concurrently. * * Once finished reading data, use \ref exr_finish to clean up * the context. * * If you have custom I/O requirements, see the initializer context * documentation \ref exr_context_initializer_t. The @p ctxtdata parameter * is optional, if `NULL`, default values will be used. */ EXR_EXPORT exr_result_t exr_start_read ( exr_context_t* ctxt, const char* filename, const exr_context_initializer_t* ctxtdata); /** @brief enum describing how default files are handled during write */ enum exr_default_write_mode { EXR_WRITE_FILE_DIRECTLY = 0, /**< overwrites filename provided directly, deleted upon error */ EXR_INTERMEDIATE_TEMP_FILE = 1 /**< creates a temporary file, renaming it upon successful write, leaving original upon error */ }; /** @brief Creates and initializes a write-only context. * * If a custom write function is provided, the filename is for * informational purposes only, and the @p default_mode parameter will be * ignored. As such, the system assumes the user has previously opened * a stream, file, or whatever and placed relevant data in userdata to * access that. * * Multi-Threading: To avoid issues with creating multi-part EXR * files, the library approaches writing as a multi-step process, so * the same concurrent guarantees can not be made for writing a * file. The steps are: * * 1. Context creation (this function) * * 2. Part definition (required attributes and additional metadata) * * 3. Transition to writing data (this "commits" the part definitions, * any changes requested after will result in an error) * * 4. Write part data in sequential order of parts ( part 0->(N-1) ). * * 5. Within each part, multiple threads can be encoding and writing * data concurrently. For some EXR part definitions, this may be able * to write data concurrently when it can predict the chunk sizes, or * data is allowed to be padded. For others, it may need to * temporarily cache chunks until the data is received to flush in * order. The concurrency around this is handled by the library * * 6. Once finished writing data, use \ref exr_finish to clean * up the context, which will flush any unwritten data such as the * final chunk offset tables, and handle the temporary file flags. * * If you have custom I/O requirements, see the initializer context * documentation \ref exr_context_initializer_t. The @p ctxtdata * parameter is optional, if NULL, default values will be used. */ EXR_EXPORT exr_result_t exr_start_write ( exr_context_t* ctxt, const char* filename, enum exr_default_write_mode default_mode, const exr_context_initializer_t* ctxtdata); /** @brief Creates a new context for updating an exr file in place * * This is a custom mode that allows one to modify the value of a * metadata entry, although not to change the size of the header, or * any of the image data. * * If you have custom I/O requirements, see the initializer context * documentation \ref exr_context_initializer_t. The @p ctxtdata parameter * is optional, if NULL, default values will be used. */ EXR_EXPORT exr_result_t exr_start_inplace_header_update ( exr_context_t* ctxt, const char* filename, const exr_context_initializer_t* ctxtdata); /** @brief Retrieve the file name the context is for as provided * during the start routine. * * Do not free the resulting string. */ EXR_EXPORT exr_result_t exr_get_file_name (exr_const_context_t ctxt, const char** name); /** @brief Query the user data the context was constructed with. This * is perhaps useful in the error handler callback to jump back into * an object the user controls. */ EXR_EXPORT exr_result_t exr_get_user_data (exr_const_context_t ctxt, void** userdata); /** Any opaque attribute data entry of the specified type is tagged * with these functions enabling downstream users to unpack (or pack) * the data. * * The library handles the memory packed data internally, but the * handler is expected to allocate and manage memory for the * *unpacked* buffer (the library will call the destroy function). * * NB: the pack function will be called twice (unless there is a * memory failure), the first with a NULL buffer, requesting the * maximum size (or exact size if known) for the packed buffer, then * the second to fill the output packed buffer, at which point the * size can be re-updated to have the final, precise size to put into * the file. */ EXR_EXPORT exr_result_t exr_register_attr_type_handler ( exr_context_t ctxt, const char* type, exr_result_t (*unpack_func_ptr) ( exr_context_t ctxt, const void* data, int32_t attrsize, int32_t* outsize, void** outbuffer), exr_result_t (*pack_func_ptr) ( exr_context_t ctxt, const void* data, int32_t datasize, int32_t* outsize, void* outbuffer), void (*destroy_unpacked_func_ptr) ( exr_context_t ctxt, void* data, int32_t datasize)); /** @brief Enable long name support in the output context */ EXR_EXPORT exr_result_t exr_set_longname_support (exr_context_t ctxt, int onoff); /** @brief Write the header data * * Opening a new output file has a small initialization state problem * compared to opening for read / update: we need to enable the user * to specify an arbitrary set of metadata across an arbitrary number * of parts. To avoid having to create the list of parts and entire * metadata up front, prior to calling the above \ref exr_start_write, * allow the data to be set, then once this is called, it switches * into a mode where the library assumes the data is now valid. * * It will recompute the number of chunks that will be written, and * reset the chunk offsets. If you modify file attributes or part * information after a call to this, it will error. */ EXR_EXPORT exr_result_t exr_write_header (exr_context_t ctxt); /** @} */ #ifdef __cplusplus } /* extern "C" */ #endif #endif /* OPENEXR_CONTEXT_H */ PK rM�[.=*) ) ImfIDManifestAttribute.hnu �[��� // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. #ifndef INCLUDED_IMF_IDMANIFEST_ATTRIBUTE_H #define INCLUDED_IMF_IDMANIFEST_ATTRIBUTE_H #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" #include "ImfIDManifest.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER #if defined(_MSC_VER) // suppress warning about non-exported base classes #pragma warning (disable : 4251) #pragma warning (disable : 4275) #endif typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::CompressedIDManifest> IDManifestAttribute; #ifndef COMPILING_IMF_IDMANIFEST_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::CompressedIDManifest>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[ u�Kh; h; ImfDeepTiledInputFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_DEEP_TILED_INPUT_FILE_H #define INCLUDED_IMF_DEEP_TILED_INPUT_FILE_H //----------------------------------------------------------------------------- // // class DeepTiledInputFile // //----------------------------------------------------------------------------- #include "ImfForward.h" #include "ImfThreading.h" #include "ImfGenericInputFile.h" #include "ImfTileDescription.h" #include <ImathBox.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE DeepTiledInputFile : public GenericInputFile { public: //-------------------------------------------------------------------- // A constructor that opens the file with the specified name, and // reads the file header. The constructor throws an IEX_NAMESPACE::ArgExc // exception if the file is not tiled. // The numThreads parameter specifies how many worker threads this // file will try to keep busy when decompressing individual tiles. // Destroying TiledInputFile objects constructed with this constructor // automatically closes the corresponding files. //-------------------------------------------------------------------- IMF_EXPORT DeepTiledInputFile (const char fileName[], int numThreads = globalThreadCount ()); // ---------------------------------------------------------- // A constructor that attaches the new TiledInputFile object // to a file that has already been opened. // Destroying TiledInputFile objects constructed with this // constructor does not automatically close the corresponding // files. // ---------------------------------------------------------- IMF_EXPORT DeepTiledInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int numThreads = globalThreadCount ()); //----------- // Destructor //----------- IMF_EXPORT virtual ~DeepTiledInputFile (); //------------------------ // Access to the file name //------------------------ IMF_EXPORT const char * fileName () const; //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; //---------------------------------- // Access to the file format version //---------------------------------- IMF_EXPORT int version () const; //----------------------------------------------------------- // Set the current frame buffer -- copies the FrameBuffer // object into the TiledInputFile object. // // The current frame buffer is the destination for the pixel // data read from the file. The current frame buffer must be // set at least once before readTile() is called. // The current frame buffer can be changed after each call // to readTile(). //----------------------------------------------------------- IMF_EXPORT void setFrameBuffer (const DeepFrameBuffer &frameBuffer); //----------------------------------- // Access to the current frame buffer //----------------------------------- IMF_EXPORT const DeepFrameBuffer & frameBuffer () const; //------------------------------------------------------------ // Check if the file is complete: // // isComplete() returns true if all pixels in the data window // (in all levels) are present in the input file, or false if // any pixels are missing. (Another program may still be busy // writing the file, or file writing may have been aborted // prematurely.) //------------------------------------------------------------ IMF_EXPORT bool isComplete () const; //-------------------------------------------------- // Utility functions: //-------------------------------------------------- //--------------------------------------------------------- // Multiresolution mode and tile size: // The following functions return the xSize, ySize and mode // fields of the file header's TileDescriptionAttribute. //--------------------------------------------------------- IMF_EXPORT unsigned int tileXSize () const; IMF_EXPORT unsigned int tileYSize () const; IMF_EXPORT LevelMode levelMode () const; IMF_EXPORT LevelRoundingMode levelRoundingMode () const; //-------------------------------------------------------------------- // Number of levels: // // numXLevels() returns the file's number of levels in x direction. // // if levelMode() == ONE_LEVEL: // return value is: 1 // // if levelMode() == MIPMAP_LEVELS: // return value is: rfunc (log (max (w, h)) / log (2)) + 1 // // if levelMode() == RIPMAP_LEVELS: // return value is: rfunc (log (w) / log (2)) + 1 // // where // w is the width of the image's data window, max.x - min.x + 1, // y is the height of the image's data window, max.y - min.y + 1, // and rfunc(x) is either floor(x), or ceil(x), depending on // whether levelRoundingMode() returns ROUND_DOWN or ROUND_UP. // // numYLevels() returns the file's number of levels in y direction. // // if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS: // return value is the same as for numXLevels() // // if levelMode() == RIPMAP_LEVELS: // return value is: rfunc (log (h) / log (2)) + 1 // // // numLevels() is a convenience function for use with // MIPMAP_LEVELS files. // // if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS: // return value is the same as for numXLevels() // // if levelMode() == RIPMAP_LEVELS: // an IEX_NAMESPACE::LogicExc exception is thrown // // isValidLevel(lx, ly) returns true if the file contains // a level with level number (lx, ly), false if not. // // totalTiles() returns the total number of tiles in the image // //-------------------------------------------------------------------- IMF_EXPORT int numLevels () const; IMF_EXPORT int numXLevels () const; IMF_EXPORT int numYLevels () const; IMF_EXPORT bool isValidLevel (int lx, int ly) const; IMF_EXPORT size_t totalTiles() const; //---------------------------------------------------------- // Dimensions of a level: // // levelWidth(lx) returns the width of a level with level // number (lx, *), where * is any number. // // return value is: // max (1, rfunc (w / pow (2, lx))) // // // levelHeight(ly) returns the height of a level with level // number (*, ly), where * is any number. // // return value is: // max (1, rfunc (h / pow (2, ly))) // //---------------------------------------------------------- IMF_EXPORT int levelWidth (int lx) const; IMF_EXPORT int levelHeight (int ly) const; //-------------------------------------------------------------- // Number of tiles: // // numXTiles(lx) returns the number of tiles in x direction // that cover a level with level number (lx, *), where * is // any number. // // return value is: // (levelWidth(lx) + tileXSize() - 1) / tileXSize() // // // numYTiles(ly) returns the number of tiles in y direction // that cover a level with level number (*, ly), where * is // any number. // // return value is: // (levelHeight(ly) + tileXSize() - 1) / tileXSize() // //-------------------------------------------------------------- IMF_EXPORT int numXTiles (int lx = 0) const; IMF_EXPORT int numYTiles (int ly = 0) const; //--------------------------------------------------------------- // Level pixel ranges: // // dataWindowForLevel(lx, ly) returns a 2-dimensional region of // valid pixel coordinates for a level with level number (lx, ly) // // return value is a Box2i with min value: // (dataWindow.min.x, dataWindow.min.y) // // and max value: // (dataWindow.min.x + levelWidth(lx) - 1, // dataWindow.min.y + levelHeight(ly) - 1) // // dataWindowForLevel(level) is a convenience function used // for ONE_LEVEL and MIPMAP_LEVELS files. It returns // dataWindowForLevel(level, level). // //--------------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int lx, int ly) const; //------------------------------------------------------------------- // Tile pixel ranges: // // dataWindowForTile(dx, dy, lx, ly) returns a 2-dimensional // region of valid pixel coordinates for a tile with tile coordinates // (dx,dy) and level number (lx, ly). // // return value is a Box2i with min value: // (dataWindow.min.x + dx * tileXSize(), // dataWindow.min.y + dy * tileYSize()) // // and max value: // (dataWindow.min.x + (dx + 1) * tileXSize() - 1, // dataWindow.min.y + (dy + 1) * tileYSize() - 1) // // dataWindowForTile(dx, dy, level) is a convenience function // used for ONE_LEVEL and MIPMAP_LEVELS files. It returns // dataWindowForTile(dx, dy, level, level). // //------------------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int lx, int ly) const; //------------------------------------------------------------ // Read pixel data: // // readTile(dx, dy, lx, ly) reads the tile with tile // coordinates (dx, dy), and level number (lx, ly), // and stores it in the current frame buffer. // // dx must lie in the interval [0, numXTiles(lx)-1] // dy must lie in the interval [0, numYTiles(ly)-1] // // lx must lie in the interval [0, numXLevels()-1] // ly must lie in the inverval [0, numYLevels()-1] // // readTile(dx, dy, level) is a convenience function used // for ONE_LEVEL and MIPMAP_LEVELS files. It calls // readTile(dx, dy, level, level). // // The two readTiles(dx1, dx2, dy1, dy2, ...) functions allow // reading multiple tiles at once. If multi-threading is used // the multiple tiles are read concurrently. // // Pixels that are outside the pixel coordinate range for the // tile's level, are never accessed by readTile(). // // Attempting to access a tile that is not present in the file // throws an InputExc exception. // //------------------------------------------------------------ IMF_EXPORT void readTile (int dx, int dy, int l = 0); IMF_EXPORT void readTile (int dx, int dy, int lx, int ly); IMF_EXPORT void readTiles (int dx1, int dx2, int dy1, int dy2, int lx, int ly); IMF_EXPORT void readTiles (int dx1, int dx2, int dy1, int dy2, int l = 0); //-------------------------------------------------- // Read a tile of raw pixel data from the file, // without uncompressing it (this function is // used to implement TiledOutputFile::copyPixels()). //-------------------------------------------------- IMF_EXPORT void rawTileData (int &dx, int &dy, int &lx, int &ly, char *pixelData, uint64_t &dataSize) const; //------------------------------------------------------------------ // Read pixel sample counts into a slice in the frame buffer. // // readPixelSampleCount(dx, dy, lx, ly) reads the sample counts // for tile (dx, dy) in level (lx, ly). // // readPixelSampleCount(dx, dy, l) calls // readPixelSampleCount(dx, dy, lx = l, ly = l) // // dx must lie in the interval [0, numXTiles(lx)-1] // dy must lie in the interval [0, numYTiles(ly)-1] // // lx must lie in the interval [0, numXLevels()-1] // ly must lie in the inverval [0, numYLevels()-1] // // readPixelSampleCounts(dx1, dx2, dy1, dy2, lx, ly) reads all // the sample counts for tiles within range // [(min(dx1, dx2), min(dy1, dy2))...(max(dx1, dx2), max(dy1, dy2)], // and on level (lx, ly) // // readPixelSampleCounts(dx1, dx2, dy1, dy2, l) calls // readPixelSampleCounts(dx1, dx2, dy1, dy2, lx = l, ly = l). //------------------------------------------------------------------ IMF_EXPORT void readPixelSampleCount (int dx, int dy, int l = 0); IMF_EXPORT void readPixelSampleCount (int dx, int dy, int lx, int ly); IMF_EXPORT void readPixelSampleCounts (int dx1, int dx2, int dy1, int dy2, int lx, int ly); IMF_EXPORT void readPixelSampleCounts (int dx1, int dx2, int dy1, int dy2, int l = 0); struct Data; private: friend class InputFile; friend class MultiPartInputFile; DeepTiledInputFile (InputPartData* part); DeepTiledInputFile (const DeepTiledInputFile &) = delete; DeepTiledInputFile & operator = (const DeepTiledInputFile &) = delete; DeepTiledInputFile (DeepTiledInputFile &&) = delete; DeepTiledInputFile & operator = (DeepTiledInputFile &&) = delete; DeepTiledInputFile (const Header &header, OPENEXR_IMF_INTERNAL_NAMESPACE::IStream *is, int version, int numThreads); void initialize (); void multiPartInitialize(InputPartData* part); void compatibilityInitialize(OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is); bool isValidTile (int dx, int dy, int lx, int ly) const; size_t bytesPerLineForTile (int dx, int dy, int lx, int ly) const; void getTileOrder(int dx[],int dy[],int lx[],int ly[]) const; Data * _data; // needed for copyPixels friend class DeepTiledOutputFile; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[=$T�5 5 ImfChromaticitiesAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_CHROMATICITIES_ATTRIBUTE_H #define INCLUDED_IMF_CHROMATICITIES_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class ChromaticitiesAttribute // //----------------------------------------------------------------------------- #include "ImfAttribute.h" #include "ImfChromaticities.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Chromaticities> ChromaticitiesAttribute; #ifndef COMPILING_IMF_CHROMATICITIES_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Chromaticities>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[}��l` ` ImfChromaticities.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_CHROMATICITIES_H #define INCLUDED_IMF_CHROMATICITIES_H //----------------------------------------------------------------------------- // // CIE (x,y) chromaticities, and conversions between // RGB tiples and CIE XYZ tristimulus values. // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImathMatrix.h" #include "ImathVec.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER struct IMF_EXPORT_TYPE Chromaticities { //----------------------------------------------- // The CIE x and y coordinates of the RGB triples // (1,0,0), (0,1,0), (0,0,1) and (1,1,1). //----------------------------------------------- IMATH_NAMESPACE::V2f red; IMATH_NAMESPACE::V2f green; IMATH_NAMESPACE::V2f blue; IMATH_NAMESPACE::V2f white; //-------------------------------------------- // Default constructor produces chromaticities // according to Rec. ITU-R BT.709-3 //-------------------------------------------- IMF_EXPORT Chromaticities (const IMATH_NAMESPACE::V2f &red = IMATH_NAMESPACE::V2f (0.6400f, 0.3300f), const IMATH_NAMESPACE::V2f &green = IMATH_NAMESPACE::V2f (0.3000f, 0.6000f), const IMATH_NAMESPACE::V2f &blue = IMATH_NAMESPACE::V2f (0.1500f, 0.0600f), const IMATH_NAMESPACE::V2f &white = IMATH_NAMESPACE::V2f (0.3127f, 0.3290f)); //--------- // Equality //--------- IMF_EXPORT bool operator == (const Chromaticities &v) const; IMF_EXPORT bool operator != (const Chromaticities &v) const; }; // // Conversions between RGB and CIE XYZ // // RGB to XYZ: // // Given a set of chromaticities, c, and the luminance, Y, of the RGB // triple (1,1,1), or "white", RGBtoXYZ(c,Y) computes a matrix, M, so // that multiplying an RGB value, v, with M produces an equivalent // XYZ value, w. (w == v * M) // // If we define that // // (Xr, Yr, Zr) == (1, 0, 0) * M // (Xg, Yg, Zg) == (0, 1, 0) * M // (Xb, Yb, Zb) == (0, 0, 1) * M // (Xw, Yw, Zw) == (1, 1, 1) * M, // // then the following statements are true: // // Xr / (Xr + Yr + Zr) == c.red.x // Yr / (Xr + Yr + Zr) == c.red.y // // Xg / (Xg + Yg + Zg) == c.red.x // Yg / (Xg + Yg + Zg) == c.red.y // // Xb / (Xb + Yb + Zb) == c.red.x // Yb / (Xb + Yb + Zb) == c.red.y // // Xw / (Xw + Yw + Zw) == c.red.x // Yw / (Xw + Yw + Zw) == c.red.y // // Yw == Y. // // XYZ to RGB: // // XYZtoRGB(c,Y) returns RGBtoXYZ(c,Y).inverse(). // IMF_EXPORT IMATH_NAMESPACE::M44f RGBtoXYZ (const Chromaticities &chroma, float Y); IMF_EXPORT IMATH_NAMESPACE::M44f XYZtoRGB (const Chromaticities &chroma, float Y); OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[VC��� � ImfFramesPerSecond.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_FRAMES_PER_SECOND_H #define INCLUDED_IMF_FRAMES_PER_SECOND_H //----------------------------------------------------------------------------- // // Convenience functions related to the framesPerSecond attribute // // Functions that return the exact values for commonly used frame rates: // // name frames per second // // fps_23_976() 23.976023... // fps_24() 24.0 35mm film frames // fps_25() 25.0 PAL video frames // fps_29_97() 29.970029... NTSC video frames // fps_30() 30.0 60Hz HDTV frames // fps_47_952() 47.952047... // fps_48() 48.0 // fps_50() 50.0 PAL video fields // fps_59_94() 59.940059... NTSC video fields // fps_60() 60.0 60Hz HDTV fields // // Functions that try to convert inexact frame rates into exact ones: // // Given a frame rate, fps, that is close to one of the pre-defined // frame rates fps_23_976(), fps_29_97(), fps_47_952() or fps_59_94(), // guessExactFps(fps) returns the corresponding pre-defined frame // rate. If fps is not close to one of the pre-defined frame rates, // then guessExactFps(fps) returns Rational(fps). // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfRational.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER inline Rational fps_23_976 () {return Rational (24000, 1001);} inline Rational fps_24 () {return Rational (24, 1);} inline Rational fps_25 () {return Rational (25, 1);} inline Rational fps_29_97 () {return Rational (30000, 1001);} inline Rational fps_30 () {return Rational (30, 1);} inline Rational fps_47_952 () {return Rational (48000, 1001);} inline Rational fps_48 () {return Rational (48, 1);} inline Rational fps_50 () {return Rational (50, 1);} inline Rational fps_59_94 () {return Rational (60000, 1001);} inline Rational fps_60 () {return Rational (60, 1);} IMF_EXPORT Rational guessExactFps (double fps); IMF_EXPORT Rational guessExactFps (const Rational &fps); OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[Y4ל�/ �/ ImfStandardAttributes.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_STANDARD_ATTRIBUTES_H #define INCLUDED_IMF_STANDARD_ATTRIBUTES_H //----------------------------------------------------------------------------- // // Optional Standard Attributes -- these attributes are "optional" // because not every image file header has them, but they define a // "standard" way to represent commonly used data in the file header. // // For each attribute, with name "foo", and type "T", the following // functions are automatically generated via macros: // // void addFoo (Header &header, const T &value); // bool hasFoo (const Header &header); // const TypedAttribute<T> & fooAttribute (const Header &header); // TypedAttribute<T> & fooAttribute (Header &header); // const T & foo (const Header &Header); // T & foo (Header &Header); // //----------------------------------------------------------------------------- #include "ImfHeader.h" #include "ImfBoxAttribute.h" #include "ImfChromaticitiesAttribute.h" #include "ImfEnvmapAttribute.h" #include "ImfDeepImageStateAttribute.h" #include "ImfFloatAttribute.h" #include "ImfKeyCodeAttribute.h" #include "ImfMatrixAttribute.h" #include "ImfRationalAttribute.h" #include "ImfStringAttribute.h" #include "ImfStringVectorAttribute.h" #include "ImfTimeCodeAttribute.h" #include "ImfVecAttribute.h" #include "ImfNamespace.h" #include "ImfExport.h" #include "ImfIDManifestAttribute.h" #define IMF_ADD_SUFFIX(suffix) add##suffix #define IMF_HAS_SUFFIX(suffix) has##suffix #define IMF_NAME_ATTRIBUTE(name) name##Attribute #define IMF_STD_ATTRIBUTE_DEF(name,suffix,object) \ \ OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER \ IMF_EXPORT void IMF_ADD_SUFFIX(suffix) (Header &header, const object &v); \ IMF_EXPORT bool IMF_HAS_SUFFIX(suffix) (const Header &header); \ IMF_EXPORT const TypedAttribute<object> & \ IMF_NAME_ATTRIBUTE(name) (const Header &header); \ IMF_EXPORT TypedAttribute<object> & \ IMF_NAME_ATTRIBUTE(name) (Header &header); \ IMF_EXPORT const object & \ name (const Header &header); \ IMF_EXPORT object & name (Header &header); \ OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT \ // // chromaticities -- for RGB images, specifies the CIE (x,y) // chromaticities of the primaries and the white point // IMF_STD_ATTRIBUTE_DEF (chromaticities, Chromaticities, Chromaticities) // // whiteLuminance -- for RGB images, defines the luminance, in Nits // (candelas per square meter) of the RGB value (1.0, 1.0, 1.0). // // If the chromaticities and the whiteLuminance of an RGB image are // known, then it is possible to convert the image's pixels from RGB // to CIE XYZ tristimulus values (see function RGBtoXYZ() in header // file ImfChromaticities.h). // // IMF_STD_ATTRIBUTE_DEF (whiteLuminance, WhiteLuminance, float) // // adoptedNeutral -- specifies the CIE (x,y) coordinates that should // be considered neutral during color rendering. Pixels in the image // file whose (x,y) coordinates match the adoptedNeutral value should // be mapped to neutral values on the display. // IMF_STD_ATTRIBUTE_DEF (adoptedNeutral, AdoptedNeutral, IMATH_NAMESPACE::V2f) // // renderingTransform, lookModTransform -- specify the names of the // CTL functions that implements the intended color rendering and look // modification transforms for this image. // IMF_STD_ATTRIBUTE_DEF (renderingTransform, RenderingTransform, std::string) IMF_STD_ATTRIBUTE_DEF (lookModTransform, LookModTransform, std::string) // // xDensity -- horizontal output density, in pixels per inch. // The image's vertical output density is xDensity * pixelAspectRatio. // IMF_STD_ATTRIBUTE_DEF (xDensity, XDensity, float) // // owner -- name of the owner of the image // IMF_STD_ATTRIBUTE_DEF (owner, Owner, std::string) // // comments -- additional image information in human-readable // form, for example a verbal description of the image // IMF_STD_ATTRIBUTE_DEF (comments, Comments, std::string) // // capDate -- the date when the image was created or captured, // in local time, and formatted as // // YYYY:MM:DD hh:mm:ss // // where YYYY is the year (4 digits, e.g. 2003), MM is the month // (2 digits, 01, 02, ... 12), DD is the day of the month (2 digits, // 01, 02, ... 31), hh is the hour (2 digits, 00, 01, ... 23), mm // is the minute, and ss is the second (2 digits, 00, 01, ... 59). // // IMF_STD_ATTRIBUTE_DEF (capDate, CapDate, std::string) // // utcOffset -- offset of local time at capDate from // Universal Coordinated Time (UTC), in seconds: // // UTC == local time + utcOffset // IMF_STD_ATTRIBUTE_DEF (utcOffset, UtcOffset, float) // // longitude, latitude, altitude -- for images of real objects, the // location where the image was recorded. Longitude and latitude are // in degrees east of Greenwich and north of the equator. Altitude // is in meters above sea level. For example, Kathmandu, Nepal is // at longitude 85.317, latitude 27.717, altitude 1305. // IMF_STD_ATTRIBUTE_DEF (longitude, Longitude, float) IMF_STD_ATTRIBUTE_DEF (latitude, Latitude, float) IMF_STD_ATTRIBUTE_DEF (altitude, Altitude, float) // // focus -- the camera's focus distance, in meters // IMF_STD_ATTRIBUTE_DEF (focus, Focus, float) // // exposure -- exposure time, in seconds // IMF_STD_ATTRIBUTE_DEF (expTime, ExpTime, float) // // aperture -- the camera's lens aperture, in f-stops (focal length // of the lens divided by the diameter of the iris opening) // IMF_STD_ATTRIBUTE_DEF (aperture, Aperture, float) // // isoSpeed -- the ISO speed of the film or image sensor // that was used to record the image // IMF_STD_ATTRIBUTE_DEF (isoSpeed, IsoSpeed, float) // // envmap -- if this attribute is present, the image represents // an environment map. The attribute's value defines how 3D // directions are mapped to 2D pixel locations. For details // see header file ImfEnvmap.h // IMF_STD_ATTRIBUTE_DEF (envmap, Envmap, Envmap) // // keyCode -- for motion picture film frames. Identifies film // manufacturer, film type, film roll and frame position within // the roll. // IMF_STD_ATTRIBUTE_DEF (keyCode, KeyCode, KeyCode) // // timeCode -- time and control code // IMF_STD_ATTRIBUTE_DEF (timeCode, TimeCode, TimeCode) // // wrapmodes -- determines how texture map images are extrapolated. // If an OpenEXR file is used as a texture map for 3D rendering, // texture coordinates (0.0, 0.0) and (1.0, 1.0) correspond to // the upper left and lower right corners of the data window. // If the image is mapped onto a surface with texture coordinates // outside the zero-to-one range, then the image must be extrapolated. // This attribute tells the renderer how to do this extrapolation. // The attribute contains either a pair of comma-separated keywords, // to specify separate extrapolation modes for the horizontal and // vertical directions; or a single keyword, to specify extrapolation // in both directions (e.g. "clamp,periodic" or "clamp"). Extra white // space surrounding the keywords is allowed, but should be ignored // by the renderer ("clamp, black " is equivalent to "clamp,black"). // The keywords listed below are predefined; some renderers may support // additional extrapolation modes: // // black pixels outside the zero-to-one range are black // // clamp texture coordinates less than 0.0 and greater // than 1.0 are clamped to 0.0 and 1.0 respectively // // periodic the texture image repeats periodically // // mirror the texture image repeats periodically, but // every other instance is mirrored // IMF_STD_ATTRIBUTE_DEF (wrapmodes, Wrapmodes, std::string) // // framesPerSecond -- defines the nominal playback frame rate for image // sequences, in frames per second. Every image in a sequence should // have a framesPerSecond attribute, and the attribute value should be // the same for all images in the sequence. If an image sequence has // no framesPerSecond attribute, playback software should assume that // the frame rate for the sequence is 24 frames per second. // // In order to allow exact representation of NTSC frame and field rates, // framesPerSecond is stored as a rational number. A rational number is // a pair of integers, n and d, that represents the value n/d. // // For the exact values of commonly used frame rates, please see header // file ImfFramesPerSecond.h. // IMF_STD_ATTRIBUTE_DEF (framesPerSecond, FramesPerSecond, Rational) // // multiView -- defines the view names for multi-view image files. // A multi-view image contains two or more views of the same scene, // as seen from different viewpoints, for example a left-eye and // a right-eye view for stereo displays. The multiView attribute // lists the names of the views in an image, and a naming convention // identifies the channels that belong to each view. // // For details, please see header file ImfMultiView.h // IMF_STD_ATTRIBUTE_DEF (multiView , MultiView, StringVector) // // worldToCamera -- for images generated by 3D computer graphics rendering, // a matrix that transforms 3D points from the world to the camera coordinate // space of the renderer. // // The camera coordinate space is left-handed. Its origin indicates the // location of the camera. The positive x and y axes correspond to the // "right" and "up" directions in the rendered image. The positive z // axis indicates the camera's viewing direction. (Objects in front of // the camera have positive z coordinates.) // // Camera coordinate space in OpenEXR is the same as in Pixar's Renderman. // IMF_STD_ATTRIBUTE_DEF (worldToCamera, WorldToCamera, IMATH_NAMESPACE::M44f) // // worldToNDC -- for images generated by 3D computer graphics rendering, a // matrix that transforms 3D points from the world to the Normalized Device // Coordinate (NDC) space of the renderer. // // NDC is a 2D coordinate space that corresponds to the image plane, with // positive x and pointing to the right and y positive pointing down. The // coordinates (0, 0) and (1, 1) correspond to the upper left and lower right // corners of the OpenEXR display window. // // To transform a 3D point in word space into a 2D point in NDC space, // multiply the 3D point by the worldToNDC matrix and discard the z // coordinate. // // NDC space in OpenEXR is the same as in Pixar's Renderman. // IMF_STD_ATTRIBUTE_DEF (worldToNDC, WorldToNDC, IMATH_NAMESPACE::M44f) // // deepImageState -- specifies whether the pixels in a deep image are // sorted and non-overlapping. // // Note: this attribute can be set by application code that writes a file // in order to tell applications that read the file whether the pixel data // must be cleaned up prior to image processing operations such as flattening. // The OpenEXR library does not verify that the attribute is consistent with // the actual state of the pixels. Application software may assume that the // attribute is valid, as long as the software will not crash or lock up if // any pixels are inconsistent with the deepImageState attribute. // IMF_STD_ATTRIBUTE_DEF (deepImageState, DeepImageState, DeepImageState) // // originalDataWindow -- if application software crops an image, then it // should save the data window of the original, un-cropped image in the // originalDataWindow attribute. // IMF_STD_ATTRIBUTE_DEF (originalDataWindow, OriginalDataWindow, IMATH_NAMESPACE::Box2i) // // dwaCompressionLevel -- sets the quality level for images compressed // with the DWAA or DWAB method. // IMF_STD_ATTRIBUTE_DEF (dwaCompressionLevel, DwaCompressionLevel, float) // // ID Manifest // IMF_STD_ATTRIBUTE_DEF( idManifest,IDManifest,CompressedIDManifest) #endif PK rM�[���ud d ImfTestFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_TEST_FILE_H #define INCLUDED_IMF_TEST_FILE_H //----------------------------------------------------------------------------- // // Utility routines to test quickly if a given // file is an OpenEXR file, and whether the // file is scanline-based or tiled. // //----------------------------------------------------------------------------- #include "ImfForward.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER IMF_EXPORT bool isOpenExrFile (const char fileName[]); IMF_EXPORT bool isOpenExrFile (const char fileName[], bool &isTiled); IMF_EXPORT bool isOpenExrFile (const char fileName[], bool &isTiled, bool &isDeep); IMF_EXPORT bool isOpenExrFile (const char fileName[], bool &isTiled, bool &isDeep, bool &isMultiPart); IMF_EXPORT bool isTiledOpenExrFile (const char fileName[]); IMF_EXPORT bool isDeepOpenExrFile (const char fileName[]); IMF_EXPORT bool isMultiPartOpenExrFile (const char fileName[]); IMF_EXPORT bool isOpenExrFile (IStream &is); IMF_EXPORT bool isOpenExrFile (IStream &is, bool &isTiled); IMF_EXPORT bool isOpenExrFile (IStream &is, bool &isTiled, bool &isDeep); IMF_EXPORT bool isOpenExrFile (IStream &is, bool &isTiled, bool &isDeep, bool &isMultiPart); IMF_EXPORT bool isTiledOpenExrFile (IStream &is); IMF_EXPORT bool isDeepOpenExrFile (IStream &is); IMF_EXPORT bool isMultiPartOpenExrFile (IStream &is); OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[Z��A~ ~ ImfTimeCode.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_TIME_CODE_H #define INCLUDED_IMF_TIME_CODE_H #include "ImfExport.h" #include "ImfNamespace.h" //----------------------------------------------------------------------------- // // class TimeCode // // A TimeCode object stores time and control codes as described // in SMPTE standard 12M-1999. A TimeCode object contains the // following fields: // // Time Address: // // hours integer, range 0 - 23 // minutes integer, range 0 - 59 // seconds integer, range 0 - 59 // frame integer, range 0 - 29 // // Flags: // // drop frame flag boolean // color frame flag boolean // field/phase flag boolean // bgf0 boolean // bgf1 boolean // bgf2 boolean // // Binary groups for user-defined data and control codes: // // binary group 1 integer, range 0 - 15 // binary group 2 integer, range 0 - 15 // ... // binary group 8 integer, range 0 - 15 // // Class TimeCode contains methods to convert between the fields // listed above and a more compact representation where the fields // are packed into two unsigned 32-bit integers. In the packed // integer representations, bit 0 is the least significant bit, // and bit 31 is the most significant bit of the integer value. // // The time address and flags fields can be packed in three // different ways: // // bits packing for packing for packing for // 24-frame 60-field 50-field // film television television // // 0 - 3 frame units frame units frame units // 4 - 5 frame tens frame tens frame tens // 6 unused, set to 0 drop frame flag unused, set to 0 // 7 unused, set to 0 color frame flag color frame flag // 8 - 11 seconds units seconds units seconds units // 12 - 14 seconds tens seconds tens seconds tens // 15 phase flag field/phase flag bgf0 // 16 - 19 minutes units minutes units minutes units // 20 - 22 minutes tens minutes tens minutes tens // 23 bgf0 bgf0 bgf2 // 24 - 27 hours units hours units hours units // 28 - 29 hours tens hours tens hours tens // 30 bgf1 bgf1 bgf1 // 31 bgf2 bgf2 field/phase flag // // User-defined data and control codes are packed as follows: // // bits field // // 0 - 3 binary group 1 // 4 - 7 binary group 2 // 8 - 11 binary group 3 // 12 - 15 binary group 4 // 16 - 19 binary group 5 // 20 - 23 binary group 6 // 24 - 27 binary group 7 // 28 - 31 binary group 8 // //----------------------------------------------------------------------------- OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE TimeCode { public: //--------------------- // Bit packing variants //--------------------- enum IMF_EXPORT_ENUM Packing { TV60_PACKING, // packing for 60-field television TV50_PACKING, // packing for 50-field television FILM24_PACKING // packing for 24-frame film }; //------------------------------------- // Constructors and assignment operator //------------------------------------- IMF_EXPORT TimeCode (); // all fields set to 0 or false IMF_EXPORT TimeCode (int hours, int minutes, int seconds, int frame, bool dropFrame = false, bool colorFrame = false, bool fieldPhase = false, bool bgf0 = false, bool bgf1 = false, bool bgf2 = false, int binaryGroup1 = 0, int binaryGroup2 = 0, int binaryGroup3 = 0, int binaryGroup4 = 0, int binaryGroup5 = 0, int binaryGroup6 = 0, int binaryGroup7 = 0, int binaryGroup8 = 0); IMF_EXPORT TimeCode (unsigned int timeAndFlags, unsigned int userData = 0, Packing packing = TV60_PACKING); IMF_EXPORT TimeCode (const TimeCode &other); ~TimeCode () = default; IMF_EXPORT TimeCode & operator = (const TimeCode &other); //---------------------------- // Access to individual fields //---------------------------- IMF_EXPORT int hours () const; IMF_EXPORT void setHours (int value); IMF_EXPORT int minutes () const; IMF_EXPORT void setMinutes (int value); IMF_EXPORT int seconds () const; IMF_EXPORT void setSeconds (int value); IMF_EXPORT int frame () const; IMF_EXPORT void setFrame (int value); IMF_EXPORT bool dropFrame () const; IMF_EXPORT void setDropFrame (bool value); IMF_EXPORT bool colorFrame () const; IMF_EXPORT void setColorFrame (bool value); IMF_EXPORT bool fieldPhase () const; IMF_EXPORT void setFieldPhase (bool value); IMF_EXPORT bool bgf0 () const; IMF_EXPORT void setBgf0 (bool value); IMF_EXPORT bool bgf1 () const; IMF_EXPORT void setBgf1 (bool value); IMF_EXPORT bool bgf2 () const; IMF_EXPORT void setBgf2 (bool value); IMF_EXPORT int binaryGroup (int group) const; // group must be between 1 and 8 IMF_EXPORT void setBinaryGroup (int group, int value); //--------------------------------- // Access to packed representations //--------------------------------- IMF_EXPORT unsigned int timeAndFlags (Packing packing = TV60_PACKING) const; IMF_EXPORT void setTimeAndFlags (unsigned int value, Packing packing = TV60_PACKING); IMF_EXPORT unsigned int userData () const; IMF_EXPORT void setUserData (unsigned int value); //--------- // Equality //--------- IMF_EXPORT bool operator == (const TimeCode &v) const; IMF_EXPORT bool operator != (const TimeCode &v) const; private: unsigned int _time; unsigned int _user; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[ �a��& �& ImfEnvmap.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_ENVMAP_H #define INCLUDED_IMF_ENVMAP_H //----------------------------------------------------------------------------- // // Environment maps // // Environment maps define a mapping from 3D directions to 2D // pixel space locations. Environment maps are typically used // in 3D rendering, for effects such as quickly approximating // how shiny surfaces reflect their environment. // // Environment maps can be stored in scanline-based or in tiled // OpenEXR files. The fact that an image is an environment map // is indicated by the presence of an EnvmapAttribute whose name // is "envmap". (Convenience functions to access this attribute // are defined in header file ImfStandardAttributes.h.) // The attribute's value defines the mapping from 3D directions // to 2D pixel space locations. // // This header file defines the set of possible EnvmapAttribute // values. // // For each possible EnvmapAttribute value, this header file also // defines a set of convienience functions to convert between 3D // directions and 2D pixel locations. // // Most of the convenience functions defined below require a // dataWindow parameter. For scanline-based images, and for // tiled images with level mode ONE_LEVEL, the dataWindow // parameter should be set to the image's data window, as // defined in the image header. For tiled images with level // mode MIPMAP_LEVELS or RIPMAP_LEVELS, the data window of the // image level that is being accessed should be used instead. // (See the dataWindowForLevel() methods in ImfTiledInputFile.h // and ImfTiledOutputFile.h.) // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include <ImathBox.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER //-------------------------------- // Supported environment map types //-------------------------------- enum IMF_EXPORT_ENUM Envmap : int { ENVMAP_LATLONG = 0, // Latitude-longitude environment map ENVMAP_CUBE = 1, // Cube map NUM_ENVMAPTYPES // Number of different environment map types }; //------------------------------------------------------------------------- // Latitude-Longitude Map: // // The environment is projected onto the image using polar coordinates // (latitude and longitude). A pixel's x coordinate corresponds to // its longitude, and the y coordinate corresponds to its latitude. // Pixel (dataWindow.min.x, dataWindow.min.y) has latitude +pi/2 and // longitude +pi; pixel (dataWindow.max.x, dataWindow.max.y) has // latitude -pi/2 and longitude -pi. // // In 3D space, latitudes -pi/2 and +pi/2 correspond to the negative and // positive y direction. Latitude 0, longitude 0 points into positive // z direction; and latitude 0, longitude pi/2 points into positive x // direction. // // The size of the data window should be 2*N by N pixels (width by height), // where N can be any integer greater than 0. //------------------------------------------------------------------------- namespace LatLongMap { //---------------------------------------------------- // Convert a 3D direction to a 2D vector whose x and y // components represent the corresponding latitude // and longitude. //---------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::V2f latLong (const IMATH_NAMESPACE::V3f &direction); //-------------------------------------------------------- // Convert the position of a pixel to a 2D vector whose // x and y components represent the corresponding latitude // and longitude. //-------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::V2f latLong (const IMATH_NAMESPACE::Box2i &dataWindow, const IMATH_NAMESPACE::V2f &pixelPosition); //------------------------------------------------------------- // Convert a 2D vector, whose x and y components represent // longitude and latitude, into a corresponding pixel position. //------------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::V2f pixelPosition (const IMATH_NAMESPACE::Box2i &dataWindow, const IMATH_NAMESPACE::V2f &latLong); //----------------------------------------------------- // Convert a 3D direction vector into a corresponding // pixel position. pixelPosition(dw,dir) is equivalent // to pixelPosition(dw,latLong(dw,dir)). //----------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::V2f pixelPosition (const IMATH_NAMESPACE::Box2i &dataWindow, const IMATH_NAMESPACE::V3f &direction); //-------------------------------------------------------- // Convert the position of a pixel in a latitude-longitude // map into a corresponding 3D direction. //-------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::V3f direction (const IMATH_NAMESPACE::Box2i &dataWindow, const IMATH_NAMESPACE::V2f &pixelPosition); } //-------------------------------------------------------------- // Cube Map: // // The environment is projected onto the six faces of an // axis-aligned cube. The cube's faces are then arranged // in a 2D image as shown below. // // 2-----------3 // / /| // / / | Y // / / | | // 6-----------7 | | // | | | | // | | | | // | 0 | 1 *------- X // | | / / // | | / / // | |/ / // 4-----------5 Z // // dataWindow.min // / // / // +-----------+ // |3 Y 7| // | | | // | | | // | ---+---Z | +X face // | | | // | | | // |1 5| // +-----------+ // |6 Y 2| // | | | // | | | // | Z---+--- | -X face // | | | // | | | // |4 0| // +-----------+ // |6 Z 7| // | | | // | | | // | ---+---X | +Y face // | | | // | | | // |2 3| // +-----------+ // |0 1| // | | | // | | | // | ---+---X | -Y face // | | | // | | | // |4 Z 5| // +-----------+ // |7 Y 6| // | | | // | | | // | X---+--- | +Z face // | | | // | | | // |5 4| // +-----------+ // |2 Y 3| // | | | // | | | // | ---+---X | -Z face // | | | // | | | // |0 1| // +-----------+ // / // / // dataWindow.max // // The size of the data window should be N by 6*N pixels // (width by height), where N can be any integer greater // than 0. // //-------------------------------------------------------------- //------------------------------------ // Names for the six faces of the cube //------------------------------------ enum IMF_EXPORT_ENUM CubeMapFace { CUBEFACE_POS_X, // +X face CUBEFACE_NEG_X, // -X face CUBEFACE_POS_Y, // +Y face CUBEFACE_NEG_Y, // -Y face CUBEFACE_POS_Z, // +Z face CUBEFACE_NEG_Z // -Z face }; namespace CubeMap { //--------------------------------------------- // Width and height of a cube's face, in pixels //--------------------------------------------- IMF_EXPORT int sizeOfFace (const IMATH_NAMESPACE::Box2i &dataWindow); //------------------------------------------ // Compute the region in the environment map // that is covered by the specified face. //------------------------------------------ IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForFace (CubeMapFace face, const IMATH_NAMESPACE::Box2i &dataWindow); //---------------------------------------------------- // Convert the coordinates of a pixel within a face // [in the range from (0,0) to (s-1,s-1), where // s == sizeOfFace(dataWindow)] to pixel coordinates // in the environment map. //---------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::V2f pixelPosition (CubeMapFace face, const IMATH_NAMESPACE::Box2i &dataWindow, IMATH_NAMESPACE::V2f positionInFace); //-------------------------------------------------------------- // Convert a 3D direction into a cube face, and a pixel position // within that face. // // If you have a 3D direction, dir, the following code fragment // finds the position, pos, of the corresponding pixel in an // environment map with data window dw: // // CubeMapFace f; // V2f pif, pos; // // faceAndPixelPosition (dir, dw, f, pif); // pos = pixelPosition (f, dw, pif); // //-------------------------------------------------------------- IMF_EXPORT void faceAndPixelPosition (const IMATH_NAMESPACE::V3f &direction, const IMATH_NAMESPACE::Box2i &dataWindow, CubeMapFace &face, IMATH_NAMESPACE::V2f &positionInFace); // -------------------------------------------------------- // Given a cube face and a pixel position within that face, // compute the corresponding 3D direction. // -------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::V3f direction (CubeMapFace face, const IMATH_NAMESPACE::Box2i &dataWindow, const IMATH_NAMESPACE::V2f &positionInFace); } OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[� -�� � ImfOutputPart.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef IMFOUTPUTPART_H_ #define IMFOUTPUTPART_H_ #include "ImfForward.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER //--------------------------------------------------------------------- // class OutputPart: // // Same interface as OutputFile. Please refer to OutputFile. //--------------------------------------------------------------------- class IMF_EXPORT_TYPE OutputPart { public: IMF_EXPORT OutputPart(MultiPartOutputFile& multiPartFile, int partNumber); IMF_EXPORT const char * fileName () const; IMF_EXPORT const Header & header () const; IMF_EXPORT void setFrameBuffer (const FrameBuffer &frameBuffer); IMF_EXPORT const FrameBuffer & frameBuffer () const; IMF_EXPORT void writePixels (int numScanLines = 1); IMF_EXPORT int currentScanLine () const; IMF_EXPORT void copyPixels (InputFile &in); IMF_EXPORT void copyPixels (InputPart &in); IMF_EXPORT void updatePreviewImage (const PreviewRgba newPixels[]); IMF_EXPORT void breakScanLine (int y, int offset, int length, char c); private: OutputFile* file; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif /* IMFOUTPUTPART_H_ */ PK rM�[>��l l IexMathFloatExc.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IEXMATHFLOATEXC_H #define INCLUDED_IEXMATHFLOATEXC_H #include "IexExport.h" #include "IexNamespace.h" #include "IexMathIeeeExc.h" IEX_INTERNAL_NAMESPACE_HEADER_ENTER //------------------------------------------------------------- // Function mathExcOn() defines which floating point exceptions // will be trapped and converted to C++ exceptions. //------------------------------------------------------------- IEX_EXPORT void mathExcOn (int when = (IEEE_OVERFLOW | IEEE_DIVZERO | IEEE_INVALID)); //---------------------------------------------------------------------- // Function getMathExcOn() tells you for which floating point exceptions // trapping and conversion to C++ exceptions is currently enabled. //---------------------------------------------------------------------- IEX_EXPORT int getMathExcOn(); //------------------------------------------------------------------------ // A classs that temporarily sets floating point exception trapping // and conversion, and later restores the previous settings. // // Example: // // float // trickyComputation (float x) // { // MathExcOn meo (0); // temporarily disable floating // // point exception trapping // // float result = ...; // computation which may cause // // floating point exceptions // // return result; // destruction of meo restores // } // the program's previous floating // // point exception settings //------------------------------------------------------------------------ class IEX_EXPORT_TYPE MathExcOn { public: IEX_EXPORT MathExcOn (int when); IEX_EXPORT ~MathExcOn (); MathExcOn (const MathExcOn&) = delete; MathExcOn& operator= (const MathExcOn&) = delete; MathExcOn (MathExcOn&&) = delete; MathExcOn& operator= (MathExcOn&&) = delete; // It is possible for functions to set the exception registers // yet not trigger a SIGFPE. Specifically, the implementation // of pow(x, y) we're using can generates a NaN from a negative x // and fractional y but a SIGFPE is not generated. // This function examimes the exception registers and calls the // fpHandler if those registers modulo the exception mask are set. // It should be called wherever this class is commonly used where it has // been found that certain floating point exceptions are not being thrown. IEX_EXPORT void handleOutstandingExceptions(); private: bool _changed; int _saved; }; IEX_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[&�2^ ^ IlmThreadForward.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_ILMTHREADFORWARD_H #define INCLUDED_ILMTHREADFORWARD_H #include "IlmThreadConfig.h" #include "IlmThreadNamespace.h" #if ILMTHREAD_THREADING_ENABLED namespace std { class mutex; } #endif ILMTHREAD_INTERNAL_NAMESPACE_HEADER_ENTER class Thread; #if ILMTHREAD_THREADING_ENABLED using Mutex = std::mutex; #else class Mutex; #endif class Lock; class ThreadPool; class Task; class TaskGroup; class Semaphore; ILMTHREAD_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_ILMTHREADFORWARD_H PK rM�[�lT��B �B ImfTiledOutputFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_TILED_OUTPUT_FILE_H #define INCLUDED_IMF_TILED_OUTPUT_FILE_H //----------------------------------------------------------------------------- // // class TiledOutputFile // //----------------------------------------------------------------------------- #include "ImfForward.h" #include "ImfThreading.h" #include "ImfGenericOutputFile.h" #include "ImfTileDescription.h" #include <ImathBox.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER struct PreviewRgba; class IMF_EXPORT_TYPE TiledOutputFile : public GenericOutputFile { public: //------------------------------------------------------------------- // A constructor that opens the file with the specified name, and // writes the file header. The file header is also copied into the // TiledOutputFile object, and can later be accessed via the header() // method. // // Destroying TiledOutputFile constructed with this constructor // automatically closes the corresponding files. // // The header must contain a TileDescriptionAttribute called "tiles". // // The x and y subsampling factors for all image channels must be 1; // subsampling is not supported. // // Tiles can be written to the file in arbitrary order. The line // order attribute can be used to cause the tiles to be sorted in // the file. When the file is read later, reading the tiles in the // same order as they are in the file tends to be significantly // faster than reading the tiles in random order (see writeTile, // below). //------------------------------------------------------------------- IMF_EXPORT TiledOutputFile (const char fileName[], const Header &header, int numThreads = globalThreadCount ()); // ---------------------------------------------------------------- // A constructor that attaches the new TiledOutputFile object to // a file that has already been opened. Destroying TiledOutputFile // objects constructed with this constructor does not automatically // close the corresponding files. // ---------------------------------------------------------------- IMF_EXPORT TiledOutputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, const Header &header, int numThreads = globalThreadCount ()); //----------------------------------------------------- // Destructor // // Destroying a TiledOutputFile object before all tiles // have been written results in an incomplete file. //----------------------------------------------------- IMF_EXPORT virtual ~TiledOutputFile (); //------------------------ // Access to the file name //------------------------ IMF_EXPORT const char * fileName () const; //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; //------------------------------------------------------- // Set the current frame buffer -- copies the FrameBuffer // object into the TiledOutputFile object. // // The current frame buffer is the source of the pixel // data written to the file. The current frame buffer // must be set at least once before writeTile() is // called. The current frame buffer can be changed // after each call to writeTile(). //------------------------------------------------------- IMF_EXPORT void setFrameBuffer (const FrameBuffer &frameBuffer); //----------------------------------- // Access to the current frame buffer //----------------------------------- IMF_EXPORT const FrameBuffer & frameBuffer () const; //------------------- // Utility functions: //------------------- //--------------------------------------------------------- // Multiresolution mode and tile size: // The following functions return the xSize, ySize and mode // fields of the file header's TileDescriptionAttribute. //--------------------------------------------------------- IMF_EXPORT unsigned int tileXSize () const; IMF_EXPORT unsigned int tileYSize () const; IMF_EXPORT LevelMode levelMode () const; IMF_EXPORT LevelRoundingMode levelRoundingMode () const; //-------------------------------------------------------------------- // Number of levels: // // numXLevels() returns the file's number of levels in x direction. // // if levelMode() == ONE_LEVEL: // return value is: 1 // // if levelMode() == MIPMAP_LEVELS: // return value is: rfunc (log (max (w, h)) / log (2)) + 1 // // if levelMode() == RIPMAP_LEVELS: // return value is: rfunc (log (w) / log (2)) + 1 // // where // w is the width of the image's data window, max.x - min.x + 1, // y is the height of the image's data window, max.y - min.y + 1, // and rfunc(x) is either floor(x), or ceil(x), depending on // whether levelRoundingMode() returns ROUND_DOWN or ROUND_UP. // // numYLevels() returns the file's number of levels in y direction. // // if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS: // return value is the same as for numXLevels() // // if levelMode() == RIPMAP_LEVELS: // return value is: rfunc (log (h) / log (2)) + 1 // // // numLevels() is a convenience function for use with MIPMAP_LEVELS // files. // // if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS: // return value is the same as for numXLevels() // // if levelMode() == RIPMAP_LEVELS: // an IEX_NAMESPACE::LogicExc exception is thrown // // isValidLevel(lx, ly) returns true if the file contains // a level with level number (lx, ly), false if not. // //-------------------------------------------------------------------- IMF_EXPORT int numLevels () const; IMF_EXPORT int numXLevels () const; IMF_EXPORT int numYLevels () const; IMF_EXPORT bool isValidLevel (int lx, int ly) const; //--------------------------------------------------------- // Dimensions of a level: // // levelWidth(lx) returns the width of a level with level // number (lx, *), where * is any number. // // return value is: // max (1, rfunc (w / pow (2, lx))) // // // levelHeight(ly) returns the height of a level with level // number (*, ly), where * is any number. // // return value is: // max (1, rfunc (h / pow (2, ly))) // //--------------------------------------------------------- IMF_EXPORT int levelWidth (int lx) const; IMF_EXPORT int levelHeight (int ly) const; //---------------------------------------------------------- // Number of tiles: // // numXTiles(lx) returns the number of tiles in x direction // that cover a level with level number (lx, *), where * is // any number. // // return value is: // (levelWidth(lx) + tileXSize() - 1) / tileXSize() // // // numYTiles(ly) returns the number of tiles in y direction // that cover a level with level number (*, ly), where * is // any number. // // return value is: // (levelHeight(ly) + tileXSize() - 1) / tileXSize() // //---------------------------------------------------------- IMF_EXPORT int numXTiles (int lx = 0) const; IMF_EXPORT int numYTiles (int ly = 0) const; //--------------------------------------------------------- // Level pixel ranges: // // dataWindowForLevel(lx, ly) returns a 2-dimensional // region of valid pixel coordinates for a level with // level number (lx, ly) // // return value is a Box2i with min value: // (dataWindow.min.x, dataWindow.min.y) // // and max value: // (dataWindow.min.x + levelWidth(lx) - 1, // dataWindow.min.y + levelHeight(ly) - 1) // // dataWindowForLevel(level) is a convenience function used // for ONE_LEVEL and MIPMAP_LEVELS files. It returns // dataWindowForLevel(level, level). // //--------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int lx, int ly) const; //------------------------------------------------------------------- // Tile pixel ranges: // // dataWindowForTile(dx, dy, lx, ly) returns a 2-dimensional // region of valid pixel coordinates for a tile with tile coordinates // (dx,dy) and level number (lx, ly). // // return value is a Box2i with min value: // (dataWindow.min.x + dx * tileXSize(), // dataWindow.min.y + dy * tileYSize()) // // and max value: // (dataWindow.min.x + (dx + 1) * tileXSize() - 1, // dataWindow.min.y + (dy + 1) * tileYSize() - 1) // // dataWindowForTile(dx, dy, level) is a convenience function // used for ONE_LEVEL and MIPMAP_LEVELS files. It returns // dataWindowForTile(dx, dy, level, level). // //------------------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int lx, int ly) const; //------------------------------------------------------------------ // Write pixel data: // // writeTile(dx, dy, lx, ly) writes the tile with tile // coordinates (dx, dy), and level number (lx, ly) to // the file. // // dx must lie in the interval [0, numXTiles(lx) - 1] // dy must lie in the interval [0, numYTiles(ly) - 1] // // lx must lie in the interval [0, numXLevels() - 1] // ly must lie in the inverval [0, numYLevels() - 1] // // writeTile(dx, dy, level) is a convenience function // used for ONE_LEVEL and MIPMAP_LEVEL files. It calls // writeTile(dx, dy, level, level). // // The two writeTiles(dx1, dx2, dy1, dy2, ...) functions allow // writing multiple tiles at once. If multi-threading is used // multiple tiles are written concurrently. The tile coordinates, // dx1, dx2 and dy1, dy2, specify inclusive ranges of tile // coordinates. It is valid for dx1 < dx2 or dy1 < dy2; the // tiles are always written in the order specified by the line // order attribute. Hence, it is not possible to specify an // "invalid" or empty tile range. // // Pixels that are outside the pixel coordinate range for the tile's // level, are never accessed by writeTile(). // // Each tile in the file must be written exactly once. // // The file's line order attribute determines the order of the tiles // in the file: // // INCREASING_Y In the file, the tiles for each level are stored // in a contiguous block. The levels are ordered // like this: // // (0, 0) (1, 0) ... (nx-1, 0) // (0, 1) (1, 1) ... (nx-1, 1) // ... // (0,ny-1) (1,ny-1) ... (nx-1,ny-1) // // where nx = numXLevels(), and ny = numYLevels(). // In an individual level, (lx, ly), the tiles // are stored in the following order: // // (0, 0) (1, 0) ... (tx-1, 0) // (0, 1) (1, 1) ... (tx-1, 1) // ... // (0,ty-1) (1,ty-1) ... (tx-1,ty-1) // // where tx = numXTiles(lx), // and ty = numYTiles(ly). // // DECREASING_Y As for INCREASING_Y, the tiles for each level // are stored in a contiguous block. The levels // are ordered the same way as for INCREASING_Y, // but within an individual level, the tiles // are stored in this order: // // (0,ty-1) (1,ty-1) ... (tx-1,ty-1) // ... // (0, 1) (1, 1) ... (tx-1, 1) // (0, 0) (1, 0) ... (tx-1, 0) // // // RANDOM_Y The order of the calls to writeTile() determines // the order of the tiles in the file. // //------------------------------------------------------------------ IMF_EXPORT void writeTile (int dx, int dy, int l = 0); IMF_EXPORT void writeTile (int dx, int dy, int lx, int ly); IMF_EXPORT void writeTiles (int dx1, int dx2, int dy1, int dy2, int lx, int ly); IMF_EXPORT void writeTiles (int dx1, int dx2, int dy1, int dy2, int l = 0); //------------------------------------------------------------------ // Shortcut to copy all pixels from a TiledInputFile into this file, // without uncompressing and then recompressing the pixel data. // This file's header must be compatible with the TiledInputFile's // header: The two header's "dataWindow", "compression", // "lineOrder", "channels", and "tiles" attributes must be the same. //------------------------------------------------------------------ IMF_EXPORT void copyPixels (TiledInputFile &in); IMF_EXPORT void copyPixels (TiledInputPart &in); //------------------------------------------------------------------ // Shortcut to copy all pixels from an InputFile into this file, // without uncompressing and then recompressing the pixel data. // This file's header must be compatible with the InputFile's // header: The two header's "dataWindow", "compression", // "lineOrder", "channels", and "tiles" attributes must be the same. // // To use this function, the InputFile must be tiled. //------------------------------------------------------------------ IMF_EXPORT void copyPixels (InputFile &in); IMF_EXPORT void copyPixels (InputPart &in); //-------------------------------------------------------------- // Updating the preview image: // // updatePreviewImage() supplies a new set of pixels for the // preview image attribute in the file's header. If the header // does not contain a preview image, updatePreviewImage() throws // an IEX_NAMESPACE::LogicExc. // // Note: updatePreviewImage() is necessary because images are // often stored in a file incrementally, a few tiles at a time, // while the image is being generated. Since the preview image // is an attribute in the file's header, it gets stored in the // file as soon as the file is opened, but we may not know what // the preview image should look like until we have written the // last tile of the main image. // //-------------------------------------------------------------- IMF_EXPORT void updatePreviewImage (const PreviewRgba newPixels[]); //------------------------------------------------------------- // Break a tile -- for testing and debugging only: // // breakTile(dx,dy,lx,ly,p,n,c) introduces an error into the // output file by writing n copies of character c, starting // p bytes from the beginning of the tile with tile coordinates // (dx, dy) and level number (lx, ly). // // Warning: Calling this function usually results in a broken // image file. The file or parts of it may not be readable, // or the file may contain bad data. // //------------------------------------------------------------- IMF_EXPORT void breakTile (int dx, int dy, int lx, int ly, int offset, int length, char c); struct IMF_HIDDEN Data; private: // ---------------------------------------------------------------- // A constructor attaches the OutputStreamMutex to the // given one from MultiPartOutputFile. Set the previewPosition // and lineOffsetsPosition which have been acquired from // the constructor of MultiPartOutputFile as well. // ---------------------------------------------------------------- IMF_HIDDEN TiledOutputFile (const OutputPartData* part); TiledOutputFile (const TiledOutputFile &) = delete; TiledOutputFile & operator = (const TiledOutputFile &) = delete; TiledOutputFile (TiledOutputFile &&) = delete; TiledOutputFile & operator = (TiledOutputFile &&) = delete; IMF_HIDDEN void initialize (const Header &header); IMF_HIDDEN bool isValidTile (int dx, int dy, int lx, int ly) const; IMF_HIDDEN size_t bytesPerLineForTile (int dx, int dy, int lx, int ly) const; Data * _data; OutputStreamMutex* _streamData; bool _deleteStream; friend class MultiPartOutputFile; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[z^^�: : ImfLineOrder.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_LINE_ORDER_H #define INCLUDED_IMF_LINE_ORDER_H //----------------------------------------------------------------------------- // // enum LineOrder // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER enum IMF_EXPORT_ENUM LineOrder { INCREASING_Y = 0, // first scan line has lowest y coordinate DECREASING_Y = 1, // first scan line has highest y coordinate RANDOM_Y = 2, // only for tiled files; tiles are written // in random order NUM_LINEORDERS // number of different line orders }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[]�� � openexr_chunkio.hnu �[��� /* ** SPDX-License-Identifier: BSD-3-Clause ** Copyright Contributors to the OpenEXR Project. */ #ifndef OPENEXR_CORE_CHUNKIO_H #define OPENEXR_CORE_CHUNKIO_H #include "openexr_part.h" #include <stdint.h> #ifdef __cplusplus extern "C" { #endif /** * Structure describing raw data information about a chunk. * * A chunk is the generic term for a pixel data block in an EXR file, * as described in the OpenEXR File Layout documentation. This is * common between all different forms of data that can be stored. */ typedef struct { int32_t idx; /** for tiles, this is the tilex; for scans it is the x */ int32_t start_x; /** for tiles, this is the tiley; for scans it is the scanline y */ int32_t start_y; int32_t height; /**< for this chunk */ int32_t width; /**< for this chunk */ uint8_t level_x; /**< for tiled files */ uint8_t level_y; /**< for tiled files */ uint8_t type; uint8_t compression; uint64_t data_offset; uint64_t packed_size; uint64_t unpacked_size; uint64_t sample_count_data_offset; uint64_t sample_count_table_size; } exr_chunk_info_t; EXR_EXPORT exr_result_t exr_read_scanline_chunk_info ( exr_const_context_t ctxt, int part_index, int y, exr_chunk_info_t* cinfo); EXR_EXPORT exr_result_t exr_read_tile_chunk_info ( exr_const_context_t ctxt, int part_index, int tilex, int tiley, int levelx, int levely, exr_chunk_info_t* cinfo); /** Read the packed data block for a chunk * * This assumes that the buffer pointed to by @p packed_data is * large enough to hold the chunk block info packed_size bytes */ EXR_EXPORT exr_result_t exr_read_chunk ( exr_const_context_t ctxt, int part_index, const exr_chunk_info_t* cinfo, void* packed_data); /** * Read chunk for deep data. * * This allows one to read the packed data, the sample count data, or both. * \ref exr_read_chunk also works to read deep data packed data, * but this is a routine to get the sample count table and the packed * data in one go, or if you want to pre-read the sample count data, * you can get just that buffer. */ EXR_EXPORT exr_result_t exr_read_deep_chunk ( exr_const_context_t ctxt, int part_index, const exr_chunk_info_t* cinfo, void* packed_data, void* sample_data); /**************************************/ /** Initialize a \ref exr_chunk_info_t structure when encoding scanline * data (similar to read but does not do anything with a chunk * table) */ EXR_EXPORT exr_result_t exr_write_scanline_chunk_info ( exr_context_t ctxt, int part_index, int y, exr_chunk_info_t* cinfo); /** Initialize a \ref chunk_info_t structure when encoding tiled data * (similar to read but does not do anything with a chunk table) */ EXR_EXPORT exr_result_t exr_write_tile_chunk_info ( exr_context_t ctxt, int part_index, int tilex, int tiley, int levelx, int levely, exr_chunk_info_t* cinfo); /** * @p y must the appropriate starting y for the specified chunk */ EXR_EXPORT exr_result_t exr_write_scanline_chunk ( exr_context_t ctxt, int part_index, int y, const void* packed_data, uint64_t packed_size); /** * @p y must the appropriate starting y for the specified chunk */ EXR_EXPORT exr_result_t exr_write_deep_scanline_chunk ( exr_context_t ctxt, int part_index, int y, const void* packed_data, uint64_t packed_size, uint64_t unpacked_size, const void* sample_data, uint64_t sample_data_size); EXR_EXPORT exr_result_t exr_write_tile_chunk ( exr_context_t ctxt, int part_index, int tilex, int tiley, int levelx, int levely, const void* packed_data, uint64_t packed_size); EXR_EXPORT exr_result_t exr_write_deep_tile_chunk ( exr_context_t ctxt, int part_index, int tilex, int tiley, int levelx, int levely, const void* packed_data, uint64_t packed_size, uint64_t unpacked_size, const void* sample_data, uint64_t sample_data_size); #ifdef __cplusplus } /* extern "C" */ #endif #endif /* OPENEXR_CORE_CHUNKIO_H */ PK rM�[��L�< < ImfTimeCodeAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_TIME_CODE_ATTRIBUTE_H #define INCLUDED_IMF_TIME_CODE_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class TimeCodeAttribute // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" #include "ImfTimeCode.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::TimeCode> TimeCodeAttribute; #ifndef COMPILING_IMF_TIMECODE_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::TimeCode>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[��z�m m ImfTileDescriptionAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_TILE_DESCRIPTION_ATTRIBUTE_H #define INCLUDED_IMF_TILE_DESCRIPTION_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class TileDescriptionAttribute // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" #include "ImfTileDescription.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::TileDescription> TileDescriptionAttribute; #ifndef COMPILING_IMF_STRING_VECTOR_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::TileDescription>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�j��� � ImfHuf.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_HUF_H #define INCLUDED_IMF_HUF_H #include "ImfExport.h" #include "ImfNamespace.h" //----------------------------------------------------------------------------- // // 16-bit Huffman compression and decompression: // // hufCompress (r, nr, c) // // Compresses the contents of array r (of length nr), // stores the compressed data in array c, and returns // the size of the compressed data (in bytes). // // To avoid buffer overflows, the size of array c should // be at least 2 * nr + 65536. // // hufUncompress (c, nc, r, nr) // // Uncompresses the data in array c (with length nc), // and stores the results in array r (with length nr). // //----------------------------------------------------------------------------- OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER IMF_EXPORT int hufCompress (const unsigned short raw[/*nRaw*/], int nRaw, char compressed[/*2 * nRaw + 65536*/]); IMF_EXPORT void hufUncompress (const char compressed[/*nCompressed*/], int nCompressed, unsigned short raw[/*nRaw*/], int nRaw); OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�r�S S ImfChannelListAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_CHANNEL_LIST_ATTRIBUTE_H #define INCLUDED_IMF_CHANNEL_LIST_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class ChannelListAttribute // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" #include "ImfChannelList.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::ChannelList> ChannelListAttribute; #ifndef COMPILING_IMF_CHANNEL_LIST_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::ChannelList>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[���K� � ImfDeepScanLineOutputPart.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef IMFDEEPSCANLINEOUTPUTPART_H_ #define IMFDEEPSCANLINEOUTPUTPART_H_ #include "ImfDeepScanLineOutputFile.h" #include "ImfMultiPartOutputFile.h" #include "ImfNamespace.h" #include "ImfExport.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class DeepScanLineOutputPart { public: IMF_EXPORT DeepScanLineOutputPart(MultiPartOutputFile& multiPartFile, int partNumber); //------------------------ // Access to the file name //------------------------ IMF_EXPORT const char * fileName () const; //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; //------------------------------------------------------- // Set the current frame buffer -- copies the FrameBuffer // object into the OutputFile object. // // The current frame buffer is the source of the pixel // data written to the file. The current frame buffer // must be set at least once before writePixels() is // called. The current frame buffer can be changed // after each call to writePixels. //------------------------------------------------------- IMF_EXPORT void setFrameBuffer (const DeepFrameBuffer &frameBuffer); //----------------------------------- // Access to the current frame buffer //----------------------------------- IMF_EXPORT const DeepFrameBuffer & frameBuffer () const; //------------------------------------------------------------------- // Write pixel data: // // writePixels(n) retrieves the next n scan lines worth of data from // the current frame buffer, starting with the scan line indicated by // currentScanLine(), and stores the data in the output file, and // progressing in the direction indicated by header.lineOrder(). // // To produce a complete and correct file, exactly m scan lines must // be written, where m is equal to // header().dataWindow().max.y - header().dataWindow().min.y + 1. //------------------------------------------------------------------- IMF_EXPORT void writePixels (int numScanLines = 1); //------------------------------------------------------------------ // Access to the current scan line: // // currentScanLine() returns the y coordinate of the first scan line // that will be read from the current frame buffer during the next // call to writePixels(). // // If header.lineOrder() == INCREASING_Y: // // The current scan line before the first call to writePixels() // is header().dataWindow().min.y. After writing each scan line, // the current scan line is incremented by 1. // // If header.lineOrder() == DECREASING_Y: // // The current scan line before the first call to writePixels() // is header().dataWindow().max.y. After writing each scan line, // the current scan line is decremented by 1. // //------------------------------------------------------------------ IMF_EXPORT int currentScanLine () const; //-------------------------------------------------------------- // Shortcut to copy all pixels from an InputFile into this file, // without uncompressing and then recompressing the pixel data. // This file's header must be compatible with the InputFile's // header: The two header's "dataWindow", "compression", // "lineOrder" and "channels" attributes must be the same. //-------------------------------------------------------------- IMF_EXPORT void copyPixels (DeepScanLineInputFile &in); IMF_EXPORT void copyPixels (DeepScanLineInputPart &in); //-------------------------------------------------------------- // Updating the preview image: // // updatePreviewImage() supplies a new set of pixels for the // preview image attribute in the file's header. If the header // does not contain a preview image, updatePreviewImage() throws // an IEX_NAMESPACE::LogicExc. // // Note: updatePreviewImage() is necessary because images are // often stored in a file incrementally, a few scan lines at a // time, while the image is being generated. Since the preview // image is an attribute in the file's header, it gets stored in // the file as soon as the file is opened, but we may not know // what the preview image should look like until we have written // the last scan line of the main image. // //-------------------------------------------------------------- IMF_EXPORT void updatePreviewImage (const PreviewRgba newPixels[]); private: DeepScanLineOutputFile* file; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif /* IMFDEEPSCANLINEOUTPUTPART_H_ */ PK rM�[VGJd ImfRationalAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_RATIONAL_ATTRIBUTE_H #define INCLUDED_IMF_RATIONAL_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class RationalAttribute // //----------------------------------------------------------------------------- #include "ImfAttribute.h" #include "ImfRational.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Rational> RationalAttribute; #ifndef COMPILING_IMF_RATIONAL_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Rational>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[p$�tR R ImfVecAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_VEC_ATTRIBUTE_H #define INCLUDED_IMF_VEC_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class V2iAttribute // class V2fAttribute // class V2dAttribute // class V3iAttribute // class V3fAttribute // class V3dAttribute // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" #include <ImathVec.h> #if defined(_MSC_VER) // suppress warning about non-exported base classes #pragma warning (push) #pragma warning (disable : 4251) #pragma warning (disable : 4275) #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<IMATH_NAMESPACE::V2i> V2iAttribute; typedef TypedAttribute<IMATH_NAMESPACE::V2f> V2fAttribute; typedef TypedAttribute<IMATH_NAMESPACE::V2d> V2dAttribute; typedef TypedAttribute<IMATH_NAMESPACE::V3i> V3iAttribute; typedef TypedAttribute<IMATH_NAMESPACE::V3f> V3fAttribute; typedef TypedAttribute<IMATH_NAMESPACE::V3d> V3dAttribute; #ifndef COMPILING_IMF_VECTOR_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<IMATH_NAMESPACE::V2i>; extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<IMATH_NAMESPACE::V2f>; extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<IMATH_NAMESPACE::V2d>; extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<IMATH_NAMESPACE::V3i>; extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<IMATH_NAMESPACE::V3f>; extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<IMATH_NAMESPACE::V3d>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #if defined(_MSC_VER) // suppress warning about non-exported base classes #pragma warning (pop) #endif #endif PK rM�[�emDs s openexr_std_attr.hnu �[��� /* ** SPDX-License-Identifier: BSD-3-Clause ** Copyright Contributors to the OpenEXR Project. */ #ifndef OPENEXR_CORE_STD_ATTR_H #define OPENEXR_CORE_STD_ATTR_H #include "openexr_attr.h" #ifdef __cplusplus extern "C" { #endif /** * @defgroup Standard attributes * @brief These are a group of attributes which are not strictly required, * but have common definitions and should be preferred for representing * the information they describe. * @{ */ /* chromaticities whiteLuminance adoptedNeutral renderingTransform lookModTransform xDensity owner comments capDate utcOffset longitude latitude altitude focus expTime aperture isoSpeed envmap keyCode timeCode wrapmodes framesPerSecond multiView worldToCamera worldToNDC deepImageState originalDataWindow dwaCompressionLevel */ /** @} */ #ifdef __cplusplus } /* extern "C" */ #endif #endif /* OPENEXR_CORE_STD_ATTR_H */ PK rM�[Q�vx� � ImfDeepImage.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_DEEP_IMAGE_H #define INCLUDED_IMF_DEEP_IMAGE_H //---------------------------------------------------------------------------- // // class DeepImage // // For an explanation of images, levels and channels, // see the comments in header file Image.h. // //---------------------------------------------------------------------------- #include "ImfDeepImageLevel.h" #include "ImfImage.h" #include "ImfUtilExport.h" #include "ImfTileDescription.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMFUTIL_EXPORT_TYPE DeepImage : public Image { public: // // Constructors and destructor. // The default constructor constructs an image with an empty data // window level mode ONE_LEVEL and level rounding mode ROUND_DOWN. // IMFUTIL_EXPORT DeepImage(); IMFUTIL_EXPORT DeepImage(const IMATH_NAMESPACE::Box2i &dataWindow, LevelMode levelMode = ONE_LEVEL, LevelRoundingMode levelRoundingMode = ROUND_DOWN); IMFUTIL_EXPORT virtual ~DeepImage(); // // Accessing image levels by level number // IMFUTIL_EXPORT virtual DeepImageLevel & level(int l = 0); IMFUTIL_EXPORT virtual const DeepImageLevel & level(int l = 0) const; IMFUTIL_EXPORT virtual DeepImageLevel & level(int lx, int ly); IMFUTIL_EXPORT virtual const DeepImageLevel & level(int lx, int ly) const; protected: IMFUTIL_EXPORT virtual DeepImageLevel * newLevel (int lx, int ly, const IMATH_NAMESPACE::Box2i &dataWindow); }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�5+� � openexr_base.hnu �[��� /* ** SPDX-License-Identifier: BSD-3-Clause ** Copyright Contributors to the OpenEXR Project. */ #ifndef OPENEXR_BASE_H #define OPENEXR_BASE_H #include "openexr_conf.h" #include <stddef.h> #ifdef __cplusplus extern "C" { #endif /** @brief Retrieve the current library version. The @p extra string is for * custom installs, and is a static string, do not free the returned pointer */ EXR_EXPORT void exr_get_library_version (int* maj, int* min, int* patch, const char** extra); /** * @defgroup SafetyChecks Controls for internal safety checks * @{ */ /** @brief Limit the size of image allowed to be parsed or created by * the library * * This is used as a safety check against corrupt files, but can also * serve to avoid potential issues on machines which have very * constrained RAM * * These values are among the only globals in the core layer of * OpenEXR. The intended use is for applications to define a global * default, which will be combined with the values provided to the * individual context creation routine. The values are used to check * against parsed header values. This adds some level of safety from * memory overruns where a corrupt file given to the system may cause * a large allocation to happen, enabling buffer overruns or other * potential security issue. * * These global values are combined with the values in * \ref exr_context_initializer_t using the following rules: * * 1. negative values are ignored. * * 2. if either value has a positive (non-zero) value, and the other * has 0, the positive value is preferred. * * 3. If both are positive (non-zero), the minimum value is used. * * 4. If both values are 0, this disables the constrained size checks. * * This function does not fail. */ EXR_EXPORT void exr_set_default_maximum_image_size (int w, int h); /** @brief Retrieve the global default maximum image size * * This function does not fail. */ EXR_EXPORT void exr_get_default_maximum_image_size (int* w, int* h); /** @brief Limit the size of an image tile allowed to be parsed or * created by the library * * Similar to image size, this places constraints on the maximum tile * size as a safety check against bad file data * * This is used as a safety check against corrupt files, but can also * serve to avoid potential issues on machines which have very * constrained RAM * * These values are among the only globals in the core layer of * OpenEXR. The intended use is for applications to define a global * default, which will be combined with the values provided to the * individual context creation routine. The values are used to check * against parsed header values. This adds some level of safety from * memory overruns where a corrupt file given to the system may cause * a large allocation to happen, enabling buffer overruns or other * potential security issue. * * These global values are combined with the values in * \ref exr_context_initializer_t using the following rules: * * 1. negative values are ignored. * * 2. if either value has a positive (non-zero) value, and the other * has 0, the positive value is preferred. * * 3. If both are positive (non-zero), the minimum value is used. * * 4. If both values are 0, this disables the constrained size checks. * * This function does not fail. */ EXR_EXPORT void exr_set_default_maximum_tile_size (int w, int h); /** @brief Retrieve the global maximum tile size. * * This function does not fail. */ EXR_EXPORT void exr_get_default_maximum_tile_size (int* w, int* h); /** @brief function pointer used to hold a malloc-like routine * * Providing these to a context will override what memory is used to * allocate the context itself, as well as any allocations which * happen during processing of a file or stream. This can be used by * systems which provide rich malloc tracking routines to override the * internal allocations performed by the library. * * This function is expected to allocate and return a new memory * handle, or NULL if allocation failed (which the library will then * handle and return an out-of-memory error). * * If one is provided, both should be provided. * @sa exr_memory_free_func_t */ typedef void* (*exr_memory_allocation_func_t) (size_t bytes); /** @brief function pointer used to hold a free-like routine * * Providing these to a context will override what memory is used to * allocate the context itself, as well as any allocations which * happen during processing of a file or stream. This can be used by * systems which provide rich malloc tracking routines to override the * internal allocations performed by the library. * * This function is expected to return memory to the system, ala free * from the C library. * * If providing one, probably need to provide both routines. * @sa exr_memory_allocation_func_t */ typedef void (*exr_memory_free_func_t) (void* ptr); /** @brief Allows the user to override default allocator used internal allocations necessary for * files, attributes, and other temporary memory. * * These routines may be overridden when creating a specific context, * however this provides global defaults such that the default can be * applied. * * If either pointer is 0, the appropriate malloc/free routine will be substituted. * * This function does not fail. */ EXR_EXPORT void exr_set_default_memory_routines ( exr_memory_allocation_func_t alloc_func, exr_memory_free_func_t free_func); /** @} */ #ifdef __cplusplus } /* extern "C" */ #endif #endif /* OPENEXR_BASE_H */ PK rM�[��� � ImfName.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_NAME_H #define INCLUDED_IMF_NAME_H //----------------------------------------------------------------------------- // // class ImfName -- a zero-terminated string // with a fixed, small maximum length // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include <cstring> #if defined(_MSC_VER) #pragma warning( push, 0 ) #pragma warning (disable : 4996) #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE Name { public: //------------- // Constructors //------------- Name (); Name (const char text[]); Name (const Name &) = default; Name (Name &&) = default; ~Name () = default; //-------------------- // Assignment operator //-------------------- Name &operator = (const Name &) = default; Name &operator = (Name &&) = default; Name &operator = (const char text[]); //--------------------- // Access to the string //--------------------- inline const char * text () const {return _text;} inline const char * operator * () const {return _text;} //--------------- // Maximum length //--------------- static const int SIZE = 256; static const int MAX_LENGTH = SIZE - 1; private: char _text[SIZE]; }; //----------------- // Inline functions //----------------- inline Name & Name::operator = (const char text[]) { strncpy (_text, text, MAX_LENGTH); return *this; } inline Name::Name () { _text[0] = 0; } inline Name::Name (const char text[]) { *this = text; _text [MAX_LENGTH] = 0; } inline bool operator == (const Name &x, const Name &y) { return strcmp (*x, *y) == 0; } inline bool operator == (const Name &x, const char text[]) { return strcmp (*x, text) == 0; } inline bool operator == (const char text[], const Name &y) { return strcmp (text, *y) == 0; } inline bool operator != (const Name &x, const Name &y) { return !(x == y); } inline bool operator != (const Name &x, const char text[]) { return !(x == text); } inline bool operator != (const char text[], const Name &y) { return !(text == y); } inline bool operator < (const Name &x, const Name &y) { return strcmp (*x, *y) < 0; } inline bool operator < (const Name &x, const char text[]) { return strcmp (*x, text) < 0; } inline bool operator < (const char text[], const Name &y) { return strcmp (text, *y) < 0; } OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #if defined(_MSC_VER) #pragma warning (pop) #endif #endif PK rM�[�t�'( '( ImfFrameBuffer.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_FRAME_BUFFER_H #define INCLUDED_IMF_FRAME_BUFFER_H //----------------------------------------------------------------------------- // // class Slice // class FrameBuffer // //----------------------------------------------------------------------------- #include "ImfForward.h" #include "ImfName.h" #include "ImfPixelType.h" #include <ImathBox.h> #include <map> #include <string> #include <cstdint> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER //------------------------------------------------------- // Description of a single slice of the frame buffer: // // Note -- terminology: as part of a file, a component of // an image (e.g. red, green, blue, depth etc.) is called // a "channel". As part of a frame buffer, an image // component is called a "slice". //------------------------------------------------------- struct IMF_EXPORT_TYPE Slice { //------------------------------ // Data type; see ImfPixelType.h //------------------------------ PixelType type; //--------------------------------------------------------------------- // Memory layout: The address of pixel (x, y) is // // base + (xp / xSampling) * xStride + (yp / ySampling) * yStride // // where xp and yp are computed as follows: // // * If we are reading or writing a scanline-based file: // // xp = x // yp = y // // * If we are reading a tile whose upper left coorner is at (xt, yt): // // if xTileCoords is true then xp = x - xt, else xp = x // if yTileCoords is true then yp = y - yt, else yp = y // //--------------------------------------------------------------------- char * base; size_t xStride; size_t yStride; //-------------------------------------------- // Subsampling: pixel (x, y) is present in the // slice only if // // x % xSampling == 0 && y % ySampling == 0 // //-------------------------------------------- int xSampling; int ySampling; //---------------------------------------------------------- // Default value, used to fill the slice when a file without // a channel that corresponds to this slice is read. //---------------------------------------------------------- double fillValue; //------------------------------------------------------- // For tiled files, the xTileCoords and yTileCoords flags // determine whether pixel addressing is performed using // absolute coordinates or coordinates relative to a // tile's upper left corner. (See the comment on base, // xStride and yStride, above.) // // For scanline-based files these flags have no effect; // pixel addressing is always done using absolute // coordinates. //------------------------------------------------------- bool xTileCoords; bool yTileCoords; //------------ // Constructor //------------ IMF_EXPORT Slice (PixelType type = HALF, char * base = 0, size_t xStride = 0, size_t yStride = 0, int xSampling = 1, int ySampling = 1, double fillValue = 0.0, bool xTileCoords = false, bool yTileCoords = false); // Does the heavy lifting of computing the base pointer for a slice, // avoiding overflow issues with large origin offsets // // if xStride == 0, assumes sizeof(pixeltype) // if yStride == 0, assumes xStride * ( w / xSampling ) IMF_EXPORT static Slice Make(PixelType type, const void *ptr, const IMATH_NAMESPACE::V2i &origin, int64_t w, int64_t h, size_t xStride = 0, size_t yStride = 0, int xSampling = 1, int ySampling = 1, double fillValue = 0.0, bool xTileCoords = false, bool yTileCoords = false); // same as above, just computes w and h for you // from a data window IMF_EXPORT static Slice Make(PixelType type, const void *ptr, const IMATH_NAMESPACE::Box2i &dataWindow, size_t xStride = 0, size_t yStride = 0, int xSampling = 1, int ySampling = 1, double fillValue = 0.0, bool xTileCoords = false, bool yTileCoords = false); }; class IMF_EXPORT_TYPE FrameBuffer { public: //------------ // Add a slice //------------ IMF_EXPORT void insert (const char name[], const Slice &slice); IMF_EXPORT void insert (const std::string &name, const Slice &slice); //---------------------------------------------------------------- // Access to existing slices: // // [n] Returns a reference to the slice with name n. // If no slice with name n exists, an IEX_NAMESPACE::ArgExc // is thrown. // // findSlice(n) Returns a pointer to the slice with name n, // or 0 if no slice with name n exists. // //---------------------------------------------------------------- IMF_EXPORT Slice & operator [] (const char name[]); IMF_EXPORT const Slice & operator [] (const char name[]) const; IMF_EXPORT Slice & operator [] (const std::string &name); IMF_EXPORT const Slice & operator [] (const std::string &name) const; IMF_EXPORT Slice * findSlice (const char name[]); IMF_EXPORT const Slice * findSlice (const char name[]) const; IMF_EXPORT Slice * findSlice (const std::string &name); IMF_EXPORT const Slice * findSlice (const std::string &name) const; //----------------------------------------- // Iterator-style access to existing slices //----------------------------------------- typedef std::map <Name, Slice> SliceMap; class Iterator; class ConstIterator; IMF_EXPORT Iterator begin (); IMF_EXPORT ConstIterator begin () const; IMF_EXPORT Iterator end (); IMF_EXPORT ConstIterator end () const; IMF_EXPORT Iterator find (const char name[]); IMF_EXPORT ConstIterator find (const char name[]) const; IMF_EXPORT Iterator find (const std::string &name); IMF_EXPORT ConstIterator find (const std::string &name) const; private: SliceMap _map; }; //---------- // Iterators //---------- class IMF_EXPORT_TYPE FrameBuffer::Iterator { public: IMF_EXPORT Iterator (); IMF_EXPORT Iterator (const FrameBuffer::SliceMap::iterator &i); IMF_EXPORT Iterator & operator ++ (); IMF_EXPORT Iterator operator ++ (int); IMF_EXPORT const char * name () const; IMF_EXPORT Slice & slice () const; private: friend class FrameBuffer::ConstIterator; FrameBuffer::SliceMap::iterator _i; }; class IMF_EXPORT_TYPE FrameBuffer::ConstIterator { public: IMF_EXPORT ConstIterator (); IMF_EXPORT ConstIterator (const FrameBuffer::SliceMap::const_iterator &i); IMF_EXPORT ConstIterator (const FrameBuffer::Iterator &other); IMF_EXPORT ConstIterator & operator ++ (); IMF_EXPORT ConstIterator operator ++ (int); IMF_EXPORT const char * name () const; IMF_EXPORT const Slice & slice () const; private: friend bool operator == (const ConstIterator &, const ConstIterator &); friend bool operator != (const ConstIterator &, const ConstIterator &); FrameBuffer::SliceMap::const_iterator _i; }; //----------------- // Inline Functions //----------------- inline FrameBuffer::Iterator::Iterator (): _i() { // empty } inline FrameBuffer::Iterator::Iterator (const FrameBuffer::SliceMap::iterator &i): _i (i) { // empty } inline FrameBuffer::Iterator & FrameBuffer::Iterator::operator ++ () { ++_i; return *this; } inline FrameBuffer::Iterator FrameBuffer::Iterator::operator ++ (int) { Iterator tmp = *this; ++_i; return tmp; } inline const char * FrameBuffer::Iterator::name () const { return *_i->first; } inline Slice & FrameBuffer::Iterator::slice () const { return _i->second; } inline FrameBuffer::ConstIterator::ConstIterator (): _i() { // empty } inline FrameBuffer::ConstIterator::ConstIterator (const FrameBuffer::SliceMap::const_iterator &i): _i (i) { // empty } inline FrameBuffer::ConstIterator::ConstIterator (const FrameBuffer::Iterator &other): _i (other._i) { // empty } inline FrameBuffer::ConstIterator & FrameBuffer::ConstIterator::operator ++ () { ++_i; return *this; } inline FrameBuffer::ConstIterator FrameBuffer::ConstIterator::operator ++ (int) { ConstIterator tmp = *this; ++_i; return tmp; } inline const char * FrameBuffer::ConstIterator::name () const { return *_i->first; } inline const Slice & FrameBuffer::ConstIterator::slice () const { return _i->second; } inline bool operator == (const FrameBuffer::ConstIterator &x, const FrameBuffer::ConstIterator &y) { return x._i == y._i; } inline bool operator != (const FrameBuffer::ConstIterator &x, const FrameBuffer::ConstIterator &y) { return !(x == y); } OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�W� - - openexr_decode.hnu �[��� /* ** SPDX-License-Identifier: BSD-3-Clause ** Copyright Contributors to the OpenEXR Project. */ #ifndef OPENEXR_CORE_DECODE_H #define OPENEXR_CORE_DECODE_H #include "openexr_chunkio.h" #include "openexr_coding.h" #ifdef __cplusplus extern "C" { #endif /** Can be bit-wise or'ed into the decode_flags in the decode pipeline. * * Indicates that the sample count table should be decoded to a an * individual sample count list (n, m, o, ...), with an extra int at * the end containing the total samples. * * Without this (i.e. a value of 0 in that bit), indicates the sample * count table should be decoded to a cumulative list (n, n+m, n+m+o, * ...), which is the on-disk representation */ #define EXR_DECODE_SAMPLE_COUNTS_AS_INDIVIDUAL ((uint16_t) (1 << 0)) /** Can be bit-wise or'ed into the decode_flags in the decode pipeline. * * Indicates that the data in the channel pointers to decode to is not * a direct pointer, but instead is a pointer-to-pointers. In this * mode, the user_pixel_stride and user_line_stride are used to * advance the pointer offsets for each pixel in the output, but the * user_bytes_per_element and user_data_type are used to put * (successive) entries into each destination pointer (if not null). * * So each channel pointer must then point to an array of * chunk.width * chunk.height pointers. * * With this, you can only extract desired pixels (although all the * pixels must be initially decompressed) to handle such operations * like proxying where you might want to read every other pixel. * * If this is NOT set (0), the default unpacking routine assumes the * data will be planar and contiguous (each channel is a separate * memory block), ignoring user_line_stride and user_pixel_stride */ #define EXR_DECODE_NON_IMAGE_DATA_AS_POINTERS ((uint16_t) (1 << 1)) /** When reading non-image data (i.e. deep), only read the sample table */ #define EXR_DECODE_SAMPLE_DATA_ONLY ((uint16_t) (1 << 2)) /** * Structure meant to be used on a per-thread basis for reading exr data * * As should be obvious, this structure is NOT thread safe, but rather * meant to be used by separate threads, which can all be accessing * the same context concurrently. */ typedef struct _exr_decode_pipeline { /** the output channel information for this chunk * * User is expected to fill the channel pointers for the desired * output channels (any that are NULL will be skipped) if you are * going to use \ref exr_choose_unpack_routine. If all that is * desired is to read and decompress the data, this can be left * uninitialized. * * Describes the channel information. This information is * allocated dynamically during \ref exr_initialize_decoding */ exr_coding_channel_info_t* channels; int16_t channel_count; /** Decode flags to control the behavior*/ uint16_t decode_flags; /** copy of the parameters given to the initialize / update for convenience */ int part_index; exr_const_context_t context; exr_chunk_info_t chunk; /** * can be used by the user to pass custom context data through * the decode pipeline */ void* decoding_user_data; /** the (compressed) buffer. * * If null, will be allocated during the run of the pipeline. * * If the caller wishes to take control of the buffer, simple * adopt the pointer and set it to null here. Be cognizant of any * custom allocators. */ void* packed_buffer; /** used when re-using the same decode pipeline struct to know if * chunk is changed size whether current buffer is large enough */ size_t packed_alloc_size; /** the decompressed buffer (unpacked_size from the chunk block * info), but still packed into storage order, only needed for * compressed files * * If null, will be allocated during the run of the pipeline when * needed. * * If the caller wishes to take control of the buffer, simple * adopt the pointer and set it to null here. Be cognizant of any * custom allocators. */ void* unpacked_buffer; /** used when re-using the same decode pipeline struct to know if * chunk is changed size whether current buffer is large enough */ size_t unpacked_alloc_size; /** for deep or other non-image data */ /** packed sample table (i.e. compressed, raw on disk representation)*/ void* packed_sample_count_table; size_t packed_sample_count_alloc_size; /** usable, native sample count table. Depending on the flag set * above, will be decoded to either a cumulative list (n, n+m, * n+m+o, ...), or an individual table (n, m, o, ...). As an * optimization, if the latter individual count table is chosen, * an extra int32_t will be allocated at the end of the table to * contain the total count of samples, so the table will be n+1 * samples in size */ int32_t* sample_count_table; size_t sample_count_alloc_size; /** a scratch buffer of unpacked_size for intermediate results * * If null, will be allocated during the run of the pipeline when * needed. * * If the caller wishes to take control of the buffer, simple * adopt the pointer and set it to null here. Be cognizant of any * custom allocators. */ void* scratch_buffer_1; /** used when re-using the same decode pipeline struct to know if * chunk is changed size whether current buffer is large enough */ size_t scratch_alloc_size_1; /** some decompression routines may need a second scratch buffer (i.e. zlib) * * If null, will be allocated during the run of the pipeline when * needed. * * If the caller wishes to take control of the buffer, simple * adopt the pointer and set it to null here. Be cognizant of any * custom allocators. */ void* scratch_buffer_2; /** used when re-using the same decode pipeline struct to know if * chunk is changed size whether current buffer is large enough */ size_t scratch_alloc_size_2; /** * enables a custom allocator for the different buffers (i.e. if * decoding on a GPU). If NULL, will use the allocator from the * context */ void* (*alloc_fn) (enum transcoding_pipeline_buffer_id, size_t); /** * enables a custom allocator for the different buffers (i.e. if * decoding on a GPU). If NULL, will use the allocator from the * context */ void (*free_fn) (enum transcoding_pipeline_buffer_id, void*); /** * Function chosen to read chunk data from the context. * * Initialized to a default generic read routine, may be updated * based on channel information when \ref * exr_choose_default_routines is called. This is done such that * if the file is uncompressed and the output channel data is * planar and the same type, the read function can read straight * into the output channels, getting closer to a zero-copy * operation. Otherwise a more traditional read, decompress, then * unpack pipeline will be used with a default reader. * * This is allowed to be overridden, but probably is not necessary * in most scenarios */ exr_result_t (*read_fn) (struct _exr_decode_pipeline* pipeline); /** * Function chosen based on the compression type of the part to * decompress data. * * If the user has a custom decompression method for the * compression on this part, this can be changed after * initialization. * * If only compressed data is desired, then assign this to NULL * after initialization. */ exr_result_t (*decompress_fn) (struct _exr_decode_pipeline* pipeline); /** * Function which can be provided if you have bespoke handling for * non-image data and need to re-allocate the data to handle the * about-to-be unpacked data. * * If left NULL, will assume the memory pointed to by the channel * pointers is sufficient */ exr_result_t (*realloc_nonimage_data_fn) ( struct _exr_decode_pipeline* pipeline); /** * Function chosen based on the output layout of the channels of the part to * decompress data. * * This will be NULL after initialization, until the user * specifies a custom routine, or initializes the channel data and * calls \ref exr_choose_unpack_routine. * * If only compressed data is desired, then leave or assign this * to NULL after initialization. */ exr_result_t (*unpack_and_convert_fn) ( struct _exr_decode_pipeline* pipeline); /** * Small stash of channel info values. This is faster than calling * malloc when the channel count in the part is small (RGBAZ), * which is super common, however if there are a large number of * channels, it will allocate space for that, so do not rely on * this being used */ exr_coding_channel_info_t _quick_chan_store[5]; } exr_decode_pipeline_t; /** @brief simple macro to initialize an empty decode pipeline */ #define EXR_DECODE_PIPELINE_INITIALIZER \ { \ 0 \ } /** Initialize the decoding pipeline structure with the channel info * for the specified part, and the first block to be read. * * NB: The \ref unpack_and_convert_fn will be NULL after this. If that * stage is desired, initialize the channel output information and * call \ref exr_choose_unpack_routine */ EXR_EXPORT exr_result_t exr_decoding_initialize ( exr_const_context_t ctxt, int part_index, const exr_chunk_info_t* cinfo, exr_decode_pipeline_t* decode); /** Given an initialized decode pipeline, find appropriate functions * to read and shuffle / convert data into the defined channel outputs * * Calling this is not required if custom routines will be used, or if * just the raw compressed data is desired. Although in that scenario, * it is probably easier to just read the chunk directly using \ref * exr_read_chunk */ EXR_EXPORT exr_result_t exr_decoding_choose_default_routines ( exr_const_context_t ctxt, int part_index, exr_decode_pipeline_t* decode); /** Given a decode pipeline previously initialized, update it for the * new chunk to be read. * * In this manner, memory buffers can be re-used to avoid continual * malloc / free calls. Further, it allows the previous choices for * the various functions to be quickly re-used. */ EXR_EXPORT exr_result_t exr_decoding_update ( exr_const_context_t ctxt, int part_index, const exr_chunk_info_t* cinfo, exr_decode_pipeline_t* decode); /** Execute the decoding pipeline */ EXR_EXPORT exr_result_t exr_decoding_run ( exr_const_context_t ctxt, int part_index, exr_decode_pipeline_t* decode); /** Free any intermediate memory in the decoding pipeline * * This does *not* free any pointers referred to in the channel info * areas, but rather only the intermediate buffers and memory needed * for the structure itself. */ EXR_EXPORT exr_result_t exr_decoding_destroy (exr_const_context_t ctxt, exr_decode_pipeline_t* decode); #ifdef __cplusplus } /* extern "C" */ #endif #endif /* OPENEXR_CORE_DECODE_H */ PK rM�[�tն � openexr_coding.hnu �[��� /* ** SPDX-License-Identifier: BSD-3-Clause ** Copyright Contributors to the OpenEXR Project. */ #ifndef OPENEXR_CORE_CODING_H #define OPENEXR_CORE_CODING_H #include <stdint.h> #ifdef __cplusplus extern "C" { #endif /** * Enum for use in a custom allocator in the encode / decode pipelines * (i.e. so the implementor knows whether to allocate on which device * based on the buffer disposition) */ enum transcoding_pipeline_buffer_id { EXR_TRANSCODE_BUFFER_PACKED, EXR_TRANSCODE_BUFFER_UNPACKED, EXR_TRANSCODE_BUFFER_COMPRESSED, EXR_TRANSCODE_BUFFER_SCRATCH1, EXR_TRANSCODE_BUFFER_SCRATCH2, EXR_TRANSCODE_BUFFER_PACKED_SAMPLES, EXR_TRANSCODE_BUFFER_SAMPLES }; /** @brief Structure for negotiating buffers when decoding / encoding * chunks of data * * This is generic and meant to negotiate exr data bi-directionally, * in that the same structure is used for both decoding and encoding * chunks for read and write, respectively. * * The first half of the structure will be filled by the library, and * the caller is expected to fill the second half appropriately. */ typedef struct { /************************************************** * Elements below are populated by the library when * decoding is initialized / updated and must be left * untouched when using the default decoder routines **************************************************/ /** channel name * * This is provided as a convenient reference. Do not free, this * refers to the internal data structure in the context. */ const char* channel_name; /** number of lines for this channel in this chunk * * May be 0 or less than overall image height based on sampling * (i.e. when in 4:2:0 type sampling) */ int32_t height; /** width in pixel count * * May be 0 or less than overall image width based on sampling * (i.e. 4:2:2 will have some channels have fewer values) */ int32_t width; /** horizontal subsampling information */ int32_t x_samples; /** vertical subsampling information */ int32_t y_samples; /** linear flag from channel definition (used by b44)*/ uint8_t p_linear; /** * how many bytes per pixel this channel consumes (i.e. 2 for * float16, 4 for float32 / uint32) */ int8_t bytes_per_element; /** small form of exr_pixel_type_t enum (EXR_PIXEL_UINT/HALF/FLOAT) */ uint16_t data_type; /************************************************** * Elements below must be edited by the caller * to control encoding / decoding **************************************************/ /** * how many bytes per pixel the input is or output should be * (i.e. 2 for float16, 4 for float32 / uint32). Defaults to same * size as input */ int16_t user_bytes_per_element; /** small form of exr_pixel_type_t enum * (EXR_PIXEL_UINT/HALF/FLOAT). Defaults to same type as input */ uint16_t user_data_type; /** increment to get to next pixel * * This is in bytes. Must be specified when the decode pointer is * specified (and always for encode). * * This is useful for implementing transcoding generically of * planar or interleaved data. For planar data, where the layout * is RRRRRGGGGGBBBBB, you can pass in 1 * bytes per component */ int32_t user_pixel_stride; /** * When lines > 1 for a chunk, this is the increment used to get * from beginning of line to beginning of next line. * * This is in bytes. Must be specified when the decode pointer is * specified (and always for encode). */ int32_t user_line_stride; /** * This data member has different requirements reading vs * writing. When reading, if this is left as NULL, the channel * will be skipped during read and not filled in. During a write * operation, this pointer is considered const and not * modified. To make this more clear, a union is used here. */ union { uint8_t* decode_to_ptr; const uint8_t* encode_from_ptr; }; } exr_coding_channel_info_t; #ifdef __cplusplus } /* extern "C" */ #endif #endif /* OPENEXR_CORE_CODING_H */ PK rM�[�] n ImfGenericOutputFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef IMFGENERICOUTPUTFILE_H_ #define IMFGENERICOUTPUTFILE_H_ #include "ImfForward.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE GenericOutputFile { public: IMF_EXPORT virtual ~GenericOutputFile(); protected: IMF_EXPORT GenericOutputFile(); IMF_EXPORT void writeMagicNumberAndVersionField (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream& os, const Header& header); IMF_EXPORT void writeMagicNumberAndVersionField (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream& os, const Header * headers, int parts); }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif /* GENERICOUTPUTFILE_H_ */ PK rM�[],\�1 1 ImfRgbaFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_RGBA_FILE_H #define INCLUDED_IMF_RGBA_FILE_H //----------------------------------------------------------------------------- // // Simplified RGBA image I/O // // class RgbaOutputFile // class RgbaInputFile // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfHeader.h" #include "ImfFrameBuffer.h" #include "ImfRgba.h" #include <ImathVec.h> #include <ImathBox.h> #include <half.h> #include "ImfThreading.h" #include <string> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER //------------------------------------------------------- // Utility to compute the origin-based pointer address // // With large offsets for the data window, the naive code // can wrap around, especially on 32-bit machines. // This can be used to avoid that //------------------------------------------------------- inline const Rgba * ComputeBasePointer ( const Rgba* ptr, const IMATH_NAMESPACE::V2i& origin, int64_t w, size_t xStride = 1, size_t yStride = 0) { if (yStride == 0) yStride = w; int64_t offx = static_cast<int64_t> (origin.x); offx *= xStride; int64_t offy = static_cast<int64_t> (origin.y); offy *= yStride; return ptr - offx - offy; } inline const Rgba * ComputeBasePointer (const Rgba* ptr, const IMATH_NAMESPACE::Box2i& dataWindow) { return ComputeBasePointer (ptr, dataWindow.min, static_cast<int64_t> (dataWindow.max.x) - static_cast<int64_t> (dataWindow.min.x) + 1); } inline Rgba* ComputeBasePointer ( Rgba* ptr, const IMATH_NAMESPACE::V2i& origin, int64_t w, size_t xStride = 1, size_t yStride = 0) { if (yStride == 0) yStride = w; int64_t offx = static_cast<int64_t> (origin.x); offx *= xStride; int64_t offy = static_cast<int64_t> (origin.y); offy *= yStride; return ptr - offx - offy; } inline Rgba* ComputeBasePointer (Rgba* ptr, const IMATH_NAMESPACE::Box2i& dataWindow) { return ComputeBasePointer ( ptr, dataWindow.min, static_cast<int64_t> (dataWindow.max.x) - static_cast<int64_t> (dataWindow.min.x) + 1); } // // RGBA output file. // class IMF_EXPORT_TYPE RgbaOutputFile { public: //--------------------------------------------------- // Constructor -- header is constructed by the caller //--------------------------------------------------- IMF_EXPORT RgbaOutputFile (const char name[], const Header &header, RgbaChannels rgbaChannels = WRITE_RGBA, int numThreads = globalThreadCount()); //---------------------------------------------------- // Constructor -- header is constructed by the caller, // file is opened by the caller, destructor will not // automatically close the file. //---------------------------------------------------- IMF_EXPORT RgbaOutputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, const Header &header, RgbaChannels rgbaChannels = WRITE_RGBA, int numThreads = globalThreadCount()); //---------------------------------------------------------------- // Constructor -- header data are explicitly specified as function // call arguments (empty dataWindow means "same as displayWindow") //---------------------------------------------------------------- IMF_EXPORT RgbaOutputFile (const char name[], const IMATH_NAMESPACE::Box2i &displayWindow, const IMATH_NAMESPACE::Box2i &dataWindow = IMATH_NAMESPACE::Box2i(), RgbaChannels rgbaChannels = WRITE_RGBA, float pixelAspectRatio = 1, const IMATH_NAMESPACE::V2f screenWindowCenter = IMATH_NAMESPACE::V2f (0, 0), float screenWindowWidth = 1, LineOrder lineOrder = INCREASING_Y, Compression compression = PIZ_COMPRESSION, int numThreads = globalThreadCount()); //----------------------------------------------- // Constructor -- like the previous one, but both // the display window and the data window are // Box2i (V2i (0, 0), V2i (width - 1, height -1)) //----------------------------------------------- IMF_EXPORT RgbaOutputFile (const char name[], int width, int height, RgbaChannels rgbaChannels = WRITE_RGBA, float pixelAspectRatio = 1, const IMATH_NAMESPACE::V2f screenWindowCenter = IMATH_NAMESPACE::V2f (0, 0), float screenWindowWidth = 1, LineOrder lineOrder = INCREASING_Y, Compression compression = PIZ_COMPRESSION, int numThreads = globalThreadCount()); //----------- // Destructor //----------- IMF_EXPORT virtual ~RgbaOutputFile (); //------------------------------------------------ // Define a frame buffer as the pixel data source: // Pixel (x, y) is at address // // base + x * xStride + y * yStride // //------------------------------------------------ IMF_EXPORT void setFrameBuffer (const Rgba *base, size_t xStride, size_t yStride); //--------------------------------------------- // Write pixel data (see class Imf::OutputFile) //--------------------------------------------- IMF_EXPORT void writePixels (int numScanLines = 1); IMF_EXPORT int currentScanLine () const; //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; IMF_EXPORT const FrameBuffer & frameBuffer () const; IMF_EXPORT const IMATH_NAMESPACE::Box2i & displayWindow () const; IMF_EXPORT const IMATH_NAMESPACE::Box2i & dataWindow () const; IMF_EXPORT float pixelAspectRatio () const; IMF_EXPORT const IMATH_NAMESPACE::V2f screenWindowCenter () const; IMF_EXPORT float screenWindowWidth () const; IMF_EXPORT LineOrder lineOrder () const; IMF_EXPORT Compression compression () const; IMF_EXPORT RgbaChannels channels () const; // -------------------------------------------------------------------- // Update the preview image (see Imf::OutputFile::updatePreviewImage()) // -------------------------------------------------------------------- IMF_EXPORT void updatePreviewImage (const PreviewRgba[]); //----------------------------------------------------------------------- // Rounding control for luminance/chroma images: // // If the output file contains luminance and chroma channels (WRITE_YC // or WRITE_YCA), then the the significands of the luminance and // chroma values are rounded to roundY and roundC bits respectively (see // function half::round()). Rounding improves compression with minimal // image degradation, usually much less than the degradation caused by // chroma subsampling. By default, roundY is 7, and roundC is 5. // // If the output file contains RGB channels or a luminance channel, // without chroma, then no rounding is performed. //----------------------------------------------------------------------- IMF_EXPORT void setYCRounding (unsigned int roundY, unsigned int roundC); //---------------------------------------------------- // Break a scan line -- for testing and debugging only // (see Imf::OutputFile::updatePreviewImage() // // Warning: Calling this function usually results in a // broken image file. The file or parts of it may not // be readable, or the file may contain bad data. // //---------------------------------------------------- IMF_EXPORT void breakScanLine (int y, int offset, int length, char c); private: RgbaOutputFile (const RgbaOutputFile &) = delete; RgbaOutputFile & operator = (const RgbaOutputFile &) = delete; RgbaOutputFile (RgbaOutputFile &&) = delete; RgbaOutputFile & operator = (RgbaOutputFile &&) = delete; class IMF_HIDDEN ToYca; OutputFile * _outputFile; ToYca * _toYca; }; // // RGBA input file // class IMF_EXPORT_TYPE RgbaInputFile { public: //------------------------------------------------------- // Constructor -- opens the file with the specified name, // destructor will automatically close the file. //------------------------------------------------------- IMF_EXPORT RgbaInputFile (const char name[], int numThreads = globalThreadCount()); //----------------------------------------------------------- // Constructor -- attaches the new RgbaInputFile object to a // file that has already been opened by the caller. // Destroying the RgbaInputFile object will not automatically // close the file. //----------------------------------------------------------- IMF_EXPORT RgbaInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int numThreads = globalThreadCount()); //-------------------------------------------------------------- // Constructors -- the same as the previous two, but the names // of the red, green, blue, alpha, luminance and chroma channels // are expected to be layerName.R, layerName.G, etc. //-------------------------------------------------------------- IMF_EXPORT RgbaInputFile (const char name[], const std::string &layerName, int numThreads = globalThreadCount()); IMF_EXPORT RgbaInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, const std::string &layerName, int numThreads = globalThreadCount()); //----------- // Destructor //----------- IMF_EXPORT virtual ~RgbaInputFile (); //----------------------------------------------------- // Define a frame buffer as the pixel data destination: // Pixel (x, y) is at address // // base + x * xStride + y * yStride // //----------------------------------------------------- IMF_EXPORT void setFrameBuffer (Rgba *base, size_t xStride, size_t yStride); //---------------------------------------------------------------- // Switch to a different layer -- subsequent calls to readPixels() // will read channels layerName.R, layerName.G, etc. // After each call to setLayerName(), setFrameBuffer() must be // called at least once before the next call to readPixels(). //---------------------------------------------------------------- IMF_EXPORT void setLayerName (const std::string &layerName); //------------------------------------------- // Read pixel data (see class Imf::InputFile) //------------------------------------------- IMF_EXPORT void readPixels (int scanLine1, int scanLine2); IMF_EXPORT void readPixels (int scanLine); //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; IMF_EXPORT const FrameBuffer & frameBuffer () const; IMF_EXPORT const IMATH_NAMESPACE::Box2i & displayWindow () const; IMF_EXPORT const IMATH_NAMESPACE::Box2i & dataWindow () const; IMF_EXPORT float pixelAspectRatio () const; IMF_EXPORT const IMATH_NAMESPACE::V2f screenWindowCenter () const; IMF_EXPORT float screenWindowWidth () const; IMF_EXPORT LineOrder lineOrder () const; IMF_EXPORT Compression compression () const; IMF_EXPORT RgbaChannels channels () const; IMF_EXPORT const char * fileName () const; IMF_EXPORT bool isComplete () const; //---------------------------------- // Access to the file format version //---------------------------------- IMF_EXPORT int version () const; private: RgbaInputFile (const RgbaInputFile &) = delete; RgbaInputFile & operator = (const RgbaInputFile &) = delete; RgbaInputFile (RgbaInputFile &&) = delete; RgbaInputFile & operator = (RgbaInputFile &&) = delete; class IMF_HIDDEN FromYca; InputFile * _inputFile; FromYca * _fromYca; std::string _channelNamePrefix; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[^��� � IexBaseExc.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IEXBASEEXC_H #define INCLUDED_IEXBASEEXC_H #include "IexNamespace.h" #include "IexExport.h" //---------------------------------------------------------- // // A general exception base class, and a few // useful exceptions derived from the base class. // //---------------------------------------------------------- #include <string> #include <exception> #include <sstream> IEX_INTERNAL_NAMESPACE_HEADER_ENTER //------------------------------- // Our most basic exception class //------------------------------- class IEX_EXPORT_TYPE BaseExc: public std::exception { public: //---------------------------- // Constructors and destructor //---------------------------- IEX_EXPORT BaseExc (const char *s = nullptr); IEX_EXPORT BaseExc (const std::string &s); IEX_EXPORT BaseExc (std::string &&s); // not noexcept because of stacktrace IEX_EXPORT BaseExc (std::stringstream &s); IEX_EXPORT BaseExc (const BaseExc &be); IEX_EXPORT BaseExc (BaseExc &&be) noexcept; IEX_EXPORT virtual ~BaseExc () noexcept; IEX_EXPORT BaseExc & operator = (const BaseExc& be); IEX_EXPORT BaseExc & operator = (BaseExc&& be) noexcept; //--------------------------------------------------- // what() method -- e.what() returns _message.c_str() //--------------------------------------------------- IEX_EXPORT virtual const char * what () const noexcept; //-------------------------------------------------- // Convenient methods to change the exception's text //-------------------------------------------------- IEX_EXPORT BaseExc & assign (std::stringstream &s); // assign (s.str()) IEX_EXPORT BaseExc & operator = (std::stringstream &s); IEX_EXPORT BaseExc & append (std::stringstream &s); // append (s.str()) IEX_EXPORT BaseExc & operator += (std::stringstream &s); //-------------------------------------------------- // These methods from the base class get obscured by // the definitions above. //-------------------------------------------------- IEX_EXPORT BaseExc & assign (const char *s); IEX_EXPORT BaseExc & operator = (const char *s); IEX_EXPORT BaseExc & append (const char *s); IEX_EXPORT BaseExc & operator += (const char *s); //--------------------------------------------------- // Access to the string representation of the message //--------------------------------------------------- IEX_EXPORT const std::string & message () const noexcept; //-------------------------------------------------- // Stack trace for the point at which the exception // was thrown. The stack trace will be an empty // string unless a working stack-tracing routine // has been installed (see below, setStackTracer()). //-------------------------------------------------- IEX_EXPORT const std::string & stackTrace () const noexcept; private: std::string _message; std::string _stackTrace; }; //----------------------------------------------------- // A macro to save typing when declararing an exception // class derived directly or indirectly from BaseExc: //----------------------------------------------------- #define DEFINE_EXC_EXP(exp, name, base) \ class IEX_EXPORT_TYPE name: public base \ { \ public: \ exp name(); \ exp name (const char* text); \ exp name (const std::string &text); \ exp name (std::string &&text); \ exp name (std::stringstream &text); \ exp name (const name &other); \ exp name (name &&other) noexcept; \ exp name& operator = (name &other); \ exp name& operator = (name &&other) noexcept; \ exp ~name() noexcept; \ }; #define DEFINE_EXC_EXP_IMPL(exp, name, base) \ exp name::name () : base () {} \ exp name::name (const char* text) : base (text) {} \ exp name::name (const std::string& text) : base (text) {} \ exp name::name (std::string&& text) : base (std::move (text)) {} \ exp name::name (std::stringstream& text) : base (text) {} \ exp name::name (const name &other) : base (other) {} \ exp name::name (name &&other) noexcept : base (other) {} \ exp name& name::operator = (name &other) { base::operator=(other); return *this; } \ exp name& name::operator = (name &&other) noexcept { base::operator=(other); return *this; } \ exp name::~name () noexcept {} // For backward compatibility. #define DEFINE_EXC(name, base) DEFINE_EXC_EXP(, name, base) //-------------------------------------------------------- // Some exceptions which should be useful in most programs //-------------------------------------------------------- DEFINE_EXC_EXP (IEX_EXPORT, ArgExc, BaseExc) // Invalid arguments to a function call DEFINE_EXC_EXP (IEX_EXPORT, LogicExc, BaseExc) // General error in a program's logic, // for example, a function was called // in a context where the call does // not make sense. DEFINE_EXC_EXP (IEX_EXPORT, InputExc, BaseExc) // Invalid input data, e.g. from a file DEFINE_EXC_EXP (IEX_EXPORT, IoExc, BaseExc) // Input or output operation failed DEFINE_EXC_EXP (IEX_EXPORT, MathExc, BaseExc) // Arithmetic exception; more specific // exceptions derived from this class // are defined in ExcMath.h DEFINE_EXC_EXP (IEX_EXPORT, ErrnoExc, BaseExc) // Base class for exceptions corresponding // to errno values (see errno.h); more // specific exceptions derived from this // class are defined in ExcErrno.h DEFINE_EXC_EXP (IEX_EXPORT, NoImplExc, BaseExc) // Missing method exception e.g. from a // call to a method that is only partially // or not at all implemented. A reminder // to lazy software people to get back // to work. DEFINE_EXC_EXP (IEX_EXPORT, NullExc, BaseExc) // A pointer is inappropriately null. DEFINE_EXC_EXP (IEX_EXPORT, TypeExc, BaseExc) // An object is an inappropriate type, // i.e. a dynamnic_cast failed. //---------------------------------------------------------------------- // Stack-tracing support: // // setStackTracer(st) // // installs a stack-tracing routine, st, which will be called from // class BaseExc's constructor every time an exception derived from // BaseExc is thrown. The stack-tracing routine should return a // string that contains a printable representation of the program's // current call stack. This string will be stored in the BaseExc // object; the string is accesible via the BaseExc::stackTrace() // method. // // setStackTracer(0) // // removes the current stack tracing routine. When an exception // derived from BaseExc is thrown, the stack trace string stored // in the BaseExc object will be empty. // // stackTracer() // // returns a pointer to the current stack-tracing routine, or 0 // if there is no current stack stack-tracing routine. // //---------------------------------------------------------------------- typedef std::string (* StackTracer) (); IEX_EXPORT void setStackTracer (StackTracer stackTracer); IEX_EXPORT StackTracer stackTracer (); IEX_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IEXBASEEXC_H PK rM�[�� x x ImfTiledInputPart.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef IMFTILEDINPUTPART_H_ #define IMFTILEDINPUTPART_H_ #include "ImfForward.h" #include "ImfTileDescription.h" #include <ImathBox.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER //----------------------------------------------------------------------------- // class TiledInputPart: // // Same interface as TiledInputFile. Please have a reference to TiledInputFile. //----------------------------------------------------------------------------- class IMF_EXPORT_TYPE TiledInputPart { public: IMF_EXPORT TiledInputPart(MultiPartInputFile& multiPartFile, int partNumber); IMF_EXPORT const char * fileName () const; IMF_EXPORT const Header & header () const; IMF_EXPORT int version () const; IMF_EXPORT void setFrameBuffer (const FrameBuffer &frameBuffer); IMF_EXPORT const FrameBuffer & frameBuffer () const; IMF_EXPORT bool isComplete () const; IMF_EXPORT unsigned int tileXSize () const; IMF_EXPORT unsigned int tileYSize () const; IMF_EXPORT LevelMode levelMode () const; IMF_EXPORT LevelRoundingMode levelRoundingMode () const; IMF_EXPORT int numLevels () const; IMF_EXPORT int numXLevels () const; IMF_EXPORT int numYLevels () const; IMF_EXPORT bool isValidLevel (int lx, int ly) const; IMF_EXPORT int levelWidth (int lx) const; IMF_EXPORT int levelHeight (int ly) const; IMF_EXPORT int numXTiles (int lx = 0) const; IMF_EXPORT int numYTiles (int ly = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int lx, int ly) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int lx, int ly) const; IMF_EXPORT void readTile (int dx, int dy, int l = 0); IMF_EXPORT void readTile (int dx, int dy, int lx, int ly); IMF_EXPORT void readTiles (int dx1, int dx2, int dy1, int dy2, int lx, int ly); IMF_EXPORT void readTiles (int dx1, int dx2, int dy1, int dy2, int l = 0); IMF_EXPORT void rawTileData (int &dx, int &dy, int &lx, int &ly, const char *&pixelData, int &pixelDataSize); private: TiledInputFile* file; // for internal use - allow TiledOutputFile access to file for copyPixels friend class TiledOutputFile; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif /* IMFTILEDINPUTPART_H_ */ PK rM�[q �> > IlmThreadSemaphore.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_ILM_THREAD_SEMAPHORE_H #define INCLUDED_ILM_THREAD_SEMAPHORE_H //----------------------------------------------------------------------------- // // class Semaphore -- a wrapper class for // system-dependent counting semaphores // //----------------------------------------------------------------------------- #include "IlmThreadExport.h" #include "IlmThreadConfig.h" #include "IlmThreadNamespace.h" #if ILMTHREAD_THREADING_ENABLED # if ILMTHREAD_HAVE_POSIX_SEMAPHORES # include <semaphore.h> # elif defined(__APPLE__) # include <dispatch/dispatch.h> # elif (defined (_WIN32) || defined (_WIN64)) # ifdef NOMINMAX # undef NOMINMAX # endif # define NOMINMAX # include <windows.h> # else # include <mutex> # include <condition_variable> # endif #endif ILMTHREAD_INTERNAL_NAMESPACE_HEADER_ENTER class ILMTHREAD_EXPORT_TYPE Semaphore { public: ILMTHREAD_EXPORT Semaphore (unsigned int value = 0); ILMTHREAD_EXPORT virtual ~Semaphore(); ILMTHREAD_EXPORT void wait(); ILMTHREAD_EXPORT bool tryWait(); ILMTHREAD_EXPORT void post(); ILMTHREAD_EXPORT int value() const; private: #if ILMTHREAD_HAVE_POSIX_SEMAPHORES mutable sem_t _semaphore; #elif defined(__APPLE__) mutable dispatch_semaphore_t _semaphore; #elif (defined (_WIN32) || defined (_WIN64)) mutable HANDLE _semaphore; #elif ILMTHREAD_THREADING_ENABLED // // If the platform has threads but no semapohores, // then we implement them ourselves using condition variables // struct sema_t { unsigned int count; unsigned long numWaiting; std::mutex mutex; std::condition_variable nonZero; }; mutable sema_t _semaphore; #endif void operator = (const Semaphore& s) = delete; Semaphore (const Semaphore& s) = delete; void operator = (Semaphore&& s) = delete; Semaphore (Semaphore&& s) = delete; }; ILMTHREAD_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_ILM_THREAD_SEMAPHORE_H PK rM�[��� ImfCompressionAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_COMPRESSION_ATTRIBUTE_H #define INCLUDED_IMF_COMPRESSION_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class CompressionAttribute // //----------------------------------------------------------------------------- #include "ImfAttribute.h" #include "ImfCompression.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Compression> CompressionAttribute; #ifndef COMPILING_IMF_COMPRESSION_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Compression>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[��& & ImfDeepImageState.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_DEEPIMAGESTATE_H #define INCLUDED_IMF_DEEPIMAGESTATE_H //----------------------------------------------------------------------------- // // enum DeepImageState -- describes how orderly the pixel data // in a deep image are // // The samples in a deep image pixel may be sorted according to // depth, and the sample depths or depth ranges may or may not // overlap each other. A pixel is // // - SORTED if for every i and j with i < j // // (Z[i] < Z[j]) || (Z[i] == Z[j] && ZBack[i] < ZBack[j]), // // - NON_OVERLAPPING if for every i and j with i != j // // (Z[i] < Z[j] && ZBack[i] <= Z[j]) || // (Z[j] < Z[i] && ZBack[j] <= Z[i]) || // (Z[i] == Z[j] && ZBack[i] <= Z[i] & ZBack[j] > Z[j]) || // (Z[i] == Z[j] && ZBack[j] <= Z[j] & ZBack[i] > Z[i]), // // - TIDY if it is SORTED and NON_OVERLAPPING, // // - MESSY if it is neither SORTED nor NON_OVERLAPPING. // // A deep image is // // - MESSY if at least one of its pixels is MESSY, // - SORTED if all of its pixels are SORTED, // - NON_OVERLAPPING if all of its pixels are NON_OVERLAPPING, // - TIDY if all of its pixels are TIDY. // // Note: the rather complicated definition of NON_OVERLAPPING prohibits // overlapping volume samples, coincident point samples and point samples // in the middle of a volume sample, but it does allow point samples at // the front or back of a volume sample. // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER enum IMF_EXPORT_ENUM DeepImageState : int { DIS_MESSY = 0, DIS_SORTED = 1, DIS_NON_OVERLAPPING = 2, DIS_TIDY = 3, DIS_NUMSTATES // Number of different image states }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�\r�h h ImfGenericInputFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef IMFGENERICINPUTFILE_H_ #define IMFGENERICINPUTFILE_H_ #include "ImfForward.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE GenericInputFile { public: IMF_EXPORT virtual ~GenericInputFile(); protected: IMF_EXPORT GenericInputFile(); IMF_EXPORT void readMagicNumberAndVersionField(OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is, int& version); }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif /* IMFGENERICINPUTFILE_H_ */ PK rM�[1��% % ImfTileDescription.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_TILE_DESCRIPTION_H #define INCLUDED_IMF_TILE_DESCRIPTION_H //----------------------------------------------------------------------------- // // class TileDescription and enum LevelMode // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER enum IMF_EXPORT_ENUM LevelMode { ONE_LEVEL = 0, MIPMAP_LEVELS = 1, RIPMAP_LEVELS = 2, NUM_LEVELMODES // number of different level modes }; enum IMF_EXPORT_ENUM LevelRoundingMode { ROUND_DOWN = 0, ROUND_UP = 1, NUM_ROUNDINGMODES // number of different rounding modes }; class IMF_EXPORT_TYPE TileDescription { public: unsigned int xSize; // size of a tile in the x dimension unsigned int ySize; // size of a tile in the y dimension LevelMode mode; LevelRoundingMode roundingMode; TileDescription (unsigned int xs = 32, unsigned int ys = 32, LevelMode m = ONE_LEVEL, LevelRoundingMode r = ROUND_DOWN) : xSize (xs), ySize (ys), mode (m), roundingMode (r) { // empty } bool operator == (const TileDescription &other) const { return xSize == other.xSize && ySize == other.ySize && mode == other.mode && roundingMode == other.roundingMode; } }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[��"ѝ � ImfDeepFrameBuffer.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef IMFDEEPFRAMEBUFFER_H_ #define IMFDEEPFRAMEBUFFER_H_ #include "ImfForward.h" #include "ImfFrameBuffer.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER //-------------------------------------------------------- // Description of a single deep slice of the frame buffer: //-------------------------------------------------------- struct IMF_EXPORT_TYPE DeepSlice : public Slice { //--------------------------------------------------------------------- // The stride for each sample in this slice. // // Memory layout: The address of sample i in pixel (x, y) is // // base + (xp / xSampling) * xStride + (yp / ySampling) * yStride // + i * sampleStride // // where xp and yp are computed as follows: // // * If we are reading or writing a scanline-based file: // // xp = x // yp = y // // * If we are reading a tile whose upper left coorner is at (xt, yt): // // if xTileCoords is true then xp = x - xt, else xp = x // if yTileCoords is true then yp = y - yt, else yp = y // //--------------------------------------------------------------------- int sampleStride; //------------ // Constructor //------------ IMF_EXPORT DeepSlice (PixelType type = HALF, char * base = 0, size_t xStride = 0, size_t yStride = 0, size_t sampleStride = 0, int xSampling = 1, int ySampling = 1, double fillValue = 0.0, bool xTileCoords = false, bool yTileCoords = false); }; //----------------- // DeepFrameBuffer. //----------------- class IMF_EXPORT_TYPE DeepFrameBuffer { public: //------------ // Add a slice //------------ IMF_EXPORT void insert (const char name[], const DeepSlice &slice); IMF_EXPORT void insert (const std::string &name, const DeepSlice &slice); //---------------------------------------------------------------- // Access to existing slices: // // [n] Returns a reference to the slice with name n. // If no slice with name n exists, an IEX_NAMESPACE::ArgExc // is thrown. // // findSlice(n) Returns a pointer to the slice with name n, // or 0 if no slice with name n exists. // //---------------------------------------------------------------- IMF_EXPORT DeepSlice & operator [] (const char name[]); IMF_EXPORT const DeepSlice & operator [] (const char name[]) const; IMF_EXPORT DeepSlice & operator [] (const std::string &name); IMF_EXPORT const DeepSlice & operator [] (const std::string &name) const; IMF_EXPORT DeepSlice * findSlice (const char name[]); IMF_EXPORT const DeepSlice * findSlice (const char name[]) const; IMF_EXPORT DeepSlice * findSlice (const std::string &name); IMF_EXPORT const DeepSlice * findSlice (const std::string &name) const; //----------------------------------------- // Iterator-style access to existing slices //----------------------------------------- typedef std::map <Name, DeepSlice> SliceMap; class Iterator; class ConstIterator; IMF_EXPORT Iterator begin (); IMF_EXPORT ConstIterator begin () const; IMF_EXPORT Iterator end (); IMF_EXPORT ConstIterator end () const; IMF_EXPORT Iterator find (const char name[]); IMF_EXPORT ConstIterator find (const char name[]) const; IMF_EXPORT Iterator find (const std::string &name); IMF_EXPORT ConstIterator find (const std::string &name) const; //---------------------------------------------------- // Public function for accessing a sample count slice. //---------------------------------------------------- IMF_EXPORT void insertSampleCountSlice(const Slice & slice); IMF_EXPORT const Slice & getSampleCountSlice() const; private: SliceMap _map; Slice _sampleCounts; }; //---------- // Iterators //---------- class IMF_EXPORT_TYPE DeepFrameBuffer::Iterator { public: IMF_EXPORT Iterator (); IMF_EXPORT Iterator (const DeepFrameBuffer::SliceMap::iterator &i); IMF_EXPORT Iterator & operator ++ (); IMF_EXPORT Iterator operator ++ (int); IMF_EXPORT const char * name () const; IMF_EXPORT DeepSlice & slice () const; private: friend class DeepFrameBuffer::ConstIterator; DeepFrameBuffer::SliceMap::iterator _i; }; class IMF_EXPORT_TYPE DeepFrameBuffer::ConstIterator { public: IMF_EXPORT ConstIterator (); IMF_EXPORT ConstIterator (const DeepFrameBuffer::SliceMap::const_iterator &i); IMF_EXPORT ConstIterator (const DeepFrameBuffer::Iterator &other); IMF_EXPORT ConstIterator & operator ++ (); IMF_EXPORT ConstIterator operator ++ (int); IMF_EXPORT const char * name () const; IMF_EXPORT const DeepSlice & slice () const; private: friend bool operator == (const ConstIterator &, const ConstIterator &); friend bool operator != (const ConstIterator &, const ConstIterator &); DeepFrameBuffer::SliceMap::const_iterator _i; }; //----------------- // Inline Functions //----------------- inline DeepFrameBuffer::Iterator::Iterator (): _i() { // empty } inline DeepFrameBuffer::Iterator::Iterator (const DeepFrameBuffer::SliceMap::iterator &i): _i (i) { // empty } inline DeepFrameBuffer::Iterator & DeepFrameBuffer::Iterator::operator ++ () { ++_i; return *this; } inline DeepFrameBuffer::Iterator DeepFrameBuffer::Iterator::operator ++ (int) { Iterator tmp = *this; ++_i; return tmp; } inline const char * DeepFrameBuffer::Iterator::name () const { return *_i->first; } inline DeepSlice & DeepFrameBuffer::Iterator::slice () const { return _i->second; } inline DeepFrameBuffer::ConstIterator::ConstIterator (): _i() { // empty } inline DeepFrameBuffer::ConstIterator::ConstIterator (const DeepFrameBuffer::SliceMap::const_iterator &i): _i (i) { // empty } inline DeepFrameBuffer::ConstIterator::ConstIterator (const DeepFrameBuffer::Iterator &other): _i (other._i) { // empty } inline DeepFrameBuffer::ConstIterator & DeepFrameBuffer::ConstIterator::operator ++ () { ++_i; return *this; } inline DeepFrameBuffer::ConstIterator DeepFrameBuffer::ConstIterator::operator ++ (int) { ConstIterator tmp = *this; ++_i; return tmp; } inline const char * DeepFrameBuffer::ConstIterator::name () const { return *_i->first; } inline const DeepSlice & DeepFrameBuffer::ConstIterator::slice () const { return _i->second; } inline bool operator == (const DeepFrameBuffer::ConstIterator &x, const DeepFrameBuffer::ConstIterator &y) { return x._i == y._i; } inline bool operator != (const DeepFrameBuffer::ConstIterator &x, const DeepFrameBuffer::ConstIterator &y) { return !(x == y); } OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif /* IMFDEEPFRAMEBUFFER_H_ */ PK rM�[�m}�Q Q ImfDeepImageStateAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_DEEPIMAGESTATE_ATTRIBUTE_H #define INCLUDED_IMF_DEEPIMAGESTATE_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class DeepImageStateAttribute // //----------------------------------------------------------------------------- #include "ImfAttribute.h" #include "ImfDeepImageState.h" #include "ImfExport.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::DeepImageState> DeepImageStateAttribute; #ifndef COMPILING_IMF_DEEP_IMAGE_STATE_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::DeepImageState>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[Hb�� ImfEnvmapAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_ENVMAP_ATTRIBUTE_H #define INCLUDED_IMF_ENVMAP_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class EnvmapAttribute // //----------------------------------------------------------------------------- #include "ImfAttribute.h" #include "ImfEnvmap.h" #include "ImfExport.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Envmap> EnvmapAttribute; #ifndef COMPILING_IMF_ENVMAP_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Envmap>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[F��*)( )( ImfDeepScanLineInputFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_DEEP_SCAN_LINE_INPUT_FILE_H #define INCLUDED_IMF_DEEP_SCAN_LINE_INPUT_FILE_H //----------------------------------------------------------------------------- // // class DeepScanLineInputFile // //----------------------------------------------------------------------------- #include "ImfForward.h" #include "ImfThreading.h" #include "ImfGenericInputFile.h" #include "ImfDeepScanLineOutputFile.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE DeepScanLineInputFile : public GenericInputFile { public: //------------ // Constructor //------------ IMF_EXPORT DeepScanLineInputFile (const char fileName[], int numThreads = globalThreadCount()); IMF_EXPORT DeepScanLineInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int numThreads = globalThreadCount()); IMF_EXPORT DeepScanLineInputFile (const Header &header, OPENEXR_IMF_INTERNAL_NAMESPACE::IStream *is, int version, /*version field from file*/ int numThreads = globalThreadCount()); DeepScanLineInputFile (const DeepScanLineInputFile& other) = delete; DeepScanLineInputFile& operator = (const DeepScanLineInputFile& other) = delete; DeepScanLineInputFile (DeepScanLineInputFile&& other) = delete; DeepScanLineInputFile& operator = (DeepScanLineInputFile&& other) = delete; //----------------------------------------- // Destructor -- deallocates internal data // structures, but does not close the file. //----------------------------------------- IMF_EXPORT virtual ~DeepScanLineInputFile (); //------------------------ // Access to the file name //------------------------ IMF_EXPORT const char * fileName () const; //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; //---------------------------------- // Access to the file format version //---------------------------------- IMF_EXPORT int version () const; //----------------------------------------------------------- // Set the current frame buffer -- copies the FrameBuffer // object into the InputFile object. // // The current frame buffer is the destination for the pixel // data read from the file. The current frame buffer must be // set at least once before readPixels() is called. // The current frame buffer can be changed after each call // to readPixels(). //----------------------------------------------------------- IMF_EXPORT void setFrameBuffer (const DeepFrameBuffer &frameBuffer); //----------------------------------- // Access to the current frame buffer //----------------------------------- IMF_EXPORT const DeepFrameBuffer & frameBuffer () const; //--------------------------------------------------------------- // Check if the file is complete: // // isComplete() returns true if all pixels in the data window are // present in the input file, or false if any pixels are missing. // (Another program may still be busy writing the file, or file // writing may have been aborted prematurely.) //--------------------------------------------------------------- IMF_EXPORT bool isComplete () const; //--------------------------------------------------------------- // Read pixel data: // // readPixels(s1,s2) reads all scan lines with y coordinates // in the interval [min (s1, s2), max (s1, s2)] from the file, // and stores them in the current frame buffer. // // Both s1 and s2 must be within the interval // [header().dataWindow().min.y, header.dataWindow().max.y] // // The scan lines can be read from the file in random order, and // individual scan lines may be skipped or read multiple times. // For maximum efficiency, the scan lines should be read in the // order in which they were written to the file. // // readPixels(s) calls readPixels(s,s). // // If threading is enabled, readPixels (s1, s2) tries to perform // decopmression of multiple scanlines in parallel. // //--------------------------------------------------------------- IMF_EXPORT void readPixels (int scanLine1, int scanLine2); IMF_EXPORT void readPixels (int scanLine); //--------------------------------------------------------------- // Extract pixel data from pre-read block // // readPixels(rawPixelData,frameBuffer,s1,s2) reads all scan lines with y coordinates // in the interval [min (s1, s2), max (s1, s2)] from the data provided and // stores them in the provided frameBuffer. // the data can be obtained from a call to rawPixelData() // // // Both s1 and s2 must be within the data specified // // you must provide a frameBuffer with a samplecountslice, which must have been read // and the data valid - readPixels uses your sample count buffer to compute // offsets to the data it needs // // This call does not block, and is thread safe for clients with an existing // threading model. The InputFile's frameBuffer is not used in this call. // // This call is only provided for clients which have an existing threading model in place // and unpredictable access patterns to the data. // The fastest way to read an entire image is to enable threading,use setFrameBuffer then // readPixels(header().dataWindow().min.y, header.dataWindow().max.y) // //--------------------------------------------------------------- IMF_EXPORT void readPixels (const char * rawPixelData, const DeepFrameBuffer & frameBuffer, int scanLine1, int scanLine2) const; //---------------------------------------------- // Read a block of raw pixel data from the file, // without uncompressing it (this function is // used to implement OutputFile::copyPixels()). // note: returns the entire payload of the relevant chunk of data, not including part number // including compressed and uncompressed sizes // on entry, if pixelDataSize is insufficiently large, no bytes are read (pixelData can safely be NULL) // on exit, pixelDataSize is the number of bytes required to read the chunk // //---------------------------------------------- IMF_EXPORT void rawPixelData (int firstScanLine, char * pixelData, uint64_t &pixelDataSize); //------------------------------------------------- // firstScanLineInChunk() returns the row number of the first row that's stored in the // same chunk as scanline y. Depending on the compression mode, this may not be the same as y // // lastScanLineInChunk() returns the row number of the last row that's stored in the same // chunk as scanline y. Depending on the compression mode, this may not be the same as y. // The last chunk in the file may be smaller than all the others // //------------------------------------------------ IMF_EXPORT int firstScanLineInChunk(int y) const; IMF_EXPORT int lastScanLineInChunk (int y) const; //----------------------------------------------------------- // Read pixel sample counts into a slice in the frame buffer. // // readPixelSampleCounts(s1, s2) reads all the counts of // pixel samples with y coordinates in the interval // [min (s1, s2), max (s1, s2)] from the file, and stores // them in the slice naming "sample count". // // Both s1 and s2 must be within the interval // [header().dataWindow().min.y, header.dataWindow().max.y] // // readPixelSampleCounts(s) calls readPixelSampleCounts(s,s). // //----------------------------------------------------------- IMF_EXPORT void readPixelSampleCounts (int scanline1, int scanline2); IMF_EXPORT void readPixelSampleCounts (int scanline); //---------------------------------------------------------- // Read pixel sample counts into the provided frameBuffer // using a block read of data read by rawPixelData // for multi-scanline compression schemes, you must decode the entire block // so scanline1=firstScanLineInChunk(y) and scanline2=lastScanLineInChunk(y) // // This call does not block, and is thread safe for clients with an existing // threading model. The InputFile's frameBuffer is not used in this call. // // The fastest way to read an entire image is to enable threading in OpenEXR, use setFrameBuffer then // readPixelSampleCounts(header().dataWindow().min.y, header.dataWindow().max.y) // //---------------------------------------------------------- IMF_EXPORT void readPixelSampleCounts (const char * rawdata , const DeepFrameBuffer & frameBuffer, int scanLine1 , int scanLine2) const; struct IMF_HIDDEN Data; private: Data * _data; DeepScanLineInputFile (InputPartData* part); void initialize(const Header& header); void compatibilityInitialize(OPENEXR_IMF_INTERNAL_NAMESPACE::IStream & is); void multiPartInitialize(InputPartData* part); friend class InputFile; friend class MultiPartInputFile; friend void DeepScanLineOutputFile::copyPixels(DeepScanLineInputFile &); }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[C��b b IlmThreadExport.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_ILMTHREADEXPORT_H #define INCLUDED_ILMTHREADEXPORT_H #include "OpenEXRConfig.h" // See docs/SymbolVisibility.md for more discussion /// \addtogroup ExportMacros /// @{ // are we making a DLL under windows (might be msvc or mingw or others) #if defined(OPENEXR_DLL) // when building as a DLL for windows, typical dllexport / import case // where we need to switch depending on whether we are compiling // internally or not # if defined(ILMTHREAD_EXPORTS) # define ILMTHREAD_EXPORT __declspec(dllexport) # else # define ILMTHREAD_EXPORT __declspec(dllimport) # endif // DLLs don't support these types of visibility controls, just leave them as empty # define ILMTHREAD_EXPORT_TYPE # define ILMTHREAD_HIDDEN #else // OPENEXR_DLL // just pass these through from the top level config # define ILMTHREAD_EXPORT OPENEXR_EXPORT # define ILMTHREAD_HIDDEN OPENEXR_HIDDEN # define ILMTHREAD_EXPORT_TYPE OPENEXR_EXPORT_TYPE #endif // OPENEXR_DLL /// @} #endif // INCLUDED_ILMTHREADEXPORT_H PK rM�[3ܝgo o ImfFloatVectorAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Weta Digital, Ltd and Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_FLOATVECTOR_ATTRIBUTE_H #define INCLUDED_IMF_FLOATVECTOR_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class FloatVectorAttribute // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" #include <vector> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef std::vector<float> FloatVector; typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::FloatVector> FloatVectorAttribute; #ifndef COMPILING_IMF_FLOAT_VECTOR_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<FloatVector>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[#�)�Q6 Q6 ImfDeepTiledOutputPart.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef IMFDEEPTILEDOUTPUTPART_H_ #define IMFDEEPTILEDOUTPUTPART_H_ #include "ImfForward.h" #include "ImfTileDescription.h" #include <ImathBox.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE DeepTiledOutputPart { public: IMF_EXPORT DeepTiledOutputPart(MultiPartOutputFile& multiPartFile, int partNumber); //------------------------ // Access to the file name //------------------------ IMF_EXPORT const char * fileName () const; //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; //------------------------------------------------------- // Set the current frame buffer -- copies the FrameBuffer // object into the TiledOutputFile object. // // The current frame buffer is the source of the pixel // data written to the file. The current frame buffer // must be set at least once before writeTile() is // called. The current frame buffer can be changed // after each call to writeTile(). //------------------------------------------------------- IMF_EXPORT void setFrameBuffer (const DeepFrameBuffer &frameBuffer); //----------------------------------- // Access to the current frame buffer //----------------------------------- IMF_EXPORT const DeepFrameBuffer & frameBuffer () const; //------------------- // Utility functions: //------------------- //--------------------------------------------------------- // Multiresolution mode and tile size: // The following functions return the xSize, ySize and mode // fields of the file header's TileDescriptionAttribute. //--------------------------------------------------------- IMF_EXPORT unsigned int tileXSize () const; IMF_EXPORT unsigned int tileYSize () const; IMF_EXPORT LevelMode levelMode () const; IMF_EXPORT LevelRoundingMode levelRoundingMode () const; //-------------------------------------------------------------------- // Number of levels: // // numXLevels() returns the file's number of levels in x direction. // // if levelMode() == ONE_LEVEL: // return value is: 1 // // if levelMode() == MIPMAP_LEVELS: // return value is: rfunc (log (max (w, h)) / log (2)) + 1 // // if levelMode() == RIPMAP_LEVELS: // return value is: rfunc (log (w) / log (2)) + 1 // // where // w is the width of the image's data window, max.x - min.x + 1, // y is the height of the image's data window, max.y - min.y + 1, // and rfunc(x) is either floor(x), or ceil(x), depending on // whether levelRoundingMode() returns ROUND_DOWN or ROUND_UP. // // numYLevels() returns the file's number of levels in y direction. // // if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS: // return value is the same as for numXLevels() // // if levelMode() == RIPMAP_LEVELS: // return value is: rfunc (log (h) / log (2)) + 1 // // // numLevels() is a convenience function for use with MIPMAP_LEVELS // files. // // if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS: // return value is the same as for numXLevels() // // if levelMode() == RIPMAP_LEVELS: // an IEX_NAMESPACE::LogicExc exception is thrown // // isValidLevel(lx, ly) returns true if the file contains // a level with level number (lx, ly), false if not. // //-------------------------------------------------------------------- IMF_EXPORT int numLevels () const; IMF_EXPORT int numXLevels () const; IMF_EXPORT int numYLevels () const; IMF_EXPORT bool isValidLevel (int lx, int ly) const; //--------------------------------------------------------- // Dimensions of a level: // // levelWidth(lx) returns the width of a level with level // number (lx, *), where * is any number. // // return value is: // max (1, rfunc (w / pow (2, lx))) // // // levelHeight(ly) returns the height of a level with level // number (*, ly), where * is any number. // // return value is: // max (1, rfunc (h / pow (2, ly))) // //--------------------------------------------------------- IMF_EXPORT int levelWidth (int lx) const; IMF_EXPORT int levelHeight (int ly) const; //---------------------------------------------------------- // Number of tiles: // // numXTiles(lx) returns the number of tiles in x direction // that cover a level with level number (lx, *), where * is // any number. // // return value is: // (levelWidth(lx) + tileXSize() - 1) / tileXSize() // // // numYTiles(ly) returns the number of tiles in y direction // that cover a level with level number (*, ly), where * is // any number. // // return value is: // (levelHeight(ly) + tileXSize() - 1) / tileXSize() // //---------------------------------------------------------- IMF_EXPORT int numXTiles (int lx = 0) const; IMF_EXPORT int numYTiles (int ly = 0) const; //--------------------------------------------------------- // Level pixel ranges: // // dataWindowForLevel(lx, ly) returns a 2-dimensional // region of valid pixel coordinates for a level with // level number (lx, ly) // // return value is a Box2i with min value: // (dataWindow.min.x, dataWindow.min.y) // // and max value: // (dataWindow.min.x + levelWidth(lx) - 1, // dataWindow.min.y + levelHeight(ly) - 1) // // dataWindowForLevel(level) is a convenience function used // for ONE_LEVEL and MIPMAP_LEVELS files. It returns // dataWindowForLevel(level, level). // //--------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int lx, int ly) const; //------------------------------------------------------------------- // Tile pixel ranges: // // dataWindowForTile(dx, dy, lx, ly) returns a 2-dimensional // region of valid pixel coordinates for a tile with tile coordinates // (dx,dy) and level number (lx, ly). // // return value is a Box2i with min value: // (dataWindow.min.x + dx * tileXSize(), // dataWindow.min.y + dy * tileYSize()) // // and max value: // (dataWindow.min.x + (dx + 1) * tileXSize() - 1, // dataWindow.min.y + (dy + 1) * tileYSize() - 1) // // dataWindowForTile(dx, dy, level) is a convenience function // used for ONE_LEVEL and MIPMAP_LEVELS files. It returns // dataWindowForTile(dx, dy, level, level). // //------------------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int lx, int ly) const; //------------------------------------------------------------------ // Write pixel data: // // writeTile(dx, dy, lx, ly) writes the tile with tile // coordinates (dx, dy), and level number (lx, ly) to // the file. // // dx must lie in the interval [0, numXTiles(lx) - 1] // dy must lie in the interval [0, numYTiles(ly) - 1] // // lx must lie in the interval [0, numXLevels() - 1] // ly must lie in the inverval [0, numYLevels() - 1] // // writeTile(dx, dy, level) is a convenience function // used for ONE_LEVEL and MIPMAP_LEVEL files. It calls // writeTile(dx, dy, level, level). // // The two writeTiles(dx1, dx2, dy1, dy2, ...) functions allow // writing multiple tiles at once. If multi-threading is used // multiple tiles are written concurrently. The tile coordinates, // dx1, dx2 and dy1, dy2, specify inclusive ranges of tile // coordinates. It is valid for dx1 < dx2 or dy1 < dy2; the // tiles are always written in the order specified by the line // order attribute. Hence, it is not possible to specify an // "invalid" or empty tile range. // // Pixels that are outside the pixel coordinate range for the tile's // level, are never accessed by writeTile(). // // Each tile in the file must be written exactly once. // // The file's line order attribute determines the order of the tiles // in the file: // // INCREASING_Y In the file, the tiles for each level are stored // in a contiguous block. The levels are ordered // like this: // // (0, 0) (1, 0) ... (nx-1, 0) // (0, 1) (1, 1) ... (nx-1, 1) // ... // (0,ny-1) (1,ny-1) ... (nx-1,ny-1) // // where nx = numXLevels(), and ny = numYLevels(). // In an individual level, (lx, ly), the tiles // are stored in the following order: // // (0, 0) (1, 0) ... (tx-1, 0) // (0, 1) (1, 1) ... (tx-1, 1) // ... // (0,ty-1) (1,ty-1) ... (tx-1,ty-1) // // where tx = numXTiles(lx), // and ty = numYTiles(ly). // // DECREASING_Y As for INCREASING_Y, the tiles for each level // are stored in a contiguous block. The levels // are ordered the same way as for INCREASING_Y, // but within an individual level, the tiles // are stored in this order: // // (0,ty-1) (1,ty-1) ... (tx-1,ty-1) // ... // (0, 1) (1, 1) ... (tx-1, 1) // (0, 0) (1, 0) ... (tx-1, 0) // // // RANDOM_Y The order of the calls to writeTile() determines // the order of the tiles in the file. // //------------------------------------------------------------------ IMF_EXPORT void writeTile (int dx, int dy, int l = 0); IMF_EXPORT void writeTile (int dx, int dy, int lx, int ly); IMF_EXPORT void writeTiles (int dx1, int dx2, int dy1, int dy2, int lx, int ly); IMF_EXPORT void writeTiles (int dx1, int dx2, int dy1, int dy2, int l = 0); //------------------------------------------------------------------ // Shortcut to copy all pixels from a TiledInputFile into this file, // without uncompressing and then recompressing the pixel data. // This file's header must be compatible with the TiledInputFile's // header: The two header's "dataWindow", "compression", // "lineOrder", "channels", and "tiles" attributes must be the same. //------------------------------------------------------------------ IMF_EXPORT void copyPixels (DeepTiledInputFile &in); IMF_EXPORT void copyPixels (DeepTiledInputPart &in); //-------------------------------------------------------------- // Updating the preview image: // // updatePreviewImage() supplies a new set of pixels for the // preview image attribute in the file's header. If the header // does not contain a preview image, updatePreviewImage() throws // an IEX_NAMESPACE::LogicExc. // // Note: updatePreviewImage() is necessary because images are // often stored in a file incrementally, a few tiles at a time, // while the image is being generated. Since the preview image // is an attribute in the file's header, it gets stored in the // file as soon as the file is opened, but we may not know what // the preview image should look like until we have written the // last tile of the main image. // //-------------------------------------------------------------- IMF_EXPORT void updatePreviewImage (const PreviewRgba newPixels[]); //------------------------------------------------------------- // Break a tile -- for testing and debugging only: // // breakTile(dx,dy,lx,ly,p,n,c) introduces an error into the // output file by writing n copies of character c, starting // p bytes from the beginning of the tile with tile coordinates // (dx, dy) and level number (lx, ly). // // Warning: Calling this function usually results in a broken // image file. The file or parts of it may not be readable, // or the file may contain bad data. // //------------------------------------------------------------- IMF_EXPORT void breakTile (int dx, int dy, int lx, int ly, int offset, int length, char c); private: DeepTiledOutputFile* file; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif /* IMFDEEPTILEDOUTPUTPART_H_ */ PK rM�[%�]� openexr_conf.hnu �[��� /* ** SPDX-License-Identifier: BSD-3-Clause ** Copyright Contributors to the OpenEXR Project. */ #ifndef OPENEXR_CONF_H #define OPENEXR_CONF_H #pragma once #include "OpenEXRConfig.h" /// \addtogroup ExportMacros /// @{ // are we making a DLL under windows (might be msvc or mingw or others) #if defined(OPENEXR_DLL) // when building as a DLL for windows, typical dllexport / import case // where we need to switch depending on whether we are compiling // internally or not # if defined(OPENEXRCORE_EXPORTS) # define EXR_EXPORT __declspec(dllexport) # else # define EXR_EXPORT __declspec(dllimport) # endif #else # define EXR_EXPORT OPENEXR_EXPORT #endif /* * MSVC does have printf format checks, but it is not in the form of a * function attribute, so just skip for non-GCC / clang builds */ #if defined(__GNUC__) || defined(__clang__) # define EXR_PRINTF_FUNC_ATTRIBUTE __attribute__ ((format (printf, 3, 4))) #else # define EXR_PRINTF_FUNC_ATTRIBUTE #endif /// @} #endif /* OPENEXR_CONF_H */ PK rM�[i Ms; ; ImfInputFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_INPUT_FILE_H #define INCLUDED_IMF_INPUT_FILE_H //----------------------------------------------------------------------------- // // class InputFile -- a scanline-based interface that can be used // to read both scanline-based and tiled OpenEXR image files. // //----------------------------------------------------------------------------- #include "ImfForward.h" #include "ImfGenericInputFile.h" #include "ImfThreading.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE InputFile : public GenericInputFile { public: //----------------------------------------------------------- // A constructor that opens the file with the specified name. // Destroying the InputFile object will close the file. // // numThreads determines the number of threads that will be // used to read the file (see ImfThreading.h). //----------------------------------------------------------- IMF_EXPORT InputFile (const char fileName[], int numThreads = globalThreadCount()); //------------------------------------------------------------- // A constructor that attaches the new InputFile object to a // file that has already been opened. Destroying the InputFile // object will not close the file. // // numThreads determines the number of threads that will be // used to read the file (see ImfThreading.h). //------------------------------------------------------------- IMF_EXPORT InputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int numThreads = globalThreadCount()); //----------- // Destructor //----------- IMF_EXPORT virtual ~InputFile (); //------------------------ // Access to the file name //------------------------ IMF_EXPORT const char * fileName () const; //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; //---------------------------------- // Access to the file format version //---------------------------------- IMF_EXPORT int version () const; //----------------------------------------------------------- // Set the current frame buffer -- copies the FrameBuffer // object into the InputFile object. // // The current frame buffer is the destination for the pixel // data read from the file. The current frame buffer must be // set at least once before readPixels() is called. // The current frame buffer can be changed after each call // to readPixels(). //----------------------------------------------------------- IMF_EXPORT void setFrameBuffer (const FrameBuffer &frameBuffer); //----------------------------------- // Access to the current frame buffer //----------------------------------- IMF_EXPORT const FrameBuffer & frameBuffer () const; //--------------------------------------------------------------- // Check if the file is complete: // // isComplete() returns true if all pixels in the data window are // present in the input file, or false if any pixels are missing. // (Another program may still be busy writing the file, or file // writing may have been aborted prematurely.) //--------------------------------------------------------------- IMF_EXPORT bool isComplete () const; //--------------------------------------------------------------- // Check if SSE optimization is enabled // // Call after setFrameBuffer() to query whether optimized file decoding // is available - decode times will be faster if returns true // // Optimization depends on: // the file type (only scanline data is supported), // the framebuffer channels (RGB/RGBA mono or stereo) // the framebuffer channel types (all channels half-float format only) // the file channels (RGB/RGBA mono or stereo) // the file channel types (all channel half-float format only) // whether SSE2 instruction support was detected at compile time // // Calling isOptimizationEnabled before setFrameBuffer will throw an exception // //--------------------------------------------------------------- IMF_EXPORT bool isOptimizationEnabled () const; //--------------------------------------------------------------- // Read pixel data: // // readPixels(s1,s2) reads all scan lines with y coordinates // in the interval [min (s1, s2), max (s1, s2)] from the file, // and stores them in the current frame buffer. // // Both s1 and s2 must be within the interval // [header().dataWindow().min.y, header().dataWindow().max.y] // // The scan lines can be read from the file in random order, and // individual scan lines may be skipped or read multiple times. // For maximum efficiency, the scan lines should be read in the // order in which they were written to the file. // // readPixels(s) calls readPixels(s,s). // //--------------------------------------------------------------- IMF_EXPORT void readPixels (int scanLine1, int scanLine2); IMF_EXPORT void readPixels (int scanLine); //---------------------------------------------- // Read a block of raw pixel data from the file, // without uncompressing it (this function is // used to implement OutputFile::copyPixels()). //---------------------------------------------- IMF_EXPORT void rawPixelData (int firstScanLine, const char *&pixelData, int &pixelDataSize); //---------------------------------------------- // Read a scanline's worth of raw pixel data // from the file, without uncompressing it, and // store in an external buffer, pixelData. // pixelData should be pre-allocated with space // for pixelDataSize chars. // // This function can be used to separate the // reading of a raw scan line from the // decompression of that scan line, for // example to allow multiple scan lines to be // decompressed in parallel by an application's // own threads, where it is not convenient to // use the threading within the library. //---------------------------------------------- IMF_EXPORT void rawPixelDataToBuffer (int scanLine, char *pixelData, int &pixelDataSize) const; //-------------------------------------------------- // Read a tile of raw pixel data from the file, // without uncompressing it (this function is // used to implement TiledOutputFile::copyPixels()). //-------------------------------------------------- IMF_EXPORT void rawTileData (int &dx, int &dy, int &lx, int &ly, const char *&pixelData, int &pixelDataSize); struct IMF_HIDDEN Data; private: IMF_HIDDEN InputFile (InputPartData* part); InputFile (const InputFile &) = delete; InputFile & operator = (const InputFile &) = delete; InputFile (InputFile &&) = delete; InputFile & operator = (InputFile &&) = delete; IMF_HIDDEN void initialize (); IMF_HIDDEN void multiPartInitialize(InputPartData* part); IMF_HIDDEN void compatibilityInitialize(OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is); IMF_HIDDEN TiledInputFile * tFile (); // for copyPixels friend class TiledOutputFile; Data * _data; friend class MultiPartInputFile; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[��CV V ImfDeepImageIO.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_DEEP_IMAGE_IO_H #define INCLUDED_IMF_DEEP_IMAGE_IO_H //---------------------------------------------------------------------------- // // Functions to load deep images from OpenEXR files // and to save deep images in OpenEXR files. // //---------------------------------------------------------------------------- #include "ImfUtilExport.h" #include "ImfNamespace.h" #include "ImfDeepImage.h" #include "ImfImageDataWindow.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER // // saveDeepImage (n, h, i,d) or // saveDeepImage (n, i) // // Saves image i in an OpenEXR file with name n. The file will be // tiled if the image has more than one level, or if a header, h, is // given and contains a tile description attribute; otherwise the // file will be scan-line based. // // If header h is given, then the channel list in h is replaced with // the channel list in i, and the levelMode and the levelRounding mode // fields of the tile description are replaced with the level mode // and the levelRounding mode of i. In addition, if the data window // source flag, d, is set to USE_IMAGE_DATA_WINDOW, then the data // window in the image is copied into the header; if d is set to // USE_HEADER_DATA_WINDOW, then the data window in the header is // replaced with the intersection of the original data window in the // header and the data window in the image. The modified header then // becomes the header of the image file. // IMFUTIL_EXPORT void saveDeepImage (const std::string &fileName, const Header &hdr, const DeepImage &img, DataWindowSource dws = USE_IMAGE_DATA_WINDOW); IMFUTIL_EXPORT void saveDeepImage (const std::string &fileName, const DeepImage &img); // // loadDeepImage (n, h, i) or // loadDeepImage (n, i) // // Loads deep image i from the OpenEXR file with name n. // // If header h is given, then the header of the file is copied into h. // IMFUTIL_EXPORT void loadDeepImage (const std::string &fileName, Header &hdr, DeepImage &img); IMFUTIL_EXPORT void loadDeepImage (const std::string &fileName, DeepImage &img); // // saveDeepScanLineImage (n, h, i, d) or // saveDeepScanLineImage (n, i) // // Saves image i in a scan-line based deep OpenEXR file with file name n. // // If header h is given, then the channel list in h is replaced with // the channel list in i. In addition, if the data window source flag, d, // is set to USE_IMAGE_DATA_WINDOW, then the data window in the image is // copied into the header; if d is set to USE_HEADER_DATA_WINDOW, then // the data window in the header is replaced with the intersection of // the original data window in the header and the data window in the // image. The modified header then becomes the header of the image file. // IMFUTIL_EXPORT void saveDeepScanLineImage (const std::string &fileName, const Header &hdr, const DeepImage &img, DataWindowSource dws = USE_IMAGE_DATA_WINDOW); IMFUTIL_EXPORT void saveDeepScanLineImage (const std::string &fileName, const DeepImage &img); // // loadDeepScanLineImage (n, h, i) or // loadDeepScanLineImage (n, i) // // Loads image i from a scan-line based deep OpenEXR file with file name n. // If header h is given, then the header of the file is copied into h. // IMFUTIL_EXPORT void loadDeepScanLineImage (const std::string &fileName, Header &hdr, DeepImage &img); IMFUTIL_EXPORT void loadDeepScanLineImage (const std::string &fileName, DeepImage &img); // // saveDeepTiledImage (n, h, i, d) or // saveDeepTiledImage (n, i) // // Saves image i in a tiled deep OpenEXR file with file name n. // // If header h is given, then the channel list in h is replaced with // the channel list i, and the levelMode and the levelRounding mode // fields of the tile description are replaced with the level mode // and the levelRounding mode of i. In addition, if the data window // source flag, d, is set to USE_IMAGE_DATA_WINDOW, then the data // window in the image is copied into the header; if d is set to // USE_HEADER_DATA_WINDOW, then the data window in the header is // replaced with the intersection of the original data window in the // header and the data window in the image. The modified header then // becomes the header of the image file. // // Note: USE_HEADER_DATA_WINDOW can only be used for images with // level mode ONE_LEVEL. // IMFUTIL_EXPORT void saveDeepTiledImage (const std::string &fileName, const Header &hdr, const DeepImage &img, DataWindowSource dws = USE_IMAGE_DATA_WINDOW); IMFUTIL_EXPORT void saveDeepTiledImage (const std::string &fileName, const DeepImage &img); // // loadDeepTiledImage (n, h, i) or // loadDeepTiledImage (n, i) // // Loads image i from a tiled deep OpenEXR file with file name n. // If header h is given, then the header of the file is copied into h. // IMFUTIL_EXPORT void loadDeepTiledImage (const std::string &fileName, Header &hdr, DeepImage &img); IMFUTIL_EXPORT void loadDeepTiledImage (const std::string &fileName, DeepImage &img); OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[ﲠc� � ImfImageChannel.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_IMAGE_CHANNEL_H #define INCLUDED_IMF_IMAGE_CHANNEL_H //---------------------------------------------------------------------------- // // class ImageChannel // // For an explanation of images, levels and channels, // see the comments in header file Image.h. // //---------------------------------------------------------------------------- #include "ImfUtilExport.h" #include "ImfPixelType.h" #include "ImfFrameBuffer.h" #include "ImfChannelList.h" #include "IexBaseExc.h" #include <ImathBox.h> #include <half.h> #include <typeinfo> #include <cstring> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class ImageLevel; // // Image channels: // // An image channel holds the pixel data for a single channel of one level // of an image. Separate classes for flat and deep channels are derived // from the ImageChannel base class. // class ImageLevel; class IMFUTIL_EXPORT_TYPE ImageChannel { public: // // The OpenEXR pixel type of this channel (HALF, FLOAT or UINT). // virtual PixelType pixelType () const = 0; // // Generate an OpenEXR channel for this image channel. // IMFUTIL_EXPORT Channel channel () const; // // Access to x and y sampling rates, "perceptually linear" flag, // and the number of pixels that are stored in this channel. // int xSampling () const {return _xSampling;} int ySampling () const {return _ySampling;} bool pLinear () const {return _pLinear;} int pixelsPerRow () const {return _pixelsPerRow;} int pixelsPerColumn () const {return _pixelsPerColumn;} size_t numPixels () const {return _numPixels;} // // Access to the image level to which this channel belongs. // ImageLevel & level () {return _level;} const ImageLevel & level () const {return _level;} protected: IMFUTIL_EXPORT ImageChannel (ImageLevel &level, int xSampling, int ySampling, bool pLinear); IMFUTIL_EXPORT virtual ~ImageChannel(); IMFUTIL_EXPORT virtual void resize (); IMFUTIL_EXPORT void boundsCheck(int x, int y) const; private: ImageChannel (const ImageChannel &) = delete; ImageChannel & operator = (const ImageChannel &) = delete; ImageChannel (ImageChannel &&) = delete; ImageChannel & operator = (ImageChannel &&) = delete; ImageLevel & _level; int _xSampling; int _ySampling; bool _pLinear; int _pixelsPerRow; int _pixelsPerColumn; size_t _numPixels; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�=c1[? [? openexr_attr.hnu �[��� /* ** SPDX-License-Identifier: BSD-3-Clause ** Copyright Contributors to the OpenEXR Project. */ #ifndef OPENEXR_ATTR_H #define OPENEXR_ATTR_H #include "openexr_context.h" #include <stddef.h> #include <stdint.h> #ifdef __cplusplus extern "C" { #endif /** * @defgroup AttributeTypes Attribute / metadata value types and struct declarations * * @brief These are a group of enum values defining valid values for * some attributes and then associated structs for other types. * * Some of these types will be directly representable / storable in * the file, some not. There is some overlap here with Imath, and they * should be kept in the same order for compatibility. However do note * that these are just the raw data, and no useful functions are * declared at this layer, that is what Imath is for. * * @{ */ /** enum declaring allowed values for uint8_t value stored in built-in compression type */ typedef enum { EXR_COMPRESSION_NONE = 0, EXR_COMPRESSION_RLE = 1, EXR_COMPRESSION_ZIPS = 2, EXR_COMPRESSION_ZIP = 3, EXR_COMPRESSION_PIZ = 4, EXR_COMPRESSION_PXR24 = 5, EXR_COMPRESSION_B44 = 6, EXR_COMPRESSION_B44A = 7, EXR_COMPRESSION_DWAA = 8, EXR_COMPRESSION_DWAB = 9, EXR_COMPRESSION_LAST_TYPE /**< invalid value, provided for range checking */ } exr_compression_t; /** enum declaring allowed values for uint8_t value stored in built-in env map type */ typedef enum { EXR_ENVMAP_LATLONG = 0, EXR_ENVMAP_CUBE = 1, EXR_ENVMAP_LAST_TYPE /**< invalid value, provided for range checking */ } exr_envmap_t; /** enum declaring allowed values for uint8_t value stored in lineOrder type */ typedef enum { EXR_LINEORDER_INCREASING_Y = 0, EXR_LINEORDER_DECREASING_Y = 1, EXR_LINEORDER_RANDOM_Y = 2, EXR_LINEORDER_LAST_TYPE /**< invalid value, provided for range checking */ } exr_lineorder_t; /** enum declaring allowed values for part type */ typedef enum { EXR_STORAGE_SCANLINE = 0, /**< corresponds to type of 'scanlineimage' */ EXR_STORAGE_TILED, /**< corresponds to type of 'tiledimage' */ EXR_STORAGE_DEEP_SCANLINE, /**< corresponds to type of 'deepscanline' */ EXR_STORAGE_DEEP_TILED, /**< corresponds to type of 'deeptile' */ EXR_STORAGE_LAST_TYPE /**< invalid value, provided for range checking */ } exr_storage_t; /** @brief Enum representing what type of tile information is contained */ typedef enum { EXR_TILE_ONE_LEVEL = 0, /**< single level of image data */ EXR_TILE_MIPMAP_LEVELS = 1, /**< mipmapped image data */ EXR_TILE_RIPMAP_LEVELS = 2, /**< ripmapped image data */ EXR_TILE_LAST_TYPE /**< guard / out of range type */ } exr_tile_level_mode_t; /** @brief Enum representing how to scale positions between levels */ typedef enum { EXR_TILE_ROUND_DOWN = 0, EXR_TILE_ROUND_UP = 1, EXR_TILE_ROUND_LAST_TYPE } exr_tile_round_mode_t; /** @brief Enum capturing the underlying data type on a channel */ typedef enum { EXR_PIXEL_UINT = 0, EXR_PIXEL_HALF = 1, EXR_PIXEL_FLOAT = 2, EXR_PIXEL_LAST_TYPE } exr_pixel_type_t; /* /////////////////////////////////////// */ /* First set of structs are data where we can read directly with no allocation needed... */ /* Most are naturally aligned, but force some of these * structs to be tightly packed */ #pragma pack(push, 1) /** @brief struct to hold color chromaticities to interpret the tristimulus color values in the image data */ typedef struct { float red_x; float red_y; float green_x; float green_y; float blue_x; float blue_y; float white_x; float white_y; } exr_attr_chromaticities_t; /** @brief struct to hold keycode information */ typedef struct { int32_t film_mfc_code; int32_t film_type; int32_t prefix; int32_t count; int32_t perf_offset; int32_t perfs_per_frame; int32_t perfs_per_count; } exr_attr_keycode_t; /** @brief struct to hold a 32-bit floating-point 3x3 matrix */ typedef struct { float m[9]; } exr_attr_m33f_t; /** @brief struct to hold a 64-bit floating-point 3x3 matrix */ typedef struct { double m[9]; } exr_attr_m33d_t; /** @brief struct to hold a 32-bit floating-point 4x4 matrix */ typedef struct { float m[16]; } exr_attr_m44f_t; /** @brief struct to hold a 64-bit floating-point 4x4 matrix */ typedef struct { double m[16]; } exr_attr_m44d_t; /** @brief struct to hold an integer ratio value */ typedef struct { int32_t num; uint32_t denom; } exr_attr_rational_t; /** @brief struct to hold timecode information */ typedef struct { uint32_t time_and_flags; uint32_t user_data; } exr_attr_timecode_t; /** @brief struct to hold a 2-element integer vector */ typedef struct { union { struct { int32_t x, y; }; int32_t arr[2]; }; } exr_attr_v2i_t; /** @brief struct to hold a 2-element 32-bit float vector */ typedef struct { union { struct { float x, y; }; float arr[2]; }; } exr_attr_v2f_t; /** @brief struct to hold a 2-element 64-bit float vector */ typedef struct { union { struct { double x, y; }; double arr[2]; }; } exr_attr_v2d_t; /** @brief struct to hold a 3-element integer vector */ typedef struct { union { struct { int32_t x, y, z; }; int32_t arr[3]; }; } exr_attr_v3i_t; /** @brief struct to hold a 3-element 32-bit float vector */ typedef struct { union { struct { float x, y, z; }; float arr[3]; }; } exr_attr_v3f_t; /** @brief struct to hold a 3-element 64-bit float vector */ typedef struct { union { struct { double x, y, z; }; double arr[3]; }; } exr_attr_v3d_t; /** @brief struct to hold an integer box / region definition */ typedef struct { exr_attr_v2i_t min; exr_attr_v2i_t max; } exr_attr_box2i_t; /** @brief struct to hold a floating-point box / region definition */ typedef struct { exr_attr_v2f_t min; exr_attr_v2f_t max; } exr_attr_box2f_t; /** @brief Struct holding base tiledesc attribute type defined in spec * * NB: this is in a tightly packed area so it can be read directly, be * careful it doesn't become padded to the next uint32_t boundary */ typedef struct { uint32_t x_size; uint32_t y_size; uint8_t level_and_round; } exr_attr_tiledesc_t; /** @brief macro to access type of tiling from packed structure */ #define EXR_GET_TILE_LEVEL_MODE(tiledesc) \ ((exr_tile_level_mode_t) (((tiledesc).level_and_round) & 0xF)) /** @brief macro to access the rounding mode of tiling from packed structure */ #define EXR_GET_TILE_ROUND_MODE(tiledesc) \ ((exr_tile_round_mode_t) ((((tiledesc).level_and_round) >> 4) & 0xF)) /** @brief macro to pack the tiling type and rounding mode into packed structure */ #define EXR_PACK_TILE_LEVEL_ROUND(lvl, mode) \ ((uint8_t) ((((uint8_t) ((mode) &0xF) << 4)) | ((uint8_t) ((lvl) &0xF)))) #pragma pack(pop) /* /////////////////////////////////////// */ /* Now structs that involve heap allocation to store data. */ /** Storage for a string */ typedef struct { int32_t length; /** if this is non-zero, the string owns the data, if 0, is a const ref to a static string */ int32_t alloc_size; const char* str; } exr_attr_string_t; /** storage for a string vector */ typedef struct { int32_t n_strings; /** if this is non-zero, the string vector owns the data, if 0, is a const ref */ int32_t alloc_size; const exr_attr_string_t* strings; } exr_attr_string_vector_t; /** float vector storage struct */ typedef struct { int32_t length; /** if this is non-zero, the float vector owns the data, if 0, is a const ref */ int32_t alloc_size; const float* arr; } exr_attr_float_vector_t; /** Hint for lossy compression methods about how to treat values * (logarithmic or linear), meaning a human sees values like R, G, B, * luminance difference between 0.1 and 0.2 as about the same as 1.0 * to 2.0 (logarithmic), where chroma coordinates are closer to linear * (0.1 and 0.2 is about the same difference as 1.0 and 1.1) */ typedef enum { EXR_PERCEPTUALLY_LOGARITHMIC = 0, EXR_PERCEPTUALLY_LINEAR = 1 } exr_perceptual_treatment_t; /** Individual channel information*/ typedef struct { exr_attr_string_t name; /** Data representation for these pixels: uint, half, float */ exr_pixel_type_t pixel_type; /** Possible values are 0 and 1 per docs \ref exr_perceptual_treatment_t */ uint8_t p_linear; uint8_t reserved[3]; int32_t x_sampling; int32_t y_sampling; } exr_attr_chlist_entry_t; /** List of channel information (sorted alphabetically) */ typedef struct { int num_channels; int num_alloced; const exr_attr_chlist_entry_t* entries; } exr_attr_chlist_t; /** @brief Struct to define attributes of an embedded preview image */ typedef struct { uint32_t width; uint32_t height; /** if this is non-zero, the preview owns the data, if 0, is a const ref */ size_t alloc_size; const uint8_t* rgba; } exr_attr_preview_t; /** Custom storage structure for opaque data * * Handlers for opaque types can be registered, then when a * non-builtin type is encountered with a registered handler, the * function pointers to unpack / pack it will be set up. * * @sa exr_register_attr_type_handler */ typedef struct { int32_t size; int32_t unpacked_size; /** if this is non-zero, the struct owns the data, if 0, is a const ref */ int32_t packed_alloc_size; uint8_t pad[4]; void* packed_data; /** when an application wants to have custom data, they can store an unpacked form here which will * be requested to be destroyed upon destruction of the attribute */ void* unpacked_data; /* an application can register an attribute handler which then * fills in these function pointers. This allows a user to delay * the expansion of the custom type until access is desired, and * similarly, to delay the packing of the data until write time */ exr_result_t (*unpack_func_ptr) ( exr_context_t ctxt, const void* data, int32_t attrsize, int32_t* outsize, void** outbuffer); exr_result_t (*pack_func_ptr) ( exr_context_t ctxt, const void* data, int32_t datasize, int32_t* outsize, void* outbuffer); void (*destroy_unpacked_func_ptr) ( exr_context_t ctxt, void* data, int32_t attrsize); } exr_attr_opaquedata_t; /* /////////////////////////////////////// */ /** @brief built-in / native attribute type enum * * This will enable us to do a tagged type struct to generically store * attributes. */ typedef enum { EXR_ATTR_UNKNOWN = 0, /**< type indicating an error or uninitialized attribute */ EXR_ATTR_BOX2I, /**< integer region definition. @see exr_box2i */ EXR_ATTR_BOX2F, /**< float region definition. @see exr_box2f */ EXR_ATTR_CHLIST, /**< Definition of channels in file @see exr_chlist_entry */ EXR_ATTR_CHROMATICITIES, /**< Values to specify color space of colors in file @see exr_attr_chromaticities_t */ EXR_ATTR_COMPRESSION, /**< uint8_t declaring compression present */ EXR_ATTR_DOUBLE, /**< double precision floating point number */ EXR_ATTR_ENVMAP, /**< uint8_t declaring environment map type */ EXR_ATTR_FLOAT, /**< a normal (4 byte) precision floating point number */ EXR_ATTR_FLOAT_VECTOR, /**< a list of normal (4 byte) precision floating point numbers */ EXR_ATTR_INT, /**< a 32-bit signed integer value */ EXR_ATTR_KEYCODE, /**< structure recording keycode @see exr_attr_keycode_t */ EXR_ATTR_LINEORDER, /**< uint8_t declaring scanline ordering */ EXR_ATTR_M33F, /**< 9 32-bit floats representing a 3x3 matrix */ EXR_ATTR_M33D, /**< 9 64-bit floats representing a 3x3 matrix */ EXR_ATTR_M44F, /**< 16 32-bit floats representing a 4x4 matrix */ EXR_ATTR_M44D, /**< 16 64-bit floats representing a 4x4 matrix */ EXR_ATTR_PREVIEW, /**< 2 unsigned ints followed by 4 x w x h uint8_t image */ EXR_ATTR_RATIONAL, /**< int followed by unsigned int */ EXR_ATTR_STRING, /**< int (length) followed by char string data */ EXR_ATTR_STRING_VECTOR, /**< 0 or more text strings (int + string). number is based on attribute size */ EXR_ATTR_TILEDESC, /**< 2 unsigned ints xSize, ySize followed by mode */ EXR_ATTR_TIMECODE, /**< 2 unsigned ints time and flags, user data */ EXR_ATTR_V2I, /**< pair of 32-bit integers */ EXR_ATTR_V2F, /**< pair of 32-bit floats */ EXR_ATTR_V2D, /**< pair of 64-bit floats */ EXR_ATTR_V3I, /**< set of 3 32-bit integers */ EXR_ATTR_V3F, /**< set of 3 32-bit floats */ EXR_ATTR_V3D, /**< set of 3 64-bit floats */ EXR_ATTR_OPAQUE, /**< user / unknown provided type */ EXR_ATTR_LAST_KNOWN_TYPE } exr_attribute_type_t; /** @brief storage, name and type information for an attribute. * * Attributes (metadata) for the file cause a surprising amount of * overhead. It is not uncommon for a production-grade EXR to have * many attributes. As such, the attribute struct is designed in a * slightly more complicated manner. It is optimized to have the * storage for that attribute: the struct itself, the name, the type, * and the data all allocated as one block. Further, the type and * standard names may use a static string to avoid allocating space * for those as necessary with the pointers pointing to static strings * (not to be freed). Finally, small values are optimized for. */ typedef struct { /** name of the attribute */ const char* name; /** string type name of the attribute */ const char* type_name; /** length of name string (short flag is 31 max, long allows 255) */ uint8_t name_length; /** length of type string (short flag is 31 max, long allows 255) */ uint8_t type_name_length; uint8_t pad[2]; /** enum of the attribute type */ exr_attribute_type_t type; /** Union of pointers of different types that can be used to type * pun to an appropriate type for builtins. Do note that while * this looks like a big thing, it is only the size of a single * pointer. these are all pointers into some other data block * storing the value you want, with the exception of the pod types * which are just put in place (i.e. small value optimization) * * The attribute type \ref type should directly correlate to one of * these entries */ union { // NB: not pointers for POD types uint8_t uc; double d; float f; int32_t i; exr_attr_box2i_t* box2i; exr_attr_box2f_t* box2f; exr_attr_chlist_t* chlist; exr_attr_chromaticities_t* chromaticities; exr_attr_keycode_t* keycode; exr_attr_float_vector_t* floatvector; exr_attr_m33f_t* m33f; exr_attr_m33d_t* m33d; exr_attr_m44f_t* m44f; exr_attr_m44d_t* m44d; exr_attr_preview_t* preview; exr_attr_rational_t* rational; exr_attr_string_t* string; exr_attr_string_vector_t* stringvector; exr_attr_tiledesc_t* tiledesc; exr_attr_timecode_t* timecode; exr_attr_v2i_t* v2i; exr_attr_v2f_t* v2f; exr_attr_v2d_t* v2d; exr_attr_v3i_t* v3i; exr_attr_v3f_t* v3f; exr_attr_v3d_t* v3d; exr_attr_opaquedata_t* opaque; uint8_t* rawptr; }; } exr_attribute_t; /** @} */ #ifdef __cplusplus } /* extern "C" */ #endif #endif /* OPENEXR_ATTR_H */ PK rM�[2C'R� � IexNamespace.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IEXNAMESPACE_H #define INCLUDED_IEXNAMESPACE_H // // The purpose of this file is to make it possible to specify an // IEX_INTERNAL_NAMESPACE as a preprocessor definition and have all of the // Iex symbols defined within that namespace rather than the standard // Iex namespace. Those symbols are made available to client code through // the IEX_NAMESPACE in addition to the IEX_INTERNAL_NAMESPACE. // // To ensure source code compatibility, the IEX_NAMESPACE defaults to Iex // and then "using namespace IEX_INTERNAL_NAMESPACE;" brings all of the // declarations from the IEX_INTERNAL_NAMESPACE into the IEX_NAMESPACE. This // means that client code can continue to use syntax like Iex::BaseExc, but // at link time it will resolve to a mangled symbol based on the // IEX_INTERNAL_NAMESPACE. // // As an example, if one needed to build against a newer version of Iex and // have it run alongside an older version in the same application, it is now // possible to use an internal namespace to prevent collisions between the // older versions of Iex symbols and the newer ones. To do this, the // following could be defined at build time: // // IEX_INTERNAL_NAMESPACE = Iex_v2 // // This means that declarations inside Iex headers look like this (after the // preprocessor has done its work): // // namespace Iex_v2 { // ... // class declarations // ... // } // // namespace Iex { // using namespace Iex_v2; // } // // // Open Source version of this file pulls in the IexConfig.h file // for the configure time options. // #include "IexConfig.h" #ifndef IEX_NAMESPACE #define IEX_NAMESPACE Iex #endif #ifndef IEX_INTERNAL_NAMESPACE #define IEX_INTERNAL_NAMESPACE IEX_NAMESPACE #endif // // We need to be sure that we import the internal namespace into the public one. // To do this, we use the small bit of code below which initially defines // IEX_INTERNAL_NAMESPACE (so it can be referenced) and then defines // IEX_NAMESPACE and pulls the internal symbols into the public namespace. // namespace IEX_INTERNAL_NAMESPACE {} namespace IEX_NAMESPACE { using namespace IEX_INTERNAL_NAMESPACE; } // // There are identical pairs of HEADER/SOURCE ENTER/EXIT macros so that // future extension to the namespace mechanism is possible without changing // project source code. // #define IEX_INTERNAL_NAMESPACE_HEADER_ENTER namespace IEX_INTERNAL_NAMESPACE { #define IEX_INTERNAL_NAMESPACE_HEADER_EXIT } #define IEX_INTERNAL_NAMESPACE_SOURCE_ENTER namespace IEX_INTERNAL_NAMESPACE { #define IEX_INTERNAL_NAMESPACE_SOURCE_EXIT } #endif // INCLUDED_IEXNAMESPACE_H PK rM�[�g�2 �2 ImfTiledInputFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_TILED_INPUT_FILE_H #define INCLUDED_IMF_TILED_INPUT_FILE_H //----------------------------------------------------------------------------- // // class TiledInputFile // //----------------------------------------------------------------------------- #include "ImfForward.h" #include "ImfThreading.h" #include "ImfGenericInputFile.h" #include "ImfTileDescription.h" #include <ImathBox.h> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE TiledInputFile : public GenericInputFile { public: //-------------------------------------------------------------------- // A constructor that opens the file with the specified name, and // reads the file header. The constructor throws an IEX_NAMESPACE::ArgExc // exception if the file is not tiled. // The numThreads parameter specifies how many worker threads this // file will try to keep busy when decompressing individual tiles. // Destroying TiledInputFile objects constructed with this constructor // automatically closes the corresponding files. //-------------------------------------------------------------------- IMF_EXPORT TiledInputFile (const char fileName[], int numThreads = globalThreadCount ()); // ---------------------------------------------------------- // A constructor that attaches the new TiledInputFile object // to a file that has already been opened. // Destroying TiledInputFile objects constructed with this // constructor does not automatically close the corresponding // files. // ---------------------------------------------------------- IMF_EXPORT TiledInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int numThreads = globalThreadCount ()); //----------- // Destructor //----------- IMF_EXPORT virtual ~TiledInputFile (); TiledInputFile (const TiledInputFile& other) = delete; TiledInputFile& operator = (const TiledInputFile& other) = delete; TiledInputFile (TiledInputFile&& other) = delete; TiledInputFile& operator = (TiledInputFile&& other) = delete; //------------------------ // Access to the file name //------------------------ IMF_EXPORT const char * fileName () const; //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; //---------------------------------- // Access to the file format version //---------------------------------- IMF_EXPORT int version () const; //----------------------------------------------------------- // Set the current frame buffer -- copies the FrameBuffer // object into the TiledInputFile object. // // The current frame buffer is the destination for the pixel // data read from the file. The current frame buffer must be // set at least once before readTile() is called. // The current frame buffer can be changed after each call // to readTile(). //----------------------------------------------------------- IMF_EXPORT void setFrameBuffer (const FrameBuffer &frameBuffer); //----------------------------------- // Access to the current frame buffer //----------------------------------- IMF_EXPORT const FrameBuffer & frameBuffer () const; //------------------------------------------------------------ // Check if the file is complete: // // isComplete() returns true if all pixels in the data window // (in all levels) are present in the input file, or false if // any pixels are missing. (Another program may still be busy // writing the file, or file writing may have been aborted // prematurely.) //------------------------------------------------------------ IMF_EXPORT bool isComplete () const; //-------------------------------------------------- // Utility functions: //-------------------------------------------------- //--------------------------------------------------------- // Multiresolution mode and tile size: // The following functions return the xSize, ySize and mode // fields of the file header's TileDescriptionAttribute. //--------------------------------------------------------- IMF_EXPORT unsigned int tileXSize () const; IMF_EXPORT unsigned int tileYSize () const; IMF_EXPORT LevelMode levelMode () const; IMF_EXPORT LevelRoundingMode levelRoundingMode () const; //-------------------------------------------------------------------- // Number of levels: // // numXLevels() returns the file's number of levels in x direction. // // if levelMode() == ONE_LEVEL: // return value is: 1 // // if levelMode() == MIPMAP_LEVELS: // return value is: rfunc (log (max (w, h)) / log (2)) + 1 // // if levelMode() == RIPMAP_LEVELS: // return value is: rfunc (log (w) / log (2)) + 1 // // where // w is the width of the image's data window, max.x - min.x + 1, // y is the height of the image's data window, max.y - min.y + 1, // and rfunc(x) is either floor(x), or ceil(x), depending on // whether levelRoundingMode() returns ROUND_DOWN or ROUND_UP. // // numYLevels() returns the file's number of levels in y direction. // // if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS: // return value is the same as for numXLevels() // // if levelMode() == RIPMAP_LEVELS: // return value is: rfunc (log (h) / log (2)) + 1 // // // numLevels() is a convenience function for use with // MIPMAP_LEVELS files. // // if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS: // return value is the same as for numXLevels() // // if levelMode() == RIPMAP_LEVELS: // an IEX_NAMESPACE::LogicExc exception is thrown // // isValidLevel(lx, ly) returns true if the file contains // a level with level number (lx, ly), false if not. // //-------------------------------------------------------------------- IMF_EXPORT int numLevels () const; IMF_EXPORT int numXLevels () const; IMF_EXPORT int numYLevels () const; IMF_EXPORT bool isValidLevel (int lx, int ly) const; //---------------------------------------------------------- // Dimensions of a level: // // levelWidth(lx) returns the width of a level with level // number (lx, *), where * is any number. // // return value is: // max (1, rfunc (w / pow (2, lx))) // // // levelHeight(ly) returns the height of a level with level // number (*, ly), where * is any number. // // return value is: // max (1, rfunc (h / pow (2, ly))) // //---------------------------------------------------------- IMF_EXPORT int levelWidth (int lx) const; IMF_EXPORT int levelHeight (int ly) const; //-------------------------------------------------------------- // Number of tiles: // // numXTiles(lx) returns the number of tiles in x direction // that cover a level with level number (lx, *), where * is // any number. // // return value is: // (levelWidth(lx) + tileXSize() - 1) / tileXSize() // // // numYTiles(ly) returns the number of tiles in y direction // that cover a level with level number (*, ly), where * is // any number. // // return value is: // (levelHeight(ly) + tileXSize() - 1) / tileXSize() // //-------------------------------------------------------------- IMF_EXPORT int numXTiles (int lx = 0) const; IMF_EXPORT int numYTiles (int ly = 0) const; //--------------------------------------------------------------- // Level pixel ranges: // // dataWindowForLevel(lx, ly) returns a 2-dimensional region of // valid pixel coordinates for a level with level number (lx, ly) // // return value is a Box2i with min value: // (dataWindow.min.x, dataWindow.min.y) // // and max value: // (dataWindow.min.x + levelWidth(lx) - 1, // dataWindow.min.y + levelHeight(ly) - 1) // // dataWindowForLevel(level) is a convenience function used // for ONE_LEVEL and MIPMAP_LEVELS files. It returns // dataWindowForLevel(level, level). // //--------------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForLevel (int lx, int ly) const; //------------------------------------------------------------------- // Tile pixel ranges: // // dataWindowForTile(dx, dy, lx, ly) returns a 2-dimensional // region of valid pixel coordinates for a tile with tile coordinates // (dx,dy) and level number (lx, ly). // // return value is a Box2i with min value: // (dataWindow.min.x + dx * tileXSize(), // dataWindow.min.y + dy * tileYSize()) // // and max value: // (dataWindow.min.x + (dx + 1) * tileXSize() - 1, // dataWindow.min.y + (dy + 1) * tileYSize() - 1) // // dataWindowForTile(dx, dy, level) is a convenience function // used for ONE_LEVEL and MIPMAP_LEVELS files. It returns // dataWindowForTile(dx, dy, level, level). // //------------------------------------------------------------------- IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int l = 0) const; IMF_EXPORT IMATH_NAMESPACE::Box2i dataWindowForTile (int dx, int dy, int lx, int ly) const; //------------------------------------------------------------ // Read pixel data: // // readTile(dx, dy, lx, ly) reads the tile with tile // coordinates (dx, dy), and level number (lx, ly), // and stores it in the current frame buffer. // // dx must lie in the interval [0, numXTiles(lx)-1] // dy must lie in the interval [0, numYTiles(ly)-1] // // lx must lie in the interval [0, numXLevels()-1] // ly must lie in the inverval [0, numYLevels()-1] // // readTile(dx, dy, level) is a convenience function used // for ONE_LEVEL and MIPMAP_LEVELS files. It calls // readTile(dx, dy, level, level). // // The two readTiles(dx1, dx2, dy1, dy2, ...) functions allow // reading multiple tiles at once. If multi-threading is used // the multiple tiles are read concurrently. // // Pixels that are outside the pixel coordinate range for the // tile's level, are never accessed by readTile(). // // Attempting to access a tile that is not present in the file // throws an InputExc exception. // //------------------------------------------------------------ IMF_EXPORT void readTile (int dx, int dy, int l = 0); IMF_EXPORT void readTile (int dx, int dy, int lx, int ly); IMF_EXPORT void readTiles (int dx1, int dx2, int dy1, int dy2, int lx, int ly); IMF_EXPORT void readTiles (int dx1, int dx2, int dy1, int dy2, int l = 0); //-------------------------------------------------- // Read a tile of raw pixel data from the file, // without uncompressing it (this function is // used to implement TiledOutputFile::copyPixels()). // // for single part files, reads the next tile in the file // for multipart files, reads the tile specified by dx,dy,lx,ly // //-------------------------------------------------- IMF_EXPORT void rawTileData (int &dx, int &dy, int &lx, int &ly, const char *&pixelData, int &pixelDataSize); struct IMF_HIDDEN Data; private: friend class InputFile; friend class MultiPartInputFile; IMF_HIDDEN TiledInputFile (InputPartData* part); IMF_HIDDEN TiledInputFile (const Header &header, OPENEXR_IMF_INTERNAL_NAMESPACE::IStream *is, int version, int numThreads); IMF_HIDDEN void initialize (); IMF_HIDDEN void multiPartInitialize(InputPartData* part); IMF_HIDDEN void compatibilityInitialize(OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is); IMF_HIDDEN bool isValidTile (int dx, int dy, int lx, int ly) const; IMF_HIDDEN size_t bytesPerLineForTile (int dx, int dy, int lx, int ly) const; IMF_HIDDEN void tileOrder(int dx[],int dy[],int lx[],int ly[]) const; Data * _data; friend class TiledOutputFile; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�L*�0 0 ImfImage.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_IMAGE_H #define INCLUDED_IMF_IMAGE_H //---------------------------------------------------------------------------- // // class Image -- an in-memory data structure that can hold an arbitrary // OpenEXR image, flat or deep, with one or multiple resolution levels, // and with an arbitrary set of channels. // // An image is a container for a set of image levels, and an image level // is a container for a set of image channels. An image channel contains // an array of pixel values of type half, float or unsigned int. // // For example: // // image --+-- level 0 --+-- channel "R" --- pixel data // | | // | +-- channel "G" --- pixel data // | | // | +-- channel "B" --- pixel data // | // +-- level 1 --+-- channel "R" --- pixel data // | | // | +-- channel "G" --- pixel data // | | // | +-- channel "B" --- pixel data // | // +-- level 2 --+-- channel "R" --- pixel data // | // +-- channel "G" --- pixel data // | // +-- channel "B" --- pixel data // // An image has a level mode, which can be ONE_LEVEL, MIPMAP_LEVELS or // RIPMAP_LEVELS, and a level rounding mode, which can be ROUND_UP or // ROUND_DOWN. Together, the level mode and the level rounding mode // determine how many levels an image contains, and how large the data // window for each level is. All levels in an image have the same set // of channels. // // An image channel has a name (e.g. "R", "Z", or "xVelocity"), a type // (HALF, FLOAT or UINT) and x and y sampling rates. A channel stores // samples for a pixel if the pixel is inside the data window of the // level to which the channel belongs, and the x and y coordinates of // the pixel are divisible by the x and y sampling rates of the channel. // // An image can be either flat or deep. In a flat image each channel // in each level stores at most one value per pixel. In a deep image // each channel in each level stores an arbitrary number of values per // pixel. As an exception, each level of a deep image has a sample count // channel with a single value per pixel; this value determines how many // values each of the other channels in the same level has at the same // pixel location. // // The classes Image, ImageLevel and ImageChannel are abstract base // classes. Two sets of concrete classes, one for flat and one for // deep images, are derived from the base classes. // //---------------------------------------------------------------------------- #include "ImfUtilExport.h" #include "ImfNamespace.h" #include "ImfImageLevel.h" #include "ImfTileDescription.h" #include "ImfArray.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER struct Channel; class IMFUTIL_EXPORT_TYPE Image { public: // // Constructor and destructor // IMFUTIL_EXPORT Image (); IMFUTIL_EXPORT virtual ~Image (); // // Access to the image's level mode and level rounding mode. // IMFUTIL_EXPORT LevelMode levelMode() const; IMFUTIL_EXPORT LevelRoundingMode levelRoundingMode() const; // // Number of levels: // // numXLevels() returns the image's number of levels in the x direction. // // if levelMode() == ONE_LEVEL: // return value is: 1 // // if levelMode() == MIPMAP_LEVELS: // return value is: rfunc (log (max (w, h)) / log (2)) + 1 // // if levelMode() == RIPMAP_LEVELS: // return value is: rfunc (log (w) / log (2)) + 1 // // where // w is the width of the image's data window, max.x - min.x + 1, // h is the height of the image's data window, max.y - min.y + 1, // and rfunc(x) is either floor(x), or ceil(x), depending on // whether levelRoundingMode() returns ROUND_DOWN or ROUND_UP. // // numYLevels() returns the image's number of levels in the y direction. // // if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS: // return value is the same as for numXLevels() // // if levelMode() == RIPMAP_LEVELS: // return value is: rfunc (log (h) / log (2)) + 1 // // // numLevels() is a convenience function for use with MIPMAP_LEVELS images. // // if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS: // return value is the same as for numXLevels() // // if levelMode() == RIPMAP_LEVELS: // a LogicExc exception is thrown // IMFUTIL_EXPORT int numLevels() const; IMFUTIL_EXPORT int numXLevels() const; IMFUTIL_EXPORT int numYLevels() const; // // Per-level data windows // // dataWindow() returns the data window for the image; this is the // same as the data window for the level with level number (0, 0). // // dataWindowForLevel(lx, ly) returns the data window for level x, // that is, the window for which the image level with level number // (lx, ly) has allocated pixel storage. // // return value is a Box2i with min value: // (dataWindow().min.x, // dataWindow().min.y) // // and max value: // (dataWindow().min.x + levelWidth(lx) - 1, // dataWindow().min.y + levelHeight(ly) - 1) // // dataWindowForLevel(l) is a convenience function used for ONE_LEVEL // and MIPMAP_LEVELS files. It returns dataWindowForLevel(l,l)). // IMFUTIL_EXPORT const IMATH_NAMESPACE::Box2i & dataWindow() const; IMFUTIL_EXPORT const IMATH_NAMESPACE::Box2i & dataWindowForLevel(int l) const; IMFUTIL_EXPORT const IMATH_NAMESPACE::Box2i & dataWindowForLevel(int lx, int ly) const; // // Size of a level: // // levelWidth(lx) returns the width of a level with level // number (lx, *), where * is any number. // // return value is: // max (1, rfunc (w / pow (2, lx))) // // // levelHeight(ly) returns the height of a level with level // number (*, ly), where * is any number. // // return value is: // max (1, rfunc (h / pow (2, ly))) // IMFUTIL_EXPORT int levelWidth (int lx) const; IMFUTIL_EXPORT int levelHeight (int ly) const; // // Resize the image: // // resize(dw,lm,lrm) sets the data window of the image to dw, // sets the level mode to lm and the level rounding mode to lrm, // and allocates new storage for image levels and image channels. // The set of channels in the image does not change. // // The contents of the image are lost; pixel data are not preserved // across the resize operation. If resizing fails, then the image // will be left with an empty data window and no image levels. // // resize(dw) is the same as resize(dw,levelMode(),levelRoundingMode()) // IMFUTIL_EXPORT void resize(const IMATH_NAMESPACE::Box2i &dataWindow); IMFUTIL_EXPORT virtual void resize(const IMATH_NAMESPACE::Box2i &dataWindow, LevelMode levelMode, LevelRoundingMode levelRoundingMode); // // Shift the pixels and the data window of an image: // // shiftPixels(dx,dy) shifts the image by dx pixels horizontally and // dy pixels vertically. A pixel at location (x,y) moves to position // (x+dx, y+dy). The data window of the image is shifted along with // the pixels. No pixel data are lost. // // The horizontal and vertical shift distances must be multiples of // the x and y sampling rates of all image channels. If they are not, // shiftPixels() throws an ArgExc exception. // IMFUTIL_EXPORT void shiftPixels(int dx, int dy); // // Insert a new channel into the image. // // The arguments to this function are the same as for adding a // a channel to an OpenEXR file: channel name, x and y sampling // rates, and a "perceptually approximately linear" flag. // // If the image already contains a channel with the same name // as the new name then the existing channel is deleted before // the new channel is added. // IMFUTIL_EXPORT void insertChannel (const std::string &name, PixelType type, int xSampling = 1, int ySampling = 1, bool pLinear = false); IMFUTIL_EXPORT void insertChannel (const std::string &name, const Channel &channel); // // Erase channels from an image: // // eraseChannel(n) erases the channel with name n. // clearChannels() erases all channels. // IMFUTIL_EXPORT void eraseChannel(const std::string &name); IMFUTIL_EXPORT void clearChannels(); // // Rename an image channel: // // renameChannel(nOld,nNew) changes the name of the image channel // with name nOld to nNew. // // If the image already contains a channel called nNew, or if the // image does not contain a channel called nOld, then renameChannel() // throws an ArgExc exception. // // In the (unlikely) event that renaming the image channel causes // the program to run out of memory, renameChannel() erases the // channel that is being renamed, and throws an exception. // IMFUTIL_EXPORT void renameChannel(const std::string &oldName, const std::string &newName); // // Rename multiple image channels at the same time: // // Given a map, m, from old to new channel names, renameChannels(m) // assigns new names to the channels in the image. If m has an entry // for a channel named c, then the channel will be renamed to m[c]. // If m has no entry for c, then the channel keeps its old name. // // If the same name would be assigned to more than one channel, then // renameChannels() does not rename any channels but throws an ArgExc // exception instead. // // In the (unlikely) event that renaming the image channel causes the // program to run out of memory, renameChannels() erases all channels // in the image and throws an exception. // IMFUTIL_EXPORT void renameChannels(const RenamingMap &oldToNewNames); // // Accessing image levels by level number. // // level(lx,ly) returns a reference to the image level // with level number (lx,ly). // // level(l) returns level(l,l). // IMFUTIL_EXPORT virtual ImageLevel & level (int l = 0); IMFUTIL_EXPORT virtual const ImageLevel & level (int l = 0) const; IMFUTIL_EXPORT virtual ImageLevel & level (int lx, int ly); IMFUTIL_EXPORT virtual const ImageLevel & level (int lx, int ly) const; protected: virtual ImageLevel * newLevel (int lx, int ly, const IMATH_NAMESPACE::Box2i &dataWindow) = 0; private: IMFUTIL_HIDDEN bool levelNumberIsValid (int lx, int ly) const; IMFUTIL_HIDDEN void clearLevels (); struct IMFUTIL_HIDDEN ChannelInfo { ChannelInfo (PixelType type = HALF, int xSampling = 1, int ySampling = 1, bool pLinear = false); PixelType type; int xSampling; int ySampling; bool pLinear; }; typedef std::map <std::string, ChannelInfo> ChannelMap; IMATH_NAMESPACE::Box2i _dataWindow; LevelMode _levelMode; LevelRoundingMode _levelRoundingMode; ChannelMap _channels; Array2D<ImageLevel *> _levels; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[��&� ImfIO.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_IO_H #define INCLUDED_IMF_IO_H //----------------------------------------------------------------------------- // // Low-level file input and output for OpenEXR. // //----------------------------------------------------------------------------- #include "ImfForward.h" #include <string> #include <cstdint> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER //----------------------------------------------------------- // class IStream -- an abstract base class for input streams. //----------------------------------------------------------- class IMF_EXPORT_TYPE IStream { public: //----------- // Destructor //----------- IMF_EXPORT virtual ~IStream (); //------------------------------------------------- // Does this input stream support memory-mapped IO? // // Memory-mapped streams can avoid an extra copy; // memory-mapped read operations return a pointer // to an internal buffer instead of copying data // into a buffer supplied by the caller. //------------------------------------------------- IMF_EXPORT virtual bool isMemoryMapped () const; //------------------------------------------------------ // Read from the stream: // // read(c,n) reads n bytes from the stream, and stores // them in array c. If the stream contains less than n // bytes, or if an I/O error occurs, read(c,n) throws // an exception. If read(c,n) reads the last byte from // the file it returns false, otherwise it returns true. //------------------------------------------------------ virtual bool read (char c[/*n*/], int n) = 0; //--------------------------------------------------- // Read from a memory-mapped stream: // // readMemoryMapped(n) reads n bytes from the stream // and returns a pointer to the first byte. The // returned pointer remains valid until the stream // is closed. If there are less than n byte left to // read in the stream or if the stream is not memory- // mapped, readMemoryMapped(n) throws an exception. //--------------------------------------------------- IMF_EXPORT virtual char * readMemoryMapped (int n); //-------------------------------------------------------- // Get the current reading position, in bytes from the // beginning of the file. If the next call to read() will // read the first byte in the file, tellg() returns 0. //-------------------------------------------------------- virtual uint64_t tellg () = 0; //------------------------------------------- // Set the current reading position. // After calling seekg(i), tellg() returns i. //------------------------------------------- virtual void seekg (uint64_t pos) = 0; //------------------------------------------------------ // Clear error conditions after an operation has failed. //------------------------------------------------------ IMF_EXPORT virtual void clear (); //------------------------------------------------------ // Get the name of the file associated with this stream. //------------------------------------------------------ IMF_EXPORT const char * fileName () const; protected: IMF_EXPORT IStream (const char fileName[]); private: IStream (const IStream &) = delete; IStream & operator = (const IStream &) = delete; IStream (IStream &&) = delete; IStream & operator = (IStream &&) = delete; std::string _fileName; }; //----------------------------------------------------------- // class OStream -- an abstract base class for output streams //----------------------------------------------------------- class IMF_EXPORT_TYPE OStream { public: //----------- // Destructor //----------- IMF_EXPORT virtual ~OStream (); //---------------------------------------------------------- // Write to the stream: // // write(c,n) takes n bytes from array c, and stores them // in the stream. If an I/O error occurs, write(c,n) throws // an exception. //---------------------------------------------------------- virtual void write (const char c[/*n*/], int n) = 0; //--------------------------------------------------------- // Get the current writing position, in bytes from the // beginning of the file. If the next call to write() will // start writing at the beginning of the file, tellp() // returns 0. //--------------------------------------------------------- virtual uint64_t tellp () = 0; //------------------------------------------- // Set the current writing position. // After calling seekp(i), tellp() returns i. //------------------------------------------- virtual void seekp (uint64_t pos) = 0; //------------------------------------------------------ // Get the name of the file associated with this stream. //------------------------------------------------------ IMF_EXPORT const char * fileName () const; protected: IMF_EXPORT OStream (const char fileName[]); private: OStream (const OStream &) = delete; OStream & operator = (const OStream &) = delete; OStream (OStream &&) = delete; OStream & operator = (OStream &&) = delete; std::string _fileName; }; //----------------------- // Helper classes for Xdr //----------------------- struct StreamIO { static inline void writeChars (OStream &os, const char c[/*n*/], int n) { os.write (c, n); } static inline bool readChars (IStream &is, char c[/*n*/], int n) { return is.read (c, n); } }; struct CharPtrIO { static inline void writeChars (char *&op, const char c[/*n*/], int n) { while (n--) *op++ = *c++; } static inline bool readChars (const char *&ip, char c[/*n*/], int n) { while (n--) *c++ = *ip++; return true; } }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[��P� ImfArray.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_ARRAY_H #define INCLUDED_IMF_ARRAY_H #include "ImfForward.h" //------------------------------------------------------------------------- // // class Array // class Array2D // // "Arrays of T" whose sizes are not known at compile time. // When an array goes out of scope, its elements are automatically // deleted. // // Usage example: // // struct C // { // C () {std::cout << "C::C (" << this << ")\n";}; // virtual ~C () {std::cout << "C::~C (" << this << ")\n";}; // }; // // int // main () // { // Array <C> a(3); // // C &b = a[1]; // const C &c = a[1]; // C *d = a + 2; // const C *e = a; // // return 0; // } // //------------------------------------------------------------------------- OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER template <class T> class IMF_EXPORT_TEMPLATE_TYPE Array { public: //----------------------------- // Constructors and destructors //----------------------------- Array () {_data = 0; _size = 0;} Array (long size) {_data = new T[size]; _size = size;} ~Array () {delete [] _data;} //----------------------------- // Access to the array elements //----------------------------- operator T * () {return _data;} operator const T * () const {return _data;} //------------------------------------------------------ // Resize and clear the array (the contents of the array // are not preserved across the resize operation). // // resizeEraseUnsafe() is more memory efficient than // resizeErase() because it deletes the old memory block // before allocating a new one, but if allocating the // new block throws an exception, resizeEraseUnsafe() // leaves the array in an unusable state. // //------------------------------------------------------ void resizeErase (long size); void resizeEraseUnsafe (long size); //------------------------------- // Return the size of this array. //------------------------------- long size() const {return _size;} private: Array (const Array &) = delete; Array & operator = (const Array &) = delete; Array (Array &&) = delete; Array & operator = (Array &&) = delete; long _size; T * _data; }; template <class T> class IMF_EXPORT_TEMPLATE_TYPE Array2D { public: //----------------------------- // Constructors and destructors //----------------------------- Array2D (); // empty array, 0 by 0 elements Array2D (long sizeX, long sizeY); // sizeX by sizeY elements ~Array2D (); //----------------------------- // Access to the array elements //----------------------------- T * operator [] (long x); const T * operator [] (long x) const; //------------------------------------------------------ // Resize and clear the array (the contents of the array // are not preserved across the resize operation). // // resizeEraseUnsafe() is more memory efficient than // resizeErase() because it deletes the old memory block // before allocating a new one, but if allocating the // new block throws an exception, resizeEraseUnsafe() // leaves the array in an unusable state. // //------------------------------------------------------ void resizeErase (long sizeX, long sizeY); void resizeEraseUnsafe (long sizeX, long sizeY); //------------------------------- // Return the size of this array. //------------------------------- long height() const {return _sizeX;} long width() const {return _sizeY;} private: Array2D (const Array2D &) = delete; Array2D & operator = (const Array2D &) = delete; Array2D (Array2D &&) = delete; Array2D & operator = (Array2D &&) = delete; long _sizeX; long _sizeY; T * _data; }; //--------------- // Implementation //--------------- template <class T> inline void Array<T>::resizeErase (long size) { T *tmp = new T[size]; delete [] _data; _size = size; _data = tmp; } template <class T> inline void Array<T>::resizeEraseUnsafe (long size) { delete [] _data; _data = 0; _size = 0; _data = new T[size]; _size = size; } template <class T> inline Array2D<T>::Array2D (): _sizeX(0), _sizeY (0), _data (0) { // emtpy } template <class T> inline Array2D<T>::Array2D (long sizeX, long sizeY): _sizeX (sizeX), _sizeY (sizeY), _data (new T[sizeX * sizeY]) { // emtpy } template <class T> inline Array2D<T>::~Array2D () { delete [] _data; } template <class T> inline T * Array2D<T>::operator [] (long x) { return _data + x * _sizeY; } template <class T> inline const T * Array2D<T>::operator [] (long x) const { return _data + x * _sizeY; } template <class T> inline void Array2D<T>::resizeErase (long sizeX, long sizeY) { T *tmp = new T[sizeX * sizeY]; delete [] _data; _sizeX = sizeX; _sizeY = sizeY; _data = tmp; } template <class T> inline void Array2D<T>::resizeEraseUnsafe (long sizeX, long sizeY) { delete [] _data; _data = 0; _sizeX = 0; _sizeY = 0; _data = new T[sizeX * sizeY]; _sizeX = sizeX; _sizeY = sizeY; } OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�P�6 6 ImfImageLevel.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_IMAGE_LEVEL_H #define INCLUDED_IMF_IMAGE_LEVEL_H //---------------------------------------------------------------------------- // // class ImageLevel // // For an explanation of images, levels and channels, // see the comments in header file Image.h. // //---------------------------------------------------------------------------- #include "ImfUtilExport.h" #include "ImfImageChannel.h" #include "ImfImageChannelRenaming.h" #include <ImathBox.h> #include <string> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class Image; class IMFUTIL_EXPORT_TYPE ImageLevel { public: // // Access to the image to which the level belongs. // Image & image () {return _image;} const Image & image () const {return _image;} // // Access to the level number and the data window of this level. // int xLevelNumber () const {return _xLevelNumber;} int yLevelNumber () const {return _yLevelNumber;} const IMATH_NAMESPACE::Box2i & dataWindow () const {return _dataWindow;} protected: friend class Image; IMFUTIL_EXPORT ImageLevel (Image& image, int xLevelNumber, int yLevelNumber); IMFUTIL_EXPORT virtual ~ImageLevel (); IMFUTIL_EXPORT virtual void resize (const IMATH_NAMESPACE::Box2i& dataWindow); IMFUTIL_EXPORT virtual void shiftPixels (int dx, int dy); virtual void insertChannel (const std::string& name, PixelType type, int xSampling, int ySampling, bool pLinear) = 0; virtual void eraseChannel (const std::string& name) = 0; virtual void clearChannels () = 0; virtual void renameChannel (const std::string &oldName, const std::string &newName) = 0; virtual void renameChannels (const RenamingMap &oldToNewNames) = 0; IMFUTIL_EXPORT void throwChannelExists(const std::string& name) const; IMFUTIL_EXPORT void throwBadChannelName(const std::string& name) const; IMFUTIL_EXPORT void throwBadChannelNameOrType (const std::string& name) const; private: ImageLevel (const ImageLevel &); // not implemented ImageLevel & operator = (const ImageLevel &); // not implemented Image & _image; int _xLevelNumber; int _yLevelNumber; IMATH_NAMESPACE::Box2i _dataWindow; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[���b� � ImfCompression.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_COMPRESSION_H #define INCLUDED_IMF_COMPRESSION_H //----------------------------------------------------------------------------- // // enum Compression // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER enum IMF_EXPORT_ENUM Compression { NO_COMPRESSION = 0, // no compression RLE_COMPRESSION = 1, // run length encoding ZIPS_COMPRESSION = 2, // zlib compression, one scan line at a time ZIP_COMPRESSION = 3, // zlib compression, in blocks of 16 scan lines PIZ_COMPRESSION = 4, // piz-based wavelet compression PXR24_COMPRESSION = 5, // lossy 24-bit float compression B44_COMPRESSION = 6, // lossy 4-by-4 pixel block compression, // fixed compression rate B44A_COMPRESSION = 7, // lossy 4-by-4 pixel block compression, // flat fields are compressed more DWAA_COMPRESSION = 8, // lossy DCT based compression, in blocks // of 32 scanlines. More efficient for partial // buffer access. DWAB_COMPRESSION = 9, // lossy DCT based compression, in blocks // of 256 scanlines. More efficient space // wise and faster to decode full frames // than DWAA_COMPRESSION. NUM_COMPRESSION_METHODS // number of different compression methods }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�W-z% z% ImfAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_ATTRIBUTE_H #define INCLUDED_IMF_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class Attribute // //----------------------------------------------------------------------------- #include "ImfForward.h" #include "ImfIO.h" #include "ImfXdr.h" #include "IexBaseExc.h" #include <typeinfo> #include <cstring> #if defined(_MSC_VER) // suppress warning about non-exported base classes #pragma warning (push) #pragma warning (disable : 4251) #pragma warning (disable : 4275) #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE Attribute { public: //--------------------------- // Constructor and destructor //--------------------------- IMF_EXPORT Attribute (); IMF_EXPORT virtual ~Attribute (); //------------------------------- // Get this attribute's type name //------------------------------- virtual const char * typeName () const = 0; //------------------------------ // Make a copy of this attribute //------------------------------ virtual Attribute * copy () const = 0; //---------------------------------------- // Type-specific attribute I/O and copying //---------------------------------------- virtual void writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, int version) const = 0; virtual void readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int size, int version) = 0; virtual void copyValueFrom (const Attribute &other) = 0; //------------------ // Attribute factory //------------------ IMF_EXPORT static Attribute * newAttribute (const char typeName[]); //----------------------------------------------------------- // Test if a given attribute type has already been registered //----------------------------------------------------------- IMF_EXPORT static bool knownType (const char typeName[]); protected: //-------------------------------------------------- // Register an attribute type so that newAttribute() // knows how to make objects of this type. //-------------------------------------------------- IMF_EXPORT static void registerAttributeType (const char typeName[], Attribute *(*newAttribute)()); //------------------------------------------------------ // Un-register an attribute type so that newAttribute() // no longer knows how to make objects of this type (for // debugging only). //------------------------------------------------------ IMF_EXPORT static void unRegisterAttributeType (const char typeName[]); }; //------------------------------------------------- // Class template for attributes of a specific type //------------------------------------------------- template <class T> class IMF_EXPORT_TEMPLATE_TYPE TypedAttribute: public Attribute { public: //------------------------------------------------------------ // Constructors and destructor: default behavior. This assumes // that the type T is copyable/assignable/moveable. //------------------------------------------------------------ TypedAttribute () = default; TypedAttribute (const T &value); TypedAttribute (const TypedAttribute<T> &other) = default; TypedAttribute (TypedAttribute<T> &&other) = default; //NB: if we use a default destructor, it wreaks havoc with where the vtable and such end up //at least under mingw+windows, and since we are providing extern template instantiations //this will be pretty trim and should reduce code bloat virtual ~TypedAttribute (); TypedAttribute& operator = (const TypedAttribute<T>& other) = default; TypedAttribute& operator = (TypedAttribute<T>&& other) = default; //-------------------------------- // Access to the attribute's value //-------------------------------- T & value (); const T &value () const; //-------------------------------- // Get this attribute's type name. //-------------------------------- virtual const char * typeName () const; //--------------------------------------------------------- // Static version of typeName() // This function must be specialized for each value type T. //--------------------------------------------------------- static const char * staticTypeName (); //--------------------- // Make a new attribute //--------------------- static Attribute * makeNewAttribute (); //------------------------------ // Make a copy of this attribute //------------------------------ virtual Attribute * copy () const; //----------------------------------------------------------------- // Type-specific attribute I/O and copying. // Depending on type T, these functions may have to be specialized. //----------------------------------------------------------------- virtual void writeValueTo ( OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, int version) const; virtual void readValueFrom ( OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int size, int version); virtual void copyValueFrom (const Attribute &other); //------------------------------------------------------------ // Dynamic casts that throw exceptions instead of returning 0. //------------------------------------------------------------ static TypedAttribute * cast (Attribute *attribute); static const TypedAttribute * cast (const Attribute *attribute); static TypedAttribute & cast (Attribute &attribute); static const TypedAttribute & cast (const Attribute &attribute); //--------------------------------------------------------------- // Register this attribute type so that Attribute::newAttribute() // knows how to make objects of this type. // // Note that this function is not thread-safe because it modifies // a global variable in the IlmIlm library. A thread in a multi- // threaded program may call registerAttributeType() only when no // other thread is accessing any functions or classes in the // OpenEXR library. // //--------------------------------------------------------------- static void registerAttributeType (); //----------------------------------------------------- // Un-register this attribute type (for debugging only) //----------------------------------------------------- static void unRegisterAttributeType (); private: T _value; }; //------------------------------------ // Implementation of TypedAttribute<T> //------------------------------------ template <class T> TypedAttribute<T>::TypedAttribute (const T & value): Attribute (), _value (value) { // empty } template <class T> TypedAttribute<T>::~TypedAttribute () { // empty } template <class T> inline T & TypedAttribute<T>::value () { return _value; } template <class T> inline const T & TypedAttribute<T>::value () const { return _value; } template <class T> const char * TypedAttribute<T>::typeName () const { return staticTypeName(); } template <class T> Attribute * TypedAttribute<T>::makeNewAttribute () { return new TypedAttribute<T>(); } template <class T> Attribute * TypedAttribute<T>::copy () const { Attribute * attribute = new TypedAttribute<T>(); attribute->copyValueFrom (*this); return attribute; } template <class T> void TypedAttribute<T>::writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, int version) const { OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (os, _value); } template <class T> void TypedAttribute<T>::readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int size, int version) { OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, _value); } template <class T> void TypedAttribute<T>::copyValueFrom (const Attribute &other) { _value = cast(other)._value; } template <class T> TypedAttribute<T> * TypedAttribute<T>::cast (Attribute *attribute) { TypedAttribute<T> *t = dynamic_cast <TypedAttribute<T> *> (attribute); if (t == 0) throw IEX_NAMESPACE::TypeExc ("Unexpected attribute type."); return t; } template <class T> const TypedAttribute<T> * TypedAttribute<T>::cast (const Attribute *attribute) { const TypedAttribute<T> *t = dynamic_cast <const TypedAttribute<T> *> (attribute); if (t == 0) throw IEX_NAMESPACE::TypeExc ("Unexpected attribute type."); return t; } template <class T> inline TypedAttribute<T> & TypedAttribute<T>::cast (Attribute &attribute) { return *cast (&attribute); } template <class T> inline const TypedAttribute<T> & TypedAttribute<T>::cast (const Attribute &attribute) { return *cast (&attribute); } template <class T> inline void TypedAttribute<T>::registerAttributeType () { Attribute::registerAttributeType (staticTypeName(), makeNewAttribute); } template <class T> inline void TypedAttribute<T>::unRegisterAttributeType () { Attribute::unRegisterAttributeType (staticTypeName()); } OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #if defined(_MSC_VER) #pragma warning (pop) #endif #endif PK rM�[�xf% f% ImfAcesFile.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_ACES_FILE_H #define INCLUDED_IMF_ACES_FILE_H //----------------------------------------------------------------------------- // // ACES image file I/O. // // This header file declares two classes that directly support // image file input and output according to the Academy Image // Interchange Framework. // // The Academy Image Interchange file format is a subset of OpenEXR: // // - Images are stored as scanlines. Tiles are not allowed. // // - Images contain three color channels, either // R, G, B (red, green, blue) or // Y, RY, BY (luminance, sub-sampled chroma) // // - Images may optionally contain an alpha channel. // // - Only three compression types are allowed: // - NO_COMPRESSION (file is not compressed) // - PIZ_COMPRESSION (lossless) // - B44A_COMPRESSION (lossy) // // - The "chromaticities" header attribute must specify // the ACES RGB primaries and white point. // // class AcesOutputFile writes an OpenEXR file, enforcing the // restrictions listed above. Pixel data supplied by application // software must already be in the ACES RGB space. // // class AcesInputFile reads an OpenEXR file. Pixel data delivered // to application software is guaranteed to be in the ACES RGB space. // If the RGB space of the file is not the same as the ACES space, // then the pixels are automatically converted: the pixels are // converted to CIE XYZ, a color adaptation transform shifts the // white point, and the result is converted to ACES RGB. // //----------------------------------------------------------------------------- #include "ImfHeader.h" #include "ImfRgba.h" #include "ImathVec.h" #include "ImathBox.h" #include "ImfThreading.h" #include "ImfNamespace.h" #include "ImfExport.h" #include "ImfForward.h" #include <string> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER // // ACES red, green, blue and white-point chromaticities. // const Chromaticities & acesChromaticities (); // // ACES output file. // class IMF_EXPORT_TYPE AcesOutputFile { public: //--------------------------------------------------- // Constructor -- header is constructed by the caller //--------------------------------------------------- IMF_EXPORT AcesOutputFile (const std::string &name, const Header &header, RgbaChannels rgbaChannels = WRITE_RGBA, int numThreads = globalThreadCount()); //---------------------------------------------------- // Constructor -- header is constructed by the caller, // file is opened by the caller, destructor will not // automatically close the file. //---------------------------------------------------- IMF_EXPORT AcesOutputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, const Header &header, RgbaChannels rgbaChannels = WRITE_RGBA, int numThreads = globalThreadCount()); //---------------------------------------------------------------- // Constructor -- header data are explicitly specified as function // call arguments (empty dataWindow means "same as displayWindow") //---------------------------------------------------------------- IMF_EXPORT AcesOutputFile (const std::string &name, const IMATH_NAMESPACE::Box2i &displayWindow, const IMATH_NAMESPACE::Box2i &dataWindow = IMATH_NAMESPACE::Box2i(), RgbaChannels rgbaChannels = WRITE_RGBA, float pixelAspectRatio = 1, const IMATH_NAMESPACE::V2f screenWindowCenter = IMATH_NAMESPACE::V2f (0, 0), float screenWindowWidth = 1, LineOrder lineOrder = INCREASING_Y, Compression compression = PIZ_COMPRESSION, int numThreads = globalThreadCount()); //----------------------------------------------- // Constructor -- like the previous one, but both // the display window and the data window are // Box2i (V2i (0, 0), V2i (width - 1, height -1)) //----------------------------------------------- IMF_EXPORT AcesOutputFile (const std::string &name, int width, int height, RgbaChannels rgbaChannels = WRITE_RGBA, float pixelAspectRatio = 1, const IMATH_NAMESPACE::V2f screenWindowCenter = IMATH_NAMESPACE::V2f (0, 0), float screenWindowWidth = 1, LineOrder lineOrder = INCREASING_Y, Compression compression = PIZ_COMPRESSION, int numThreads = globalThreadCount()); //----------- // Destructor //----------- IMF_EXPORT virtual ~AcesOutputFile (); //------------------------------------------------ // Define a frame buffer as the pixel data source: // Pixel (x, y) is at address // // base + x * xStride + y * yStride // //------------------------------------------------ IMF_EXPORT void setFrameBuffer (const Rgba *base, size_t xStride, size_t yStride); //------------------------------------------------- // Write pixel data (see class Imf::OutputFile) // The pixels are assumed to contain ACES RGB data. //------------------------------------------------- IMF_EXPORT void writePixels (int numScanLines = 1); IMF_EXPORT int currentScanLine () const; //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; IMF_EXPORT const IMATH_NAMESPACE::Box2i & displayWindow () const; IMF_EXPORT const IMATH_NAMESPACE::Box2i & dataWindow () const; IMF_EXPORT float pixelAspectRatio () const; IMF_EXPORT const IMATH_NAMESPACE::V2f screenWindowCenter () const; IMF_EXPORT float screenWindowWidth () const; IMF_EXPORT LineOrder lineOrder () const; IMF_EXPORT Compression compression () const; IMF_EXPORT RgbaChannels channels () const; // -------------------------------------------------------------------- // Update the preview image (see Imf::OutputFile::updatePreviewImage()) // -------------------------------------------------------------------- IMF_EXPORT void updatePreviewImage (const PreviewRgba[]); private: AcesOutputFile (const AcesOutputFile &) = delete; AcesOutputFile & operator = (const AcesOutputFile &) = delete; AcesOutputFile (AcesOutputFile &&) = delete; AcesOutputFile & operator = (AcesOutputFile &&) = delete; class IMF_HIDDEN Data; Data * _data; }; // // ACES input file // class IMF_EXPORT_TYPE AcesInputFile { public: //------------------------------------------------------- // Constructor -- opens the file with the specified name, // destructor will automatically close the file. //------------------------------------------------------- IMF_EXPORT AcesInputFile (const std::string &name, int numThreads = globalThreadCount()); //----------------------------------------------------------- // Constructor -- attaches the new AcesInputFile object to a // file that has already been opened by the caller. // Destroying the AcesInputFile object will not automatically // close the file. //----------------------------------------------------------- IMF_EXPORT AcesInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int numThreads = globalThreadCount()); //----------- // Destructor //----------- IMF_EXPORT virtual ~AcesInputFile (); //----------------------------------------------------- // Define a frame buffer as the pixel data destination: // Pixel (x, y) is at address // // base + x * xStride + y * yStride // //----------------------------------------------------- IMF_EXPORT void setFrameBuffer (Rgba *base, size_t xStride, size_t yStride); //-------------------------------------------- // Read pixel data (see class Imf::InputFile) // Pixels returned will contain ACES RGB data. //-------------------------------------------- IMF_EXPORT void readPixels (int scanLine1, int scanLine2); IMF_EXPORT void readPixels (int scanLine); //-------------------------- // Access to the file header //-------------------------- IMF_EXPORT const Header & header () const; IMF_EXPORT const IMATH_NAMESPACE::Box2i & displayWindow () const; IMF_EXPORT const IMATH_NAMESPACE::Box2i & dataWindow () const; IMF_EXPORT float pixelAspectRatio () const; IMF_EXPORT const IMATH_NAMESPACE::V2f screenWindowCenter () const; IMF_EXPORT float screenWindowWidth () const; IMF_EXPORT LineOrder lineOrder () const; IMF_EXPORT Compression compression () const; IMF_EXPORT RgbaChannels channels () const; IMF_EXPORT const char * fileName () const; IMF_EXPORT bool isComplete () const; //---------------------------------- // Access to the file format version //---------------------------------- IMF_EXPORT int version () const; private: AcesInputFile (const AcesInputFile &) = delete; AcesInputFile & operator = (const AcesInputFile &) = delete; AcesInputFile (AcesInputFile &&) = delete; AcesInputFile & operator = (AcesInputFile &&) = delete; class IMF_HIDDEN Data; Data * _data; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[Crߝ ImfImageIO.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_IMAGE_IO_H #define INCLUDED_IMF_IMAGE_IO_H //---------------------------------------------------------------------------- // // Functions to load flat or deep images from OpenEXR files // and to save flat or deep images in OpenEXR files. // //---------------------------------------------------------------------------- #include "ImfUtilExport.h" #include "ImfImage.h" #include "ImfImageDataWindow.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER // // saveImage (n, h, i, d) or // saveImage (n, i) // // Saves image i in an OpenEXR file with name n. The file will be // tiled if the image has more than one level, or if a header, h, is // given and contains a tile description attribute; otherwise the // file will be scan-line based. The file will be deep if the image // is deep; otherwise the file will be flat. // // If header h is given, then the channel list in h is replaced with // the channel list in i, and the levelMode and the levelRounding mode // fields of the tile description are replaced with the level mode // and the levelRounding mode of i. In addition, if the data window // source flag, d, is set to USE_IMAGE_DATA_WINDOW, then the data // window in the image is copied into the header; if d is set to // USE_HEADER_DATA_WINDOW, then the data window in the header is // replaced with the intersection of the original data window in the // header and the data window in the image. The modified header then // becomes the header of the image file. // // Note: USE_HEADER_DATA_WINDOW can only be used for images with // level mode ONE_LEVEL. // IMFUTIL_EXPORT void saveImage (const std::string &fileName, const Header &hdr, const Image &img, DataWindowSource dws = USE_IMAGE_DATA_WINDOW); IMFUTIL_EXPORT void saveImage (const std::string &fileName, const Image &img); // // loadImage (n, h) or // loadImage (n) // // Loads deep an image from the OpenEXR file with name n, and returns // a pointer to the image. The caller owns the image and is responsible // for deleting it. // // If header h is given, then the header of the file is copied into h. // IMFUTIL_EXPORT Image * loadImage (const std::string &fileName, Header &hdr); IMFUTIL_EXPORT Image * loadImage (const std::string &fileName); OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[v���5 5 ImfUtilExport.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMFUTILEXPORT_H #define INCLUDED_IMFUTILEXPORT_H #include "OpenEXRConfig.h" /// \addtogroup ExportMacros /// @{ // are we making a DLL under windows (might be msvc or mingw or others) #if defined(OPENEXR_DLL) # if defined(OPENEXRUTIL_EXPORTS) # define IMFUTIL_EXPORT __declspec(dllexport) // mingw needs the export when the extern is defined # if defined(__MINGW32__) # define IMFUTIL_EXPORT_EXTERN_TEMPLATE IMFUTIL_EXPORT # define IMFUTIL_EXPORT_TEMPLATE_INSTANCE // for mingw windows, we need to cause this to export the // typeinfo tables (but you don't need to have the // complementary import, because might be a local template too!) # define IMFUTIL_EXPORT_TEMPLATE_TYPE IMFUTIL_EXPORT # else // for normal msvc, need to export the actual instantiation in // the cpp code, and none of the others # define IMFUTIL_EXPORT_EXTERN_TEMPLATE # define IMFUTIL_EXPORT_TEMPLATE_INSTANCE IMFUTIL_EXPORT # define IMFUTIL_EXPORT_TEMPLATE_TYPE # endif # else // OPENEXRUTIL_EXPORTS # define IMFUTIL_EXPORT __declspec(dllimport) # define IMFUTIL_EXPORT_EXTERN_TEMPLATE IMFUTIL_EXPORT # define IMFUTIL_EXPORT_TEMPLATE_INSTANCE # define IMFUTIL_EXPORT_TEMPLATE_TYPE # endif // DLLs don't support these types of visibility controls, just leave them as empty # define IMFUTIL_EXPORT_TYPE # define IMFUTIL_EXPORT_ENUM # define IMFUTIL_HIDDEN #else // not an OPENEXR_DLL // just pass these through from the top level config # define IMFUTIL_EXPORT OPENEXR_EXPORT # define IMFUTIL_HIDDEN OPENEXR_HIDDEN # define IMFUTIL_EXPORT_ENUM OPENEXR_EXPORT_ENUM # define IMFUTIL_EXPORT_TYPE OPENEXR_EXPORT_TYPE # define IMFUTIL_EXPORT_TEMPLATE_TYPE OPENEXR_EXPORT_TEMPLATE_TYPE # define IMFUTIL_EXPORT_EXTERN_TEMPLATE OPENEXR_EXPORT_EXTERN_TEMPLATE # define IMFUTIL_EXPORT_TEMPLATE_INSTANCE OPENEXR_EXPORT_TEMPLATE_INSTANCE #endif // OPENEXR_DLL /// @} #endif // INCLUDED_IMFUTILEXPORT_H PK rM�[��㖦 � ImfStringVectorAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Weta Digital, Ltd and Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_STRINGVECTOR_ATTRIBUTE_H #define INCLUDED_IMF_STRINGVECTOR_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class StringVectorAttribute // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" #include <string> #include <vector> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef std::vector<std::string> StringVector; typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::StringVector> StringVectorAttribute; #ifndef COMPILING_IMF_STRING_VECTOR_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::StringVector>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK rM�[�灂N N IexMathExc.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IEXMATHEXC_H #define INCLUDED_IEXMATHEXC_H #include "IexBaseExc.h" IEX_INTERNAL_NAMESPACE_HEADER_ENTER //--------------------------------------------------------- // Exception classess which correspond to specific floating // point exceptions. //--------------------------------------------------------- DEFINE_EXC_EXP (IEX_EXPORT, OverflowExc, MathExc) // Overflow DEFINE_EXC_EXP (IEX_EXPORT, UnderflowExc, MathExc) // Underflow DEFINE_EXC_EXP (IEX_EXPORT, DivzeroExc, MathExc) // Division by zero DEFINE_EXC_EXP (IEX_EXPORT, InexactExc, MathExc) // Inexact result DEFINE_EXC_EXP (IEX_EXPORT, InvalidFpOpExc, MathExc) // Invalid operation IEX_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IEXMATHEXC_H PK rM�[���f�7 �7 ImfIDManifest.hnu �[��� // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. #ifndef INCLUDED_IMF_ID_MANIFEST_H #define INCLUDED_IMF_ID_MANIFEST_H //----------------------------------------------------------------------------- // // class IDManifest, to store a table mapping ID numbers to text // //----------------------------------------------------------------------------- #include "ImfForward.h" #include <cstdint> #include <map> #include <vector> #include <set> #include <string> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE IDManifest { public: // indication of how long a mapping between an ID number and the text holds for enum IMF_EXPORT_ENUM IdLifetime { LIFETIME_FRAME, // The mapping may change every frame: LIFETIME_SHOT, // The mapping is consistent for every frame of a shot LIFETIME_STABLE // The mapping is consistent for all time. }; // // hashing scheme is stored as a string rather than an enum, to allow // proprietary schemes to be encoded with less danger of collision // proprietary schemes should be encoded in a reverse-URL syntax // IMF_EXPORT static const std::string UNKNOWN; // = "unknown" : default value for encoding scheme and hash scheme - should be changed IMF_EXPORT static const std::string NOTHASHED; // = "none" : no relationship between text and ID IMF_EXPORT static const std::string CUSTOMHASH; // = "custom" : text is hashed using defined scheme IMF_EXPORT static const std::string MURMURHASH3_32; // = "MurmurHash3_32" : MurmurHash3 32 bit is used IMF_EXPORT static const std::string MURMURHASH3_64; // = "MurmurHash3_64" : bottom 8 bytes of MurmarHash3_128 (64 bit architecture version) is used IMF_EXPORT static const std::string ID_SCHEME; // ="id" : 32 bit ID stored directly in a UINT channel IMF_EXPORT static const std::string ID2_SCHEME; // ="id2" : 64 bit ID stored in two channels, specified by the ChannelGroup IMF_EXPORT IDManifest(); friend class CompressedIDManifest; // // decompress a compressed IDManifest into IDManifest for reading // IMF_EXPORT IDManifest(const CompressedIDManifest&); // // construct manifest from serialized representation stored at 'data' // IMF_EXPORT IDManifest(const char* data, const char* end); private : // internal helper function called by constructors IMF_HIDDEN void init(const char* data,const char* end); public : // // Description of the information represented by a single group of channels // class IMF_EXPORT_TYPE ChannelGroupManifest { private: std::set<std::string> _channels; // group of channels this manifest represents std::vector<std::string> _components; // ordered list of components represented by this channel group IdLifetime _lifeTime; std::string _hashScheme; //one of above strings or custom value e.g "nz.co.wetafx.cleverhash2" std::string _encodingScheme; //string identifying scheme to encode ID numbers within the image typedef std::map<uint64_t, std::vector<std::string> > IDTable; IDTable _table; // used for << operator to work: tracks the last item inserted into the Manifest IDTable::iterator _insertionIterator; bool _insertingEntry; // true if << has been called but not enough strings yet set public: IMF_EXPORT ChannelGroupManifest(); IMF_EXPORT const std::set<std::string>& getChannels() const; IMF_EXPORT std::set<std::string>& getChannels(); IMF_EXPORT void setChannels(const std::set<std::string>& channels); IMF_EXPORT void setChannel(const std::string& channel); // get list of components for this channel group IMF_EXPORT const std::vector<std::string>& getComponents() const; // set components: throws an exception if there are already entries in the table // and the component length changes IMF_EXPORT void setComponents(const std::vector<std::string>& components); // set name of single component: throws an exception if there are already entries in the table // unless there was previously one component IMF_EXPORT void setComponent(const std::string& component); IdLifetime getLifetime() const { return _lifeTime;} void setLifetime(const IdLifetime& lifeTime) { _lifeTime = lifeTime;} const std::string& getHashScheme() const { return _hashScheme;} void setHashScheme(const std::string& hashScheme) { _hashScheme = hashScheme;} const std::string& getEncodingScheme() const { return _encodingScheme;} void setEncodingScheme(const std::string& encodingScheme) { _encodingScheme = encodingScheme;} class Iterator; // iterator which allows modification of the text class ConstIterator; // iterator which does not allow modification IMF_EXPORT Iterator begin(); IMF_EXPORT ConstIterator begin() const; IMF_EXPORT Iterator end(); IMF_EXPORT ConstIterator end() const; // return number of entries in manifest - could be 0 IMF_EXPORT size_t size() const ; // insert a new entry - text must contain same number of items as getComponents IMF_EXPORT Iterator insert(uint64_t idValue, const std::vector<std::string>& text); // insert a new entry - getComponents must be a single entry IMF_EXPORT Iterator insert(uint64_t idValue, const std::string& text); // compute hash of given entry, insert into manifest, and return // the computed hash. Exception will be thrown if hash scheme isn't recognised IMF_EXPORT uint64_t insert(const std::vector<std::string>& text); IMF_EXPORT uint64_t insert(const std::string& text); IMF_EXPORT Iterator find(uint64_t idValue); IMF_EXPORT ConstIterator find(uint64_t idValue) const; IMF_EXPORT void erase(uint64_t idValue); // return reference to idName for given idValue. Adds the mapping to the vector if it doesn't exist IMF_EXPORT std::vector<std::string>& operator[](uint64_t idValue); // add a new entry to the manifest as an insertion operator: << // the component strings must also be inserted using << // throws an exception if the previous insert operation didn't insert the correct number of string components IMF_EXPORT ChannelGroupManifest& operator<<(uint64_t idValue); // insert a string as the next component of a previously inserted attribute IMF_EXPORT ChannelGroupManifest& operator<<(const std::string& text); IMF_EXPORT bool operator==(const ChannelGroupManifest& other) const; bool operator!=(const ChannelGroupManifest& other) const { return !(*this==other);} friend class IDManifest; }; private: std::vector<ChannelGroupManifest> _manifest; public: // add a new channel group definition to the table, presumably populated with mappings // 'table' will be copied to the internal manifest; to further modify use the return value IMF_EXPORT ChannelGroupManifest& add(const ChannelGroupManifest& table); //insert an empty table definition for the given channel / group of channels IMF_EXPORT ChannelGroupManifest& add(const std::set<std::string>& group); IMF_EXPORT ChannelGroupManifest& add(const std::string& channel); // return number of items in manifest IMF_EXPORT size_t size() const; // find the first manifest ChannelGroupManifest that defines the given channel // if channel not find, returns a value equal to size() IMF_EXPORT size_t find(const std::string& channel) const; IMF_EXPORT const ChannelGroupManifest& operator[](size_t index) const; IMF_EXPORT ChannelGroupManifest& operator[](size_t index); // // serialize manifest into data array. Array will be resized to the required size // IMF_EXPORT void serialize(std::vector<char>& data) const; IMF_EXPORT bool operator==(const IDManifest& other) const; IMF_EXPORT bool operator!=(const IDManifest& other) const; // // add entries from 'other' into this manifest if possible // * all ChannelGroupsManifests for different ChannelGroups // will be appended. // * Where 'other' contains a manifest for the same // ChannelGroup: // * If _components differs, the entire ChannelGroupManifest is skipped // * Otherwise, entries not present in 'this' will be inserted // * _hashScheme, _lifeTime and _encodingScheme will be unchanged // // returns 'false' if the same ChannelGroupManifest appears in both 'other' and 'this', // but with different _components, _hashScheme, _lifeTime or _encodingScheme // or if any idValue maps to different strings in 'other' and 'this' // IMF_EXPORT bool merge(const IDManifest& other); // // static has generation functions // IMF_EXPORT static unsigned int MurmurHash32(const std::string& idString); IMF_EXPORT static unsigned int MurmurHash32(const std::vector<std::string>& idString); IMF_EXPORT static uint64_t MurmurHash64(const std::string& idString); IMF_EXPORT static uint64_t MurmurHash64(const std::vector<std::string>& idString); }; // // zlip compressed version of IDManifest - the IDManifestAttribute encodes this format // This should be transparent to the user, since there is implicit casting between the two types // class CompressedIDManifest { public: IMF_EXPORT CompressedIDManifest(); IMF_EXPORT CompressedIDManifest(const CompressedIDManifest& other); IMF_EXPORT CompressedIDManifest& operator=(const CompressedIDManifest& other); // // construct a compressed version of the given manifest - to decompress it cast to an IDManifest // IMF_EXPORT CompressedIDManifest(const IDManifest& manifest); IMF_EXPORT ~CompressedIDManifest(); int _compressedDataSize; size_t _uncompressedDataSize; unsigned char* _data; }; // // Read/Write Iterator object to access individual entries within a manifest // class IDManifest::ChannelGroupManifest::Iterator { public: IMF_EXPORT Iterator (); IMF_EXPORT explicit Iterator (const IDManifest::ChannelGroupManifest::IDTable::iterator &i); friend class IDManifest::ChannelGroupManifest::ConstIterator; IMF_EXPORT Iterator & operator ++ (); IMF_EXPORT uint64_t id() const; IMF_EXPORT std::vector<std::string>& text(); private: std::map< uint64_t , std::vector<std::string> >::iterator _i; }; // // Read-only Iterator object to access individual entries within a manifest // class IDManifest::ChannelGroupManifest::ConstIterator { public: IMF_EXPORT ConstIterator (); // explicit cast from internal map operator (for internal use only) IMF_EXPORT explicit ConstIterator (const IDManifest::ChannelGroupManifest::IDTable::const_iterator &i); // cast from non-const to const iterator IMF_EXPORT ConstIterator (const IDManifest::ChannelGroupManifest::Iterator &other); IMF_EXPORT ConstIterator & operator ++ (); IMF_EXPORT uint64_t id() const; IMF_EXPORT const std::vector<std::string>& text() const; private: std::map< uint64_t , std::vector<std::string> >::const_iterator _i; friend bool operator == (const ConstIterator &, const ConstIterator &); friend bool operator != (const ConstIterator &, const ConstIterator &); }; // // ChannelGroupManifest::Iterator implementation: all inline // inline IDManifest::ChannelGroupManifest::Iterator::Iterator() {} inline IDManifest::ChannelGroupManifest::Iterator::Iterator(const IDManifest::ChannelGroupManifest::IDTable::iterator &i) :_i(i) {} inline uint64_t IDManifest::ChannelGroupManifest::Iterator::id() const { return _i->first;} inline std::vector<std::string>& IDManifest::ChannelGroupManifest::Iterator::text() { return _i->second;} inline IDManifest::ChannelGroupManifest::Iterator& IDManifest::ChannelGroupManifest::Iterator::operator++() { ++_i; return *this; } // // ChannelGroupManifest::ConstIterator implementation: all inline // inline IDManifest::ChannelGroupManifest::ConstIterator::ConstIterator() {} inline IDManifest::ChannelGroupManifest::ConstIterator::ConstIterator(const IDManifest::ChannelGroupManifest::Iterator &other) : _i(other._i) {} inline IDManifest::ChannelGroupManifest::ConstIterator::ConstIterator(const IDManifest::ChannelGroupManifest::IDTable::const_iterator &i) :_i(i) {} inline uint64_t IDManifest::ChannelGroupManifest::ConstIterator::id() const { return _i->first;} inline const std::vector<std::string>& IDManifest::ChannelGroupManifest::ConstIterator::text() const { return _i->second;} inline IDManifest::ChannelGroupManifest::ConstIterator & IDManifest::ChannelGroupManifest::ConstIterator::operator++() { ++_i; return *this; } inline bool operator==(const IDManifest::ChannelGroupManifest::ConstIterator& a, const IDManifest::ChannelGroupManifest::ConstIterator& b) { return a._i ==b._i; } inline bool operator!=(const IDManifest::ChannelGroupManifest::ConstIterator& a, const IDManifest::ChannelGroupManifest::ConstIterator& b) { return a._i !=b._i; } OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK sM�[�!X < < ImfNamespace.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMFNAMESPACE_H #define INCLUDED_IMFNAMESPACE_H // // The purpose of this file is to have all of the Imath symbols defined within // the OPENEXR_IMF_INTERNAL_NAMESPACE namespace rather than the standard Imath // namespace. Those symbols are made available to client code through the // OPENEXR_IMF_NAMESPACE in addition to the OPENEXR_IMF_INTERNAL_NAMESPACE. // // To ensure source code compatibility, the OPENEXR_IMF_NAMESPACE defaults to // Imath and then "using namespace OPENEXR_IMF_INTERNAL_NAMESPACE;" brings all // of the declarations from the OPENEXR_IMF_INTERNAL_NAMESPACE into the // OPENEXR_IMF_NAMESPACE. // This means that client code can continue to use syntax like // Imf::Header, but at link time it will resolve to a // mangled symbol based on the OPENEXR_IMF_INTERNAL_NAMESPACE. // // As an example, if one needed to build against a newer version of Imath and // have it run alongside an older version in the same application, it is now // possible to use an internal namespace to prevent collisions between the // older versions of Imath symbols and the newer ones. To do this, the // following could be defined at build time: // // OPENEXR_IMF_INTERNAL_NAMESPACE = Imf_v2 // // This means that declarations inside Imath headers look like this (after // the preprocessor has done its work): // // namespace Imf_v2 { // ... // class declarations // ... // } // // namespace Imf { // using namespace IMF_NAMESPACE_v2; // } // // // Open Source version of this file pulls in the OpenEXRConfig.h file // for the configure time options. // #include "OpenEXRConfig.h" #ifndef OPENEXR_IMF_NAMESPACE #define OPENEXR_IMF_NAMESPACE Imf #endif #ifndef OPENEXR_IMF_INTERNAL_NAMESPACE #define OPENEXR_IMF_INTERNAL_NAMESPACE OPENEXR_IMF_NAMESPACE #endif // // We need to be sure that we import the internal namespace into the public one. // To do this, we use the small bit of code below which initially defines // OPENEXR_IMF_INTERNAL_NAMESPACE (so it can be referenced) and then defines // OPENEXR_IMF_NAMESPACE and pulls the internal symbols into the public // namespace. // namespace OPENEXR_IMF_INTERNAL_NAMESPACE {} namespace OPENEXR_IMF_NAMESPACE { using namespace OPENEXR_IMF_INTERNAL_NAMESPACE; } // // There are identical pairs of HEADER/SOURCE ENTER/EXIT macros so that // future extension to the namespace mechanism is possible without changing // project source code. // #define OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER namespace OPENEXR_IMF_INTERNAL_NAMESPACE { #define OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT } #define OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER namespace OPENEXR_IMF_INTERNAL_NAMESPACE { #define OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT } #endif /* INCLUDED_IMFNAMESPACE_H */ PK sM�[���< < ImfFlatImageIO.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_FLAT_IMAGE_IO_H #define INCLUDED_IMF_FLAT_IMAGE_IO_H //---------------------------------------------------------------------------- // // Functions to load flat images from OpenEXR files // and to save flat images in OpenEXR files. // //---------------------------------------------------------------------------- #include "ImfFlatImage.h" #include "ImfImageDataWindow.h" #include "ImfUtilExport.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER // // saveFlatImage (n, h, i, d) or // saveFlatImage (n, i) // // Saves image i in an OpenEXR file with name n. The file will be // tiled if the image has more than one level, or if a header, h, is // given and contains a tile description attribute; otherwise the // file will be scan-line based. // // If header h is given, then the channel list in h is replaced with // the channel list in i, and the levelMode and the levelRounding mode // fields of the tile description are replaced with the level mode // and the levelRounding mode of i. In addition, if the data window // source flag, d, is set to USE_IMAGE_DATA_WINDOW, then the data // window in the image is copied into the header; if d is set to // USE_HEADER_DATA_WINDOW, then the data window in the header is // replaced with the intersection of the original data window in the // header and the data window in the image. The modified header then // becomes the header of the image file. // IMFUTIL_EXPORT void saveFlatImage (const std::string &fileName, const Header &hdr, const FlatImage &img, DataWindowSource dws = USE_IMAGE_DATA_WINDOW); IMFUTIL_EXPORT void saveFlatImage (const std::string &fileName, const FlatImage &img); // // loadFlatImage (n, h, i) or // loadFlatImage (n, i) // // Loads flat image i from the OpenEXR file with name n. // // If header h is given, then the header of the file is copied into h. // IMFUTIL_EXPORT void loadFlatImage (const std::string &fileName, Header &hdr, FlatImage &img); IMFUTIL_EXPORT void loadFlatImage (const std::string &fileName, FlatImage &img); // // saveFlatScanLineImage (n, h, i, d) or // saveFlatScanLineImage (n, i) // // Saves image i in a scan-line based flat OpenEXR file with file name n. // // If header h is given, then the channel list in h is replaced with // the channel list in i. In addition, if the data window source flag, d, // is set to USE_IMAGE_DATA_WINDOW, then the data window in the image is // copied into the header; if d is set to USE_HEADER_DATA_WINDOW, then // the data window in the header is replaced with the intersection of // the original data window in the header and the data window in the // image. The modified header then becomes the header of the image file. // IMFUTIL_EXPORT void saveFlatScanLineImage (const std::string &fileName, const Header &hdr, const FlatImage &img, DataWindowSource dws = USE_IMAGE_DATA_WINDOW); IMFUTIL_EXPORT void saveFlatScanLineImage (const std::string &fileName, const FlatImage &img); // // loadFlatScanLineImage (n, h, i) or // loadFlatScanLineImage (n, i) // // Loads image i from a scan-line based flat OpenEXR file with file name n. // If header h is given, then the header of the file is copied into h. // IMFUTIL_EXPORT void loadFlatScanLineImage (const std::string &fileName, Header &hdr, FlatImage &img); IMFUTIL_EXPORT void loadFlatScanLineImage (const std::string &fileName, FlatImage &img); // // saveFlatTiledImage (n, h, i, d) or // saveFlatTiledImage (n, i) // // Saves image i in a tiled flat OpenEXR file with file name n. // // If header h is given, then the channel list in h is replaced with // the channel list i, and the levelMode and the levelRounding mode // fields of the tile description are replaced with the level mode // and the levelRounding mode of i. In addition, if the data window // source flag, d, is set to USE_IMAGE_DATA_WINDOW, then the data // window in the image is copied into the header; if d is set to // USE_HEADER_DATA_WINDOW, then the data window in the header is // replaced with the intersection of the original data window in the // header and the data window in the image. The modified header then // becomes the header of the image file. // // Note: USE_HEADER_DATA_WINDOW can only be used for images with // level mode ONE_LEVEL. // IMFUTIL_EXPORT void saveFlatTiledImage (const std::string &fileName, const Header &hdr, const FlatImage &img, DataWindowSource dws = USE_IMAGE_DATA_WINDOW); IMFUTIL_EXPORT void saveFlatTiledImage (const std::string &fileName, const FlatImage &img); // // loadFlatTiledImage (n, h, i) or // loadFlatTiledImage (n, i) // // Loads image i from a tiled flat OpenEXR file with file name n. // If header h is given, then the header of the file is copied into h. // IMFUTIL_EXPORT void loadFlatTiledImage (const std::string &fileName, Header &hdr, FlatImage &img); IMFUTIL_EXPORT void loadFlatTiledImage (const std::string &fileName, FlatImage &img); OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK sM�[Wc_�� � openexr.hnu �[��� /* ** SPDX-License-Identifier: BSD-3-Clause ** Copyright Contributors to the OpenEXR Project. */ #ifndef OPENEXR_CORE_H #define OPENEXR_CORE_H #include "openexr_conf.h" #include "openexr_base.h" #include "openexr_errors.h" #include "openexr_context.h" #include "openexr_attr.h" #include "openexr_part.h" #include "openexr_std_attr.h" #include "openexr_chunkio.h" #include "openexr_decode.h" #include "openexr_encode.h" #include "openexr_debug.h" #endif /* OPENEXR_CORE_H */ PK sM�[(�o ImfOpaqueAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_OPAQUE_ATTRIBUTE_H #define INCLUDED_IMF_OPAQUE_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class OpaqueAttribute // // When an image file is read, OpqaqueAttribute objects are used // to hold the values of attributes whose types are not recognized // by the reading program. OpaqueAttribute objects can be read // from an image file, copied, and written back to to another image // file, but their values are inaccessible. // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" #include "ImfArray.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class IMF_EXPORT_TYPE OpaqueAttribute: public Attribute { public: //---------------------------- // Constructors and destructor //---------------------------- IMF_EXPORT OpaqueAttribute (const char typeName[]); IMF_EXPORT OpaqueAttribute (const OpaqueAttribute &other); IMF_EXPORT virtual ~OpaqueAttribute (); //------------------------------- // Get this attribute's type name //------------------------------- IMF_EXPORT virtual const char * typeName () const; //------------------------------ // Make a copy of this attribute //------------------------------ IMF_EXPORT virtual Attribute * copy () const; //---------------- // I/O and copying //---------------- IMF_EXPORT virtual void writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, int version) const; IMF_EXPORT virtual void readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int size, int version); IMF_EXPORT virtual void copyValueFrom (const Attribute &other); int dataSize() const { return _dataSize; } const Array<char>& data() const { return _data; } private: std::string _typeName; long _dataSize; Array<char> _data; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK sM�[�o �F F ImfForward.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_FORWARD_H #define INCLUDED_IMF_FORWARD_H //////////////////////////////////////////////////////////////////// // // Forward declarations for OpenEXR - correctly declares namespace // //////////////////////////////////////////////////////////////////// #include "ImfExport.h" #include "ImfNamespace.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER // classes for basic types; template<class T> class IMF_EXPORT_TEMPLATE_TYPE Array; template<class T> class IMF_EXPORT_TEMPLATE_TYPE Array2D; struct IMF_EXPORT_TYPE Channel; class IMF_EXPORT_TYPE ChannelList; struct IMF_EXPORT_TYPE Chromaticities; // attributes used in headers are TypedAttributes class IMF_EXPORT_TYPE Attribute; class IMF_EXPORT_TYPE Header; // file handling classes class IMF_EXPORT_TYPE OutputFile; class IMF_EXPORT_TYPE TiledInputFile; class IMF_EXPORT_TYPE ScanLineInputFile; class IMF_EXPORT_TYPE InputFile; class IMF_EXPORT_TYPE TiledOutputFile; class IMF_EXPORT_TYPE DeepScanLineInputFile; class IMF_EXPORT_TYPE DeepScanLineOutputFile; class IMF_EXPORT_TYPE DeepTiledInputFile; class IMF_EXPORT_TYPE DeepTiledOutputFile; class IMF_EXPORT_TYPE AcesInputFile; class IMF_EXPORT_TYPE AcesOutputFile; class IMF_EXPORT_TYPE TiledInputPart; class IMF_EXPORT_TYPE TiledInputFile; class IMF_EXPORT_TYPE TileOffsets; // multipart file handling class IMF_EXPORT_TYPE GenericInputFile; class IMF_EXPORT_TYPE GenericOutputFile; class IMF_EXPORT_TYPE MultiPartInputFile; class IMF_EXPORT_TYPE MultiPartOutputFile; class IMF_EXPORT_TYPE InputPart; class IMF_EXPORT_TYPE TiledInputPart; class IMF_EXPORT_TYPE DeepScanLineInputPart; class IMF_EXPORT_TYPE DeepTiledInputPart; class IMF_EXPORT_TYPE OutputPart; class IMF_EXPORT_TYPE ScanLineOutputPart; class IMF_EXPORT_TYPE TiledOutputPart; class IMF_EXPORT_TYPE DeepScanLineOutputPart; class IMF_EXPORT_TYPE DeepTiledOutputPart; // internal use only struct InputPartData; struct OutputStreamMutex; struct OutputPartData; struct InputStreamMutex; // frame buffers class IMF_EXPORT_TYPE FrameBuffer; class IMF_EXPORT_TYPE DeepFrameBuffer; struct IMF_EXPORT_TYPE DeepSlice; // compositing class IMF_EXPORT_TYPE DeepCompositing; class IMF_EXPORT_TYPE CompositeDeepScanLine; // preview image class IMF_EXPORT_TYPE PreviewImage; struct IMF_EXPORT_TYPE PreviewRgba; // streams class IMF_EXPORT_TYPE OStream; class IMF_EXPORT_TYPE IStream; class IMF_EXPORT_TYPE IDManifest; class IMF_EXPORT_TYPE CompressedIDManifest; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif // include guard PK sM�[�+)�� � ImfStdIO.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_STD_IO_H #define INCLUDED_IMF_STD_IO_H //----------------------------------------------------------------------------- // // Low-level file input and output for OpenEXR // based on C++ standard iostreams. // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfIO.h" #include <fstream> #include <sstream> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER //------------------------------------------- // class StdIFStream -- an implementation of // class OPENEXR_IMF_INTERNAL_NAMESPACE::IStream based on class std::ifstream //------------------------------------------- class IMF_EXPORT_TYPE StdIFStream: public OPENEXR_IMF_INTERNAL_NAMESPACE::IStream { public: //------------------------------------------------------- // A constructor that opens the file with the given name. // The destructor will close the file. //------------------------------------------------------- IMF_EXPORT StdIFStream (const char fileName[]); //--------------------------------------------------------- // A constructor that uses a std::ifstream that has already // been opened by the caller. The StdIFStream's destructor // will not close the std::ifstream. //--------------------------------------------------------- IMF_EXPORT StdIFStream (std::ifstream &is, const char fileName[]); IMF_EXPORT virtual ~StdIFStream (); StdIFStream (const StdIFStream &) = delete; StdIFStream (StdIFStream &&) = delete; StdIFStream &operator=(const StdIFStream &) = delete; StdIFStream &operator=(StdIFStream &&) = delete; IMF_EXPORT virtual bool read (char c[/*n*/], int n); IMF_EXPORT virtual uint64_t tellg (); IMF_EXPORT virtual void seekg (uint64_t pos); IMF_EXPORT virtual void clear (); private: std::ifstream * _is; bool _deleteStream; }; //------------------------------------------------ // class StdISStream -- an implementation of class // OPENEXR_IMF_INTERNAL_NAMESPACE::IStream, based on class std::istringstream //------------------------------------------------ class IMF_EXPORT_TYPE StdISStream: public OPENEXR_IMF_INTERNAL_NAMESPACE::IStream { public: IMF_EXPORT StdISStream (); IMF_EXPORT ~StdISStream (); StdISStream (const StdISStream &) = delete; StdISStream (StdISStream &&) = delete; StdISStream &operator=(const StdISStream &) = delete; StdISStream &operator=(StdISStream &&) = delete; IMF_EXPORT virtual bool read (char c[/*n*/], int n); IMF_EXPORT virtual uint64_t tellg (); IMF_EXPORT virtual void seekg (uint64_t pos); IMF_EXPORT virtual void clear (); IMF_EXPORT std::string str () const; IMF_EXPORT void str (const std::string &s); private: std::istringstream _is; }; //------------------------------------------- // class StdOFStream -- an implementation of // class OPENEXR_IMF_INTERNAL_NAMESPACE::OStream based on class std::ofstream //------------------------------------------- class IMF_EXPORT_TYPE StdOFStream: public OPENEXR_IMF_INTERNAL_NAMESPACE::OStream { public: //------------------------------------------------------- // A constructor that opens the file with the given name. // The destructor will close the file. //------------------------------------------------------- IMF_EXPORT StdOFStream (const char fileName[]); //--------------------------------------------------------- // A constructor that uses a std::ofstream that has already // been opened by the caller. The StdOFStream's destructor // will not close the std::ofstream. //--------------------------------------------------------- IMF_EXPORT StdOFStream (std::ofstream &os, const char fileName[]); IMF_EXPORT virtual ~StdOFStream (); StdOFStream (const StdOFStream &) = delete; StdOFStream (StdOFStream &&) = delete; StdOFStream &operator=(const StdOFStream &) = delete; StdOFStream &operator=(StdOFStream &&) = delete; IMF_EXPORT virtual void write (const char c[/*n*/], int n); IMF_EXPORT virtual uint64_t tellp (); IMF_EXPORT virtual void seekp (uint64_t pos); private: std::ofstream * _os; bool _deleteStream; }; //------------------------------------------------ // class StdOSStream -- an implementation of class // OPENEXR_IMF_INTERNAL_NAMESPACE::OStream, based on class std::ostringstream //------------------------------------------------ class IMF_EXPORT_TYPE StdOSStream: public OPENEXR_IMF_INTERNAL_NAMESPACE::OStream { public: IMF_EXPORT StdOSStream (); IMF_EXPORT ~StdOSStream (); StdOSStream (const StdOSStream &) = delete; StdOSStream (StdOSStream &&) = delete; StdOSStream &operator=(const StdOSStream &) = delete; StdOSStream &operator=(StdOSStream &&) = delete; IMF_EXPORT virtual void write (const char c[/*n*/], int n); IMF_EXPORT virtual uint64_t tellp (); IMF_EXPORT virtual void seekp (uint64_t pos); IMF_EXPORT std::string str () const; private: std::ostringstream _os; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK sM�[��7_� � IexExport.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IEXEXPORT_H #define INCLUDED_IEXEXPORT_H #include "OpenEXRConfig.h" #if defined(OPENEXR_DLL) // when building as a DLL for windows, typical dllexport / import case // where we need to switch depending on whether we are compiling // internally or not # if defined(IEX_EXPORTS) # define IEX_EXPORT __declspec(dllexport) # else # define IEX_EXPORT __declspec(dllimport) # endif // DLLs don't support these types of visibility controls, just leave them as empty # define IEX_EXPORT_TYPE # define IEX_EXPORT_ENUM #else // OPENEXR_DLL // just pass these through from the top level config # define IEX_EXPORT OPENEXR_EXPORT # define IEX_EXPORT_TYPE OPENEXR_EXPORT_TYPE # define IEX_EXPORT_ENUM OPENEXR_EXPORT_ENUM #endif // OPENEXR_DLL /// @} #endif // #ifndef INCLUDED_IEXEXPORT_H PK sM�[t4�:( :( ImfDeepImageLevel.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_DEEP_IMAGE_LEVEL_H #define INCLUDED_IMF_DEEP_IMAGE_LEVEL_H //---------------------------------------------------------------------------- // // class DeepImageLevel // class DeepImageLevel::Iterator // class DeepImageLevel::ConstIterator // // For an explanation of images, levels and channels, // see the comments in header file Image.h. // //---------------------------------------------------------------------------- #include "ImfUtilExport.h" #include "ImfNamespace.h" #include "ImfDeepImageChannel.h" #include "ImfSampleCountChannel.h" #include "ImfImageLevel.h" #include <string> #include <map> OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class DeepImage; class IMFUTIL_EXPORT_TYPE DeepImageLevel : public ImageLevel { public: // // Access to the image to which the level belongs. // IMFUTIL_EXPORT DeepImage & deepImage (); IMFUTIL_EXPORT const DeepImage & deepImage () const; // // Access to deep channels by name: // // findChannel(n) returns a pointer to the image channel with // name n, or 0 if no such channel exists. // // channel(n) returns a reference to the image channel with // name n, or throws an Iex::ArgExc exception if // no such channel exists. // // findTypedChannel<T>(n) returns a pointer to the image channel with // name n and type T, or 0 if no such channel // exists. // // typedChannel(n) returns a reference to the image channel with // name n and type T, or throws an Iex::ArgExc // exception if no such channel exists. // IMFUTIL_EXPORT DeepImageChannel * findChannel (const std::string& name); IMFUTIL_EXPORT const DeepImageChannel * findChannel (const std::string& name) const; IMFUTIL_EXPORT DeepImageChannel & channel (const std::string& name); IMFUTIL_EXPORT const DeepImageChannel & channel (const std::string& name) const; template <class T> TypedDeepImageChannel<T> * findTypedChannel (const std::string& name); template <class T> const TypedDeepImageChannel<T> * findTypedChannel (const std::string& name) const; template <class T> TypedDeepImageChannel<T> & typedChannel (const std::string& name); template <class T> const TypedDeepImageChannel<T> & typedChannel (const std::string& name) const; // // Iterator-style access to deep channels // typedef std::map <std::string, DeepImageChannel *> ChannelMap; class Iterator; class ConstIterator; IMFUTIL_EXPORT Iterator begin(); IMFUTIL_EXPORT ConstIterator begin() const; IMFUTIL_EXPORT Iterator end(); IMFUTIL_EXPORT ConstIterator end() const; // // Access to the sample count channel // IMFUTIL_EXPORT SampleCountChannel & sampleCounts(); IMFUTIL_EXPORT const SampleCountChannel & sampleCounts() const; private: friend class DeepImage; friend class SampleCountChannel; // // The constructor and destructor are private. // Deep image levels exist only as part of a deep image. // IMF_HIDDEN DeepImageLevel (DeepImage& image, int xLevelNumber, int yLevelNumber, const IMATH_NAMESPACE::Box2i& dataWindow); IMF_HIDDEN ~DeepImageLevel (); IMF_HIDDEN void setSamplesToZero (size_t i, unsigned int oldNumSamples, unsigned int newNumSamples); IMF_HIDDEN void moveSampleList (size_t i, unsigned int oldNumSamples, unsigned int newNumSamples, size_t newSampleListPosition); IMF_HIDDEN void moveSamplesToNewBuffer (const unsigned int * oldNumSamples, const unsigned int * newNumSamples, const size_t * newSampleListPositions); IMF_HIDDEN void initializeSampleLists (); IMF_HIDDEN virtual void resize (const IMATH_NAMESPACE::Box2i& dataWindow); IMF_HIDDEN virtual void shiftPixels (int dx, int dy); IMF_HIDDEN virtual void insertChannel (const std::string& name, PixelType type, int xSampling, int ySampling, bool pLinear); IMF_HIDDEN virtual void eraseChannel (const std::string& name); IMF_HIDDEN virtual void clearChannels (); IMF_HIDDEN virtual void renameChannel (const std::string &oldName, const std::string &newName); IMF_HIDDEN virtual void renameChannels (const RenamingMap &oldToNewNames); ChannelMap _channels; SampleCountChannel _sampleCounts; }; class IMFUTIL_EXPORT_TYPE DeepImageLevel::Iterator { public: IMFUTIL_EXPORT Iterator (); IMFUTIL_EXPORT Iterator (const DeepImageLevel::ChannelMap::iterator& i); // // Advance the iterator // IMFUTIL_EXPORT Iterator & operator ++ (); IMFUTIL_EXPORT Iterator operator ++ (int); // // Access to the channel to which the iterator points, // and to the name of that channel. // IMFUTIL_EXPORT const std::string & name () const; IMFUTIL_EXPORT DeepImageChannel & channel () const; private: friend class DeepImageLevel::ConstIterator; DeepImageLevel::ChannelMap::iterator _i; }; class IMFUTIL_EXPORT_TYPE DeepImageLevel::ConstIterator { public: IMFUTIL_EXPORT ConstIterator (); IMFUTIL_EXPORT ConstIterator (const DeepImageLevel::ChannelMap::const_iterator& i); IMFUTIL_EXPORT ConstIterator (const DeepImageLevel::Iterator& other); // // Advance the iterator // IMFUTIL_EXPORT ConstIterator & operator ++ (); IMFUTIL_EXPORT ConstIterator operator ++ (int); // // Access to the channel to which the iterator points, // and to the name of that channel. // IMFUTIL_EXPORT const std::string & name () const; IMFUTIL_EXPORT const DeepImageChannel & channel () const; private: friend bool operator == (const ConstIterator &, const ConstIterator &); friend bool operator != (const ConstIterator &, const ConstIterator &); DeepImageLevel::ChannelMap::const_iterator _i; }; //----------------------------------------------------------------------------- // Implementation of inline functions //----------------------------------------------------------------------------- template <class T> TypedDeepImageChannel<T> * DeepImageLevel::findTypedChannel (const std::string& name) { return dynamic_cast <TypedDeepImageChannel<T> *> (findChannel (name)); } template <class T> const TypedDeepImageChannel<T> * DeepImageLevel::findTypedChannel (const std::string& name) const { return dynamic_cast <const TypedDeepImageChannel<T> *> (findChannel (name)); } template <class T> TypedDeepImageChannel<T> & DeepImageLevel::typedChannel (const std::string& name) { TypedDeepImageChannel<T> * ptr = findTypedChannel<T> (name); if (ptr == 0) throwBadChannelNameOrType (name); return *ptr; } template <class T> const TypedDeepImageChannel<T> & DeepImageLevel::typedChannel (const std::string& name) const { const TypedDeepImageChannel<T> * ptr = findTypedChannel<T> (name); if (ptr == 0) throwBadChannelNameOrType (name); return *ptr; } inline SampleCountChannel & DeepImageLevel::sampleCounts () { return _sampleCounts; } inline const SampleCountChannel & DeepImageLevel::sampleCounts () const { return _sampleCounts; } inline DeepImageLevel::Iterator::Iterator (): _i() { // empty } inline DeepImageLevel::Iterator::Iterator (const DeepImageLevel::ChannelMap::iterator& i) : _i (i) { // empty } inline DeepImageLevel::Iterator & DeepImageLevel::Iterator::operator ++ () { ++_i; return *this; } inline DeepImageLevel::Iterator DeepImageLevel::Iterator::operator ++ (int) { Iterator tmp = *this; ++_i; return tmp; } inline const std::string & DeepImageLevel::Iterator::name () const { return _i->first; } inline DeepImageChannel & DeepImageLevel::Iterator::channel () const { return *_i->second; } inline DeepImageLevel::ConstIterator::ConstIterator (): _i() { // empty } inline DeepImageLevel::ConstIterator::ConstIterator (const DeepImageLevel::ChannelMap::const_iterator& i): _i (i) { // empty } inline DeepImageLevel::ConstIterator::ConstIterator (const DeepImageLevel::Iterator& other): _i (other._i) { // empty } inline DeepImageLevel::ConstIterator & DeepImageLevel::ConstIterator::operator ++ () { ++_i; return *this; } inline DeepImageLevel::ConstIterator DeepImageLevel::ConstIterator::operator ++ (int) { ConstIterator tmp = *this; ++_i; return tmp; } inline const std::string & DeepImageLevel::ConstIterator::name () const { return _i->first; } inline const DeepImageChannel & DeepImageLevel::ConstIterator::channel () const { return *_i->second; } inline bool operator == (const DeepImageLevel::ConstIterator& x, const DeepImageLevel::ConstIterator& y) { return x._i == y._i; } inline bool operator != (const DeepImageLevel::ConstIterator& x, const DeepImageLevel::ConstIterator& y) { return !(x == y); } OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK sM�[`�8$� � IexErrnoExc.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IEXERRNOEXC_H #define INCLUDED_IEXERRNOEXC_H //---------------------------------------------------------------- // // Exceptions which correspond to "errno" error codes. // //---------------------------------------------------------------- #include "IexBaseExc.h" IEX_INTERNAL_NAMESPACE_HEADER_ENTER DEFINE_EXC_EXP (IEX_EXPORT, EpermExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnoentExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EsrchExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EintrExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EioExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnxioExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, E2bigExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnoexecExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EbadfExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EchildExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EagainExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnomemExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EaccesExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EfaultExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnotblkExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EbusyExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EexistExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, ExdevExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnodevExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnotdirExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EisdirExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EinvalExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnfileExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EmfileExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnottyExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EtxtbsyExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EfbigExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnospcExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EspipeExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, ErofsExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EmlinkExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EpipeExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EdomExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, ErangeExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnomsgExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EidrmExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EchrngExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, El2nsyncExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, El3hltExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, El3rstExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, ElnrngExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EunatchExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnocsiExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, El2hltExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EdeadlkExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnolckExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EbadeExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EbadrExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, ExfullExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnoanoExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EbadrqcExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EbadsltExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EdeadlockExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EbfontExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnostrExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnodataExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EtimeExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnosrExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnonetExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnopkgExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EremoteExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnolinkExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EadvExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EsrmntExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EcommExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EprotoExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EmultihopExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EbadmsgExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnametoolongExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EoverflowExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnotuniqExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EbadfdExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EremchgExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, ElibaccExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, ElibbadExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, ElibscnExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, ElibmaxExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, ElibexecExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EilseqExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnosysExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EloopExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, ErestartExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EstrpipeExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnotemptyExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EusersExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnotsockExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EdestaddrreqExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EmsgsizeExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EprototypeExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnoprotooptExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EprotonosupportExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EsocktnosupportExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EopnotsuppExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EpfnosupportExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EafnosupportExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EaddrinuseExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EaddrnotavailExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnetdownExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnetunreachExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnetresetExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EconnabortedExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EconnresetExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnobufsExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EisconnExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnotconnExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EshutdownExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EtoomanyrefsExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EtimedoutExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EconnrefusedExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EhostdownExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EhostunreachExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EalreadyExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EinprogressExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EstaleExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EioresidExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EucleanExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnotnamExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnavailExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EisnamExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EremoteioExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EinitExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EremdevExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EcanceledExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnolimfileExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EproclimExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EdisjointExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnologinExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EloginlimExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EgrouploopExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnoattachExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnotsupExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnoattrExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EdircorruptedExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EdquotExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnfsremoteExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EcontrollerExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnotcontrollerExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EenqueuedExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnotenqueuedExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EjoinedExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnotjoinedExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnoprocExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EmustrunExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnotstoppedExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EclockcpuExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EinvalstateExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnoexistExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EendofminorExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EbufsizeExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EemptyExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EnointrgroupExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EinvalmodeExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EcantextentExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EinvaltimeExc, ErrnoExc) DEFINE_EXC_EXP (IEX_EXPORT, EdestroyedExc, ErrnoExc) IEX_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK sM�[�:�r� � IexForward.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IEXFORWARD_H #define INCLUDED_IEXFORWARD_H #include "IexNamespace.h" IEX_INTERNAL_NAMESPACE_HEADER_ENTER // // Base exceptions. // class BaseExc; class ArgExc; class LogicExc; class InputExc; class IoExc; class MathExc; class ErrnoExc; class NoImplExc; class NullExc; class TypeExc; // // Math exceptions. // class OverflowExc; class UnderflowExc; class DivzeroExc; class InexactExc; class InvalidFpOpExc; // // Errno exceptions. // class EpermExc; class EnoentExc; class EsrchExc; class EintrExc; class EioExc; class EnxioExc; class E2bigExc; class EnoexecExc; class EbadfExc; class EchildExc; class EagainExc; class EnomemExc; class EaccesExc; class EfaultExc; class EnotblkExc; class EbusyExc; class EexistExc; class ExdevExc; class EnodevExc; class EnotdirExc; class EisdirExc; class EinvalExc; class EnfileExc; class EmfileExc; class EnottyExc; class EtxtbsyExc; class EfbigExc; class EnospcExc; class EspipeExc; class ErofsExc; class EmlinkExc; class EpipeExc; class EdomExc; class ErangeExc; class EnomsgExc; class EidrmExc; class EchrngExc; class El2nsyncExc; class El3hltExc; class El3rstExc; class ElnrngExc; class EunatchExc; class EnocsiExc; class El2hltExc; class EdeadlkExc; class EnolckExc; class EbadeExc; class EbadrExc; class ExfullExc; class EnoanoExc; class EbadrqcExc; class EbadsltExc; class EdeadlockExc; class EbfontExc; class EnostrExc; class EnodataExc; class EtimeExc; class EnosrExc; class EnonetExc; class EnopkgExc; class EremoteExc; class EnolinkExc; class EadvExc; class EsrmntExc; class EcommExc; class EprotoExc; class EmultihopExc; class EbadmsgExc; class EnametoolongExc; class EoverflowExc; class EnotuniqExc; class EbadfdExc; class EremchgExc; class ElibaccExc; class ElibbadExc; class ElibscnExc; class ElibmaxExc; class ElibexecExc; class EilseqExc; class EnosysExc; class EloopExc; class ErestartExc; class EstrpipeExc; class EnotemptyExc; class EusersExc; class EnotsockExc; class EdestaddrreqExc; class EmsgsizeExc; class EprototypeExc; class EnoprotooptExc; class EprotonosupportExc; class EsocktnosupportExc; class EopnotsuppExc; class EpfnosupportExc; class EafnosupportExc; class EaddrinuseExc; class EaddrnotavailExc; class EnetdownExc; class EnetunreachExc; class EnetresetExc; class EconnabortedExc; class EconnresetExc; class EnobufsExc; class EisconnExc; class EnotconnExc; class EshutdownExc; class EtoomanyrefsExc; class EtimedoutExc; class EconnrefusedExc; class EhostdownExc; class EhostunreachExc; class EalreadyExc; class EinprogressExc; class EstaleExc; class EioresidExc; class EucleanExc; class EnotnamExc; class EnavailExc; class EisnamExc; class EremoteioExc; class EinitExc; class EremdevExc; class EcanceledExc; class EnolimfileExc; class EproclimExc; class EdisjointExc; class EnologinExc; class EloginlimExc; class EgrouploopExc; class EnoattachExc; class EnotsupExc; class EnoattrExc; class EdircorruptedExc; class EdquotExc; class EnfsremoteExc; class EcontrollerExc; class EnotcontrollerExc; class EenqueuedExc; class EnotenqueuedExc; class EjoinedExc; class EnotjoinedExc; class EnoprocExc; class EmustrunExc; class EnotstoppedExc; class EclockcpuExc; class EinvalstateExc; class EnoexistExc; class EendofminorExc; class EbufsizeExc; class EemptyExc; class EnointrgroupExc; class EinvalmodeExc; class EcantextentExc; class EinvaltimeExc; class EdestroyedExc; IEX_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IEXFORWARD_H PK sM�[N0��ce ce openexr_part.hnu �[��� /* ** 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 /** * @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 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 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); /**************************************/ /** @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); enum exr_attr_list_access_mode { EXR_ATTR_LIST_FILE_ORDER, /**< order they appear in the file */ EXR_ATTR_LIST_SORTED_ORDER /**< alphabetically sorted */ }; /** @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, enum exr_attr_list_access_mode 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, enum exr_attr_list_access_mode 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 int 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. * * @param 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 */ PK sM�[�^� � ImfFloatAttribute.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_FLOAT_ATTRIBUTE_H #define INCLUDED_IMF_FLOAT_ATTRIBUTE_H //----------------------------------------------------------------------------- // // class FloatAttribute // //----------------------------------------------------------------------------- #include "ImfExport.h" #include "ImfNamespace.h" #include "ImfAttribute.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER typedef TypedAttribute<float> FloatAttribute; #ifndef COMPILING_IMF_FLOAT_ATTRIBUTE extern template class IMF_EXPORT_EXTERN_TEMPLATE TypedAttribute<float>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK sM�[�+j2� � openexr_errors.hnu �[��� /* ** SPDX-License-Identifier: BSD-3-Clause ** Copyright Contributors to the OpenEXR Project. */ #ifndef OPENEXR_ERRORS_H #define OPENEXR_ERRORS_H #include "openexr_conf.h" #include <stdint.h> #ifdef __cplusplus extern "C" { #endif /** * @defgroup ErrorCodes Error Handling * @brief These are a group of definitions related to error handling * * All functions in the C layer will return a result, which will * correspond to one of these codes. To ensure binary stability, the * return type is separate from the error code, and is a fixed size. * * @{ */ /** error codes that may be returned by various functions */ typedef enum { EXR_ERR_SUCCESS = 0, EXR_ERR_OUT_OF_MEMORY, EXR_ERR_MISSING_CONTEXT_ARG, EXR_ERR_INVALID_ARGUMENT, EXR_ERR_ARGUMENT_OUT_OF_RANGE, EXR_ERR_FILE_ACCESS, EXR_ERR_FILE_BAD_HEADER, EXR_ERR_NOT_OPEN_READ, EXR_ERR_NOT_OPEN_WRITE, EXR_ERR_HEADER_NOT_WRITTEN, EXR_ERR_READ_IO, EXR_ERR_WRITE_IO, EXR_ERR_NAME_TOO_LONG, EXR_ERR_MISSING_REQ_ATTR, EXR_ERR_INVALID_ATTR, EXR_ERR_NO_ATTR_BY_NAME, EXR_ERR_ATTR_TYPE_MISMATCH, EXR_ERR_ATTR_SIZE_MISMATCH, EXR_ERR_SCAN_TILE_MIXEDAPI, EXR_ERR_TILE_SCAN_MIXEDAPI, EXR_ERR_MODIFY_SIZE_CHANGE, EXR_ERR_ALREADY_WROTE_ATTRS, EXR_ERR_BAD_CHUNK_LEADER, EXR_ERR_CORRUPT_CHUNK, EXR_ERR_INCORRECT_PART, EXR_ERR_INCORRECT_CHUNK, EXR_ERR_USE_SCAN_DEEP_WRITE, EXR_ERR_USE_TILE_DEEP_WRITE, EXR_ERR_USE_SCAN_NONDEEP_WRITE, EXR_ERR_USE_TILE_NONDEEP_WRITE, EXR_ERR_INVALID_SAMPLE_DATA, EXR_ERR_FEATURE_NOT_IMPLEMENTED, EXR_ERR_UNKNOWN } exr_error_code_t; /** Return type for all functions */ typedef int32_t exr_result_t; /** @brief Return a static string corresponding to the specified error code * * The string should not be freed (it is compiled into the binary). */ EXR_EXPORT const char* exr_get_default_error_message (exr_result_t code); /** @brief Return a static string corresponding to the specified error code * * The string should not be freed (it is compiled into the binary). */ EXR_EXPORT const char* exr_get_error_code_as_string (exr_result_t code); /** @} */ #ifdef __cplusplus } /* extern "C" */ #endif #endif /* OPENEXR_ERRORS_H */ PK sM�[P�M�� � ImfDeepImageChannel.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_DEEP_IMAGE_CHANNEL_H #define INCLUDED_IMF_DEEP_IMAGE_CHANNEL_H //---------------------------------------------------------------------------- // // class DeepImageChannel, // template class TypedDeepImageChannel<T> // // For an explanation of images, levels and channels, // see the comments in header file Image.h. // //---------------------------------------------------------------------------- #include "ImfUtilExport.h" #include "ImfNamespace.h" #include "ImfImageChannel.h" #include "ImfSampleCountChannel.h" #include "ImfImageLevel.h" #include "ImfDeepFrameBuffer.h" OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER class DeepImageLevel; class SampleCountChannel; // // Image channels: // // A TypedDeepImageChannel<T> holds the pixel data for a single channel // of one level of a deep image. Each pixel in the channel contains an // array of n samples of type T, where T is either half, float or // unsigned int, and n is stored in a separate sample count channel. // Sample storage is allocated only for pixels within the data window // of the level. // class IMFUTIL_EXPORT_TYPE DeepImageChannel: public ImageChannel { public: // // Construct an OpenEXR frame buffer slice for this channel. // This function is needed reading an image from an OpenEXR // file and for saving an image in an OpenEXR file. // virtual DeepSlice slice () const = 0; // // Access to the image level to which this channel belongs. // IMFUTIL_EXPORT DeepImageLevel & deepLevel(); IMFUTIL_EXPORT const DeepImageLevel & deepLevel() const; // // Access to the sample count channel for this deep channel. // IMFUTIL_EXPORT SampleCountChannel & sampleCounts(); IMFUTIL_EXPORT const SampleCountChannel & sampleCounts() const; protected: friend class DeepImageLevel; IMFUTIL_EXPORT DeepImageChannel (DeepImageLevel &level, bool pLinear); IMFUTIL_EXPORT virtual ~DeepImageChannel(); DeepImageChannel (const DeepImageChannel& other) = delete; DeepImageChannel& operator = (const DeepImageChannel& other) = delete; DeepImageChannel (DeepImageChannel&& other) = delete; DeepImageChannel& operator = (DeepImageChannel&& other) = delete; virtual void setSamplesToZero (size_t i, unsigned int oldNumSamples, unsigned int newNumSamples) = 0; virtual void moveSampleList (size_t i, unsigned int oldNumSamples, unsigned int newNumSamples, size_t newSampleListPosition) = 0; virtual void moveSamplesToNewBuffer (const unsigned int * oldNumSamples, const unsigned int * newNumSamples, const size_t * newSampleListPositions) = 0; virtual void initializeSampleLists () = 0; IMFUTIL_EXPORT virtual void resize (); virtual void resetBasePointer () = 0; }; template <class T> class IMFUTIL_EXPORT_TEMPLATE_TYPE TypedDeepImageChannel: public DeepImageChannel { public: // // The OpenEXR pixel type of this channel (HALF, FLOAT or UINT). // virtual PixelType pixelType () const; // // Construct an OpenEXR frame buffer slice for this channel. // This function is needed reading an image from an OpenEXR // file and for saving an image in an OpenEXR file. // virtual DeepSlice slice () const; // // Access to the pixel at pixel space location (x, y), without bounds // checking. Accessing a location outside the data window of the image // level results in undefined behavior. // // The pixel contains a pointer to an array of samples to type T. The // number of samples in this array is sampleCounts().at(x,y). // T * operator () (int x, int y); const T * operator () (int x, int y) const; // // Access to the pixel at pixel space location (x, y), with bounds // checking. Accessing a location outside the data window of the // image level throws an Iex::ArgExc exception. // T * at (int x, int y); const T * at (int x, int y) const; // // Faster access to all pixels in a single horizontal row of the // channel. Access is not bounds checked; accessing out of bounds // rows or pixels results in undefined behavior. // // Rows are numbered from 0 to pixelsPerColumn()-1, and each row // contains pixelsPerRow() values. The number of samples in // row(r)[i] is sampleCounts().row(r)[i]. // T * const * row (int r); const T * const * row (int r) const; private: friend class DeepImageLevel; IMFUTIL_HIDDEN TypedDeepImageChannel (DeepImageLevel &level, bool pLinear); IMFUTIL_HIDDEN virtual ~TypedDeepImageChannel (); TypedDeepImageChannel (const TypedDeepImageChannel& other) = delete; TypedDeepImageChannel& operator = (const TypedDeepImageChannel& other) = delete; TypedDeepImageChannel (TypedDeepImageChannel&& other) = delete; TypedDeepImageChannel& operator = (TypedDeepImageChannel&& other) = delete; IMFUTIL_HIDDEN virtual void setSamplesToZero (size_t i, unsigned int oldNumSamples, unsigned int newNumSamples); IMFUTIL_HIDDEN virtual void moveSampleList (size_t i, unsigned int oldNumSamples, unsigned int newNumSamples, size_t newSampleListPosition); IMFUTIL_HIDDEN virtual void moveSamplesToNewBuffer (const unsigned int * oldNumSamples, const unsigned int * newNumSamples, const size_t * newSampleListPositions); IMFUTIL_HIDDEN virtual void initializeSampleLists (); IMFUTIL_HIDDEN virtual void resize (); IMFUTIL_HIDDEN virtual void resetBasePointer (); T ** _sampleListPointers; // Array of pointers to per-pixel //sample lists T ** _base; // Base pointer for faster access // to entries in _sampleListPointers T * _sampleBuffer; // Contiguous memory block that // contains all sample lists for // this channel }; // // Channel typedefs for the pixel data types supported by OpenEXR. // typedef TypedDeepImageChannel<half> DeepHalfChannel; typedef TypedDeepImageChannel<float> DeepFloatChannel; typedef TypedDeepImageChannel<unsigned int> DeepUIntChannel; //----------------------------------------------------------------------------- // Implementation of templates and inline functions //----------------------------------------------------------------------------- template <class T> inline T * TypedDeepImageChannel<T>::operator () (int x, int y) { return _base[y * pixelsPerRow() + x]; } template <class T> inline const T * TypedDeepImageChannel<T>::operator () (int x, int y) const { return _base[y * pixelsPerRow() + x]; } template <class T> inline T * TypedDeepImageChannel<T>::at (int x, int y) { boundsCheck (x, y); return _base[y * pixelsPerRow() + x]; } template <class T> inline const T * TypedDeepImageChannel<T>::at (int x, int y) const { boundsCheck (x, y); return _base[y * pixelsPerRow() + x]; } template <class T> inline T * const * TypedDeepImageChannel<T>::row (int r) { return _base + r * pixelsPerRow(); } template <class T> inline const T * const * TypedDeepImageChannel<T>::row (int r) const { return _base + r * pixelsPerRow(); } #ifndef COMPILING_IMF_DEEP_IMAGE_CHANNEL extern template class IMFUTIL_EXPORT_EXTERN_TEMPLATE TypedDeepImageChannel<half>; extern template class IMFUTIL_EXPORT_EXTERN_TEMPLATE TypedDeepImageChannel<float>; extern template class IMFUTIL_EXPORT_EXTERN_TEMPLATE TypedDeepImageChannel<unsigned int>; #endif OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK sM�[�6��� � OpenEXRConfig.hnu �[��� // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // This file is auto-generated by the configure step #ifndef INCLUDED_OPENEXR_CONFIG_H #define INCLUDED_OPENEXR_CONFIG_H 1 #pragma once // // Options / configuration based on O.S. / compiler ///////////////////// // // Define and set to 1 if the target system has support for large // stack sizes. // /* #undef OPENEXR_HAVE_LARGE_STACK */ ////////////////////// // // C++ namespace configuration / options // // Current internal library namepace name // #define OPENEXR_IMF_INTERNAL_NAMESPACE_CUSTOM 0 #define OPENEXR_IMF_INTERNAL_NAMESPACE Imf_3_1 // // Current public user namepace name // #define OPENEXR_IMF_NAMESPACE_CUSTOM 0 #define OPENEXR_IMF_NAMESPACE Imf // // Version string for runtime access // #define OPENEXR_VERSION_STRING "3.1.1" #define OPENEXR_PACKAGE_STRING "OpenEXR 3.1.1" #define OPENEXR_VERSION_MAJOR 3 #define OPENEXR_VERSION_MINOR 1 #define OPENEXR_VERSION_PATCH 1 #define OPENEXR_VERSION_RELEASE_TYPE "" // Deprecated, for back compatibility: #define OPENEXR_VERSION_EXTRA "" #define OPENEXR_LIB_VERSION_STRING "30.1.0" // Version as a single hex number, e.g. 0x01000300 == 1.0.3 #define OPENEXR_VERSION_HEX ((uint32_t(OPENEXR_VERSION_MAJOR) << 24) | \ (uint32_t(OPENEXR_VERSION_MINOR) << 16) | \ (uint32_t(OPENEXR_VERSION_PATCH) << 8)) // Whether the user configured the library to have symbol visibility // tagged #define OPENEXR_ENABLE_API_VISIBILITY /// \defgroup ExportMacros Macros to manage symbol visibility /// /// See docs/SymbolVisibility.md for more discussion about the /// motivation for these macros /// /// If we are compiling a DLL for Windows, there needs to be custom /// rules for each library such that the macro swaps between doing a /// dllexport and a dllimport, so the defines here are less /// useful. Further, MSVC does not have this concept at all currently, /// so is elided. /// /// The top level macros which start with OPENEXR can act as simple /// ways to combine the logic however for non-DLL or non-windows /// platforms, but until the current patterns change, one should check /// the specific library export.h (i.e. @sa IexExport.h, /// @sa IlmThreadExport.h, @sa ImfExport.h, @sa ImfUtilExport.h ) /// /// These per-library exports define a subset which are used by that /// library. /// /// Iex is simple and does not need to do more than expose class types /// and functions, and does not have any private members to hide, so /// only provides a couple of the possible macros. /// /// Similarly, IlmThread is also reasonably simple. /// /// OpenEXR and OpenEXRUtil have much more logic and have to deal with /// templates and template instantiation, and so define more of the /// macros. /// /// @{ #if defined(OPENEXR_ENABLE_API_VISIBILITY) && ! ( defined(OPENEXR_DLL) || defined(_MSC_VER) ) # define OPENEXR_PUBLIC_SYMBOL_ATTRIBUTE __attribute__ ((__visibility__ ("default"))) # define OPENEXR_PRIVATE_SYMBOL_ATTRIBUTE __attribute__ ((__visibility__ ("hidden"))) // clang differs from gcc and has type visibility which is needed // for enums and templates, and isn't well documented, but causes // the vtable and typeinfo to be made visible, but not necessarily // all the members # if __has_attribute(__type_visibility__) # define OPENEXR_PUBLIC_TYPE_VISIBILITY_ATTRIBUTE __attribute__ ((__type_visibility__ ("default"))) # endif // these are always the same, at least in current compilers # define OPENEXR_EXPORT OPENEXR_PUBLIC_SYMBOL_ATTRIBUTE # define OPENEXR_HIDDEN OPENEXR_PRIVATE_SYMBOL_ATTRIBUTE // currently define this as the same between compilers to export // things like default copy ctors etc, and do not use the type // visibility which only exports the typeinfo / vtable # define OPENEXR_EXPORT_TYPE OPENEXR_EXPORT # define OPENEXR_EXPORT_EXTERN_TEMPLATE OPENEXR_EXPORT # ifdef OPENEXR_PUBLIC_TYPE_VISIBILITY_ATTRIBUTE # define OPENEXR_EXPORT_ENUM OPENEXR_PUBLIC_TYPE_VISIBILITY_ATTRIBUTE # define OPENEXR_EXPORT_TEMPLATE_TYPE OPENEXR_PUBLIC_TYPE_VISIBILITY_ATTRIBUTE // clang (well, type_visibility) seems empirically need the // default/public symbol tag when specifying explicit template // instantiations, where gcc (no type_visibility) complains if // you set that # define OPENEXR_EXPORT_TEMPLATE_INSTANCE OPENEXR_EXPORT # else # define OPENEXR_EXPORT_ENUM # define OPENEXR_EXPORT_TEMPLATE_TYPE OPENEXR_EXPORT # define OPENEXR_EXPORT_TEMPLATE_INSTANCE # endif #else // msvc or api visibility disabled, just clear all this out (DLLs will define a set anyway) # define OPENEXR_EXPORT # define OPENEXR_HIDDEN # define OPENEXR_EXPORT_TYPE # define OPENEXR_EXPORT_EXTERN_TEMPLATE # define OPENEXR_EXPORT_ENUM # define OPENEXR_EXPORT_TEMPLATE_TYPE # define OPENEXR_EXPORT_TYPE # define OPENEXR_EXPORT_TEMPLATE_INSTANCE #endif #endif // INCLUDED_OPENEXR_CONFIG_H PK sM�[L�%�l l ImfPreviewImage.hnu �[��� // // SPDX-License-Identifier: BSD-3-Clause // Copyright (c) Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMF_PREVIEW_IMAGE_H #define INCLUDED_IMF_PREVIEW_IMAGE_H #include "ImfForward.h" //----------------------------------------------------------------------------- // // class PreviewImage -- a usually small, low-dynamic range image, // that is intended to be stored in an image file's header. // // struct PreviewRgba -- holds the value of a PreviewImage pixel. // //----------------------------------------------------------------------------- OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER struct IMF_EXPORT_TYPE PreviewRgba { unsigned char r; // Red, green and blue components of unsigned char g; // the pixel's color; intensity is unsigned char b; // proportional to pow (x/255, 2.2), // where x is r, g, or b. unsigned char a; // The pixel's alpha; 0 == transparent, // 255 == opaque. PreviewRgba (unsigned char r = 0, unsigned char g = 0, unsigned char b = 0, unsigned char a = 255) : r(r), g(g), b(b), a(a) {} }; class IMF_EXPORT_TYPE PreviewImage { public: //-------------------------------------------------------------------- // Constructor: // // PreviewImage(w,h,p) constructs a preview image with w by h pixels // whose initial values are specified in pixel array p. The x and y // coordinates of the pixels in p go from 0 to w-1, and from 0 to h-1. // The pixel with coordinates (x, y) is at address p + y*w + x. // Pixel (0, 0) is in the upper left corner of the preview image. // If p is zero, the pixels in the preview image are initialized with // (r = 0, b = 0, g = 0, a = 255). // //-------------------------------------------------------------------- IMF_EXPORT PreviewImage (unsigned int width = 0, unsigned int height = 0, const PreviewRgba pixels[] = 0); //----------------------------------------------------- // Copy constructor, destructor and assignment operator //----------------------------------------------------- IMF_EXPORT PreviewImage (const PreviewImage &other); IMF_EXPORT ~PreviewImage (); IMF_EXPORT PreviewImage & operator = (const PreviewImage &other); //----------------------------------------------- // Access to width, height and to the pixel array //----------------------------------------------- inline unsigned int width () const {return _width;} inline unsigned int height () const {return _height;} inline PreviewRgba * pixels () {return _pixels;} inline const PreviewRgba * pixels () const {return _pixels;} //---------------------------- // Access to individual pixels //---------------------------- inline PreviewRgba & pixel (unsigned int x, unsigned int y) {return _pixels[y * _width + x];} inline const PreviewRgba & pixel (unsigned int x, unsigned int y) const {return _pixels[y * _width + x];} private: unsigned int _width; unsigned int _height; PreviewRgba * _pixels; }; OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif PK �!�[��� � OpenEXRConfig.cmakenu �[��� PK �!�[f� c� � OpenEXRTargets.cmakenu �[��� PK �!�[C�@�� � � OpenEXRTargets-release.cmakenu �[��� PK �!�[��)�� � �, OpenEXRConfigVersion.cmakenu �[��� PK rM�[�L��Z Z �7 ImfExport.hnu �[��� PK rM�[�"�n[) [) h@ ImfSampleCountChannel.hnu �[��� PK rM�[~��@ @ j ImfLineOrderAttribute.hnu �[��� PK rM�[If�o o �m ImfImageChannelRenaming.hnu �[��� PK rM�[ �qD� � Is ImfBoxAttribute.hnu �[��� PK rM�[a�� � 3w ImfDoubleAttribute.hnu �[��� PK rM�[�aD�� � -z ImfDeepScanLineOutputFile.hnu �[��� PK rM�[��z� � `� ImfIntAttribute.hnu �[��� PK rM�[ � �: �: \� ImfXdr.hnu �[��� PK rM�[z�xU�> �> � ImfTiledRgbaFile.hnu �[��� PK rM�[��.X X ImfImageDataWindow.hnu �[��� PK rM�[!�W7 7 � ImfVersion.hnu �[��� PK rM�[��\ \ ( ImfThreading.hnu �[��� PK rM�[~(�I3 3 �2 ImfKeyCodeAttribute.hnu �[��� PK rM�[���, �, )6 ImfCRgbaFile.hnu �[��� PK rM�[���^ ^ %c ImfFlatImageChannel.hnu �[��� PK rM�[�[��� � �| ImfConvert.hnu �[��� PK rM�[;��-Y Y � ImfPreviewImageAttribute.hnu �[��� PK rM�[�w�Q �� ImfPartType.hnu �[��� PK rM�[o>�# �# ݊ ImfFlatImageLevel.hnu �[��� PK rM�[��=1� � �� ImfMatrixAttribute.hnu �[��� PK rM�[^}��D D � ImfCompositeDeepScanLine.hnu �[��� PK rM�[��'�C �C o� ImfDeepTiledOutputFile.hnu �[��� PK rM�[i�9 v ImfKeyCode.hnu �[��� PK rM�[�]�~� � � ImfLut.hnu �[��� PK rM�[R&ޮ� � �% ImfStringAttribute.hnu �[��� PK rM�[�c� � ) ImfOutputFile.hnu �[��� PK rM�[}+� � &J ImfDeepCompositing.hnu �[��� PK rM�[ �B�� � \ IlmThread.hnu �[��� PK rM�[ ��<E E )i ImfPartHelper.hnu �[��� PK rM�[b��a a �� IexMacros.hnu �[��� PK rM�[e��K�0 �0 I� openexr_encode.hnu �[��� PK rM�[e)e� e� ImfMultiPartInputFile.hnu �[��� PK rM�[�)�=k k �� ImfTiledOutputPart.hnu �[��� PK rM�[�1��� � m� ImfFlatImage.hnu �[��� PK rM�[Z��� � S� IlmThreadConfig.hnu �[��� PK rM�[�/�cZ Z x� ImfDeepScanLineInputPart.hnu �[��� PK rM�[o7?C C ImfRgba.hnu �[��� PK rM�[�G�� � � IexThrowErrnoExc.hnu �[��� PK rM�[�J�F� � � ImfRgbaYca.hnu �[��� PK rM�[q�n n �& IlmThreadPool.hnu �[��� PK rM�[[�W=� � iB ImfMultiView.hnu �[��� PK rM�[��=T T �U IlmThreadMutex.hnu �[��� PK rM�[���� � ] ImfInt64.hnu �[��� PK rM�[:5�@%0 %0 O` ImfDeepTiledInputPart.hnu �[��� PK rM�[a�x�( �( �� ImfChannelList.hnu �[��� PK rM�[ �T� � �� Iex.hnu �[��� PK rM�[<�C�� � �� IlmThreadNamespace.hnu �[��� PK rM�[� -J J e� ImfWav.hnu �[��� PK rM�[2��*� � �� ImfPixelType.hnu �[��� PK rM�[ ,dm� � � ImfCheckFile.hnu �[��� PK rM�[b%-� � 0� ImfInputPart.hnu �[��� PK rM�[��O� � .� IexMathIeeeExc.hnu �[��� PK rM�[��" " )� ImfRational.hnu �[��� PK rM�[�f �� IexConfig.hnu �[��� PK rM�[��x�^ ^ �� ImfMultiPartOutputFile.hnu �[��� PK rM�[!����K �K �� ImfHeader.hnu �[��� PK rM�[G�L�� � RB openexr_debug.hnu �[��� PK rM�[j���H �H dD openexr_context.hnu �[��� PK rM�[.=*) ) �� ImfIDManifestAttribute.hnu �[��� PK rM�[ u�Kh; h; � ImfDeepTiledInputFile.hnu �[��� PK rM�[=$T�5 5 �� ImfChromaticitiesAttribute.hnu �[��� PK rM�[}��l` ` !� ImfChromaticities.hnu �[��� PK rM�[VC��� � �� ImfFramesPerSecond.hnu �[��� PK rM�[Y4ל�/ �/ �� ImfStandardAttributes.hnu �[��� PK rM�[���ud d d ImfTestFile.hnu �[��� PK rM�[Z��A~ ~ ImfTimeCode.hnu �[��� PK rM�[ �a��& �& �3 ImfEnvmap.hnu �[��� PK rM�[� -�� � �Z ImfOutputPart.hnu �[��� PK rM�[>��l l �` IexMathFloatExc.hnu �[��� PK rM�[&�2^ ^ �k IlmThreadForward.hnu �[��� PK rM�[�lT��B �B (n ImfTiledOutputFile.hnu �[��� PK rM�[z^^�: : B� ImfLineOrder.hnu �[��� PK rM�[]�� � �� openexr_chunkio.hnu �[��� PK rM�[��L�< < �� ImfTimeCodeAttribute.hnu �[��� PK rM�[��z�m m b� ImfTileDescriptionAttribute.hnu �[��� PK rM�[�j��� � � ImfHuf.hnu �[��� PK rM�[�r�S S (� ImfChannelListAttribute.hnu �[��� PK rM�[���K� � �� ImfDeepScanLineOutputPart.hnu �[��� PK rM�[VGJd �� ImfRationalAttribute.hnu �[��� PK rM�[p$�tR R �� ImfVecAttribute.hnu �[��� PK rM�[�emDs s � openexr_std_attr.hnu �[��� PK rM�[Q�vx� � 4� ImfDeepImage.hnu �[��� PK rM�[�5+� � openexr_base.hnu �[��� PK rM�[��� � ImfName.hnu �[��� PK rM�[�t�'( '( � ImfFrameBuffer.hnu �[��� PK rM�[�W� - - PI openexr_decode.hnu �[��� PK rM�[�tն � �v openexr_coding.hnu �[��� PK rM�[�] n �� ImfGenericOutputFile.hnu �[��� PK rM�[],\�1 1 � ImfRgbaFile.hnu �[��� PK rM�[^��� � .� IexBaseExc.hnu �[��� PK rM�[�� x x f� ImfTiledInputPart.hnu �[��� PK rM�[q �> > !� IlmThreadSemaphore.hnu �[��� PK rM�[��� �� ImfCompressionAttribute.hnu �[��� PK rM�[��& & � ImfDeepImageState.hnu �[��� PK rM�[�\r�h h s� ImfGenericInputFile.hnu �[��� PK rM�[1��% % ImfTileDescription.hnu �[��� PK rM�[��"ѝ � � ImfDeepFrameBuffer.hnu �[��� PK rM�[�m}�Q Q j' ImfDeepImageStateAttribute.hnu �[��� PK rM�[Hb�� + ImfEnvmapAttribute.hnu �[��� PK rM�[F��*)( )( V. ImfDeepScanLineInputFile.hnu �[��� PK rM�[C��b b �V IlmThreadExport.hnu �[��� PK rM�[3ܝgo o l[ ImfFloatVectorAttribute.hnu �[��� PK rM�[#�)�Q6 Q6 $_ ImfDeepTiledOutputPart.hnu �[��� PK rM�[%�]� �� openexr_conf.hnu �[��� PK rM�[i Ms; ; � ImfInputFile.hnu �[��� PK rM�[��CV V �� ImfDeepImageIO.hnu �[��� PK rM�[ﲠc� � � ImfImageChannel.hnu �[��� PK rM�[�=c1[? [? (� openexr_attr.hnu �[��� PK rM�[2C'R� � � IexNamespace.hnu �[��� PK rM�[�g�2 �2 �$ ImfTiledInputFile.hnu �[��� PK rM�[�L*�0 0 �W ImfImage.hnu �[��� PK rM�[��&� � ImfIO.hnu �[��� PK rM�[��P� :� ImfArray.hnu �[��� PK rM�[�P�6 6 �� ImfImageLevel.hnu �[��� PK rM�[���b� � �� ImfCompression.hnu �[��� PK rM�[�W-z% z% �� ImfAttribute.hnu �[��� PK rM�[�xf% f% �� ImfAcesFile.hnu �[��� PK rM�[Crߝ # ImfImageIO.hnu �[��� PK rM�[v���5 5 _ ImfUtilExport.hnu �[��� PK rM�[��㖦 � �% ImfStringVectorAttribute.hnu �[��� PK rM�[�灂N N �) IexMathExc.hnu �[��� PK rM�[���f�7 �7 M- ImfIDManifest.hnu �[��� PK sM�[�!X < < �e ImfNamespace.hnu �[��� PK sM�[���< < �p ImfFlatImageIO.hnu �[��� PK sM�[Wc_�� � v� openexr.hnu �[��� PK sM�[(�o �� ImfOpaqueAttribute.hnu �[��� PK sM�[�o �F F ב ImfForward.hnu �[��� PK sM�[�+)�� � Y� ImfStdIO.hnu �[��� PK sM�[��7_� � i� IexExport.hnu �[��� PK sM�[t4�:( :( ;� ImfDeepImageLevel.hnu �[��� PK sM�[`�8$� � �� IexErrnoExc.hnu �[��� PK sM�[�:�r� � z� IexForward.hnu �[��� PK sM�[N0��ce ce | openexr_part.hnu �[��� PK sM�[�^� � r ImfFloatAttribute.hnu �[��� PK sM�[�+j2� � *u openexr_errors.hnu �[��� PK sM�[P�M�� � 8~ ImfDeepImageChannel.hnu �[��� PK sM�[�6��� � y� OpenEXRConfig.hnu �[��� PK sM�[L�%�l l G� ImfPreviewImage.hnu �[��� PK � � E- �
| ver. 1.6 |
Github
|
.
| PHP 8.2.30 | ??????????? ?????????: 0.01 |
proxy
|
phpinfo
|
???????????