Add OIIO metadata

Signed-off-by: Thomas Manceau <[email protected]>

Author: Blackhart

src/plugin/media_metadata/CMakeLists.txt

@@ -1,4 +1,5 @@
 add_src_and_test(ffprobe)
 add_src_and_test(openexr)
+add_src_and_test(openimageio)
 
 build_studio_plugins("${STUDIO_PLUGINS}")

src/plugin/media_metadata/openimageio/src/CMakeLists.txt

@@ -0,0 +1,8 @@
+find_package(OpenImageIO)
+
+SET(LINK_DEPS
+	xstudio::media_metadata
+	OpenImageIO::OpenImageIO
+)
+
+create_plugin_with_alias(media_metadata_openimageio xstudio::media_metadata::openimageio ${XSTUDIO_GLOBAL_VERSION}  "${LINK_DEPS}")

src/plugin/media_metadata/openimageio/src/openimageio_metadata.cpp

@@ -0,0 +1,178 @@
+// SPDX-License-Identifier: Apache-2.0
+#include "openimageio_metadata.hpp"
+
+#include <filesystem>
+#include <unordered_set>
+
+#include <OpenImageIO/imageio.h>
+#include <OpenImageIO/typedesc.h>
+
+#include "xstudio/utility/helpers.hpp"
+
+namespace fs = std::filesystem;
+
+using namespace xstudio::media_metadata;
+using namespace xstudio::utility;
+using namespace xstudio;
+
+OpenImageIOMediaMetadata::OpenImageIOMediaMetadata() : MediaMetadata("OpenImageIO") {}
+
+MMCertainty OpenImageIOMediaMetadata::supported(
+    const caf::uri &uri, const std::array<uint8_t, 16> &signature) {
+    // Step 1: List of supported extensions by OIIO
+    static const std::unordered_set<std::string> supported_extensions = {
+        "JPG",
+        "JPEG",
+        "PNG",
+        "TIF",
+        "TIFF",
+        "TGA",
+        "BMP",
+        "PSD",
+        "HDR",
+        "DPX",
+        "ACES",
+        "JP2",
+        "J2K",
+        "WEBP",
+        "EXR",
+    };
+
+    // Step 2: Convert the URI to a POSIX path string and fs::path
+    std::string path = uri_to_posix_path(uri);
+    fs::path p(path);
+
+    // Step 3: Check if the file exists and is a regular file
+    // Return not supported if the file does not exist or is not a regular file
+    if (!fs::exists(p) || !fs::is_regular_file(p)) {
+        return MMC_NO;
+    }
+
+    // Step 4: Get the upper-case extension (handling platform differences)
+#ifdef _WIN32
+    std::string ext = ltrim_char(to_upper_path(p.extension()), '.');
+#else
+    std::string ext = ltrim_char(to_upper(p.extension().string()), '.');
+#endif
+
+    // Step 5: Check if the extension is in the supported list
+    // Return fully supported if the extension is in the supported list
+    if (supported_extensions.count(ext)) {
+        return MMC_FULLY;
+    }
+
+    // Step 6: Try to detect via OIIO if the extension is supported
+    // Return maybe supported if the extension is supported by OIIO
+    auto in = OIIO::ImageInput::open(path);
+    if (in) {
+        in->close();
+        return MMC_MAYBE;
+    }
+
+    // Step 7: Return not supported if all checks fail
+    return MMC_NO;
+}
+
+nlohmann::json OpenImageIOMediaMetadata::read_metadata(const caf::uri &uri) {
+    std::string path = uri_to_posix_path(uri);
+
+    try {
+        // Step 1: Open the image using OpenImageIO
+        auto in = OIIO::ImageInput::open(path);
+        if (!in) {
+            throw std::runtime_error("Cannot open: " + OIIO::geterror());
+        }
+
+        // Step 2: Get the image specification
+        const OIIO::ImageSpec &spec = in->spec();
+
+        // Step 3: Initialize a JSON object for metadata
+        nlohmann::json metadata;
+
+        // Step 4: Populate basic image properties (width, height, resolution)
+        metadata["width"] = spec.width;
+        metadata["height"] = spec.height;
+        metadata["resolution"] = fmt::format("{} x {}", spec.width, spec.height);
+
+        // Step 5: Extract and format the file extension (format)
+        fs::path p(path);
+#ifdef _WIN32
+        std::string ext = ltrim_char(to_upper_path(p.extension()), '.');
+#else
+        std::string ext = ltrim_char(to_upper(p.extension().string()), '.');
+#endif
+        metadata["format"] = ext;
+        
+        // Step 6: Determine bit depth and add to metadata
+        if (spec.format == OIIO::TypeDesc::UINT8) {
+            metadata["bit_depth"] = "8 bits";
+        } else if (spec.format == OIIO::TypeDesc::UINT16) {
+            metadata["bit_depth"] = "16 bits";
+        } else if (spec.format == OIIO::TypeDesc::HALF) {
+            metadata["bit_depth"] = "16 bits float";
+        } else if (spec.format == OIIO::TypeDesc::FLOAT) {
+            metadata["bit_depth"] = "32 bits float";
+        } else {
+            metadata["bit_depth"] = "unknown";
+        }
+        
+        // Step 7: Read pixel aspect ratio and aspect ratio
+        metadata["pixel_aspect"] = spec.get_float_attribute("PixelAspectRatio", 1.0f);
+        metadata["aspect_ratio"]  = spec.get_float_attribute("XResolution", spec.width)
+                                    / spec.get_float_attribute("YResolution", spec.height);
+
+        // Step 8: Add extra attributes to metadata
+        for (const auto &param : spec.extra_attribs) {
+            metadata[param.name().string()] = param.get_string();
+        }
+
+        // Step 9: Return metadata
+        return metadata;
+    } catch (const std::exception &e) {
+        spdlog::error("Failed to read metadata from {}: {}", path, e.what());
+        return nlohmann::json::object();
+    }
+}
+
+std::optional<MediaMetadata::StandardFields>
+OpenImageIOMediaMetadata::fill_standard_fields(const nlohmann::json &metadata) {
+    // Step 1: Initialize StandardFields and set default format
+    StandardFields fields;
+    fields.format_ = "OpenImageIO";
+
+    // Step 2: Fill in the resolution if present in metadata
+    if (metadata.contains("resolution")) {
+        fields.resolution_ = metadata["resolution"].get<std::string>();
+    }
+
+    // Step 3: Fill in the image extension (format) if present in metadata
+    if (metadata.contains("format")) {
+        fields.format_ = metadata["format"].get<std::string>();
+    }
+
+    // Step 4: Fill in the bit depth if present in metadata
+    if (metadata.contains("bit_depth")) {
+        fields.bit_depth_ = metadata["bit_depth"].get<std::string>();
+    }
+
+    // Step 5: Fill in the pixel aspect ratio if present in metadata
+    if (metadata.contains("pixel_aspect")) {
+        fields.pixel_aspect_ = metadata["pixel_aspect"].get<float>();
+    }
+
+    return std::make_optional(fields);
+}
+
+// Point d'entrée du plugin
+extern "C" {
+plugin_manager::PluginFactoryCollection *plugin_factory_collection_ptr() {
+    return new plugin_manager::PluginFactoryCollection(
+        std::vector<std::shared_ptr<plugin_manager::PluginFactory>>({std::make_shared<
+            MediaMetadataPlugin<MediaMetadataActor<OpenImageIOMediaMetadata>>>(
+            Uuid("8f3c4a7e-9b2d-4e1f-a5c8-3d6f7e8a9b1c"),
+            "OpenImageIO",
+            "xStudio",
+            "OpenImageIO Media Metadata Reader",
+            semver::version("1.0.0"))}));
+}
+}

src/plugin/media_metadata/openimageio/src/openimageio_metadata.hpp

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <array>
+
+#include <nlohmann/json.hpp>
+
+#include "xstudio/media_metadata/media_metadata.hpp"
+
+namespace xstudio {
+namespace media_metadata {
+
+    class OpenImageIOMediaMetadata : public MediaMetadata {
+      public:
+        OpenImageIOMediaMetadata();
+        ~OpenImageIOMediaMetadata() override = default;
+
+        MMCertainty
+        supported(const caf::uri &uri, const std::array<uint8_t, 16> &signature) override;
+
+      protected:
+        nlohmann::json read_metadata(const caf::uri &uri) override;
+        std::optional<StandardFields>
+        fill_standard_fields(const nlohmann::json &metadata) override;
+    };
+
+} // namespace media_metadata
+} // namespace xstudio

src/plugin/media_metadata/openimageio/test/CMakeLists.txt

@@ -0,0 +1,7 @@
+include(CTest)
+
+SET(LINK_DEPS
+	CAF::core
+)
+
+create_tests("${LINK_DEPS}")

src/plugin/media_reader/openimageio/src/openimageio.cpp

@@ -127,51 +127,39 @@ OIIOMediaReader::OIIOMediaReader(const utility::JsonStore &prefs) : MediaReader(
 }
 
 void OIIOMediaReader::update_preferences(const utility::JsonStore &prefs) {
-    // Set OIIO threading based on preferences
     try {
+        // Set OIIO threading
         int threads =
             global_store::preference_value<int>(prefs, "/plugin/media_reader/OIIO/threads");
-        // Apply thread count to OIIO
         OIIO::attribute("threads", threads);
     } catch (const std::exception &e) {
-        // Warn if fetching or applying threads fails
-        spdlog::warn("{} {}", __PRETTY_FUNCTION__, e.what());
     }
 
-    // Set OIIO EXR-specific threading
     try {
+        // Set OIIO EXR-specific threading
         int exr_threads =
             global_store::preference_value<int>(prefs, "/plugin/media_reader/OIIO/exr_threads");
-        // Apply EXR threads to OIIO
         OIIO::attribute("exr_threads", exr_threads);
     } catch (const std::exception &e) {
-        // Warn if something went wrong
-        spdlog::warn("{} {}", __PRETTY_FUNCTION__, e.what());
     }
 
-    // Enable or disable TBB in OIIO
     try {
+        // Enable or disable TBB in OIIO
         int use_tbb =
             global_store::preference_value<int>(prefs, "/plugin/media_reader/OIIO/use_tbb");
-        // Set TBB usage
         OIIO::attribute("use_tbb", use_tbb);
     } catch (const std::exception &e) {
-        // Warn on error retrieving or applying use_tbb
-        spdlog::warn("{} {}", __PRETTY_FUNCTION__, e.what());
     }
 
-    // Set OIIO log times preference
-    // When the "log_times" attribute is nonzero, ImageBufAlgo functions are instrumented to
-    // record the number of times they were called and the total amount of time spent executing
-    // them.
     try {
+        // Set OIIO log times preference
+        // When the "log_times" attribute is nonzero, ImageBufAlgo functions are instrumented to
+        // record the number of times they were called and the total amount of time spent
+        // executing them.
         int log_times =
             global_store::preference_value<int>(prefs, "/plugin/media_reader/OIIO/log_times");
-        // Enable or disable logging of times
         OIIO::attribute("log_times", log_times);
     } catch (const std::exception &e) {
-        // Warn if log_times config fails
-        spdlog::warn("{} {}", __PRETTY_FUNCTION__, e.what());
     }
 }
 
@@ -971,7 +959,7 @@ plugin_manager::PluginFactoryCollection *plugin_factory_collection_ptr() {
         std::vector<std::shared_ptr<plugin_manager::PluginFactory>>(
             {std::make_shared<MediaReaderPlugin<MediaReaderActor<OIIOMediaReader>>>(
                 s_plugin_uuid,
-                "OIIO",
+                "OpenImageIO",
                 "xStudio",
                 "OpenImageIO Media Reader",
                 semver::version("1.0.0"))}));