Function LoadEXRMultipartImageFromMemory

Source/ThirdParty/tinyexr.h:10501–10630

}

int LoadEXRMultipartImageFromMemory(EXRImage *exr_images,
                                    const EXRHeader **exr_headers,
                                    unsigned int num_parts,
                                    const unsigned char *memory,
                                    const size_t size, const char **err) {
  if (exr_images == NULL || exr_headers == NULL || num_parts == 0 ||
      memory == NULL || (size <= tinyexr::kEXRVersionSize)) {
    tinyexr::SetErrorMessage(
        "Invalid argument for LoadEXRMultipartImageFromMemory()", err);
    return TINYEXR_ERROR_INVALID_ARGUMENT;
  }

  // compute total header size.
  size_t total_header_size = 0;
  for (unsigned int i = 0; i < num_parts; i++) {
    if (exr_headers[i]->header_len == 0) {
      tinyexr::SetErrorMessage("EXRHeader variable is not initialized.", err);
      return TINYEXR_ERROR_INVALID_ARGUMENT;
    }

    total_header_size += exr_headers[i]->header_len;
  }

  const char *marker = reinterpret_cast<const char *>(
      memory + total_header_size + 4 +
      4);  // +8 for magic number and version header.

  marker += 1;  // Skip empty header.

  // NOTE 1:
  //   In multipart image, There is 'part number' before chunk data.
  //   4 byte : part number
  //   4+     : chunk
  //
  // NOTE 2:
  //   EXR spec says 'part number' is 'unsigned long' but actually this is
  //   'unsigned int(4 bytes)' in OpenEXR implementation...
  //   http://www.openexr.com/openexrfilelayout.pdf

  // Load chunk offset table.
  std::vector<tinyexr::OffsetData> chunk_offset_table_list;
  chunk_offset_table_list.reserve(num_parts);
  for (size_t i = 0; i < static_cast<size_t>(num_parts); i++) {
    chunk_offset_table_list.resize(chunk_offset_table_list.size() + 1);
    tinyexr::OffsetData& offset_data = chunk_offset_table_list.back();
    if (!exr_headers[i]->tiled || exr_headers[i]->tile_level_mode == TINYEXR_TILE_ONE_LEVEL) {
      tinyexr::InitSingleResolutionOffsets(offset_data, size_t(exr_headers[i]->chunk_count));
      std::vector<tinyexr::tinyexr_uint64>& offset_table = offset_data.offsets[0][0];

      for (size_t c = 0; c < offset_table.size(); c++) {
        tinyexr::tinyexr_uint64 offset;
        memcpy(&offset, marker, 8);
        tinyexr::swap8(&offset);

        if (offset >= size) {
          tinyexr::SetErrorMessage("Invalid offset size in EXR header chunks.",
                                   err);
          return TINYEXR_ERROR_INVALID_DATA;