Lines Matching defs:exr_header
334 extern void InitEXRHeader(EXRHeader *exr_header);
340 extern int FreeEXRHeader(EXRHeader *exr_header);
445 const EXRHeader *exr_header, const char *filename,
456 const EXRHeader *exr_header,
10725 static void ConvertHeader(EXRHeader *exr_header, const HeaderInfo &info) {
10726 exr_header->pixel_aspect_ratio = info.pixel_aspect_ratio;
10727 exr_header->screen_window_center[0] = info.screen_window_center[0];
10728 exr_header->screen_window_center[1] = info.screen_window_center[1];
10729 exr_header->screen_window_width = info.screen_window_width;
10730 exr_header->chunk_count = info.chunk_count;
10731 exr_header->display_window[0] = info.display_window[0];
10732 exr_header->display_window[1] = info.display_window[1];
10733 exr_header->display_window[2] = info.display_window[2];
10734 exr_header->display_window[3] = info.display_window[3];
10735 exr_header->data_window[0] = info.data_window[0];
10736 exr_header->data_window[1] = info.data_window[1];
10737 exr_header->data_window[2] = info.data_window[2];
10738 exr_header->data_window[3] = info.data_window[3];
10739 exr_header->line_order = info.line_order;
10740 exr_header->compression_type = info.compression_type;
10742 exr_header->tile_size_x = info.tile_size_x;
10743 exr_header->tile_size_y = info.tile_size_y;
10744 exr_header->tile_level_mode = info.tile_level_mode;
10745 exr_header->tile_rounding_mode = info.tile_rounding_mode;
10747 exr_header->num_channels = static_cast<int>(info.channels.size());
10749 exr_header->channels = static_cast<EXRChannelInfo *>(malloc(
10750 sizeof(EXRChannelInfo) * static_cast<size_t>(exr_header->num_channels)));
10751 for (size_t c = 0; c < static_cast<size_t>(exr_header->num_channels); c++) {
10753 strncpy_s(exr_header->channels[c].name, info.channels[c].name.c_str(), 255);
10755 strncpy(exr_header->channels[c].name, info.channels[c].name.c_str(), 255);
10758 exr_header->channels[c].name[255] = '\0';
10760 exr_header->channels[c].pixel_type = info.channels[c].pixel_type;
10761 exr_header->channels[c].p_linear = info.channels[c].p_linear;
10762 exr_header->channels[c].x_sampling = info.channels[c].x_sampling;
10763 exr_header->channels[c].y_sampling = info.channels[c].y_sampling;
10766 exr_header->pixel_types = static_cast<int *>(
10767 malloc(sizeof(int) * static_cast<size_t>(exr_header->num_channels)));
10768 for (size_t c = 0; c < static_cast<size_t>(exr_header->num_channels); c++) {
10769 exr_header->pixel_types[c] = info.channels[c].pixel_type;
10773 exr_header->requested_pixel_types = static_cast<int *>(
10774 malloc(sizeof(int) * static_cast<size_t>(exr_header->num_channels)));
10775 for (size_t c = 0; c < static_cast<size_t>(exr_header->num_channels); c++) {
10776 exr_header->requested_pixel_types[c] = info.channels[c].pixel_type;
10779 exr_header->num_custom_attributes = static_cast<int>(info.attributes.size());
10781 if (exr_header->num_custom_attributes > 0) {
10784 if (exr_header->num_custom_attributes > TINYEXR_MAX_CUSTOM_ATTRIBUTES) {
10785 exr_header->num_custom_attributes = TINYEXR_MAX_CUSTOM_ATTRIBUTES;
10788 exr_header->custom_attributes = static_cast<EXRAttribute *>(malloc(
10789 sizeof(EXRAttribute) * size_t(exr_header->num_custom_attributes)));
10792 memcpy(exr_header->custom_attributes[i].name, info.attributes[i].name,
10794 memcpy(exr_header->custom_attributes[i].type, info.attributes[i].type,
10796 exr_header->custom_attributes[i].size = info.attributes[i].size;
10798 exr_header->custom_attributes[i].value = info.attributes[i].value;
10802 exr_header->custom_attributes = NULL;
10805 exr_header->header_len = info.header_len;
10808 static int DecodeChunk(EXRImage *exr_image, const EXRHeader *exr_header,
10812 int num_channels = exr_header->num_channels;
10815 if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_ZIP) {
10817 } else if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_PIZ) {
10819 } else if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_ZFP) {
10823 int data_width = exr_header->data_window[2] - exr_header->data_window[0] + 1;
10824 int data_height = exr_header->data_window[3] - exr_header->data_window[1] + 1;
10858 exr_header->channels)) {
10867 if (exr_header->tiled) {
10869 if (exr_header->tile_size_x < 0) {
10872 ss << "Invalid tile size x : " << exr_header->tile_size_x << "\n";
10878 if (exr_header->tile_size_y < 0) {
10881 ss << "Invalid tile size y : " << exr_header->tile_size_y << "\n";
10914 num_channels, exr_header->channels,
10915 exr_header->requested_pixel_types, exr_header->tile_size_x,
10916 exr_header->tile_size_y);
10977 exr_header->requested_pixel_types, data_ptr,
10978 static_cast<size_t>(data_len), exr_header->compression_type,
10979 exr_header->line_order, data_width, data_height,
10980 tile_coordinates[0], tile_coordinates[1], exr_header->tile_size_x,
10981 exr_header->tile_size_y, static_cast<size_t>(pixel_data_size),
10982 static_cast<size_t>(exr_header->num_custom_attributes),
10983 exr_header->custom_attributes,
10984 static_cast<size_t>(exr_header->num_channels),
10985 exr_header->channels, channel_offset_list);
11038 num_channels, exr_header->channels, exr_header->requested_pixel_types,
11097 (exr_header->data_window[3] + 1));
11112 static_cast<tinyexr_int64>(exr_header->data_window[1]);
11118 line_no -= exr_header->data_window[1];
11125 exr_image->images, exr_header->requested_pixel_types,
11127 exr_header->compression_type, exr_header->line_order,
11131 exr_header->num_custom_attributes),
11132 exr_header->custom_attributes,
11133 static_cast<size_t>(exr_header->num_channels),
11134 exr_header->channels, channel_offset_list)) {
11165 for (int c = 0; c < exr_header->num_channels; c++) {
11166 exr_header->pixel_types[c] = exr_header->requested_pixel_types[c];
11214 static int DecodeEXRImage(EXRImage *exr_image, const EXRHeader *exr_header,
11218 if (exr_image == NULL || exr_header == NULL || head == NULL ||
11225 if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_ZIP) {
11227 } else if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_PIZ) {
11229 } else if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_ZFP) {
11233 int data_width = exr_header->data_window[2] - exr_header->data_window[0];
11241 int data_height = exr_header->data_window[3] - exr_header->data_window[1];
11269 if (exr_header->chunk_count > 0) {
11271 num_blocks = static_cast<size_t>(exr_header->chunk_count);
11272 } else if (exr_header->tiled) {
11275 static_cast<size_t>(exr_header->tile_size_x);
11276 if (num_x_tiles * static_cast<size_t>(exr_header->tile_size_x) <
11281 static_cast<size_t>(exr_header->tile_size_y);
11282 if (num_y_tiles * static_cast<size_t>(exr_header->tile_size_y) <
11342 int ret = DecodeChunk(exr_image, exr_header, offsets, head, size, &e);
11353 if ((exr_header->num_channels > 0) && exr_image && exr_image->images) {
11354 for (size_t c = 0; c < size_t(exr_header->num_channels); c++) {
11370 static void GetLayers(const EXRHeader& exr_header, std::vector<std::string>& layer_names) {
11376 for (int c = 0; c < exr_header.num_channels; c++) {
11377 std::string full_name(exr_header.channels[c].name);
11396 static void ChannelsInLayer(const EXRHeader& exr_header, const std::string layer_name, std::vector<LayerChannel>& channels) {
11398 for (int c = 0; c < exr_header.num_channels; c++) {
11399 std::string ch_name(exr_header.channels[c].name);
11422 EXRHeader exr_header;
11423 InitEXRHeader(&exr_header);
11440 int ret = ParseEXRHeaderFromFile(&exr_header, &exr_version, filename, err);
11442 FreeEXRHeader(&exr_header);
11447 tinyexr::GetLayers(exr_header, layer_vec);
11460 FreeEXRHeader(&exr_header);
11478 EXRHeader exr_header;
11479 InitEXRHeader(&exr_header);
11500 int ret = ParseEXRHeaderFromFile(&exr_header, &exr_version, filename, err);
11502 FreeEXRHeader(&exr_header);
11508 for (int i = 0; i < exr_header.num_channels; i++) {
11509 if (exr_header.pixel_types[i] == TINYEXR_PIXELTYPE_HALF) {
11510 exr_header.requested_pixel_types[i] = TINYEXR_PIXELTYPE_FLOAT;
11516 int ret = LoadEXRImageFromFile(&exr_image, &exr_header, filename, err);
11518 FreeEXRHeader(&exr_header);
11530 tinyexr::GetLayers(exr_header, layer_names);
11533 tinyexr::ChannelsInLayer(exr_header, layername == NULL ? "" : std::string(layername), channels);
11537 FreeEXRHeader(&exr_header);
11568 if (exr_header.tiled) {
11570 for (int j = 0; j < exr_header.tile_size_y; j++) {
11571 for (int i = 0; i < exr_header.tile_size_x; i++) {
11573 exr_image.tiles[it].offset_x * exr_header.tile_size_x + i;
11575 exr_image.tiles[it].offset_y * exr_header.tile_size_y + j;
11585 const int srcIdx = i + j * exr_header.tile_size_x;
11613 FreeEXRHeader(&exr_header);
11620 FreeEXRHeader(&exr_header);
11627 FreeEXRHeader(&exr_header);
11635 if (exr_header.tiled) {
11637 for (int j = 0; j < exr_header.tile_size_y; j++) {
11638 for (int i = 0; i < exr_header.tile_size_x; i++) {
11640 exr_image.tiles[it].offset_x * exr_header.tile_size_x + i;
11642 exr_image.tiles[it].offset_y * exr_header.tile_size_y + j;
11652 const int srcIdx = i + j * exr_header.tile_size_x;
11690 FreeEXRHeader(&exr_header);
11707 int ParseEXRHeaderFromMemory(EXRHeader *exr_header, const EXRVersion *version,
11710 if (memory == NULL || exr_header == NULL) {
11712 "Invalid argument. `memory` or `exr_header` argument is null in "
11740 ConvertHeader(exr_header, info);
11743 exr_header->tiled = version->tiled;
11758 EXRHeader exr_header;
11760 InitEXRHeader(&exr_header);
11770 ret = ParseEXRHeaderFromMemory(&exr_header, &exr_version, memory, size, err);
11776 for (int i = 0; i < exr_header.num_channels; i++) {
11777 if (exr_header.pixel_types[i] == TINYEXR_PIXELTYPE_HALF) {
11778 exr_header.requested_pixel_types[i] = TINYEXR_PIXELTYPE_FLOAT;
11783 ret = LoadEXRImageFromMemory(&exr_image, &exr_header, memory, size, err);
11793 for (int c = 0; c < exr_header.num_channels; c++) {
11794 if (strcmp(exr_header.channels[c].name, "R") == 0) {
11796 } else if (strcmp(exr_header.channels[c].name, "G") == 0) {
11798 } else if (strcmp(exr_header.channels[c].name, "B") == 0) {
11800 } else if (strcmp(exr_header.channels[c].name, "A") == 0) {
11806 if (exr_header.num_channels == 1) {
11813 if (exr_header.tiled) {
11815 for (int j = 0; j < exr_header.tile_size_y; j++) {
11816 for (int i = 0; i < exr_header.tile_size_x; i++) {
11818 exr_image.tiles[it].offset_x * exr_header.tile_size_x + i;
11820 exr_image.tiles[it].offset_y * exr_header.tile_size_y + j;
11830 const int srcIdx = i + j * exr_header.tile_size_x;
11879 if (exr_header.tiled) {
11881 for (int j = 0; j < exr_header.tile_size_y; j++)
11882 for (int i = 0; i < exr_header.tile_size_x; i++) {
11884 exr_image.tiles[it].offset_x * exr_header.tile_size_x + i;
11886 exr_image.tiles[it].offset_y * exr_header.tile_size_y + j;
11896 const int srcIdx = i + j * exr_header.tile_size_x;
11933 FreeEXRHeader(&exr_header);
11939 int LoadEXRImageFromFile(EXRImage *exr_image, const EXRHeader *exr_header,
11979 return LoadEXRImageFromMemory(exr_image, exr_header, &buf.at(0), filesize,
11983 int LoadEXRImageFromMemory(EXRImage *exr_image, const EXRHeader *exr_header,
11993 if (exr_header->header_len == 0) {
12000 memory + exr_header->header_len +
12002 return tinyexr::DecodeEXRImage(exr_image, exr_header, head, marker, size,
12007 const EXRHeader *exr_header,
12010 exr_header->compression_type < 0) {
12016 if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_PIZ) {
12024 if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_ZFP) {
12032 for (size_t i = 0; i < static_cast<size_t>(exr_header->num_channels); i++) {
12033 if (exr_header->requested_pixel_types[i] != TINYEXR_PIXELTYPE_FLOAT) {
12053 if (exr_header->tiled) {
12056 if (exr_header->long_name) {
12059 if (exr_header->non_image) {
12062 if (exr_header->multipart) {
12070 if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_ZIP) {
12072 } else if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_PIZ) {
12074 } else if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_ZFP) {
12083 for (int c = 0; c < exr_header->num_channels; c++) {
12086 info.pixel_type = exr_header->requested_pixel_types[c];
12089 info.name = std::string(exr_header->channels[c].name);
12100 int comp = exr_header->compression_type;
12153 if (exr_header->num_custom_attributes > 0) {
12154 for (int i = 0; i < exr_header->num_custom_attributes; i++) {
12156 &memory, exr_header->custom_attributes[i].name,
12157 exr_header->custom_attributes[i].type,
12159 exr_header->custom_attributes[i].value),
12160 exr_header->custom_attributes[i].size);
12186 static_cast<size_t>(exr_header->num_channels));
12190 for (size_t c = 0; c < static_cast<size_t>(exr_header->num_channels); c++) {
12192 if (exr_header->requested_pixel_types[c] == TINYEXR_PIXELTYPE_HALF) {
12195 } else if (exr_header->requested_pixel_types[c] ==
12199 } else if (exr_header->requested_pixel_types[c] == TINYEXR_PIXELTYPE_UINT) {
12214 &zfp_compression_param, exr_header->custom_attributes,
12215 exr_header->num_custom_attributes);
12241 for (size_t c = 0; c < static_cast<size_t>(exr_header->num_channels); c++) {
12242 if (exr_header->pixel_types[c] == TINYEXR_PIXELTYPE_HALF) {
12243 if (exr_header->requested_pixel_types[c] == TINYEXR_PIXELTYPE_FLOAT) {
12263 } else if (exr_header->requested_pixel_types[c] ==
12286 } else if (exr_header->pixel_types[c] == TINYEXR_PIXELTYPE_FLOAT) {
12287 if (exr_header->requested_pixel_types[c] == TINYEXR_PIXELTYPE_HALF) {
12309 } else if (exr_header->requested_pixel_types[c] ==
12330 } else if (exr_header->pixel_types[c] == TINYEXR_PIXELTYPE_UINT) {
12349 if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_NONE) {
12365 } else if ((exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_ZIPS) ||
12366 (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_ZIP)) {
12395 } else if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_RLE) {
12420 } else if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_PIZ) {
12451 } else if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_ZFP) {
12458 exr_image->width, h, exr_header->num_channels, zfp_compression_param);
12514 int SaveEXRImageToFile(const EXRImage *exr_image, const EXRHeader *exr_header,
12517 exr_header->compression_type < 0) {
12523 if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_PIZ) {
12531 if (exr_header->compression_type == TINYEXR_COMPRESSIONTYPE_ZFP) {
12550 size_t mem_size = SaveEXRImageToMemory(exr_image, exr_header, &mem, err);
12977 void InitEXRHeader(EXRHeader *exr_header) {
12978 if (exr_header == NULL) {
12982 memset(exr_header, 0, sizeof(EXRHeader));
12985 int FreeEXRHeader(EXRHeader *exr_header) {
12986 if (exr_header == NULL) {
12990 if (exr_header->channels) {
12991 free(exr_header->channels);
12994 if (exr_header->pixel_types) {
12995 free(exr_header->pixel_types);
12998 if (exr_header->requested_pixel_types) {
12999 free(exr_header->requested_pixel_types);
13002 for (int i = 0; i < exr_header->num_custom_attributes; i++) {
13003 if (exr_header->custom_attributes[i].value) {
13004 free(exr_header->custom_attributes[i].value);
13008 if (exr_header->custom_attributes) {
13009 free(exr_header->custom_attributes);
13047 int ParseEXRHeaderFromFile(EXRHeader *exr_header, const EXRVersion *exr_version,
13049 if (exr_header == NULL || exr_version == NULL || filename == NULL) {
13086 return ParseEXRHeaderFromMemory(exr_header, exr_version, &buf.at(0), filesize,
13150 EXRHeader *exr_header = static_cast<EXRHeader *>(malloc(sizeof(EXRHeader)));
13152 ConvertHeader(exr_header, infos[i]);
13155 exr_header->tiled = exr_version->tiled;
13157 (*exr_headers)[i] = exr_header;