write()

bool MayaFlux::IO::EXRWriter::write ( const std::string &  filepath, const ImageData &  data, const ImageWriteOptions &  options = {}  )

overridevirtual

Write image data to disk.

Parameters

filepath	Destination path.
data	Image data. Must satisfy ImageData::is_consistent().
options	Format-specific options.

Returns

true on success. On failure call get_last_error().

Implements MayaFlux::IO::ImageWriter.

Definition at line 160 of file EXRWriter.cpp.

{
    m_last_error.clear();
 
    if (!data.is_consistent()) {
        m_last_error = "ImageData variant does not match declared ImageFormat";
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO, m_last_error);
        return false;
    }
 
    if (data.width == 0 || data.height == 0 || data.channels == 0) {
        m_last_error = "ImageData has zero dimensions";
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO, m_last_error);
        return false;
    }
 
    const auto* src = data.as_float();
    if (!src) {
        m_last_error = "EXR requires float ImageData (uint8 and uint16 not supported)";
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO, m_last_error);
        return false;
    }
 
    const size_t expected_elements = static_cast<size_t>(data.width) * data.height * data.channels;
    if (src->size() < expected_elements) {
        m_last_error = "EXR source buffer too small: expected "
            + std::to_string(expected_elements)
            + " got " + std::to_string(src->size());
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO, m_last_error);
        return false;
    }
 
    const auto names = resolve_channel_names(data, options);
    auto planes = deinterleave(*src, data.width, data.height, data.channels,
        options.flip_vertically);
 
    // ------------------------------------------------------------------------
    // Populate EXRImage
    // ------------------------------------------------------------------------
    EXRImage image;
    InitEXRImage(&image);
 
    image.num_channels = static_cast<int>(data.channels);
    image.width = static_cast<int>(data.width);
    image.height = static_cast<int>(data.height);
 
    std::vector<float*> plane_ptrs(data.channels);
    for (uint32_t c = 0; c < data.channels; ++c) {
        plane_ptrs[c] = planes[c].data();
    }
    image.images = reinterpret_cast<unsigned char**>(plane_ptrs.data());
 
    // ------------------------------------------------------------------------
    // Populate EXRHeader
    // ------------------------------------------------------------------------
    EXRHeader header;
    InitEXRHeader(&header);
 
    header.num_channels = static_cast<int>(data.channels);
    header.compression_type = resolve_compression(options.compression);
 
    std::vector<EXRChannelInfo> channel_infos(data.channels);
    std::vector<int> pixel_types(data.channels, TINYEXR_PIXELTYPE_FLOAT);
    std::vector<int> requested_pixel_types(data.channels, TINYEXR_PIXELTYPE_FLOAT);
 
    for (uint32_t c = 0; c < data.channels; ++c) {
        std::memset(&channel_infos[c], 0, sizeof(EXRChannelInfo));
        const std::string& n = names[c];
        const size_t copy_len = std::min<size_t>(n.size(), 255);
        std::memcpy(channel_infos[c].name, n.data(), copy_len);
        channel_infos[c].name[copy_len] = '\0';
    }
 
    header.channels = channel_infos.data();
    header.pixel_types = pixel_types.data();
    header.requested_pixel_types = requested_pixel_types.data();
 
    // ------------------------------------------------------------------------
    // Encode to memory, then flush
    // ------------------------------------------------------------------------
    unsigned char* encoded = nullptr;
    const char* err = nullptr;
 
    const size_t encoded_size = SaveEXRImageToMemory(
        &image, &header, &encoded, &err);
 
    if (encoded_size == 0 || encoded == nullptr) {
        m_last_error = err ? std::string("tinyexr: ") + err
                           : "SaveEXRImageToMemory returned 0 bytes";
        if (err) {
            FreeEXRErrorMessage(err);
        }
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO, m_last_error);
        return false;
    }
 
    const bool ok = flush_to_disk(filepath, encoded, encoded_size);
 
    std::free(encoded);
 
    if (!ok) {
        m_last_error = "Failed to write EXR file: " + filepath;
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO, m_last_error);
        return false;
    }
 
    MF_INFO(Journal::Component::IO, Journal::Context::FileIO,
        "Wrote EXR: {} ({}x{}, {} channels, compression {}, {} bytes)",
        filepath, data.width, data.height, data.channels,
        header.compression_type, encoded_size);
 
    return true;
}

References MayaFlux::IO::ImageData::as_float(), MayaFlux::IO::ImageData::channels, MayaFlux::IO::ImageWriteOptions::compression, deinterleave(), MayaFlux::Journal::FileIO, MayaFlux::IO::ImageWriteOptions::flip_vertically, MayaFlux::IO::ImageData::height, image, MayaFlux::Journal::IO, MayaFlux::IO::ImageData::is_consistent(), m_last_error, MF_ERROR, MF_INFO, resolve_channel_names(), and MayaFlux::IO::ImageData::width.

Here is the call graph for this function: