Function ParseEXRHeaderFromMemory

Source/ThirdParty/tinyexr.h:7985–8043

}

int ParseEXRHeaderFromMemory(EXRHeader *exr_header, const EXRVersion *version,
                             const unsigned char *memory, size_t size,
                             const char **err) {
  if (memory == NULL || exr_header == NULL) {
    tinyexr::SetErrorMessage(
        "Invalid argument. `memory` or `exr_header` argument is null in "
        "ParseEXRHeaderFromMemory()",
        err);

    // Invalid argument
    return TINYEXR_ERROR_INVALID_ARGUMENT;
  }

  if (size < tinyexr::kEXRVersionSize) {
    tinyexr::SetErrorMessage("Insufficient header/data size.\n", err);
    return TINYEXR_ERROR_INVALID_DATA;
  }

  const unsigned char *marker = memory + tinyexr::kEXRVersionSize;
  size_t marker_size = size - tinyexr::kEXRVersionSize;

  tinyexr::HeaderInfo info;
  info.clear();

  int ret;
  {
    std::string err_str;
    ret = ParseEXRHeader(&info, NULL, version, &err_str, marker, marker_size);

    if (ret != TINYEXR_SUCCESS) {
      if (err && !err_str.empty()) {
        tinyexr::SetErrorMessage(err_str, err);
      }
    }
  }

  {
    std::string warn;
    std::string err_str;

    if (!ConvertHeader(exr_header, info, &warn, &err_str)) {
      // release mem
      for (size_t i = 0; i < info.attributes.size(); i++) {
        if (info.attributes[i].value) {
          free(info.attributes[i].value);
        }
      }
      if (err && !err_str.empty()) {
        tinyexr::SetErrorMessage(err_str, err);
      }
      ret = TINYEXR_ERROR_INVALID_HEADER;
    }
  }

  exr_header->multipart = version->multipart ? 1 : 0;
  exr_header->non_image = version->non_image ? 1 : 0;

  return ret;