asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Backport EXR compression support from master

Browse source
This commit is contained in:
JFonS 2021-02-15 12:03:45 +01:00
parent 40c30adf04
commit 7241139356
4 changed files with 151 additions and 83 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
modules/tinyexr/SCsub
View file

@ -6,6 +6,9 @@ Import("env_modules")
env_tinyexr = env_modules.Clone() env_tinyexr = env_modules.Clone()
# Thirdparty source files # Thirdparty source files
thirdparty_obj = []
# Not unbundled for now as they are not commonly available as shared library # Not unbundled for now as they are not commonly available as shared library
thirdparty_dir = "#thirdparty/tinyexr/" thirdparty_dir = "#thirdparty/tinyexr/"
thirdparty_sources = [ thirdparty_sources = [
@ -20,7 +23,15 @@ env_tinyexr.Append(CPPDEFINES=["TINYEXR_USE_THREAD"])
env_thirdparty = env_tinyexr.Clone() env_thirdparty = env_tinyexr.Clone()
env_thirdparty.disable_warnings() env_thirdparty.disable_warnings()
env_thirdparty.add_source_files(env.modules_sources, thirdparty_sources) env_thirdparty.add_source_files(thirdparty_obj, thirdparty_sources)
env.modules_sources += thirdparty_obj
# Godot's own source files # Godot source files
env_tinyexr.add_source_files(env.modules_sources, "*.cpp")
module_obj = []
env_tinyexr.add_source_files(module_obj, "*.cpp")
env.modules_sources += module_obj
# Needed to force rebuilding the module files when the thirdparty library is updated.
env.Depends(module_obj, thirdparty_obj)

180
modules/tinyexr/image_loader_tinyexr.cpp
View file

@ -42,7 +42,8 @@ Error ImageLoaderTinyEXR::load_image(Ref<Image> p_image, FileAccess *f, bool p_f
ERR_FAIL_COND_V(src_image_len == 0, ERR_FILE_CORRUPT); ERR_FAIL_COND_V(src_image_len == 0, ERR_FILE_CORRUPT);
src_image.resize(src_image_len); src_image.resize(src_image_len);
PoolVector<uint8_t>::Write w = src_image.write(); PoolVector<uint8_t>::Write img_write = src_image.write();
uint8_t *w = img_write.ptr();
f->get_buffer(&w[0], src_image_len); f->get_buffer(&w[0], src_image_len);
@ -56,36 +57,37 @@ Error ImageLoaderTinyEXR::load_image(Ref<Image> p_image, FileAccess *f, bool p_f
EXRVersion exr_version; EXRVersion exr_version;
EXRImage exr_image; EXRImage exr_image;
EXRHeader exr_header; EXRHeader exr_header;
const char *err = NULL; const char *err = nullptr;
InitEXRHeader(&exr_header); InitEXRHeader(&exr_header);
int ret = ParseEXRVersionFromMemory(&exr_version, w.ptr(), src_image_len); int ret = ParseEXRVersionFromMemory(&exr_version, w, src_image_len);
if (ret != TINYEXR_SUCCESS) { if (ret != TINYEXR_SUCCESS) {
return ERR_FILE_CORRUPT; return ERR_FILE_CORRUPT;
} }
ret = ParseEXRHeaderFromMemory(&exr_header, &exr_version, w.ptr(), src_image_len, &err); ret = ParseEXRHeaderFromMemory(&exr_header, &exr_version, w, src_image_len, &err);
if (ret != TINYEXR_SUCCESS) { if (ret != TINYEXR_SUCCESS) {
if (err) { if (err) {
ERR_PRINTS(String(err)); ERR_PRINT(String(err));
} }
return ERR_FILE_CORRUPT; return ERR_FILE_CORRUPT;
} }
// Read HALF channel as FLOAT. (GH-13490) // Read HALF channel as FLOAT. (GH-13490)
bool use_float16 = false;
for (int i = 0; i < exr_header.num_channels; i++) { for (int i = 0; i < exr_header.num_channels; i++) {
if (exr_header.pixel_types[i] == TINYEXR_PIXELTYPE_HALF) { if (exr_header.pixel_types[i] == TINYEXR_PIXELTYPE_HALF) {
use_float16 = true;
exr_header.requested_pixel_types[i] = TINYEXR_PIXELTYPE_FLOAT; exr_header.requested_pixel_types[i] = TINYEXR_PIXELTYPE_FLOAT;
} }
} }
InitEXRImage(&exr_image); InitEXRImage(&exr_image);
ret = LoadEXRImageFromMemory(&exr_image, &exr_header, w.ptr(), src_image_len, &err); ret = LoadEXRImageFromMemory(&exr_image, &exr_header, w, src_image_len, &err);
if (ret != TINYEXR_SUCCESS) { if (ret != TINYEXR_SUCCESS) {
if (err) { if (err) {
ERR_PRINTS(String(err)); ERR_PRINT(String(err));
} }
return ERR_FILE_CORRUPT; return ERR_FILE_CORRUPT;
} }
@ -104,33 +106,10 @@ Error ImageLoaderTinyEXR::load_image(Ref<Image> p_image, FileAccess *f, bool p_f
idxB = c; idxB = c;
} else if (strcmp(exr_header.channels[c].name, "A") == 0) { } else if (strcmp(exr_header.channels[c].name, "A") == 0) {
idxA = c; idxA = c;
} } else if (strcmp(exr_header.channels[c].name, "Y") == 0) {
} idxR = c;
idxG = c;
if (exr_header.num_channels == 1) { idxB = c;
// Grayscale channel only.
idxR = 0;
idxG = 0;
idxB = 0;
idxA = 0;
} else {
// Assume RGB(A)
if (idxR == -1) {
ERR_PRINT("TinyEXR: R channel not found.");
// @todo { free exr_image }
return ERR_FILE_CORRUPT;
}
if (idxG == -1) {
ERR_PRINT("TinyEXR: G channel not found.");
// @todo { free exr_image }
return ERR_FILE_CORRUPT;
}
if (idxB == -1) {
ERR_PRINT("TinyEXR: B channel not found.");
// @todo { free exr_image }
return ERR_FILE_CORRUPT;
} }
} }
@ -140,16 +119,27 @@ Error ImageLoaderTinyEXR::load_image(Ref<Image> p_image, FileAccess *f, bool p_f
Image::Format format; Image::Format format;
int output_channels = 0; int output_channels = 0;
int channel_size = use_float16 ? 2 : 4;
if (idxA != -1) { if (idxA != -1) {
imgdata.resize(exr_image.width * exr_image.height * 4 * channel_size); //RGBA
imgdata.resize(exr_image.width * exr_image.height * 8); //RGBA16 format = use_float16 ? Image::FORMAT_RGBAH : Image::FORMAT_RGBAF;
format = Image::FORMAT_RGBAH;
output_channels = 4; output_channels = 4;
} else { } else if (idxB != -1) {
ERR_FAIL_COND_V(idxG == -1, ERR_FILE_CORRUPT);
imgdata.resize(exr_image.width * exr_image.height * 6); //RGB16 ERR_FAIL_COND_V(idxR == -1, ERR_FILE_CORRUPT);
format = Image::FORMAT_RGBH; imgdata.resize(exr_image.width * exr_image.height * 3 * channel_size); //RGB
format = use_float16 ? Image::FORMAT_RGBH : Image::FORMAT_RGBF;
output_channels = 3; output_channels = 3;
} else if (idxG != -1) {
ERR_FAIL_COND_V(idxR == -1, ERR_FILE_CORRUPT);
imgdata.resize(exr_image.width * exr_image.height * 2 * channel_size); //RG
format = use_float16 ? Image::FORMAT_RGH : Image::FORMAT_RGF;
output_channels = 2;
} else {
ERR_FAIL_COND_V(idxR == -1, ERR_FILE_CORRUPT);
imgdata.resize(exr_image.width * exr_image.height * 1 * channel_size); //R
format = use_float16 ? Image::FORMAT_RH : Image::FORMAT_RF;
output_channels = 1;
} }
EXRTile single_image_tile; EXRTile single_image_tile;
@ -179,54 +169,115 @@ Error ImageLoaderTinyEXR::load_image(Ref<Image> p_image, FileAccess *f, bool p_f
exr_tiles = exr_image.tiles; exr_tiles = exr_image.tiles;
} }
//print_line("reading format: " + Image::get_format_name(format));
{ {
PoolVector<uint8_t>::Write wd = imgdata.write();
uint16_t *iw = (uint16_t *)wd.ptr(); PoolVector<uint8_t>::Write imgdata_write = imgdata.write();
uint8_t *wd = imgdata_write.ptr();
uint16_t *iw16 = (uint16_t *)wd;
float *iw32 = (float *)wd;
// Assume `out_rgba` have enough memory allocated. // Assume `out_rgba` have enough memory allocated.
for (int tile_index = 0; tile_index < num_tiles; tile_index++) { for (int tile_index = 0; tile_index < num_tiles; tile_index++) {
const EXRTile &tile = exr_tiles[tile_index]; const EXRTile &tile = exr_tiles[tile_index];
int tw = tile.width; int tw = tile.width;
int th = tile.height; int th = tile.height;
const float *r_channel_start = reinterpret_cast<const float *>(tile.images[idxR]); const float *r_channel_start = reinterpret_cast<const float *>(tile.images[idxR]);
const float *g_channel_start = reinterpret_cast<const float *>(tile.images[idxG]); const float *g_channel_start = nullptr;
const float *b_channel_start = reinterpret_cast<const float *>(tile.images[idxB]); const float *b_channel_start = nullptr;
const float *a_channel_start = NULL; const float *a_channel_start = nullptr;
if (idxG != -1) {
g_channel_start = reinterpret_cast<const float *>(tile.images[idxG]);
}
if (idxB != -1) {
b_channel_start = reinterpret_cast<const float *>(tile.images[idxB]);
}
if (idxA != -1) { if (idxA != -1) {
a_channel_start = reinterpret_cast<const float *>(tile.images[idxA]); a_channel_start = reinterpret_cast<const float *>(tile.images[idxA]);
} }
uint16_t *first_row_w = iw + (tile.offset_y * tile_height * exr_image.width + tile.offset_x * tile_width) * output_channels; uint16_t *first_row_w16 = iw16 + (tile.offset_y * tile_height * exr_image.width + tile.offset_x * tile_width) * output_channels;
float *first_row_w32 = iw32 + (tile.offset_y * tile_height * exr_image.width + tile.offset_x * tile_width) * output_channels;
for (int y = 0; y < th; y++) { for (int y = 0; y < th; y++) {
const float *r_channel = r_channel_start + y * tile_width; const float *r_channel = r_channel_start + y * tile_width;
const float *g_channel = g_channel_start + y * tile_width; const float *g_channel = nullptr;
const float *b_channel = b_channel_start + y * tile_width; const float *b_channel = nullptr;
const float *a_channel = NULL; const float *a_channel = nullptr;
if (g_channel_start) {
g_channel = g_channel_start + y * tile_width;
}
if (b_channel_start) {
b_channel = b_channel_start + y * tile_width;
}
if (a_channel_start) { if (a_channel_start) {
a_channel = a_channel_start + y * tile_width; a_channel = a_channel_start + y * tile_width;
} }
uint16_t *row_w = first_row_w + (y * exr_image.width * output_channels); if (use_float16) {
uint16_t *row_w = first_row_w16 + (y * exr_image.width * output_channels);
for (int x = 0; x < tw; x++) { for (int x = 0; x < tw; x++) {
Color color;
color.r = *r_channel++;
if (g_channel) {
color.g = *g_channel++;
}
if (b_channel) {
color.b = *b_channel++;
}
if (a_channel) {
color.a = *a_channel++;
}
Color color(*r_channel++, *g_channel++, *b_channel++); if (p_force_linear) {
color = color.to_linear();
}
if (p_force_linear) *row_w++ = Math::make_half_float(color.r);
color = color.to_linear(); if (g_channel) {
*row_w++ = Math::make_half_float(color.g);
}
if (b_channel) {
*row_w++ = Math::make_half_float(color.b);
}
if (a_channel) {
*row_w++ = Math::make_half_float(color.a);
}
}
} else {
float *row_w = first_row_w32 + (y * exr_image.width * output_channels);
*row_w++ = Math::make_half_float(color.r); for (int x = 0; x < tw; x++) {
*row_w++ = Math::make_half_float(color.g); Color color;
*row_w++ = Math::make_half_float(color.b); color.r = *r_channel++;
if (g_channel) {
color.g = *g_channel++;
}
if (b_channel) {
color.b = *b_channel++;
}
if (a_channel) {
color.a = *a_channel++;
}
if (idxA != -1) { if (p_force_linear) {
*row_w++ = Math::make_half_float(*a_channel++); color = color.to_linear();
}
*row_w++ = color.r;
if (g_channel) {
*row_w++ = color.g;
}
if (b_channel) {
*row_w++ = color.b;
}
if (a_channel) {
*row_w++ = color.a;
}
} }
} }
} }
@ -235,7 +286,7 @@ Error ImageLoaderTinyEXR::load_image(Ref<Image> p_image, FileAccess *f, bool p_f
p_image->create(exr_image.width, exr_image.height, false, format, imgdata); p_image->create(exr_image.width, exr_image.height, false, format, imgdata);
w.release(); img_write.release();
FreeEXRHeader(&exr_header); FreeEXRHeader(&exr_header);
FreeEXRImage(&exr_image); FreeEXRImage(&exr_image);
@ -244,7 +295,6 @@ Error ImageLoaderTinyEXR::load_image(Ref<Image> p_image, FileAccess *f, bool p_f
} }
void ImageLoaderTinyEXR::get_recognized_extensions(List<String> *p_extensions) const { void ImageLoaderTinyEXR::get_recognized_extensions(List<String> *p_extensions) const {
p_extensions->push_back("exr"); p_extensions->push_back("exr");
} }

1
modules/tinyexr/image_loader_tinyexr.h
View file

@ -34,7 +34,6 @@
#include "core/io/image_loader.h" #include "core/io/image_loader.h"
class ImageLoaderTinyEXR : public ImageFormatLoader { class ImageLoaderTinyEXR : public ImageFormatLoader {
public: public:
virtual Error load_image(Ref<Image> p_image, FileAccess *f, bool p_force_linear, float p_scale); virtual Error load_image(Ref<Image> p_image, FileAccess *f, bool p_force_linear, float p_scale);
virtual void get_recognized_extensions(List<String> *p_extensions) const; virtual void get_recognized_extensions(List<String> *p_extensions) const;

36
modules/tinyexr/image_saver_tinyexr.cpp
View file

@ -58,7 +58,8 @@ static bool is_supported_format(Image::Format p_format) {
enum SrcPixelType { enum SrcPixelType {
SRC_FLOAT, SRC_FLOAT,
SRC_HALF, SRC_HALF,
SRC_BYTE SRC_BYTE,
SRC_UNSUPPORTED
}; };
static SrcPixelType get_source_pixel_type(Image::Format p_format) { static SrcPixelType get_source_pixel_type(Image::Format p_format) {
@ -79,7 +80,7 @@ static SrcPixelType get_source_pixel_type(Image::Format p_format) {
case Image::FORMAT_RGBA8: case Image::FORMAT_RGBA8:
return SRC_BYTE; return SRC_BYTE;
default: default:
CRASH_NOW(); return SRC_UNSUPPORTED;
} }
} }
@ -101,7 +102,7 @@ static int get_target_pixel_type(Image::Format p_format) {
case Image::FORMAT_RGBA8: case Image::FORMAT_RGBA8:
return TINYEXR_PIXELTYPE_HALF; return TINYEXR_PIXELTYPE_HALF;
default: default:
CRASH_NOW(); return -1;
} }
} }
@ -112,7 +113,7 @@ static int get_pixel_type_size(int p_pixel_type) {
case TINYEXR_PIXELTYPE_FLOAT: case TINYEXR_PIXELTYPE_FLOAT:
return 4; return 4;
} }
CRASH_NOW(); return -1;
} }
static int get_channel_count(Image::Format p_format) { static int get_channel_count(Image::Format p_format) {
@ -134,12 +135,11 @@ static int get_channel_count(Image::Format p_format) {
case Image::FORMAT_RGBA8: case Image::FORMAT_RGBA8:
return 4; return 4;
default: default:
CRASH_NOW(); return -1;
} }
} }
Error save_exr(const String &p_path, const Ref<Image> &p_img, bool p_grayscale) { Error save_exr(const String &p_path, const Ref<Image> &p_img, bool p_grayscale) {
Image::Format format = p_img->get_format(); Image::Format format = p_img->get_format();
if (!is_supported_format(format)) { if (!is_supported_format(format)) {
@ -173,11 +173,15 @@ Error save_exr(const String &p_path, const Ref<Image> &p_img, bool p_grayscale)
}; };
int channel_count = get_channel_count(format); int channel_count = get_channel_count(format);
ERR_FAIL_COND_V(channel_count < 0, ERR_UNAVAILABLE);
ERR_FAIL_COND_V(p_grayscale && channel_count != 1, ERR_INVALID_PARAMETER); ERR_FAIL_COND_V(p_grayscale && channel_count != 1, ERR_INVALID_PARAMETER);
int target_pixel_type = get_target_pixel_type(format); int target_pixel_type = get_target_pixel_type(format);
ERR_FAIL_COND_V(target_pixel_type < 0, ERR_UNAVAILABLE);
int target_pixel_type_size = get_pixel_type_size(target_pixel_type); int target_pixel_type_size = get_pixel_type_size(target_pixel_type);
ERR_FAIL_COND_V(target_pixel_type_size < 0, ERR_UNAVAILABLE);
SrcPixelType src_pixel_type = get_source_pixel_type(format); SrcPixelType src_pixel_type = get_source_pixel_type(format);
ERR_FAIL_COND_V(src_pixel_type == SRC_UNSUPPORTED, ERR_UNAVAILABLE);
const int pixel_count = p_img->get_width() * p_img->get_height(); const int pixel_count = p_img->get_width() * p_img->get_height();
const int *channel_mapping = channel_mappings[channel_count - 1]; const int *channel_mapping = channel_mappings[channel_count - 1];
@ -187,7 +191,6 @@ Error save_exr(const String &p_path, const Ref<Image> &p_img, bool p_grayscale)
PoolByteArray::Read src_r = src_data.read(); PoolByteArray::Read src_r = src_data.read();
for (int channel_index = 0; channel_index < channel_count; ++channel_index) { for (int channel_index = 0; channel_index < channel_count; ++channel_index) {
// De-interleave channels // De-interleave channels
PoolByteArray &dst = channels[channel_index]; PoolByteArray &dst = channels[channel_index];
@ -196,7 +199,6 @@ Error save_exr(const String &p_path, const Ref<Image> &p_img, bool p_grayscale)
PoolByteArray::Write dst_w = dst.write(); PoolByteArray::Write dst_w = dst.write();
if (src_pixel_type == SRC_FLOAT && target_pixel_type == TINYEXR_PIXELTYPE_FLOAT) { if (src_pixel_type == SRC_FLOAT && target_pixel_type == TINYEXR_PIXELTYPE_FLOAT) {
// Note: we don't save mipmaps // Note: we don't save mipmaps
CRASH_COND(src_data.size() < pixel_count * channel_count * target_pixel_type_size); CRASH_COND(src_data.size() < pixel_count * channel_count * target_pixel_type_size);
@ -208,7 +210,6 @@ Error save_exr(const String &p_path, const Ref<Image> &p_img, bool p_grayscale)
} }
} else if (src_pixel_type == SRC_HALF && target_pixel_type == TINYEXR_PIXELTYPE_HALF) { } else if (src_pixel_type == SRC_HALF && target_pixel_type == TINYEXR_PIXELTYPE_HALF) {
CRASH_COND(src_data.size() < pixel_count * channel_count * target_pixel_type_size); CRASH_COND(src_data.size() < pixel_count * channel_count * target_pixel_type_size);
const uint16_t *src_rp = (uint16_t *)src_r.ptr(); const uint16_t *src_rp = (uint16_t *)src_r.ptr();
@ -219,7 +220,6 @@ Error save_exr(const String &p_path, const Ref<Image> &p_img, bool p_grayscale)
} }
} else if (src_pixel_type == SRC_BYTE && target_pixel_type == TINYEXR_PIXELTYPE_HALF) { } else if (src_pixel_type == SRC_BYTE && target_pixel_type == TINYEXR_PIXELTYPE_HALF) {
CRASH_COND(src_data.size() < pixel_count * channel_count); CRASH_COND(src_data.size() < pixel_count * channel_count);
const uint8_t *src_rp = (uint8_t *)src_r.ptr(); const uint8_t *src_rp = (uint8_t *)src_r.ptr();
@ -262,13 +262,21 @@ Error save_exr(const String &p_path, const Ref<Image> &p_img, bool p_grayscale)
header.channels = channel_infos; header.channels = channel_infos;
header.pixel_types = pixel_types; header.pixel_types = pixel_types;
header.requested_pixel_types = requested_pixel_types; header.requested_pixel_types = requested_pixel_types;
header.compression_type = TINYEXR_COMPRESSIONTYPE_PIZ;
CharString utf8_filename = p_path.utf8(); unsigned char *mem = nullptr;
const char *err; const char *err = nullptr;
int ret = SaveEXRImageToFile(&image, &header, utf8_filename.ptr(), &err);
if (ret != TINYEXR_SUCCESS) { size_t bytes = SaveEXRImageToMemory(&image, &header, &mem, &err);
if (bytes == 0) {
print_error(String("Saving EXR failed. Error: {0}").format(varray(err))); print_error(String("Saving EXR failed. Error: {0}").format(varray(err)));
return ERR_FILE_CANT_WRITE; return ERR_FILE_CANT_WRITE;
} else {
FileAccessRef ref = FileAccess::open(p_path, FileAccess::WRITE);
ERR_FAIL_COND_V(!ref, ERR_FILE_CANT_WRITE);
ref->store_buffer(mem, bytes);
free(mem);
} }
return OK; return OK;