Lines Matching defs:tinyexr
81 // #include "tinyexr.h"
533 // including `tinyexr.h`
541 namespace tinyexr {
7116 static void cpy8(tinyexr::tinyexr_uint64 *dst_val, const tinyexr::tinyexr_uint64 *src_val) {
7131 static void swap8(tinyexr::tinyexr_uint64 *val) {
7135 tinyexr::tinyexr_uint64 tmp = (*val);
7321 tinyexr::swap4(reinterpret_cast<unsigned int *>(&data_len));
7362 tinyexr::swap4(reinterpret_cast<unsigned int *>(&outLen));
7378 std::vector<tinyexr::ChannelInfo> channels;
7468 tinyexr::swap4(reinterpret_cast<unsigned int *>(&info.pixel_type));
7469 tinyexr::swap4(reinterpret_cast<unsigned int *>(&info.x_sampling));
7470 tinyexr::swap4(reinterpret_cast<unsigned int *>(&info.y_sampling));
7500 tinyexr::swap4(reinterpret_cast<unsigned int *>(&pixel_type));
7501 tinyexr::swap4(reinterpret_cast<unsigned int *>(&x_sampling));
7502 tinyexr::swap4(reinterpret_cast<unsigned int *>(&y_sampling));
7521 tinyexr::tinyexr_uint64 &compressedSize,
7786 tinyexr::tinyexr_uint64 &compressedSize,
7842 compressedSize = static_cast<tinyexr::tinyexr_uint64>(outSize);
8275 // Adds some modification for tinyexr.
9394 tinyexr::cpy2(&minNonZero, reinterpret_cast<const unsigned short *>(ptr));
9396 tinyexr::cpy2(&maxNonZero, reinterpret_cast<const unsigned short *>(ptr + 2));
9420 tinyexr::cpy4(&length, reinterpret_cast<const int *>(ptr));
9717 bool ret = tinyexr::DecompressPiz(
9747 tinyexr::cpy2(&(hf.u), line_ptr + u);
9749 tinyexr::swap2(reinterpret_cast<unsigned short *>(&hf.u));
9794 tinyexr::cpy4(&val, line_ptr + u);
9796 tinyexr::swap4(&val);
9822 tinyexr::cpy4(&val, line_ptr + u);
9824 tinyexr::swap4(reinterpret_cast<unsigned int *>(&val));
9858 if (!tinyexr::DecompressZip(
9882 tinyexr::FP16 hf;
9885 tinyexr::cpy2(&(hf.u), line_ptr + u);
9887 tinyexr::swap2(reinterpret_cast<unsigned short *>(&hf.u));
9904 tinyexr::FP32 f32 = half_to_float(hf);
9933 tinyexr::cpy4(&val, line_ptr + u);
9935 tinyexr::swap4(&val);
9961 tinyexr::cpy4(&val, line_ptr + u);
9963 tinyexr::swap4(reinterpret_cast<unsigned int *>(&val));
9995 if (!tinyexr::DecompressRle(
10019 tinyexr::FP16 hf;
10022 tinyexr::cpy2(&(hf.u), line_ptr + u);
10024 tinyexr::swap2(reinterpret_cast<unsigned short *>(&hf.u));
10041 tinyexr::FP32 f32 = half_to_float(hf);
10067 tinyexr::cpy4(&val, line_ptr + u);
10069 tinyexr::swap4(&val);
10095 tinyexr::cpy4(&val, line_ptr + u);
10097 tinyexr::swap4(reinterpret_cast<unsigned int *>(&val));
10120 tinyexr::ZFPCompressionParam zfp_compression_param;
10134 tinyexr::DecompressZfp(reinterpret_cast<float *>(&outBuf.at(0)), width,
10159 tinyexr::cpy4(&val, line_ptr + u);
10161 tinyexr::swap4(reinterpret_cast<unsigned int *>(&val));
10209 tinyexr::FP16 hf;
10212 tinyexr::cpy2(&(hf.u), line_ptr + u);
10214 tinyexr::swap2(reinterpret_cast<unsigned short *>(&hf.u));
10234 tinyexr::FP16 hf;
10238 tinyexr::cpy2(&(hf.u), line_ptr + u);
10240 tinyexr::swap2(reinterpret_cast<unsigned short *>(&hf.u));
10242 tinyexr::FP32 f32 = half_to_float(hf);
10271 tinyexr::cpy4(&val, line_ptr + u);
10273 tinyexr::swap4(reinterpret_cast<unsigned int *>(&val));
10299 tinyexr::cpy4(&val, line_ptr + u);
10301 tinyexr::swap4(reinterpret_cast<unsigned int *>(&val));
10494 if (!tinyexr::ReadAttribute(&attr_name, &attr_type, &data, &marker_size,
10511 tinyexr::swap4(&x_size);
10512 tinyexr::swap4(&y_size);
10589 tinyexr::swap4(reinterpret_cast<unsigned int *>(&info->data_window[0]));
10590 tinyexr::swap4(reinterpret_cast<unsigned int *>(&info->data_window[1]));
10591 tinyexr::swap4(reinterpret_cast<unsigned int *>(&info->data_window[2]));
10592 tinyexr::swap4(reinterpret_cast<unsigned int *>(&info->data_window[3]));
10601 tinyexr::swap4(
10603 tinyexr::swap4(
10605 tinyexr::swap4(
10607 tinyexr::swap4(
10620 tinyexr::swap4(
10628 tinyexr::swap4(
10630 tinyexr::swap4(
10637 tinyexr::swap4(
10645 tinyexr::swap4(reinterpret_cast<unsigned int *>(&info->chunk_count));
10809 const std::vector<tinyexr::tinyexr_uint64> &offsets,
10856 if (!tinyexr::ComputeChannelLayout(&channel_offset_list, &pixel_data_size,
10913 exr_image->tiles[tile_idx].images = tinyexr::AllocateImage(
10937 tinyexr::swap4(
10939 tinyexr::swap4(
10941 tinyexr::swap4(
10943 tinyexr::swap4(
10959 tinyexr::swap4(reinterpret_cast<unsigned int *>(&data_len));
10973 bool ret = tinyexr::DecodeTiledPixelData(
11037 exr_image->images = tinyexr::AllocateImage(
11080 tinyexr::swap4(reinterpret_cast<unsigned int *>(&line_no));
11081 tinyexr::swap4(reinterpret_cast<unsigned int *>(&data_len));
11124 if (!tinyexr::DecodePixelData(
11181 std::vector<tinyexr::tinyexr_uint64> *offsets, size_t n,
11189 if ((offset + sizeof(tinyexr::tinyexr_uint64)) >= size) {
11203 tinyexr::swap4(reinterpret_cast<unsigned int *>(&y));
11204 tinyexr::swap4(reinterpret_cast<unsigned int *>(&data_len));
11219 marker == NULL || (size <= tinyexr::kEXRVersionSize)) {
11220 tinyexr::SetErrorMessage("Invalid argument for DecodeEXRImage().", err);
11236 tinyexr::SetErrorMessage("Invalid data width value", err);
11243 tinyexr::SetErrorMessage("Invalid data height value", err);
11249 tinyexr::SetErrorMessage("data width or data height is negative.", err);
11257 tinyexr::SetErrorMessage("data width too large.", err);
11261 tinyexr::SetErrorMessage("data height too large.", err);
11297 std::vector<tinyexr::tinyexr_uint64> offsets(num_blocks);
11300 tinyexr::tinyexr_uint64 offset;
11303 tinyexr::SetErrorMessage("Insufficient data size in offset table.", err);
11307 memcpy(&offset, marker, sizeof(tinyexr::tinyexr_uint64));
11308 tinyexr::swap8(&offset);
11310 tinyexr::SetErrorMessage("Invalid offset value in DecodeEXRImage.", err);
11313 marker += sizeof(tinyexr::tinyexr_uint64); // = 8
11333 tinyexr::SetErrorMessage(
11346 tinyexr::SetErrorMessage(e, err);
11418 } // namespace tinyexr
11428 tinyexr::SetErrorMessage("Invalid EXR header.", err);
11433 tinyexr::SetErrorMessage(
11447 tinyexr::GetLayers(exr_header, layer_vec);
11472 tinyexr::SetErrorMessage("Invalid argument for LoadEXR()", err);
11487 tinyexr::SetErrorMessage(ss.str(), err);
11492 tinyexr::SetErrorMessage(
11530 tinyexr::GetLayers(exr_header, layer_names);
11532 std::vector<tinyexr::LayerChannel> channels;
11533 tinyexr::ChannelsInLayer(exr_header, layername == NULL ? "" : std::string(layername), channels);
11536 tinyexr::SetErrorMessage("Layer Not Found", err);
11544 const tinyexr::LayerChannel &ch = channels[c];
11611 tinyexr::SetErrorMessage("R channel not found", err);
11619 tinyexr::SetErrorMessage("G channel not found", err);
11626 tinyexr::SetErrorMessage("B channel not found", err);
11711 tinyexr::SetErrorMessage(
11720 if (size < tinyexr::kEXRVersionSize) {
11721 tinyexr::SetErrorMessage("Insufficient header/data size.\n", err);
11725 const unsigned char *marker = memory + tinyexr::kEXRVersionSize;
11726 size_t marker_size = size - tinyexr::kEXRVersionSize;
11728 tinyexr::HeaderInfo info;
11736 tinyexr::SetErrorMessage(err_str, err);
11752 tinyexr::SetErrorMessage("Invalid argument for LoadEXRFromMemory", err);
11766 tinyexr::SetErrorMessage(ss.str(), err);
11857 tinyexr::SetErrorMessage("R channel not found", err);
11864 tinyexr::SetErrorMessage("G channel not found", err);
11870 tinyexr::SetErrorMessage("B channel not found", err);
11942 tinyexr::SetErrorMessage("Invalid argument for LoadEXRImageFromFile", err);
11953 tinyexr::SetErrorMessage("Cannot read file " + std::string(filename), err);
11965 tinyexr::SetErrorMessage("File size too short " + std::string(filename),
11987 (size < tinyexr::kEXRVersionSize)) {
11988 tinyexr::SetErrorMessage("Invalid argument for LoadEXRImageFromMemory",
11994 tinyexr::SetErrorMessage("EXRHeader variable is not initialized.", err);
12002 return tinyexr::DecodeEXRImage(exr_image, exr_header, head, marker, size,
12011 tinyexr::SetErrorMessage("Invalid argument for SaveEXRImageToMemory", err);
12017 tinyexr::SetErrorMessage("PIZ compression is not supported in this build",
12025 tinyexr::SetErrorMessage("ZFP compression is not supported in this build",
12034 tinyexr::SetErrorMessage("Pixel type must be FLOAT for ZFP compression",
12079 std::vector<tinyexr::ChannelInfo> channels;
12084 tinyexr::ChannelInfo info;
12093 tinyexr::WriteChannelInfo(data, channels);
12095 tinyexr::WriteAttributeToMemory(&memory, "channels", "chlist", &data.at(0),
12101 tinyexr::swap4(reinterpret_cast<unsigned int *>(&comp));
12102 tinyexr::WriteAttributeToMemory(
12109 tinyexr::swap4(reinterpret_cast<unsigned int *>(&data[0]));
12110 tinyexr::swap4(reinterpret_cast<unsigned int *>(&data[1]));
12111 tinyexr::swap4(reinterpret_cast<unsigned int *>(&data[2]));
12112 tinyexr::swap4(reinterpret_cast<unsigned int *>(&data[3]));
12113 tinyexr::WriteAttributeToMemory(
12116 tinyexr::WriteAttributeToMemory(
12123 tinyexr::WriteAttributeToMemory(&memory, "lineOrder", "lineOrder",
12129 tinyexr::swap4(reinterpret_cast<unsigned int *>(&aspectRatio));
12130 tinyexr::WriteAttributeToMemory(
12137 tinyexr::swap4(reinterpret_cast<unsigned int *>(¢er[0]));
12138 tinyexr::swap4(reinterpret_cast<unsigned int *>(¢er[1]));
12139 tinyexr::WriteAttributeToMemory(
12146 tinyexr::swap4(reinterpret_cast<unsigned int *>(&w));
12147 tinyexr::WriteAttributeToMemory(&memory, "screenWindowWidth", "float",
12155 tinyexr::WriteAttributeToMemory(
12174 std::vector<tinyexr::tinyexr_uint64> offsets(static_cast<size_t>(num_blocks));
12177 tinyexr::tinyexr_uint64 offset =
12181 tinyexr::tinyexr_int64); // sizeof(header) + sizeof(offsetTable)
12208 tinyexr::ZFPCompressionParam zfp_compression_param;
12213 bool ret = tinyexr::FindZFPCompressionParam(
12251 tinyexr::FP16 h16;
12255 tinyexr::FP32 f32 = half_to_float(h16);
12257 tinyexr::swap4(reinterpret_cast<unsigned int *>(&f32.f));
12260 tinyexr::cpy4(line_ptr + x, &(f32.f));
12276 tinyexr::swap2(&val);
12279 tinyexr::cpy2(line_ptr + x, &val);
12296 tinyexr::FP32 f32;
12300 tinyexr::FP16 h16;
12303 tinyexr::swap2(reinterpret_cast<unsigned short *>(&h16.u));
12306 tinyexr::cpy2(line_ptr + x, &(h16.u));
12321 tinyexr::swap4(reinterpret_cast<unsigned int *>(&val));
12324 tinyexr::cpy4(line_ptr + x, &val);
12340 tinyexr::swap4(&val);
12343 tinyexr::cpy4(line_ptr + x, &val);
12358 tinyexr::swap4(reinterpret_cast<unsigned int *>(&header.at(0)));
12359 tinyexr::swap4(reinterpret_cast<unsigned int *>(&header.at(4)));
12368 std::vector<unsigned char> block(tinyexr::miniz::mz_compressBound(
12374 tinyexr::tinyexr_uint64 outSize = block.size();
12376 tinyexr::CompressZip(&block.at(0), outSize,
12388 tinyexr::swap4(reinterpret_cast<unsigned int *>(&header.at(0)));
12389 tinyexr::swap4(reinterpret_cast<unsigned int *>(&header.at(4)));
12399 tinyexr::tinyexr_uint64 outSize = block.size();
12401 tinyexr::CompressRle(&block.at(0), outSize,
12413 tinyexr::swap4(reinterpret_cast<unsigned int *>(&header.at(0)));
12414 tinyexr::swap4(reinterpret_cast<unsigned int *>(&header.at(4)));
12441 tinyexr::swap4(reinterpret_cast<unsigned int *>(&header.at(0)));
12442 tinyexr::swap4(reinterpret_cast<unsigned int *>(&header.at(4)));
12456 tinyexr::CompressZfp(
12468 tinyexr::swap4(reinterpret_cast<unsigned int *>(&header.at(0)));
12469 tinyexr::swap4(reinterpret_cast<unsigned int *>(&header.at(4)));
12485 tinyexr::swap8(reinterpret_cast<tinyexr::tinyexr_uint64 *>(&offsets[i]));
12494 sizeof(tinyexr::tinyexr_uint64) * static_cast<size_t>(num_blocks));
12498 tinyexr::SetErrorMessage("Output memory size is zero", err);
12518 tinyexr::SetErrorMessage("Invalid argument for SaveEXRImageToFile", err);
12524 tinyexr::SetErrorMessage("PIZ compression is not supported in this build",
12532 tinyexr::SetErrorMessage("ZFP compression is not supported in this build",
12545 tinyexr::SetErrorMessage("Cannot write a file", err);
12565 tinyexr::SetErrorMessage("Cannot write a file", err);
12574 tinyexr::SetErrorMessage("Invalid argument for LoadDeepEXR", err);
12582 tinyexr::SetErrorMessage("Cannot read a file " + std::string(filename),
12589 tinyexr::SetErrorMessage("Cannot read a file " + std::string(filename),
12603 tinyexr::SetErrorMessage("File size is zero : " + std::string(filename),
12625 tinyexr::SetErrorMessage("Invalid magic number", err);
12636 tinyexr::SetErrorMessage("Unsupported version or scanline", err);
12650 std::vector<tinyexr::ChannelInfo> channels;
12653 size_t size = filesize - tinyexr::kEXRVersionSize;
12667 if (!tinyexr::ReadAttribute(&attr_name, &attr_type, &data, &marker_size,
12671 tinyexr::SetErrorMessage(ss.str(), err);
12682 tinyexr::SetErrorMessage(ss.str(), err);
12698 if (!tinyexr::ReadChannelInfo(channels, data)) {
12699 tinyexr::SetErrorMessage("Failed to parse channel info", err);
12706 tinyexr::SetErrorMessage("Invalid channels format", err);
12715 tinyexr::swap4(reinterpret_cast<unsigned int *>(&dx));
12716 tinyexr::swap4(reinterpret_cast<unsigned int *>(&dy));
12717 tinyexr::swap4(reinterpret_cast<unsigned int *>(&dw));
12718 tinyexr::swap4(reinterpret_cast<unsigned int *>(&dh));
12729 tinyexr::swap4(reinterpret_cast<unsigned int *>(&x));
12730 tinyexr::swap4(reinterpret_cast<unsigned int *>(&y));
12731 tinyexr::swap4(reinterpret_cast<unsigned int *>(&w));
12732 tinyexr::swap4(reinterpret_cast<unsigned int *>(&h));
12754 std::vector<tinyexr::tinyexr_int64> offsets(static_cast<size_t>(num_blocks));
12757 tinyexr::tinyexr_int64 offset;
12758 memcpy(&offset, marker, sizeof(tinyexr::tinyexr_int64));
12759 tinyexr::swap8(reinterpret_cast<tinyexr::tinyexr_uint64 *>(&offset));
12760 marker += sizeof(tinyexr::tinyexr_int64); // = 8
12778 tinyexr::SetErrorMessage("Unsupported compression format", err);
12809 tinyexr::tinyexr_int64 packedOffsetTableSize;
12810 tinyexr::tinyexr_int64 packedSampleDataSize;
12811 tinyexr::tinyexr_int64 unpackedSampleDataSize;
12814 sizeof(tinyexr::tinyexr_int64));
12816 sizeof(tinyexr::tinyexr_int64));
12818 sizeof(tinyexr::tinyexr_int64));
12820 tinyexr::swap4(reinterpret_cast<unsigned int *>(&line_no));
12821 tinyexr::swap8(
12822 reinterpret_cast<tinyexr::tinyexr_uint64 *>(&packedOffsetTableSize));
12823 tinyexr::swap8(
12824 reinterpret_cast<tinyexr::tinyexr_uint64 *>(&packedSampleDataSize));
12825 tinyexr::swap8(
12826 reinterpret_cast<tinyexr::tinyexr_uint64 *>(&unpackedSampleDataSize));
12834 if (!tinyexr::DecompressZip(
12854 if (!tinyexr::DecompressZip(
12899 tinyexr::tinyexr_uint64 data_offset = 0;
12909 tinyexr::cpy4(&ui, src_ptr);
12916 tinyexr::FP16 f16;
12919 tinyexr::cpy2(&(f16.u), src_ptr);
12920 tinyexr::FP32 f32 = half_to_float(f16);
12929 tinyexr::cpy4(&f, src_ptr);
13050 tinyexr::SetErrorMessage("Invalid argument for ParseEXRHeaderFromFile",
13062 tinyexr::SetErrorMessage("Cannot read file " + std::string(filename), err);
13080 tinyexr::SetErrorMessage("fread() error on " + std::string(filename),
13098 tinyexr::SetErrorMessage(
13103 if (size < tinyexr::kEXRVersionSize) {
13104 tinyexr::SetErrorMessage("Data size too short", err);
13108 const unsigned char *marker = memory + tinyexr::kEXRVersionSize;
13109 size_t marker_size = size - tinyexr::kEXRVersionSize;
13111 std::vector<tinyexr::HeaderInfo> infos;
13114 tinyexr::HeaderInfo info;
13123 tinyexr::SetErrorMessage(err_str, err);
13134 tinyexr::SetErrorMessage(
13170 tinyexr::SetErrorMessage(
13182 tinyexr::SetErrorMessage("Cannot read file " + std::string(filename), err);
13200 tinyexr::SetErrorMessage("`fread' error. file may be corrupted.", err);
13215 if (size < tinyexr::kEXRVersionSize) {
13283 if (file_size < tinyexr::kEXRVersionSize) {
13288 unsigned char buf[tinyexr::kEXRVersionSize];
13289 size_t ret = fread(&buf[0], 1, tinyexr::kEXRVersionSize, fp);
13292 if (ret != tinyexr::kEXRVersionSize) {
13296 return ParseEXRVersionFromMemory(version, buf, tinyexr::kEXRVersionSize);
13305 memory == NULL || (size <= tinyexr::kEXRVersionSize)) {
13306 tinyexr::SetErrorMessage(
13315 tinyexr::SetErrorMessage("EXRHeader variable is not initialized.", err);
13339 std::vector<std::vector<tinyexr::tinyexr_uint64> > chunk_offset_table_list;
13341 std::vector<tinyexr::tinyexr_uint64> offset_table(
13345 tinyexr::tinyexr_uint64 offset;
13347 tinyexr::swap8(&offset);
13350 tinyexr::SetErrorMessage("Invalid offset size in EXR header chunks.",
13364 std::vector<tinyexr::tinyexr_uint64> &offset_table =
13373 tinyexr::swap4(&part_no);
13376 tinyexr::SetErrorMessage("Invalid `part number' in EXR header chunks.",
13383 int ret = tinyexr::DecodeChunk(&exr_images[i], exr_headers[i], offset_table,
13387 tinyexr::SetErrorMessage(e, err);
13401 tinyexr::SetErrorMessage(
13413 tinyexr::SetErrorMessage("Cannot read file " + std::string(filename), err);
13444 tinyexr::SetErrorMessage(ss.str(), err);