// Assume this file is encoded in UTF-8
#define CATCH_CONFIG_MAIN  // This tells Catch to provide a main() - only do
                          // this in one cpp file

#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <sstream>

#include "catch.hpp"

#ifdef _WIN32
#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif
#include <windows.h>
#endif

#define TINYEXR_IMPLEMENTATION
#include "../../tinyexr.h"

// uncomment it to write out memory-saved images to files
//#define DUMP_IMAGES

// path to https://github.com/openexr/openexr-images
// TODO(syoyo): Read openexr-images path from command argument.
const char* kOpenEXRImagePath = "../../../openexr-images/";

std::string GetPath(const char* basename) {
 std::string s;
 s = std::string(kOpenEXRImagePath) + std::string(basename);
 return s;
}

// simply dumping to build folder
std::string GetDumpPath(const char* basename) {
 std::string s = basename;
 size_t index = s.find_last_of("/\\");

 if (index != std::string::npos && index + 1 < s.size()) {
   s = s.substr(index + 1);
 }
 //return "dump/" + s;
 return s;
}

// https://stackoverflow.com/questions/148403/utf8-to-from-wide-char-conversion-in-stl/148665#148665
std::wstring UTF8_to_wchar(const char* in) {
 std::wstring out;
 unsigned int codepoint;
 while (*in != 0) {
   unsigned char ch = static_cast<unsigned char>(*in);
   if (ch <= 0x7f)
     codepoint = ch;
   else if (ch <= 0xbf)
     codepoint = (codepoint << 6) | (ch & 0x3f);
   else if (ch <= 0xdf)
     codepoint = ch & 0x1f;
   else if (ch <= 0xef)
     codepoint = ch & 0x0f;
   else
     codepoint = ch & 0x07;
   ++in;
   if (((*in & 0xc0) != 0x80) && (codepoint <= 0x10ffff)) {
     if (sizeof(wchar_t) > 2)
       out.append(1, static_cast<wchar_t>(codepoint));
     else if (codepoint > 0xffff) {
       out.append(1, static_cast<wchar_t>(0xd800 + (codepoint >> 10)));
       out.append(1, static_cast<wchar_t>(0xdc00 + (codepoint & 0x03ff)));
     } else if (codepoint < 0xd800 || codepoint >= 0xe000)
       out.append(1, static_cast<wchar_t>(codepoint));
   }
 }
 return out;
}

#ifdef DUMP_IMAGES
// return true if success
static bool WriteMemoryToFile(const char *filename, const unsigned char* memory, size_t size)
{
 std::cout << "Saving:" << std::string(filename) << std::endl;
 FILE *fp = NULL;
#ifdef _WIN32
#if defined(_MSC_VER) || defined(__MINGW32__)  // MSVC, MinGW gcc or clang
 errno_t errcode =
     _wfopen_s(&fp, UTF8_to_wchar(filename).c_str(), L"wb");
 if (errcode != 0) return false;
#else
 // Unknown compiler
 fp = fopen(filename, "wb");
#endif
#else
 fp = fopen(filename, "wb");
#endif
 if (!fp) return false;

 size_t written_size = 0;
 if (size && memory) {
   written_size = fwrite(memory, 1, size, fp);
 }

 fclose(fp);

 return written_size == size;
}
#endif

// some helper funcs
static bool operator == (const EXRBox2i& a, const EXRBox2i& b)
{
 return a.min_x == b.min_x && a.min_y == b.min_y &&
   a.max_x == b.max_x && a.max_y == b.max_y;
}

static int GetWidth(const EXRBox2i& box)
{
 return box.max_x - box.min_x + 1;
}

static int GetHeight(const EXRBox2i& box)
{
 return box.max_y - box.min_y + 1;
}

static void CompareHeaders(const EXRHeader& header1, const EXRHeader& header2)
{
#if 0
 printf("header1.dataWindow = %d, %d, %d, %d\n", header1.data_window.min_x,
    header1.data_window.min_y, header1.data_window.max_x, header1.data_window.max_y);
 printf("header2.dataWindow = %d, %d, %d, %d\n", header2.data_window.min_x,
    header2.data_window.min_y, header2.data_window.max_x, header2.data_window.max_y);
#endif
 REQUIRE(header1.compression_type == header2.compression_type);
 REQUIRE(header1.num_channels == header2.num_channels);
 REQUIRE(GetWidth(header1.data_window) == GetWidth(header2.data_window));
 REQUIRE(GetHeight(header1.data_window) == GetHeight(header2.data_window));
 //REQUIRE(header1.display_window == header2.display_window);
 //REQUIRE(header1.screen_window_width == header2.screen_window_width);
 //REQUIRE(header1.pixel_aspect_ratio == header2.pixel_aspect_ratio);
 REQUIRE(header1.tiled == header2.tiled);
 REQUIRE(header1.tile_size_x == header2.tile_size_x);
 REQUIRE(header1.tile_size_y == header2.tile_size_y);
 REQUIRE(header1.tile_level_mode == header2.tile_level_mode);
 REQUIRE(header1.tile_rounding_mode == header2.tile_rounding_mode);

 REQUIRE(header1.non_image == header2.non_image);

 REQUIRE(0 == strcmp(header1.name, header2.name));

 for (int c = 0; c < header1.num_channels; c++)
 {
   REQUIRE(header1.pixel_types[c] == header2.pixel_types[c]); // assume no conversion
   REQUIRE(0 == strcmp(header1.channels[c].name, header2.channels[c].name));
   REQUIRE(header1.channels[c].pixel_type == header2.pixel_types[c]);
   //REQUIRE(header1.channels[c].p_linear == header2.channels[c].p_linear);
   //REQUIRE(header1.channels[c].x_sampling == header2.channels[c].x_sampling);
   //REQUIRE(header1.channels[c].y_sampling == header2.channels[c].y_sampling);
 }
}

static void CompareImages(const EXRImage& image1, const EXRImage& image2)
{
 bool tiles_ok = image1.tiles && image2.tiles || image1.tiles == NULL && image2.tiles == NULL;
 REQUIRE(true == tiles_ok);
 bool images_ok = image1.images && image2.images || image1.images == NULL && image2.images == NULL;
 REQUIRE(true == images_ok);
 REQUIRE(image1.num_channels == image2.num_channels);

 const EXRImage* level_image1 = &image1;
 const EXRImage* level_image2 = &image2;
 while(level_image1 && level_image2)
 {
   REQUIRE(level_image1->level_x == level_image2->level_x);
   REQUIRE(level_image1->level_y == level_image2->level_y);
   REQUIRE(level_image1->width == level_image2->width);
   REQUIRE(level_image1->height == level_image2->height);
   REQUIRE(level_image1->num_tiles == level_image2->num_tiles);
   level_image1 = level_image1->next_level;
   level_image2 = level_image2->next_level;
   bool levels_ok = level_image1 && level_image2 || level_image1 == NULL && level_image2 == NULL;
   REQUIRE(true == levels_ok);
 }
}

TEST_CASE("asakusa", "[Load]") {
 EXRVersion exr_version;
 EXRImage exr_image;
 InitEXRImage(&exr_image);
 EXRHeader exr_header;
 InitEXRHeader(&exr_header);
 const char* err = NULL;
 int ret = ParseEXRVersionFromFile(&exr_version, "../../asakusa.exr");
 REQUIRE(TINYEXR_SUCCESS == ret);

 ret = ParseEXRHeaderFromFile(&exr_header, &exr_version, "../../asakusa.exr",
                              &err);
 REQUIRE(NULL == err);
 REQUIRE(TINYEXR_SUCCESS == ret);

 FreeEXRImage(&exr_image);
 FreeEXRHeader(&exr_header);
}

TEST_CASE("utf8filename", "[Load]") {
 EXRVersion exr_version;

 EXRHeader exr_header;
 InitEXRHeader(&exr_header);
 const char* err = NULL;

#ifdef _WIN32

#if defined(_MSC_VER)
 // Include UTF-16LE encoded string
 const wchar_t* wfilename =
#include "win32-filelist-utf16le.inc"
     ;

 // convert to char*
 // https://stackoverflow.com/questions/12637779/how-to-convert-const-wchar-to-const-char/12637971

 FILE* fp;
 errno_t errcode = _wfopen_s(&fp, wfilename, L"rb");

 REQUIRE(0 == errcode);

 char filename[1024];
 int charlen = 1000;

 int strlen = WideCharToMultiByte(65001 /* UTF8 */, 0, wfilename, -1, filename,
                                  (int)charlen, NULL, NULL);

 REQUIRE(strlen == 27);
#else
 // MinGW or clang.
 // At least clang cannot feed UTF-16LE source code, so provide UTF-8 encoded
 // file path
 const char* utf8filename =
#include "win32-filelist-utf8.inc"
     ;

 // to wchar_t
 const std::wstring wfilename = UTF8_to_wchar(utf8filename);

 FILE* fp;
 errno_t errcode = _wfopen_s(&fp, wfilename.c_str(), L"rb");

 REQUIRE(0 == errcode);

 char filename[1024];
 int charlen = 1000;

 // wchar_t to multibyte char
 int strlen = WideCharToMultiByte(65001 /* UTF8 */, 0, wfilename.c_str(), -1,
                                  filename, (int)charlen, NULL, NULL);

 REQUIRE(strlen == 27);

#endif

#else
 // Assume this source code is compiled with UTF-8(UNICODE)
 const char* filename = "./regression/日本語.exr";
#endif

 int ret = ParseEXRVersionFromFile(&exr_version, filename);
 REQUIRE(TINYEXR_SUCCESS == ret);

 ret = ParseEXRHeaderFromFile(&exr_header, &exr_version, filename, &err);
 REQUIRE(NULL == err);
 REQUIRE(TINYEXR_SUCCESS == ret);

 FreeEXRHeader(&exr_header);
}

TEST_CASE("ScanLines", "[Load]") {
 std::vector<std::string> inputs;
 inputs.push_back("ScanLines/Blobbies.exr");
 inputs.push_back("ScanLines/CandleGlass.exr");
 // inputs.push_back("ScanLines/Cannon.exr"); // Cannon.exr will fail since it
 // uses b44 compression which is not yet supported on TinyEXR.
 inputs.push_back("ScanLines/Desk.exr");
 inputs.push_back("ScanLines/MtTamWest.exr");
 inputs.push_back("ScanLines/PrismsLenses.exr");
 inputs.push_back("ScanLines/StillLife.exr");
 inputs.push_back("ScanLines/Tree.exr");

 for (size_t i = 0; i < inputs.size(); i++) {
   EXRVersion exr_version;
   std::string filepath = GetPath(inputs[i].c_str());
   std::cout << "Loading" << filepath << std::endl;
   int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
   REQUIRE(TINYEXR_SUCCESS == ret);
   REQUIRE(false == exr_version.tiled);
   REQUIRE(false == exr_version.non_image);
   REQUIRE(false == exr_version.multipart);

   EXRVersion version;
   EXRHeader header;
   EXRImage image;
   InitEXRHeader(&header);
   InitEXRImage(&image);

   const char* err;
   ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
   REQUIRE(TINYEXR_SUCCESS == ret);

   ret = LoadEXRImageFromFile(&image, &header, filepath.c_str(), &err);
   REQUIRE(TINYEXR_SUCCESS == ret);

   FreeEXRHeader(&header);
   FreeEXRImage(&image);
 }
}

TEST_CASE("Chromaticities", "[Load]") {
 std::vector<std::string> inputs;
 inputs.push_back("Chromaticities/Rec709.exr");
 inputs.push_back("Chromaticities/Rec709_YC.exr");
 inputs.push_back("Chromaticities/XYZ.exr");
 inputs.push_back("Chromaticities/XYZ_YC.exr");

 for (size_t i = 0; i < inputs.size(); i++) {
   EXRVersion exr_version;
   std::string filepath = GetPath(inputs[i].c_str());
   std::cout << "Loading" << filepath << std::endl;
   int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
   REQUIRE(TINYEXR_SUCCESS == ret);
   REQUIRE(false == exr_version.tiled);
   REQUIRE(false == exr_version.non_image);
   REQUIRE(false == exr_version.multipart);

   EXRVersion version;
   EXRHeader header;
   EXRImage image;
   InitEXRHeader(&header);
   InitEXRImage(&image);

   const char* err;
   ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
   REQUIRE(TINYEXR_SUCCESS == ret);

   ret = LoadEXRImageFromFile(&image, &header, filepath.c_str(), &err);
   REQUIRE(TINYEXR_SUCCESS == ret);

   FreeEXRHeader(&header);
   FreeEXRImage(&image);
 }
}

TEST_CASE("TestImages", "[Load]") {
 std::vector<std::string> inputs;
 inputs.push_back("TestImages/AllHalfValues.exr");
 inputs.push_back("TestImages/BrightRings.exr");
 inputs.push_back("TestImages/BrightRingsNanInf.exr");
 // inputs.push_back("TestImages/GammaChart.exr"); // disable since this uses
 // pxr24 compression
 // inputs.push_back("TestImages/GrayRampsDiagonal.exr"); // pxr24
 // inputs.push_back("TestImages/GrayRampsHorizontal.exr"); // pxr24
 // inputs.push_back("TestImages/RgbRampsDiagonal.exr"); // pxr24
 // inputs.push_back("TestImages/SquaresSwirls.exr"); // pxr24
 inputs.push_back("TestImages/WideColorGamut.exr");
 // inputs.push_back("TestImages/WideFloatRange.exr"); // pxr24

 for (size_t i = 0; i < inputs.size(); i++) {
   EXRVersion exr_version;
   std::string filepath = GetPath(inputs[i].c_str());
   std::cout << "Loading" << filepath << std::endl;
   int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
   REQUIRE(TINYEXR_SUCCESS == ret);
   REQUIRE(false == exr_version.tiled);
   REQUIRE(false == exr_version.non_image);
   REQUIRE(false == exr_version.multipart);

   EXRVersion version;
   EXRHeader header;
   EXRImage image;
   InitEXRHeader(&header);
   InitEXRImage(&image);

   const char* err;
   ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
   REQUIRE(TINYEXR_SUCCESS == ret);

   ret = LoadEXRImageFromFile(&image, &header, filepath.c_str(), &err);
   REQUIRE(TINYEXR_SUCCESS == ret);

   FreeEXRHeader(&header);
   FreeEXRImage(&image);
 }
}

TEST_CASE("LuminanceChroma", "[Load]") {
 std::vector<std::string> inputs;
 // inputs.push_back("LuminanceChroma/CrissyField.exr"); // b44
 // inputs.push_back("LuminanceChroma/Flowers.exr"); // b44
 // inputs.push_back("LuminanceChroma/Garden.exr"); // tiled
 inputs.push_back("LuminanceChroma/MtTamNorth.exr");
 inputs.push_back("LuminanceChroma/StarField.exr");

 for (size_t i = 0; i < inputs.size(); i++) {
   EXRVersion exr_version;
   std::string filepath = GetPath(inputs[i].c_str());
   std::cout << "Loading" << filepath << std::endl;
   int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
   REQUIRE(TINYEXR_SUCCESS == ret);
   REQUIRE(false == exr_version.tiled);
   REQUIRE(false == exr_version.non_image);
   REQUIRE(false == exr_version.multipart);

   EXRVersion version;
   EXRHeader header;
   EXRImage image;
   InitEXRHeader(&header);
   InitEXRImage(&image);

   const char* err;
   ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
   REQUIRE(TINYEXR_SUCCESS == ret);

   ret = LoadEXRImageFromFile(&image, &header, filepath.c_str(), &err);
   REQUIRE(TINYEXR_SUCCESS == ret);

   FreeEXRHeader(&header);
   FreeEXRImage(&image);
 }
}

TEST_CASE("DisplayWindow", "[Load]") {
 std::vector<std::string> inputs;
 inputs.push_back("DisplayWindow/t01.exr");
 inputs.push_back("DisplayWindow/t02.exr");
 inputs.push_back("DisplayWindow/t03.exr");
 inputs.push_back("DisplayWindow/t04.exr");
 inputs.push_back("DisplayWindow/t05.exr");
 inputs.push_back("DisplayWindow/t06.exr");
 inputs.push_back("DisplayWindow/t07.exr");
 inputs.push_back("DisplayWindow/t08.exr");
 inputs.push_back("DisplayWindow/t09.exr");
 inputs.push_back("DisplayWindow/t10.exr");
 inputs.push_back("DisplayWindow/t11.exr");
 inputs.push_back("DisplayWindow/t12.exr");
 inputs.push_back("DisplayWindow/t13.exr");
 inputs.push_back("DisplayWindow/t14.exr");
 inputs.push_back("DisplayWindow/t15.exr");
 inputs.push_back("DisplayWindow/t16.exr");

 for (size_t i = 0; i < inputs.size(); i++) {
   EXRVersion exr_version;
   std::string filepath = GetPath(inputs[i].c_str());
   std::cout << "Loading" << filepath << std::endl;
   int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
   REQUIRE(TINYEXR_SUCCESS == ret);
   REQUIRE(false == exr_version.tiled);
   REQUIRE(false == exr_version.non_image);
   REQUIRE(false == exr_version.multipart);

   EXRVersion version;
   EXRHeader header;
   EXRImage image;
   InitEXRHeader(&header);
   InitEXRImage(&image);

   const char* err;
   ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
   REQUIRE(TINYEXR_SUCCESS == ret);

   ret = LoadEXRImageFromFile(&image, &header, filepath.c_str(), &err);
   REQUIRE(TINYEXR_SUCCESS == ret);

   FreeEXRHeader(&header);
   FreeEXRImage(&image);
 }
}

TEST_CASE("Tiles/GoldenGate.exr", "[Version]") {
 EXRVersion exr_version;
 std::string filepath = GetPath("Tiles/GoldenGate.exr");
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(true == exr_version.tiled);
}

TEST_CASE("Tiles/GoldenGate.exr|Load", "[Load]") {
 EXRVersion exr_version;
 std::string filepath = GetPath("Tiles/GoldenGate.exr");
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(true == exr_version.tiled);
 REQUIRE(false == exr_version.non_image);
 REQUIRE(false == exr_version.multipart);

 EXRVersion version;
 EXRHeader header;
 EXRImage image;
 InitEXRHeader(&header);
 InitEXRImage(&image);

 const char* err;
 ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(1 == header.tiled);
 REQUIRE(TINYEXR_TILE_ONE_LEVEL == header.tile_level_mode);
 REQUIRE(128 == header.tile_size_x);
 REQUIRE(128 == header.tile_size_y);

 ret = LoadEXRImageFromFile(&image, &header, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(NULL != image.tiles);
 REQUIRE(0 == image.level_x);
 REQUIRE(0 == image.level_y);
 REQUIRE(1 == EXRNumLevels(&image));

 FreeEXRHeader(&header);
 FreeEXRImage(&image);
}

TEST_CASE("LuminanceChroma/Garden.exr|Load", "[Load]") {
 EXRVersion exr_version;
 std::string filepath = GetPath("LuminanceChroma/Garden.exr");
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(true == exr_version.tiled);
 REQUIRE(false == exr_version.non_image);
 REQUIRE(false == exr_version.multipart);

 EXRVersion version;
 EXRHeader header;
 EXRImage image;
 InitEXRHeader(&header);
 InitEXRImage(&image);

 const char* err;
 ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);

 ret = LoadEXRImageFromFile(&image, &header, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);

 FreeEXRHeader(&header);
 FreeEXRImage(&image);
}

TEST_CASE("Tiles/Ocean.exr", "[Load]") {
 EXRVersion exr_version;
 std::string filepath = GetPath("Tiles/Ocean.exr");
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(true == exr_version.tiled);
 REQUIRE(false == exr_version.non_image);
 REQUIRE(false == exr_version.multipart);

 EXRVersion version;
 EXRHeader header;
 EXRImage image;
 InitEXRHeader(&header);
 InitEXRImage(&image);

 const char* err;
 ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);

 ret = LoadEXRImageFromFile(&image, &header, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);

 FreeEXRHeader(&header);
 FreeEXRImage(&image);
}

TEST_CASE("MultiResolution/Bonita.exr", "[Load]") {
 EXRVersion exr_version;
 std::string filepath = GetPath("MultiResolution/Bonita.exr");
 std::cout << "Loading" << filepath << std::endl;
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(true == exr_version.tiled);
 REQUIRE(false == exr_version.non_image);
 REQUIRE(false == exr_version.multipart);

 EXRVersion version;
 EXRHeader header;
 EXRImage image;
 InitEXRHeader(&header);
 InitEXRImage(&image);

 const char* err;
 ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(1 == header.tiled);
 REQUIRE(TINYEXR_TILE_MIPMAP_LEVELS == header.tile_level_mode);
 REQUIRE(TINYEXR_TILE_ROUND_DOWN == header.tile_rounding_mode);

 ret = LoadEXRImageFromFile(&image, &header, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(10 == EXRNumLevels(&image));

 FreeEXRHeader(&header);
 FreeEXRImage(&image);
}

TEST_CASE("MultiResolution/Kapaa.exr", "[Load]") {
 EXRVersion exr_version;
 std::string filepath = GetPath("MultiResolution/Kapaa.exr");
 std::cout << "Loading" << filepath << std::endl;
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(true == exr_version.tiled);
 REQUIRE(false == exr_version.non_image);
 REQUIRE(false == exr_version.multipart);

 EXRVersion version;
 EXRHeader header;
 EXRImage image;
 InitEXRHeader(&header);
 InitEXRImage(&image);

 const char* err;
 ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(1 == header.tiled);
 REQUIRE(TINYEXR_TILE_RIPMAP_LEVELS == header.tile_level_mode);
 REQUIRE(TINYEXR_TILE_ROUND_UP == header.tile_rounding_mode);
 REQUIRE(64 == header.tile_size_x);
 REQUIRE(64 == header.tile_size_y);

 ret = LoadEXRImageFromFile(&image, &header, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(11*11 == EXRNumLevels(&image));

 FreeEXRHeader(&header);
 FreeEXRImage(&image);
}

TEST_CASE("Saving ScanLines", "[Save]") {
 std::vector<std::string> inputs;
 inputs.push_back("ScanLines/Blobbies.exr");
 inputs.push_back("ScanLines/CandleGlass.exr");
 // inputs.push_back("ScanLines/Cannon.exr"); // Cannon.exr will fail since it
 // uses b44 compression which is not yet supported on TinyEXR.
 inputs.push_back("ScanLines/Desk.exr");
 inputs.push_back("ScanLines/MtTamWest.exr");
 inputs.push_back("ScanLines/PrismsLenses.exr");
 inputs.push_back("ScanLines/StillLife.exr");
 inputs.push_back("ScanLines/Tree.exr");

 for (size_t i = 0; i < inputs.size(); i++) {
   std::string filepath = GetPath(inputs[i].c_str());
   std::cout << "Input:" << filepath << std::endl;

   EXRVersion version1;
   int ret = ParseEXRVersionFromFile(&version1, filepath.c_str());
   REQUIRE(TINYEXR_SUCCESS == ret);

   EXRHeader header1;
   EXRImage image1;
   unsigned char *data = NULL;
   size_t data_size;
   // loading from file
   {
     InitEXRHeader(&header1);
     InitEXRImage(&image1);

     const char* err;
     ret = ParseEXRHeaderFromFile(&header1, &version1, filepath.c_str(), &err);
     REQUIRE(TINYEXR_SUCCESS == ret);

     ret = LoadEXRImageFromFile(&image1, &header1, filepath.c_str(), &err);
     REQUIRE(TINYEXR_SUCCESS == ret);
   }
   // saving to memory
   {
     const char* err = NULL;
     data_size = SaveEXRImageToMemory(&image1, &header1, &data, &err);
     REQUIRE(0 != data_size);
     //FreeEXRHeader(&header);
#ifdef DUMP_IMAGES
     bool ret = WriteMemoryToFile(GetDumpPath(inputs[i].c_str()).c_str(), data, data_size);
     REQUIRE(true == ret);
#endif
   }
   // loading back from memory
   {
     EXRVersion version2;
     {
       int ret = ParseEXRVersionFromMemory(&version2, data, data_size);
       REQUIRE(0 == ret);
     }
     EXRHeader header2;
     {
       const char* err = NULL;
       InitEXRHeader(&header2);
       int ret = ParseEXRHeaderFromMemory(&header2, &version2, data, data_size, &err);
       REQUIRE(0 == ret);
     }
     EXRImage image2;
     {
       const char* err = NULL;
       InitEXRImage(&image2);
       int ret = LoadEXRImageFromMemory(&image2, &header2, data, data_size, &err);
       REQUIRE(TINYEXR_SUCCESS == ret);
       free(data);
     }

     CompareHeaders(header1, header2);
     CompareImages(image1, image2);

     FreeEXRImage(&image2);
     FreeEXRHeader(&header2);
   }

   FreeEXRHeader(&header1);
   FreeEXRImage(&image1);
 }
}

TEST_CASE("Saving MultiResolution", "[Save]") {
 //std::string filepath = GetPath("MultiResolution/Bonita.exr");
 //std::cout << "Load-save-reload:" << filepath << std::endl;

 std::vector<std::string> inputs;
 inputs.push_back("MultiResolution/Bonita.exr");
 inputs.push_back("MultiResolution/Kapaa.exr");

 for (size_t i = 0; i < inputs.size(); i++) {
   std::string filepath = GetPath(inputs[i].c_str());
   std::cout << "Input:" << filepath << std::endl;

   EXRVersion version1;
   int ret = ParseEXRVersionFromFile(&version1, filepath.c_str());
   REQUIRE(TINYEXR_SUCCESS == ret);

   EXRHeader header1;
   EXRImage image1;
   unsigned char *data = NULL;
   size_t data_size;
   // loading from file
   {
     InitEXRHeader(&header1);
     InitEXRImage(&image1);

     const char* err;
     ret = ParseEXRHeaderFromFile(&header1, &version1, filepath.c_str(), &err);
     REQUIRE(TINYEXR_SUCCESS == ret);

     ret = LoadEXRImageFromFile(&image1, &header1, filepath.c_str(), &err);
     REQUIRE(TINYEXR_SUCCESS == ret);
   }
   // saving to memory
   {
     const char* err = NULL;
     data_size = SaveEXRImageToMemory(&image1, &header1, &data, &err);
     REQUIRE(0 != data_size);
#ifdef DUMP_IMAGES
     bool ret = WriteMemoryToFile(GetDumpPath(inputs[i].c_str()).c_str(), data, data_size);
     REQUIRE(true == ret);
#endif
   }
   // loading back from memory
   {
     EXRVersion version2;
     {
       int ret = ParseEXRVersionFromMemory(&version2, data, data_size);
       REQUIRE(0 == ret);
     }
     EXRHeader header2;
     {
       const char* err = NULL;
       InitEXRHeader(&header2);
       int ret = ParseEXRHeaderFromMemory(&header2, &version2, data, data_size, &err);
       REQUIRE(0 == ret);
     }
     EXRImage image2;
     {
       const char* err = NULL;
       InitEXRImage(&image2);
       int ret = LoadEXRImageFromMemory(&image2, &header2, data, data_size, &err);
       REQUIRE(TINYEXR_SUCCESS == ret);
       free(data);
     }

     CompareHeaders(header1, header2);
     CompareImages(image1, image2);

     FreeEXRImage(&image2);
     FreeEXRHeader(&header2);
   }
   FreeEXRHeader(&header1);
   FreeEXRImage(&image1);
 }
}

TEST_CASE("Saving multipart", "[Save]") {

 std::vector<std::string> inputs;
 inputs.push_back("Beachball/multipart.0001.exr");

 for (size_t i = 0; i < inputs.size(); i++) {
   std::string filepath = GetPath(inputs[i].c_str());
   std::cout << "Input:" << filepath << std::endl;

   EXRVersion version1;
   {
     int ret = ParseEXRVersionFromFile(&version1, filepath.c_str());
     REQUIRE(TINYEXR_SUCCESS == ret);
     REQUIRE(true == version1.multipart);
   }

   EXRHeader** headers1;  // list of EXRHeader pointers.
   int num_headers1;
   {
     const char* err = NULL;
     int ret = ParseEXRMultipartHeaderFromFile(&headers1, &num_headers1,
                       &version1, filepath.c_str(), &err);
     REQUIRE(TINYEXR_SUCCESS == ret);
   }

   unsigned char *data = NULL;
   size_t data_size;

   std::vector<EXRImage> images1(num_headers1);
   // loading from file
   {
     const char* err = NULL;
     for (int j = 0; j < num_headers1; j++) {
       InitEXRImage(&images1[j]);
     }
     int ret = LoadEXRMultipartImageFromFile(&images1[0], const_cast<const EXRHeader**>(headers1),
     static_cast<unsigned int>(num_headers1), filepath.c_str(), &err);
     REQUIRE(TINYEXR_SUCCESS == ret);
   }
   // saving to memory
   {
     const char* err = NULL;
     data_size = SaveEXRMultipartImageToMemory(&images1[0],
       const_cast<const EXRHeader**>(headers1), static_cast<unsigned int>(num_headers1), &data, &err);
     REQUIRE(0 != data_size);
 #ifdef DUMP_IMAGES
     bool ret = WriteMemoryToFile(GetDumpPath(inputs[i].c_str()).c_str(), data, data_size);
     REQUIRE(true == ret);
 #endif
   }
   // loading back from memory
   {
     EXRVersion version2;
     {
       int ret = ParseEXRVersionFromMemory(&version2, data, data_size);
       REQUIRE(TINYEXR_SUCCESS == ret);
       REQUIRE(true == version2.multipart);
     }
     EXRHeader** headers2;
     int num_headers2;
     {
       const char* err = NULL;
       int ret = ParseEXRMultipartHeaderFromMemory(&headers2, &num_headers2, &version2,
                                              data, data_size, &err);
             REQUIRE(TINYEXR_SUCCESS == ret);

     }
     REQUIRE(num_headers1 == num_headers2);

     std::vector<EXRImage> images2(num_headers2);
     {
       for (int j = 0; j < num_headers2; j++) {
         InitEXRImage(&images2[j]);
       }
       const char* err = NULL;
       int ret = LoadEXRMultipartImageFromMemory(&images2[0], const_cast<const EXRHeader**>(headers2),
                             static_cast<unsigned int>(num_headers2),
                              data, data_size, &err);
       REQUIRE(TINYEXR_SUCCESS == ret);
       free(data);
     }

     for (int j = 0; j < num_headers2; j++) {
       CompareHeaders(*headers1[j], *headers2[j]);
     }
     for (int j = 0; j < num_headers2; j++) {
       CompareImages(images1[j], images2[j]);
     }

     for (int j = 0; j < num_headers2; j++) {
       FreeEXRImage(&images2[j]);
       FreeEXRHeader(headers2[j]);
       free(headers2[j]);
     }
     free(headers2);
   }

   for (int j = 0; j < num_headers1; j++) {
     FreeEXRImage(&images1[j]);
     FreeEXRHeader(headers1[j]);
     free(headers1[j]);
   }
   free(headers1);
 }
}

TEST_CASE("Saving multipart|Combine", "[Save]") {

 std::vector<std::string> inputs;
 inputs.push_back("MultiResolution/Kapaa.exr"); // tiled, ripmap
 inputs.push_back("Tiles/GoldenGate.exr"); // tiled, one level
 inputs.push_back("ScanLines/Desk.exr"); // scanline
 inputs.push_back("MultiResolution/PeriodicPattern.exr"); // tiled, mipmap

 const char* dstName = "multipart.collection.exr";

 unsigned num_headers1 = inputs.size();
 std::vector<EXRHeader> headers1(num_headers1);
 std::vector<EXRImage> images1(num_headers1);
 // collecting images
 for (size_t i = 0; i < num_headers1; i++) {
   std::string filepath = GetPath(inputs[i].c_str());
   std::cout << "Input:" << filepath << std::endl;

   EXRVersion version1;
   {
     int ret = ParseEXRVersionFromFile(&version1, filepath.c_str());
     REQUIRE(TINYEXR_SUCCESS == ret);
     REQUIRE(false == version1.multipart);
   }
   {
     InitEXRHeader(&headers1[i]);
     const char* err = NULL;
     int ret = ParseEXRHeaderFromFile(&headers1[i], &version1, filepath.c_str(), &err);
     REQUIRE(TINYEXR_SUCCESS == ret);
   }
   {
     InitEXRImage(&images1[i]);
     const char* err = NULL;
     int ret = LoadEXRImageFromFile(&images1[i], &headers1[i], filepath.c_str(), &err);
     REQUIRE(TINYEXR_SUCCESS == ret);
   }
 }

 unsigned char *data = NULL;
 size_t data_size;
 // saving collection to memory as multipart
 {
   std::vector<EXRHeader*> pheaders1(num_headers1);
   for(unsigned i = 0; i < num_headers1; ++i) pheaders1[i] = &headers1[i];
   for (size_t i = 0; i < num_headers1; i++) {
     EXRSetNameAttr(pheaders1[i], inputs[i].c_str());
   }
   const char* err = NULL;
   data_size = SaveEXRMultipartImageToMemory(&images1[0],
                                             const_cast<const EXRHeader**>(&pheaders1[0]),
                                             static_cast<unsigned int>(num_headers1),
                                             &data, &err);
   REQUIRE(0 != data_size);
#ifdef DUMP_IMAGES
   bool ret = WriteMemoryToFile(GetDumpPath(dstName).c_str(), data, data_size);
   REQUIRE(true == ret);
#endif
 }
 // loading back from memory
 {
   EXRVersion version2;
   {
     int ret = ParseEXRVersionFromMemory(&version2, data, data_size);
     REQUIRE(TINYEXR_SUCCESS == ret);
     REQUIRE(true == version2.multipart);
   }
   EXRHeader** headers2;
   int num_headers2;
   {
     const char* err = NULL;
     int ret = ParseEXRMultipartHeaderFromMemory(&headers2, &num_headers2, &version2,
                                                 data, data_size, &err);
     REQUIRE(TINYEXR_SUCCESS == ret);

   }
   REQUIRE(num_headers1 == num_headers2);

   std::vector<EXRImage> images2(num_headers2);
   {
     for (int j = 0; j < num_headers2; j++) {
       InitEXRImage(&images2[j]);
     }
     const char* err = NULL;
     int ret = LoadEXRMultipartImageFromMemory(&images2[0], const_cast<const EXRHeader**>(headers2),
                                               static_cast<unsigned int>(num_headers2),
                                               data, data_size, &err);
     REQUIRE(TINYEXR_SUCCESS == ret);
     free(data);
   }

   for (int j = 0; j < num_headers2; j++) {
     CompareHeaders(headers1[j], *headers2[j]);
   }
   for (int j = 0; j < num_headers2; j++) {
     CompareImages(images1[j], images2[j]);
   }

   for (int j = 0; j < num_headers2; j++) {
     FreeEXRImage(&images2[j]);
     FreeEXRHeader(headers2[j]);
     free(headers2[j]);
   }
   free(headers2);
 }

 for (int i = 0; i < num_headers1; i++) {
   FreeEXRImage(&images1[i]);
   FreeEXRHeader(&headers1[i]);
 }
}

#if 0  // Spirals.exr uses pxr24 compression
TEST_CASE("Tiles/Spirals.exr", "[Load]") {
 EXRVersion exr_version;
 std::string filepath = GetPath("Tiles/Spirals.exr");
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(true == exr_version.tiled);
 REQUIRE(false == exr_version.non_image);
 REQUIRE(false == exr_version.multipart);

 EXRVersion version;
 EXRHeader header;
 EXRImage image;
 InitEXRHeader(&header);
 InitEXRImage(&image);

 const char* err;
 ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);


 ret= LoadEXRImageFromFile(&image, &header, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);

 FreeEXRHeader(&header);
 FreeEXRImage(&image);
}
#endif

TEST_CASE("Beachball/multipart.0001.exr", "[Version]") {
 EXRVersion exr_version;
 std::string filepath = GetPath("Beachball/multipart.0001.exr");
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(true == exr_version.multipart);

 EXRHeader* headers;
}

TEST_CASE("Beachball/multipart.0001.exr|Load", "[Load]") {
 EXRVersion exr_version;
 std::string filepath = GetPath("Beachball/multipart.0001.exr");
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(true == exr_version.multipart);

 EXRHeader** exr_headers;  // list of EXRHeader pointers.
 int num_exr_headers;
 const char* err;

 ret = ParseEXRMultipartHeaderFromFile(&exr_headers, &num_exr_headers,
                                       &exr_version, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);

 REQUIRE(10 == num_exr_headers);

 std::vector<EXRImage> images(static_cast<size_t>(num_exr_headers));
 for (int i = 0; i < num_exr_headers; i++) {
   InitEXRImage(&images[static_cast<size_t>(i)]);
 }

 ret = LoadEXRMultipartImageFromFile(
     &images.at(0), const_cast<const EXRHeader**>(exr_headers),
     static_cast<unsigned int>(num_exr_headers), filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);

 for (int i = 0; i < num_exr_headers; i++) {
   FreeEXRImage(&images.at(static_cast<size_t>(i)));
 }

 for (int i = 0; i < num_exr_headers; i++) {
   FreeEXRHeader(exr_headers[static_cast<size_t>(i)]);  // free content
   free(exr_headers[static_cast<size_t>(i)]);           // free pointer
 }
 free(exr_headers);
}

TEST_CASE("Beachbal multiparts", "[Load]") {
 int num = 8;
 char buf[1024];
 for (int i = 0; i < num + 1; i++) {
   sprintf(buf, "Beachball/multipart.%04d.exr", i);
   EXRVersion exr_version;
   std::string filepath = GetPath(buf);
   int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());

   if (i == 0) {  // multipart.0000.exr does not exist.
     REQUIRE(TINYEXR_ERROR_CANT_OPEN_FILE == ret);
     continue;
   }

   REQUIRE(TINYEXR_SUCCESS == ret);
   REQUIRE(true == exr_version.multipart);

   EXRHeader** exr_headers;  // list of EXRHeader pointers.
   int num_exr_headers;
   const char* err;

   ret = ParseEXRMultipartHeaderFromFile(&exr_headers, &num_exr_headers,
                                         &exr_version, filepath.c_str(), &err);
   REQUIRE(TINYEXR_SUCCESS == ret);

   REQUIRE(10 == num_exr_headers);

   std::vector<EXRImage> images(static_cast<size_t>(num_exr_headers));
   for (int j = 0; j < num_exr_headers; j++) {
     InitEXRImage(&images[static_cast<size_t>(j)]);
   }

   ret = LoadEXRMultipartImageFromFile(
       &images.at(0), const_cast<const EXRHeader**>(exr_headers),
       static_cast<unsigned int>(num_exr_headers), filepath.c_str(), &err);
   REQUIRE(TINYEXR_SUCCESS == ret);

   for (int j = 0; j < num_exr_headers; j++) {
     FreeEXRImage(&images.at(static_cast<size_t>(j)));
   }

   for (int j = 0; j < num_exr_headers; j++) {
     FreeEXRHeader(exr_headers[static_cast<size_t>(j)]);
     free(exr_headers[static_cast<size_t>(j)]);
   }
   free(exr_headers);
 }
}

TEST_CASE("Beachbal singleparts", "[Load]") {
 int num = 8;
 char buf[1024];
 for (int i = 0; i < num + 1; i++) {
   sprintf(buf, "Beachball/singlepart.%04d.exr", i);
   EXRVersion exr_version;
   std::string filepath = GetPath(buf);
   int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());

   if (i == 0) {  // multipart.0000.exr does not exist.
     REQUIRE(TINYEXR_ERROR_CANT_OPEN_FILE == ret);
     continue;
   }

   REQUIRE(TINYEXR_SUCCESS == ret);
   REQUIRE(false == exr_version.tiled);
   REQUIRE(false == exr_version.non_image);
   REQUIRE(false == exr_version.multipart);

   EXRVersion version;
   memset(&version, 0, sizeof(EXRVersion));
   EXRHeader header;
   EXRImage image;
   InitEXRHeader(&header);
   InitEXRImage(&image);

   const char* err;
   ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
   REQUIRE(TINYEXR_SUCCESS == ret);

   ret = LoadEXRImageFromFile(&image, &header, filepath.c_str(), &err);
   REQUIRE(TINYEXR_SUCCESS == ret);

   REQUIRE(image.tiles == NULL);
   REQUIRE(image.images);

   FreeEXRHeader(&header);
   FreeEXRImage(&image);
 }
}

TEST_CASE("ParseEXRVersionFromMemory invalid input", "[Parse]") {
 int ret = ParseEXRVersionFromMemory(NULL, NULL, 0);
 REQUIRE(ret == TINYEXR_ERROR_INVALID_ARGUMENT);

 {
   EXRVersion version;
   memset(&version, 0, sizeof(EXRVersion));
   ret = ParseEXRVersionFromMemory(&version, NULL, 0);
   REQUIRE(ret == TINYEXR_ERROR_INVALID_ARGUMENT);
 }

 {
   EXRVersion version;
   memset(&version, 0, sizeof(EXRVersion));
   std::vector<unsigned char> buf(128);
   ret = ParseEXRVersionFromMemory(&version, buf.data(), 0);
   REQUIRE(ret == TINYEXR_ERROR_INVALID_DATA);
 }

 {
   EXRVersion version;
   memset(&version, 0, sizeof(EXRVersion));
   std::vector<unsigned char> buf(4);
   ret = ParseEXRVersionFromMemory(
       &version, buf.data(), 1);  // size is less than version header size
   REQUIRE(ret == TINYEXR_ERROR_INVALID_DATA);
 }

 {
   EXRVersion version;
   memset(&version, 0, sizeof(EXRVersion));
   std::vector<unsigned char> buf(8, 0);  // invalid magic number
   ret = ParseEXRVersionFromMemory(&version, buf.data(), 8);
   REQUIRE(ret == TINYEXR_ERROR_INVALID_MAGIC_NUMBER);
 }
}

TEST_CASE("ParseEXRHeaderFromMemory invalid input", "[Parse]") {
 {
   int ret = ParseEXRHeaderFromMemory(NULL, NULL, NULL, 0, NULL);
   REQUIRE(ret == TINYEXR_ERROR_INVALID_ARGUMENT);
 }

 {
   EXRHeader header;
   InitEXRHeader(&header);
   EXRVersion version;
   memset(&version, 0, sizeof(EXRVersion));

   int ret = ParseEXRHeaderFromMemory(&header, &version, NULL, 0, NULL);
   REQUIRE(ret == TINYEXR_ERROR_INVALID_ARGUMENT);
   FreeEXRHeader(&header);
 }

 {
   EXRHeader header;
   InitEXRHeader(&header);
   EXRVersion version;
   memset(&version, 0, sizeof(EXRVersion));
   std::vector<unsigned char> buf(128);

   int ret = ParseEXRHeaderFromMemory(&header, &version, buf.data(), 0, NULL);
   REQUIRE(ret == TINYEXR_ERROR_INVALID_DATA);
   FreeEXRHeader(&header);
 }

 {
   EXRHeader header;
   InitEXRHeader(&header);
   EXRVersion version;
   memset(&version, 0, sizeof(EXRVersion));
   std::vector<unsigned char> buf(128, 0);

   int ret =
       ParseEXRHeaderFromMemory(&header, &version, buf.data(), 128, NULL);
   REQUIRE(ret == TINYEXR_ERROR_INVALID_HEADER);
   FreeEXRHeader(&header);
 }
}

TEST_CASE("Compressed is smaller than uncompressed", "[Issue40]") {
 EXRHeader header;
 InitEXRHeader(&header);

 header.compression_type = TINYEXR_COMPRESSIONTYPE_ZIP;

 EXRImage image;
 InitEXRImage(&image);

 image.num_channels = 3;

 float const images[3][1] = {
     {1.0f},
     {0.0f},
     {0.0f},
 };

 float const* const image_ptr[3] = {
     images[2],
     images[1],
     images[0],
 };

 image.images = const_cast<unsigned char**>(reinterpret_cast<const unsigned char*const *>(image_ptr));
 image.width = 1;
 image.height = 1;

 header.num_channels = 3;
 header.channels =
     static_cast<EXRChannelInfo*>(malloc(sizeof(EXRChannelInfo) * static_cast<size_t>(header.num_channels)));
 // Must be BGR(A) order, since most of EXR viewers expect this channel order.
 strncpy(header.channels[0].name, "B", 255);
 header.channels[0].name[strlen("B")] = '\0';
 strncpy(header.channels[1].name, "G", 255);
 header.channels[1].name[strlen("G")] = '\0';
 strncpy(header.channels[2].name, "R", 255);
 header.channels[2].name[strlen("R")] = '\0';

 header.pixel_types = static_cast<int*>(malloc(sizeof(int) * static_cast<size_t>(header.num_channels)));
 header.requested_pixel_types =
     static_cast<int*>(malloc(sizeof(int) * static_cast<size_t>(header.num_channels)));
 for (int i = 0; i < header.num_channels; i++) {
   header.pixel_types[i] =
       TINYEXR_PIXELTYPE_FLOAT;  // pixel type of input image
   header.requested_pixel_types[i] =
       TINYEXR_PIXELTYPE_FLOAT;  // pixel type of output image to be stored in
                                 // .EXR
 }

 const char* err;
 int const ret = SaveEXRImageToFile(&image, &header, "issue40.exr", &err);
 REQUIRE(ret == TINYEXR_SUCCESS);

 free(header.channels);
 free(header.requested_pixel_types);
 free(header.pixel_types);
}

// TEST_CASE("Regression: Issue54", "[fuzzing]") {
//  EXRVersion exr_version;
//  std::string filepath =
//  "./regression/poc-360c3b0555cb979ca108f2d178cf8a80959cfeabaa4ec1d310d062fa653a8c6b_min";
//  int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
//  REQUIRE(TINYEXR_SUCCESS == ret);
//  REQUIRE(false == exr_version.tiled);
//  REQUIRE(false == exr_version.non_image);
//  REQUIRE(false == exr_version.multipart);
//
//  EXRVersion version;
//  EXRHeader header;
//  EXRImage image;
//  InitEXRHeader(&header);
//  InitEXRImage(&image);
//
//  const char* err;
//  ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
//  REQUIRE(TINYEXR_SUCCESS == ret);
//
//  ret = LoadEXRImageFromFile(&image, &header, filepath.c_str(), &err);
//  REQUIRE(TINYEXR_SUCCESS == ret);
//
//  FreeEXRHeader(&header);
//  FreeEXRImage(&image);
//}

TEST_CASE("Regression: Issue50", "[fuzzing]") {
 EXRVersion exr_version;
 std::string filepath =
     "./regression/"
     "poc-eedff3a9e99eb1c0fd3a3b0989e7c44c0a69f04f10b23e5264f362a4773f4397_"
     "min";
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(false == exr_version.tiled);
 REQUIRE(false == exr_version.non_image);
 REQUIRE(false == exr_version.multipart);

 EXRVersion version;
 EXRHeader header;
 EXRImage image;
 InitEXRHeader(&header);
 InitEXRImage(&image);

 const char* err = nullptr;
 ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == false);
 if (ret) {
   FreeEXRErrorMessage(err);
 }

 FreeEXRHeader(&header);
 // FreeEXRImage(&image);
}

TEST_CASE("Regression: Issue57", "[fuzzing]") {
 EXRVersion exr_version;
 std::string filepath =
     "./regression/"
     "poc-df76d1f27adb8927a1446a603028272140905c168a336128465a1162ec7af270."
     "mini";
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(false == exr_version.tiled);
 REQUIRE(false == exr_version.non_image);
 REQUIRE(false == exr_version.multipart);

 EXRVersion version;
 EXRHeader header;
 EXRImage image;
 InitEXRHeader(&header);
 InitEXRImage(&image);

 const char* err = nullptr;
 ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == false);
 if (err) {
   FreeEXRErrorMessage(err);
 }

 FreeEXRHeader(&header);
 // FreeEXRImage(&image);
}

TEST_CASE("Regression: Issue56", "[fuzzing]") {
 EXRVersion exr_version;
 std::string filepath =
     "./regression/"
     "poc-1383755b301e5f505b2198dc0508918b537fdf48bbfc6deeffe268822e6f6cd6";
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(false == exr_version.tiled);
 REQUIRE(false == exr_version.non_image);
 REQUIRE(false == exr_version.multipart);

 EXRVersion version;
 EXRHeader header;
 EXRImage image;
 InitEXRHeader(&header);
 InitEXRImage(&image);

 const char* err = nullptr;
 ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == false);
 if (err) {
   FreeEXRErrorMessage(err);
 }

 FreeEXRHeader(&header);
 // FreeEXRImage(&image);
}

TEST_CASE("Regression: Issue61", "[fuzzing]") {
 EXRVersion exr_version;
 std::string filepath =
     "./regression/"
     "poc-3f1f642c3356fd8e8d2a0787613ec09a56572b3a1e38c9629b6db9e8dead1117_"
     "min";
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(false == exr_version.tiled);
 REQUIRE(false == exr_version.non_image);
 REQUIRE(false == exr_version.multipart);

 EXRVersion version;
 EXRHeader header;
 EXRImage image;
 InitEXRHeader(&header);
 InitEXRImage(&image);

 const char* err = nullptr;
 ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == false);
 if (err) {
   FreeEXRErrorMessage(err);
 }

 FreeEXRHeader(&header);
 // FreeEXRImage(&image);
}

TEST_CASE("Regression: Issue60", "[fuzzing]") {
 EXRVersion exr_version;
 std::string filepath =
     "./regression/"
     "poc-5b66774a7498c635334ad386be0c3b359951738ac47f14878a3346d1c6ea0fe5_"
     "min";
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(false == exr_version.tiled);
 REQUIRE(false == exr_version.non_image);
 REQUIRE(false == exr_version.multipart);

 EXRVersion version;
 EXRHeader header;
 EXRImage image;
 InitEXRHeader(&header);
 InitEXRImage(&image);

 const char* err = nullptr;
 ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == false);
 if (err) {
   FreeEXRErrorMessage(err);
 }

 FreeEXRHeader(&header);
 // FreeEXRImage(&image);
}

TEST_CASE("Regression: Issue71", "[issue71]") {
 std::string filepath = "./regression/2by2.exr";

 const char* err;
 int width, height;
 float* image;
 int ret = LoadEXR(&image, &width, &height, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(2 == width);
 REQUIRE(2 == height);

 REQUIRE(0.0f == Approx(image[8]));
 REQUIRE(0.447021f == Approx(image[9]));
 REQUIRE(1.0f == Approx(image[10]));
 REQUIRE(0.250977f == Approx(image[11]));
 REQUIRE(0.0f == Approx(image[12]));
 REQUIRE(0.0f == Approx(image[13]));
 REQUIRE(0.0f == Approx(image[14]));
 REQUIRE(1.0f == Approx(image[15]));

 free(image);
}

// LoadEXRLoadFromMemory fails to load tiled image.
TEST_CASE("Regression: Issue93", "[issue93]") {
 std::string filepath = GetPath("Tiles/GoldenGate.exr");

 std::ifstream f(filepath.c_str(), std::ifstream::binary);
 REQUIRE(f.good());

 f.seekg(0, f.end);
 size_t sz = static_cast<size_t>(f.tellg());
 f.seekg(0, f.beg);

 REQUIRE(sz > 16);

 std::vector<unsigned char> data;

 data.resize(sz);
 f.read(reinterpret_cast<char*>(&data.at(0)),
        static_cast<std::streamsize>(sz));
 f.close();

 const char* err;
 int width, height;
 float* image;
 int ret = LoadEXRFromMemory(&image, &width, &height, data.data(), data.size(),
                             &err);
 REQUIRE(TINYEXR_SUCCESS == ret);

 std::cout << "val = " << image[0] << ", " << image[1] << ", " << image[2]
           << ", " << image[3] << std::endl;

 REQUIRE(0.0612183 == Approx(image[0]));
 REQUIRE(0.0892334 == Approx(image[1]));
 REQUIRE(0.271973 == Approx(image[2]));

 free(image);
}

// PIZ decompress bug(issue 100)
TEST_CASE("Regression: Issue100", "[issue100]") {
 std::string filepath = "./regression/piz-bug-issue-100.exr";

 std::ifstream f(filepath.c_str(), std::ifstream::binary);
 REQUIRE(f.good());

 f.seekg(0, f.end);
 size_t sz = static_cast<size_t>(f.tellg());
 f.seekg(0, f.beg);

 REQUIRE(sz > 16);

 std::vector<unsigned char> data;

 data.resize(sz);
 f.read(reinterpret_cast<char*>(&data.at(0)),
        static_cast<std::streamsize>(sz));
 f.close();

 const char* err = nullptr;
 int width, height;
 float* image;
 int ret = LoadEXRFromMemory(&image, &width, &height, data.data(), data.size(),
                             &err);
 if (err) {
   std::cerr << "issue100 err " << err << std::endl;
   FreeEXRErrorMessage(err);
 }
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(35 == width);
 REQUIRE(1 == height);

 // pixel should be white.

 std::cout << "pixel[0] = " << image[0] << ", " << image[1] << ", " << image[2]
           << ", " << image[3] << std::endl;
 std::cout << "pixel[34] = " << image[4 * 34 + 0] << ", " << image[4 * 34 + 1]
           << ", " << image[4 * 34 + 2] << ", " << image[4 * 34 + 3]
           << std::endl;

 REQUIRE(0.0 == Approx(image[0]));
 REQUIRE(0.0 == Approx(image[1]));
 REQUIRE(0.0 == Approx(image[2]));
 REQUIRE(0.0 == Approx(image[3]));

 REQUIRE(1.0 == Approx(image[4 * 34 + 0]));
 REQUIRE(1.0 == Approx(image[4 * 34 + 1]));
 REQUIRE(1.0 == Approx(image[4 * 34 + 2]));
 REQUIRE(1.0 == Approx(image[4 * 34 + 3]));

 free(image);
}

TEST_CASE("Regression: Issue53|Channels", "[issue53]") {
 EXRVersion exr_version;
 std::string filepath = "./regression/flaga.exr";
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);

 EXRHeader header;
 EXRImage image;
 InitEXRHeader(&header);

 const char* err = nullptr;
 ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);

 std::vector<std::string> layer_names;
 tinyexr::GetLayers(header, layer_names);

 REQUIRE(2 == layer_names.size());

 std::vector<tinyexr::LayerChannel> channels;
 tinyexr::ChannelsInLayer(header, "", channels);
 REQUIRE(0 == channels.size());

 channels.clear();
 tinyexr::ChannelsInLayer(header, "Warstwa 3", channels);
 REQUIRE(0 == channels.size());

 channels.clear();
 tinyexr::ChannelsInLayer(header, "Warstwa 1", channels);
 REQUIRE(4 == channels.size());

 FreeEXRHeader(&header);

 if (err) {
   FreeEXRErrorMessage(err);
 }
}

TEST_CASE("Regression: Issue53|Image", "[issue53]") {
 std::string filepath = "./regression/flaga.exr";

 const char* err = nullptr;
 const char** layer_names = nullptr;
 int num_layers = 0;
 int ret = EXRLayers(filepath.c_str(), &layer_names, &num_layers, &err);
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(2 == num_layers);
 for (int i = 0; i < num_layers; i++) {
   free(reinterpret_cast<void*>(const_cast<char*>(layer_names[i])));
 }
 free(layer_names);

 int width, height;
 float* image;
 ret = LoadEXRWithLayer(&image, &width, &height, filepath.c_str(), NULL, &err);
 REQUIRE(TINYEXR_SUCCESS != ret);
 if (TINYEXR_SUCCESS == ret) {
   free(image);
 }
 if (err) {
   FreeEXRErrorMessage(err);
   err = nullptr;
 }

 ret = LoadEXRWithLayer(&image, &width, &height, filepath.c_str(), "Warstwa 1",
                        &err);
 REQUIRE(TINYEXR_SUCCESS == ret);
 if (TINYEXR_SUCCESS == ret) {
   free(image);
 }

 if (err) {
   FreeEXRErrorMessage(err);
 }
}

TEST_CASE("Regression: Issue53|Image|Missing Layer", "[issue53]") {
 std::string filepath = GetPath("MultiView/Impact.exr");

 const char* err = nullptr;
 int width, height;
 float* image = nullptr;
 int ret = LoadEXRWithLayer(&image, &width, &height, filepath.c_str(),
                            "Warstwa", &err);
 REQUIRE(TINYEXR_ERROR_LAYER_NOT_FOUND == ret);
 if (image) {
   free(image);
 }
 if (err) {
   FreeEXRErrorMessage(err);
 }
}

TEST_CASE("Regression: PR150|Read|1x1 1xhalf", "[pr150]") {
 std::string filepath = "./regression/tiled_half_1x1_alpha.exr";

 EXRVersion exr_version;
 std::cout << "Loading" << filepath << std::endl;
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);
 REQUIRE(true == exr_version.tiled);
 REQUIRE(false == exr_version.non_image);
 REQUIRE(false == exr_version.multipart);

 EXRVersion version;
 EXRHeader header;
 EXRImage image;
 InitEXRHeader(&header);
 InitEXRImage(&image);

 const char* err;
 ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);

 ret = LoadEXRImageFromFile(&image, &header, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);

 FreeEXRHeader(&header);
 FreeEXRImage(&image);
}

TEST_CASE("Regression: Issue194|Piz", "[issue194]") {
 std::string filepath = "./regression/000-issue194.exr";

 EXRVersion exr_version;
 std::cout << "Loading" << filepath << std::endl;
 int ret = ParseEXRVersionFromFile(&exr_version, filepath.c_str());
 REQUIRE(TINYEXR_SUCCESS == ret);

 EXRVersion version;
 EXRHeader header;
 EXRImage image;
 InitEXRHeader(&header);
 InitEXRImage(&image);

 const char* err;
 ret = ParseEXRHeaderFromFile(&header, &exr_version, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);

 ret = LoadEXRImageFromFile(&image, &header, filepath.c_str(), &err);
 REQUIRE(TINYEXR_SUCCESS == ret);

 FreeEXRHeader(&header);
 FreeEXRImage(&image);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.