🛠️🐜 Antkeeper superbuild with dependencies included
https://antkeeper.com
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1714 lines
52 KiB
1714 lines
52 KiB
// 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(8 == 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);
|
|
free(image);
|
|
if (err) {
|
|
FreeEXRErrorMessage(err);
|
|
}
|
|
|
|
ret = LoadEXRWithLayer(&image, &width, &height, filepath.c_str(), "Warstwa 1",
|
|
&err);
|
|
REQUIRE(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);
|
|
}
|