#ifndef TINYEXR_H_

#define TINYEXR_H_

/*

Copyright (c) 2014 - 2021, Syoyo Fujita and many contributors.

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright

      notice, this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright

      notice, this list of conditions and the following disclaimer in the

      documentation and/or other materials provided with the distribution.

    * Neither the name of the Syoyo Fujita nor the

      names of its contributors may be used to endorse or promote products

      derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY

DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

// TinyEXR contains some OpenEXR code, which is licensed under ------------

///////////////////////////////////////////////////////////////////////////

//

// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas

// Digital Ltd. LLC

//

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

// *       Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

// *       Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

// *       Neither the name of Industrial Light & Magic nor the names of

// its contributors may be used to endorse or promote products derived

// from this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

///////////////////////////////////////////////////////////////////////////

// End of OpenEXR license -------------------------------------------------

//

//

//   Do this:

//    #define TINYEXR_IMPLEMENTATION

//   before you include this file in *one* C or C++ file to create the

//   implementation.

//

//   // i.e. it should look like this:

//   #include ...

//   #include ...

//   #include ...

//   #define TINYEXR_IMPLEMENTATION

//   #include "tinyexr.h"

//

//

#include <stddef.h>  // for size_t

#include <stdint.h>  // guess stdint.h is available(C99)

#ifdef __cplusplus

extern "C" {

#endif

#if defined(_M_IX86) || defined(_M_X64) || defined(__i386__) || \

    defined(__i386) || defined(__i486__) || defined(__i486) ||  \

    defined(i386) || defined(__ia64__) || defined(__x86_64__)

#define TINYEXR_X86_OR_X64_CPU 1

#else

#define TINYEXR_X86_OR_X64_CPU 0

#endif

#if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || TINYEXR_X86_OR_X64_CPU

#define TINYEXR_LITTLE_ENDIAN 1

#else

#define TINYEXR_LITTLE_ENDIAN 0

#endif

// Use miniz or not to decode ZIP format pixel. Linking with zlib

// required if this flas is 0.

#ifndef TINYEXR_USE_MINIZ

#define TINYEXR_USE_MINIZ (1)

#endif

// Disable PIZ comporession when applying cpplint.

#ifndef TINYEXR_USE_PIZ

#define TINYEXR_USE_PIZ (1)

#endif

#ifndef TINYEXR_USE_ZFP

#define TINYEXR_USE_ZFP (0)  // TinyEXR extension.

// http://computation.llnl.gov/projects/floating-point-compression

#endif

#ifndef TINYEXR_USE_THREAD

#define TINYEXR_USE_THREAD (0)  // No threaded loading.

// http://computation.llnl.gov/projects/floating-point-compression

#endif

#ifndef TINYEXR_USE_OPENMP

#ifdef _OPENMP

#define TINYEXR_USE_OPENMP (1)

#else

#define TINYEXR_USE_OPENMP (0)

#endif

#endif

#define TINYEXR_SUCCESS (0)

#define TINYEXR_ERROR_INVALID_MAGIC_NUMBER (-1)

#define TINYEXR_ERROR_INVALID_EXR_VERSION (-2)

#define TINYEXR_ERROR_INVALID_ARGUMENT (-3)

#define TINYEXR_ERROR_INVALID_DATA (-4)

#define TINYEXR_ERROR_INVALID_FILE (-5)

#define TINYEXR_ERROR_INVALID_PARAMETER (-6)

#define TINYEXR_ERROR_CANT_OPEN_FILE (-7)

#define TINYEXR_ERROR_UNSUPPORTED_FORMAT (-8)

#define TINYEXR_ERROR_INVALID_HEADER (-9)

#define TINYEXR_ERROR_UNSUPPORTED_FEATURE (-10)

#define TINYEXR_ERROR_CANT_WRITE_FILE (-11)

#define TINYEXR_ERROR_SERIALZATION_FAILED (-12)

#define TINYEXR_ERROR_LAYER_NOT_FOUND (-13)

// @note { OpenEXR file format: http://www.openexr.com/openexrfilelayout.pdf }

// pixel type: possible values are: UINT = 0 HALF = 1 FLOAT = 2

#define TINYEXR_PIXELTYPE_UINT (0)

#define TINYEXR_PIXELTYPE_HALF (1)

#define TINYEXR_PIXELTYPE_FLOAT (2)

#define TINYEXR_MAX_HEADER_ATTRIBUTES (1024)

#define TINYEXR_MAX_CUSTOM_ATTRIBUTES (128)

#define TINYEXR_COMPRESSIONTYPE_NONE (0)

#define TINYEXR_COMPRESSIONTYPE_RLE (1)

#define TINYEXR_COMPRESSIONTYPE_ZIPS (2)

#define TINYEXR_COMPRESSIONTYPE_ZIP (3)

#define TINYEXR_COMPRESSIONTYPE_PIZ (4)

#define TINYEXR_COMPRESSIONTYPE_ZFP (128)  // TinyEXR extension

#define TINYEXR_ZFP_COMPRESSIONTYPE_RATE (0)

#define TINYEXR_ZFP_COMPRESSIONTYPE_PRECISION (1)

#define TINYEXR_ZFP_COMPRESSIONTYPE_ACCURACY (2)

#define TINYEXR_TILE_ONE_LEVEL (0)

#define TINYEXR_TILE_MIPMAP_LEVELS (1)

#define TINYEXR_TILE_RIPMAP_LEVELS (2)

#define TINYEXR_TILE_ROUND_DOWN (0)

#define TINYEXR_TILE_ROUND_UP (1)

typedef struct _EXRVersion {

  int version;    // this must be 2

  // tile format image;

  // not zero for only a single-part "normal" tiled file (according to spec.)

  int tiled;      

  int long_name;  // long name attribute

  // deep image(EXR 2.0);

  // for a multi-part file, indicates that at least one part is of type deep* (according to spec.)

  int non_image;  

  int multipart;  // multi-part(EXR 2.0)

} EXRVersion;

typedef struct _EXRAttribute {

  char name[256];  // name and type are up to 255 chars long.

  char type[256];

  unsigned char *value;  // uint8_t*

  int size;

  int pad0;

} EXRAttribute;

typedef struct _EXRChannelInfo {

  char name[256];  // less than 255 bytes long

  int pixel_type;

  int x_sampling;

  int y_sampling;

  unsigned char p_linear;

  unsigned char pad[3];

} EXRChannelInfo;

typedef struct _EXRTile {

  int offset_x;

  int offset_y;

  int level_x;

  int level_y;

  int width;   // actual width in a tile.

  int height;  // actual height int a tile.

  unsigned char **images;  // image[channels][pixels]

} EXRTile;

typedef struct _EXRBox2i {

  int min_x;

  int min_y;

  int max_x;

  int max_y;

} EXRBox2i;

typedef struct _EXRHeader {

  float pixel_aspect_ratio;

  int line_order;

  EXRBox2i data_window;

  EXRBox2i display_window;

  float screen_window_center[2];

  float screen_window_width;

  int chunk_count;

  // Properties for tiled format(`tiledesc`).

  int tiled;

  int tile_size_x;

  int tile_size_y;

  int tile_level_mode;

  int tile_rounding_mode;

  int long_name;

  // for a single-part file, agree with the version field bit 11

  // for a multi-part file, it is consistent with the type of part

  int non_image;

  int multipart;

  unsigned int header_len;

  // Custom attributes(exludes required attributes(e.g. `channels`,

  // `compression`, etc)

  int num_custom_attributes;

  EXRAttribute *custom_attributes;  // array of EXRAttribute. size =

                                    // `num_custom_attributes`.

  EXRChannelInfo *channels;  // [num_channels]

  int *pixel_types;  // Loaded pixel type(TINYEXR_PIXELTYPE_*) of `images` for

  // each channel. This is overwritten with `requested_pixel_types` when

  // loading.

  int num_channels;

  int compression_type;        // compression type(TINYEXR_COMPRESSIONTYPE_*)

  int *requested_pixel_types;  // Filled initially by

                               // ParseEXRHeaderFrom(Meomory|File), then users

                               // can edit it(only valid for HALF pixel type

                               // channel)

  // name attribute required for multipart files;

  // must be unique and non empty (according to spec.);

  // use EXRSetNameAttr for setting value;

  // max 255 character allowed - excluding terminating zero

  char name[256];

} EXRHeader;

typedef struct _EXRMultiPartHeader {

  int num_headers;

  EXRHeader *headers;

} EXRMultiPartHeader;

typedef struct _EXRImage {

  EXRTile *tiles;  // Tiled pixel data. The application must reconstruct image

                   // from tiles manually. NULL if scanline format.

  struct _EXRImage* next_level; // NULL if scanline format or image is the last level.

  int level_x; // x level index

  int level_y; // y level index

  unsigned char **images;  // image[channels][pixels]. NULL if tiled format.

  int width;

  int height;

  int num_channels;

  // Properties for tile format.

  int num_tiles;

} EXRImage;

typedef struct _EXRMultiPartImage {

  int num_images;

  EXRImage *images;

} EXRMultiPartImage;

typedef struct _DeepImage {

  const char **channel_names;

  float ***image;      // image[channels][scanlines][samples]

  int **offset_table;  // offset_table[scanline][offsets]

  int num_channels;

  int width;

  int height;

  int pad0;

} DeepImage;

// @deprecated { For backward compatibility. Not recommended to use. }

// Loads single-frame OpenEXR image. Assume EXR image contains A(single channel

// alpha) or RGB(A) channels.

// Application must free image data as returned by `out_rgba`

// Result image format is: float x RGBA x width x hight

// Returns negative value and may set error string in `err` when there's an

// error

extern int LoadEXR(float **out_rgba, int *width, int *height,

                   const char *filename, const char **err);

// Loads single-frame OpenEXR image by specifying layer name. Assume EXR image

// contains A(single channel alpha) or RGB(A) channels. Application must free

// image data as returned by `out_rgba` Result image format is: float x RGBA x

// width x hight Returns negative value and may set error string in `err` when

// there's an error When the specified layer name is not found in the EXR file,

// the function will return `TINYEXR_ERROR_LAYER_NOT_FOUND`.

extern int LoadEXRWithLayer(float **out_rgba, int *width, int *height,

                            const char *filename, const char *layer_name,

                            const char **err);

//

// Get layer infos from EXR file.

//

// @param[out] layer_names List of layer names. Application must free memory

// after using this.

// @param[out] num_layers The number of layers

// @param[out] err Error string(will be filled when the function returns error

// code). Free it using FreeEXRErrorMessage after using this value.

//

// @return TINYEXR_SUCCEES upon success.

//

extern int EXRLayers(const char *filename, const char **layer_names[],

                     int *num_layers, const char **err);

// @deprecated { to be removed. }

// Simple wrapper API for ParseEXRHeaderFromFile.

// checking given file is a EXR file(by just look up header)

// @return TINYEXR_SUCCEES for EXR image, TINYEXR_ERROR_INVALID_HEADER for

// others

extern int IsEXR(const char *filename);

// @deprecated { to be removed. }

// Saves single-frame OpenEXR image. Assume EXR image contains RGB(A) channels.

// components must be 1(Grayscale), 3(RGB) or 4(RGBA).

// Input image format is: `float x width x height`, or `float x RGB(A) x width x

// hight`

// Save image as fp16(HALF) format when `save_as_fp16` is positive non-zero

// value.

// Save image as fp32(FLOAT) format when `save_as_fp16` is 0.

// Use ZIP compression by default.

// Returns negative value and may set error string in `err` when there's an

// error

extern int SaveEXR(const float *data, const int width, const int height,

                   const int components, const int save_as_fp16,

                   const char *filename, const char **err);

// Returns the number of resolution levels of the image (including the base)

extern int EXRNumLevels(const EXRImage* exr_image);

// Initialize EXRHeader struct

extern void InitEXRHeader(EXRHeader *exr_header);

// Set name attribute of EXRHeader struct (it makes a copy)

extern void EXRSetNameAttr(EXRHeader *exr_header, const char* name);

// Initialize EXRImage struct

extern void InitEXRImage(EXRImage *exr_image);

// Frees internal data of EXRHeader struct

extern int FreeEXRHeader(EXRHeader *exr_header);

// Frees internal data of EXRImage struct

extern int FreeEXRImage(EXRImage *exr_image);

// Frees error message

extern void FreeEXRErrorMessage(const char *msg);

// Parse EXR version header of a file.

extern int ParseEXRVersionFromFile(EXRVersion *version, const char *filename);

// Parse EXR version header from memory-mapped EXR data.

extern int ParseEXRVersionFromMemory(EXRVersion *version,

                                     const unsigned char *memory, size_t size);

// Parse single-part OpenEXR header from a file and initialize `EXRHeader`.

// When there was an error message, Application must free `err` with

// FreeEXRErrorMessage()

extern int ParseEXRHeaderFromFile(EXRHeader *header, const EXRVersion *version,

                                  const char *filename, const char **err);

// Parse single-part OpenEXR header from a memory and initialize `EXRHeader`.

// When there was an error message, Application must free `err` with

// FreeEXRErrorMessage()

extern int ParseEXRHeaderFromMemory(EXRHeader *header,

                                    const EXRVersion *version,

                                    const unsigned char *memory, size_t size,

                                    const char **err);

// Parse multi-part OpenEXR headers from a file and initialize `EXRHeader*`

// array.

// When there was an error message, Application must free `err` with

// FreeEXRErrorMessage()

extern int ParseEXRMultipartHeaderFromFile(EXRHeader ***headers,

                                           int *num_headers,

                                           const EXRVersion *version,

                                           const char *filename,

                                           const char **err);

// Parse multi-part OpenEXR headers from a memory and initialize `EXRHeader*`

// array

// When there was an error message, Application must free `err` with

// FreeEXRErrorMessage()

extern int ParseEXRMultipartHeaderFromMemory(EXRHeader ***headers,

                                             int *num_headers,

                                             const EXRVersion *version,

                                             const unsigned char *memory,

                                             size_t size, const char **err);

// Loads single-part OpenEXR image from a file.

// Application must setup `ParseEXRHeaderFromFile` before calling this function.

// Application can free EXRImage using `FreeEXRImage`

// Returns negative value and may set error string in `err` when there's an

// error

// When there was an error message, Application must free `err` with

// FreeEXRErrorMessage()

extern int LoadEXRImageFromFile(EXRImage *image, const EXRHeader *header,

                                const char *filename, const char **err);

// Loads single-part OpenEXR image from a memory.

// Application must setup `EXRHeader` with

// `ParseEXRHeaderFromMemory` before calling this function.

// Application can free EXRImage using `FreeEXRImage`

// Returns negative value and may set error string in `err` when there's an

// error

// When there was an error message, Application must free `err` with

// FreeEXRErrorMessage()

extern int LoadEXRImageFromMemory(EXRImage *image, const EXRHeader *header,

                                  const unsigned char *memory,

                                  const size_t size, const char **err);

// Loads multi-part OpenEXR image from a file.

// Application must setup `ParseEXRMultipartHeaderFromFile` before calling this

// function.

// Application can free EXRImage using `FreeEXRImage`

// Returns negative value and may set error string in `err` when there's an

// error

// When there was an error message, Application must free `err` with

// FreeEXRErrorMessage()

extern int LoadEXRMultipartImageFromFile(EXRImage *images,

                                         const EXRHeader **headers,

                                         unsigned int num_parts,

                                         const char *filename,

                                         const char **err);

// Loads multi-part OpenEXR image from a memory.

// Application must setup `EXRHeader*` array with

// `ParseEXRMultipartHeaderFromMemory` before calling this function.

// Application can free EXRImage using `FreeEXRImage`

// Returns negative value and may set error string in `err` when there's an

// error

// When there was an error message, Application must free `err` with

// FreeEXRErrorMessage()

extern int LoadEXRMultipartImageFromMemory(EXRImage *images,

                                           const EXRHeader **headers,

                                           unsigned int num_parts,

                                           const unsigned char *memory,

                                           const size_t size, const char **err);

// Saves multi-channel, single-frame OpenEXR image to a file.

// Returns negative value and may set error string in `err` when there's an

// error

// When there was an error message, Application must free `err` with

// FreeEXRErrorMessage()

extern int SaveEXRImageToFile(const EXRImage *image,

                              const EXRHeader *exr_header, const char *filename,

                              const char **err);

// Saves multi-channel, single-frame OpenEXR image to a memory.

// Image is compressed using EXRImage.compression value.

// Return the number of bytes if success.

// Return zero and will set error string in `err` when there's an

// error.

// When there was an error message, Application must free `err` with

// FreeEXRErrorMessage()

extern size_t SaveEXRImageToMemory(const EXRImage *image,

                                   const EXRHeader *exr_header,

                                   unsigned char **memory, const char **err);

// Saves multi-channel, multi-frame OpenEXR image to a memory.

// Image is compressed using EXRImage.compression value.

// File global attributes (eg. display_window) must be set in the first header.

// Returns negative value and may set error string in `err` when there's an

// error

// When there was an error message, Application must free `err` with

// FreeEXRErrorMessage()

extern int SaveEXRMultipartImageToFile(const EXRImage *images,

                                       const EXRHeader **exr_headers,

                                       unsigned int num_parts,

                                       const char *filename, const char **err);

// Saves multi-channel, multi-frame OpenEXR image to a memory.

// Image is compressed using EXRImage.compression value.

// File global attributes (eg. display_window) must be set in the first header.

// Return the number of bytes if success.

// Return zero and will set error string in `err` when there's an

// error.

// When there was an error message, Application must free `err` with

// FreeEXRErrorMessage()

extern size_t SaveEXRMultipartImageToMemory(const EXRImage *images,

                                            const EXRHeader **exr_headers,

                                            unsigned int num_parts,

                                            unsigned char **memory, const char **err);

// Loads single-frame OpenEXR deep image.

// Application must free memory of variables in DeepImage(image, offset_table)

// Returns negative value and may set error string in `err` when there's an

// error

// When there was an error message, Application must free `err` with

// FreeEXRErrorMessage()

extern int LoadDeepEXR(DeepImage *out_image, const char *filename,

                       const char **err);

// NOT YET IMPLEMENTED:

// Saves single-frame OpenEXR deep image.

// Returns negative value and may set error string in `err` when there's an

// error

// extern int SaveDeepEXR(const DeepImage *in_image, const char *filename,

//                       const char **err);

// NOT YET IMPLEMENTED:

// Loads multi-part OpenEXR deep image.

// Application must free memory of variables in DeepImage(image, offset_table)

// extern int LoadMultiPartDeepEXR(DeepImage **out_image, int num_parts, const

// char *filename,

//                       const char **err);

// For emscripten.

// Loads single-frame OpenEXR image from memory. Assume EXR image contains

// RGB(A) channels.

// Returns negative value and may set error string in `err` when there's an

// error

// When there was an error message, Application must free `err` with

// FreeEXRErrorMessage()

extern int LoadEXRFromMemory(float **out_rgba, int *width, int *height,

                             const unsigned char *memory, size_t size,

                             const char **err);

#ifdef __cplusplus

}

#endif

#endif  // TINYEXR_H_

#ifdef TINYEXR_IMPLEMENTATION

#ifndef TINYEXR_IMPLEMENTATION_DEFINED

#define TINYEXR_IMPLEMENTATION_DEFINED

#ifdef _WIN32

#ifndef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#endif

#ifndef NOMINMAX

#define NOMINMAX

#endif

#include <windows.h>  // for UTF-8

#endif

#include <algorithm>

#include <cassert>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <sstream>

// #include <iostream> // debug

#include <limits>

#include <string>

#include <vector>

#include <set>

// https://stackoverflow.com/questions/5047971/how-do-i-check-for-c11-support

#if __cplusplus > 199711L || (defined(_MSC_VER) && _MSC_VER >= 1900)

#define TINYEXR_HAS_CXX11 (1)

// C++11

#include <cstdint>

#if TINYEXR_USE_THREAD

#include <atomic>

#include <thread>

#endif

#endif  // __cplusplus > 199711L

#if TINYEXR_USE_OPENMP

#include <omp.h>

#endif

#if TINYEXR_USE_MINIZ

#include <miniz.h>

#else

//  Issue #46. Please include your own zlib-compatible API header before

//  including `tinyexr.h`

//#include "zlib.h"

#endif

#if TINYEXR_USE_ZFP

#ifdef __clang__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Weverything"

#endif

#include "zfp.h"

#ifdef __clang__

#pragma clang diagnostic pop

#endif

#endif

namespace tinyexr {

#if __cplusplus > 199711L

// C++11

typedef uint64_t tinyexr_uint64;

typedef int64_t tinyexr_int64;

#else

// Although `long long` is not a standard type pre C++11, assume it is defined

// as a compiler's extension.

#ifdef __clang__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wc++11-long-long"

#endif

typedef unsigned long long tinyexr_uint64;

typedef long long tinyexr_int64;

#ifdef __clang__

#pragma clang diagnostic pop

#endif

#endif

// static bool IsBigEndian(void) {

//  union {

//    unsigned int i;

//    char c[4];

//  } bint = {0x01020304};

//

//  return bint.c[0] == 1;

//}

static void SetErrorMessage(const std::string &msg, const char **err) {

  if (err) {

#ifdef _WIN32

    (*err) = _strdup(msg.c_str());

#else

    (*err) = strdup(msg.c_str());

#endif

  }

}

static const int kEXRVersionSize = 8;

static void cpy2(unsigned short *dst_val, const unsigned short *src_val) {

  unsigned char *dst = reinterpret_cast<unsigned char *>(dst_val);

  const unsigned char *src = reinterpret_cast<const unsigned char *>(src_val);

  dst[0] = src[0];

  dst[1] = src[1];

}

static void swap2(unsigned short *val) {

#ifdef TINYEXR_LITTLE_ENDIAN

  (void)val;

#else

  unsigned short tmp = *val;

  unsigned char *dst = reinterpret_cast<unsigned char *>(val);

  unsigned char *src = reinterpret_cast<unsigned char *>(&tmp);

  dst[0] = src[1];

  dst[1] = src[0];

#endif

}

#ifdef __clang__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wunused-function"

#endif

#ifdef __GNUC__

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wunused-function"

#endif

static void cpy4(int *dst_val, const int *src_val) {

  unsigned char *dst = reinterpret_cast<unsigned char *>(dst_val);

  const unsigned char *src = reinterpret_cast<const unsigned char *>(src_val);

  dst[0] = src[0];

  dst[1] = src[1];

  dst[2] = src[2];

  dst[3] = src[3];

}

static void cpy4(unsigned int *dst_val, const unsigned int *src_val) {

  unsigned char *dst = reinterpret_cast<unsigned char *>(dst_val);

  const unsigned char *src = reinterpret_cast<const unsigned char *>(src_val);

  dst[0] = src[0];

  dst[1] = src[1];

  dst[2] = src[2];

  dst[3] = src[3];

}

static void cpy4(float *dst_val, const float *src_val) {

  unsigned char *dst = reinterpret_cast<unsigned char *>(dst_val);

  const unsigned char *src = reinterpret_cast<const unsigned char *>(src_val);

  dst[0] = src[0];

  dst[1] = src[1];

  dst[2] = src[2];

  dst[3] = src[3];

}

#ifdef __clang__

#pragma clang diagnostic pop

#endif

#ifdef __GNUC__

#pragma GCC diagnostic pop

#endif

static void swap4(unsigned int *val) {

#ifdef TINYEXR_LITTLE_ENDIAN

  (void)val;

#else

  unsigned int tmp = *val;

  unsigned char *dst = reinterpret_cast<unsigned char *>(val);

  unsigned char *src = reinterpret_cast<unsigned char *>(&tmp);

  dst[0] = src[3];

  dst[1] = src[2];

  dst[2] = src[1];

  dst[3] = src[0];

#endif

}

static void swap4(int *val) {

#ifdef TINYEXR_LITTLE_ENDIAN

  (void)val;

#else

  int tmp = *val;

  unsigned char *dst = reinterpret_cast<unsigned char *>(val);

  unsigned char *src = reinterpret_cast<unsigned char *>(&tmp);

  dst[0] = src[3];

  dst[1] = src[2];

  dst[2] = src[1];

  dst[3] = src[0];

#endif

}

static void swap4(float *val) {

#ifdef TINYEXR_LITTLE_ENDIAN

  (void)val;

#else

  float tmp = *val;

  unsigned char *dst = reinterpret_cast<unsigned char *>(val);

  unsigned char *src = reinterpret_cast<unsigned char *>(&tmp);

  dst[0] = src[3];

  dst[1] = src[2];

  dst[2] = src[1];

  dst[3] = src[0];

#endif

}

#if 0

static void cpy8(tinyexr::tinyexr_uint64 *dst_val, const tinyexr::tinyexr_uint64 *src_val) {

  unsigned char *dst = reinterpret_cast<unsigned char *>(dst_val);

  const unsigned char *src = reinterpret_cast<const unsigned char *>(src_val);

  dst[0] = src[0];

  dst[1] = src[1];

  dst[2] = src[2];

  dst[3] = src[3];

  dst[4] = src[4];

  dst[5] = src[5];

  dst[6] = src[6];

  dst[7] = src[7];

}

#endif

static void swap8(tinyexr::tinyexr_uint64 *val) {

#ifdef TINYEXR_LITTLE_ENDIAN

  (void)val;

#else

  tinyexr::tinyexr_uint64 tmp = (*val);

  unsigned char *dst = reinterpret_cast<unsigned char *>(val);

  unsigned char *src = reinterpret_cast<unsigned char *>(&tmp);

  dst[0] = src[7];

  dst[1] = src[6];

  dst[2] = src[5];

  dst[3] = src[4];

  dst[4] = src[3];

  dst[5] = src[2];

  dst[6] = src[1];

  dst[7] = src[0];

#endif

}

// https://gist.github.com/rygorous/2156668

union FP32 {

  unsigned int u;

  float f;

  struct {

#if TINYEXR_LITTLE_ENDIAN

    unsigned int Mantissa : 23;

    unsigned int Exponent : 8;

    unsigned int Sign : 1;

#else

    unsigned int Sign : 1;

    unsigned int Exponent : 8;

    unsigned int Mantissa : 23;

#endif

  } s;

};

#ifdef __clang__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wpadded"

#endif

union FP16 {

  unsigned short u;

  struct {

#if TINYEXR_LITTLE_ENDIAN

    unsigned int Mantissa : 10;

    unsigned int Exponent : 5;

    unsigned int Sign : 1;

#else

    unsigned int Sign : 1;

    unsigned int Exponent : 5;

    unsigned int Mantissa : 10;

#endif

  } s;

};

#ifdef __clang__

#pragma clang diagnostic pop

#endif

static FP32 half_to_float(FP16 h) {

  static const FP32 magic = {113 << 23};

  static const unsigned int shifted_exp = 0x7c00

                                          << 13;  // exponent mask after shift

  FP32 o;

  o.u = (h.u & 0x7fffU) << 13U;           // exponent/mantissa bits

  unsigned int exp_ = shifted_exp & o.u;  // just the exponent

  o.u += (127 - 15) << 23;                // exponent adjust

  // handle exponent special cases

  if (exp_ == shifted_exp)    // Inf/NaN?

    o.u += (128 - 16) << 23;  // extra exp adjust