Merge branch 'mainline' into feature/ci-tests

Author: karthikbekalp

src/deadline/cinema4d_adaptor/Cinema4DClient/cinema4d_handler.py

@@ -2,15 +2,19 @@
 from __future__ import annotations
 
 import os
+import time
 import traceback
 from typing import Any, Callable, Dict
 
 # The Cinema4D Adaptor adds the `deadline` namespace directory to PYTHONPATH,
 # so that importing just the cinema4d_adaptor should work.
 try:
-    from cinema4d_adaptor.Cinema4DClient import tile_rendering  # type: ignore[import]
+    from cinema4d_adaptor.Cinema4DClient import ocio_bake, tile_rendering  # type: ignore[import]
 except (ImportError, ModuleNotFoundError):
-    from deadline.cinema4d_adaptor.Cinema4DClient import tile_rendering  # type: ignore[import]
+    from deadline.cinema4d_adaptor.Cinema4DClient import (  # type: ignore[import]
+        ocio_bake,
+        tile_rendering,
+    )
 
 try:
     import c4d  # type: ignore
@@ -265,6 +269,14 @@ def _parse_frame_range(frame_value) -> tuple[int, int]:
         frame = int(frame_str)
         return frame, frame
 
+    def _raise_on_render_error(self, result: int) -> None:
+        """Raise if a RenderDocument result is an error (or unrecognized)."""
+        result_description = _RENDERRESULT.get(result)
+        if result_description is None:
+            raise RuntimeError("Error: unhandled render result: %s" % result)
+        if result != c4d.RENDERRESULT_OK:
+            raise RuntimeError("Error: render result: %s" % result_description)
+
     def start_render(self, data: dict) -> None:
         if self.cached_text_was_used_in_previous_frame:
             # Close and then reload document since we collapsed some text in the previous frame
@@ -303,33 +315,66 @@ def start_render(self, data: dict) -> None:
 
         width = int(self.render_data[c4d.RDATA_XRES])
         height = int(self.render_data[c4d.RDATA_YRES])
-        if is_tile_render:
-            bm = tile_rendering.create_tile_bitmap(width, height)
-        else:
-            bm = bitmaps.MultipassBitmap(width, height, c4d.COLORMODE_RGB)
         rd = self.render_data.GetDataInstance()
 
         self.cached_text_was_used_in_previous_frame = self._cache_text_if_needed(
             c4d.BaseTime(start_frame, fps)
         )
 
-        result = c4d.documents.RenderDocument(
-            self.doc,
-            rd,
-            bm,
-            c4d.RENDERFLAGS_EXTERNAL | c4d.RENDERFLAGS_SHOWERRORS,
-            prog=progress_callback,
+        render_flags = c4d.RENDERFLAGS_EXTERNAL | c4d.RENDERFLAGS_SHOWERRORS
+
+        # Non-tile OCIO workaround: RenderDocument's internal save does not bake the
+        # OCIO View Transform (a Cinema 4D SDK bug), so ordinary renders are written
+        # un-tone-mapped (dark/"Raw"). We disable the render-time bake and render ONE
+        # frame per RenderDocument call, so each frame's render-space bitmap can be
+        # OCIO-baked into its beauty file afterwards. (A single RenderDocument over a
+        # frame range leaves only the last frame in the bitmap, so the earlier frames
+        # could not be baked.) See tile_rendering.bake_full_frame_beauty.
+        # Only 8-bit display output needs the view transform baked (float/EXR stays
+        # scene-linear), so restrict the per-frame path to that case -- other outputs
+        # keep the original single range render.
+        bake_ocio = (
+            not is_tile_render
+            and hasattr(c4d, "RDATA_BAKE_OCIO_VIEW_TRANSFORM_RENDER")
+            and self.render_data[c4d.RDATA_FORMATDEPTH] == c4d.RDATA_FORMATDEPTH_8
         )
-
-        result_description = _RENDERRESULT.get(result)
-        if result_description is None:
-            raise RuntimeError("Error: unhandled render result: %s" % result)
-        if result != c4d.RENDERRESULT_OK:
-            raise RuntimeError("Error: render result: %s" % result_description)
-
-        # Post-render tile processing: OCIO bake, crop, save tile, restore paths
-        if is_tile_render and tile_ctx is not None:
-            tile_rendering.finalize_tile_render(bm, rd, tile_ctx, self.render_data, start_frame)
+        if bake_ocio:
+            # Disable the render-time bake, restoring it afterwards (the document is
+            # reused across renders in a session) -- mirrors the tile path, which saves
+            # and restores this flag in finalize_tile_render.
+            orig_bake_flag = self.render_data[c4d.RDATA_BAKE_OCIO_VIEW_TRANSFORM_RENDER]
+            self.render_data[c4d.RDATA_BAKE_OCIO_VIEW_TRANSFORM_RENDER] = False
+            try:
+                for frame in range(start_frame, end_frame + 1):
+                    self.render_data[c4d.RDATA_FRAMEFROM] = c4d.BaseTime(frame, fps)
+                    self.render_data[c4d.RDATA_FRAMETO] = c4d.BaseTime(frame, fps)
+                    frame_rd = self.render_data.GetDataInstance()
+                    # Render into a float bitmap so the OCIO view transform is baked from
+                    # full-precision render-space data (baking 8-bit data would band the
+                    # gradients) -- same rationale as the tile path's create_tile_bitmap.
+                    frame_bm = bitmaps.MultipassBitmap(width, height, c4d.COLORMODE_RGBf)
+                    render_start = time.time()
+                    result = c4d.documents.RenderDocument(
+                        self.doc, frame_rd, frame_bm, render_flags, prog=progress_callback
+                    )
+                    self._raise_on_render_error(result)
+                    ocio_bake.bake_full_frame_beauty(
+                        frame_bm, frame_rd, self.render_data, self.doc, frame, render_start
+                    )
+            finally:
+                self.render_data[c4d.RDATA_BAKE_OCIO_VIEW_TRANSFORM_RENDER] = orig_bake_flag
+        else:
+            if is_tile_render:
+                bm = tile_rendering.create_tile_bitmap(width, height)
+            else:
+                bm = bitmaps.MultipassBitmap(width, height, c4d.COLORMODE_RGB)
+            result = c4d.documents.RenderDocument(
+                self.doc, rd, bm, render_flags, prog=progress_callback
+            )
+            self._raise_on_render_error(result)
+            # Post-render tile processing: OCIO bake, crop, save tile, restore paths
+            if is_tile_render and tile_ctx is not None:
+                tile_rendering.finalize_tile_render(bm, rd, tile_ctx, self.render_data, start_frame)
 
         print("Finished Rendering")
 
@@ -375,7 +420,7 @@ def get_child_takes(take):
                     all_takes.extend(get_child_takes(child_take))
             return all_takes
 
-        main_take = take_data.GetCurrentTake()
+        main_take = take_data.GetMainTake()
         all_takes = [main_take] + get_child_takes(main_take)
 
         matched_take = None

src/deadline/cinema4d_adaptor/Cinema4DClient/ocio_bake.py

@@ -0,0 +1,160 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+"""OCIO view-transform baking for non-tile renders.
+
+Works around a Cinema 4D SDK bug: ``RenderDocument``'s internal save does not apply
+the OCIO View Transform, so ordinary (non-tile) renders to 8-bit display formats are
+written un-tone-mapped (dark/"Raw"). This bakes the view transform into the beauty
+image after the render -- the tile path (tile_rendering.finalize_tile_render) already
+does the equivalent for tiles.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+try:
+    import c4d  # type: ignore
+except ImportError:  # pragma: no cover
+    raise OSError("Could not find the Cinema4D module. Are you running this inside of Cinema4D?")
+
+try:
+    from cinema4d_adaptor.Cinema4DClient.tile_rendering import (  # type: ignore[import]
+        C4D_VERSION_2025_2,
+        get_format_info,
+    )
+except ImportError:
+    from deadline.cinema4d_adaptor.Cinema4DClient.tile_rendering import (  # type: ignore[import]
+        C4D_VERSION_2025_2,
+        get_format_info,
+    )
+
+
+def _resolve_render_path(doc: Any, render_data: Any, render_bc: Any, frame: int, path: str) -> str:
+    """Resolve a C4D render-path's tokens ($take, $frame, $res, ...) using C4D's own
+    token system -- the same resolver C4D uses at save time. Returns ``path``
+    unchanged if the token system is unavailable or resolution fails.
+
+    Note: this expands tokens only; C4D still appends the frame number + extension to
+    the result at save time (per RDATA_NAMEFORMAT), so the return value is the output
+    BASE (a filename prefix), not the full final path.
+    """
+    tokensystem = getattr(c4d.modules, "tokensystem", None)
+    if tokensystem is None or not hasattr(tokensystem, "FilenameConvertTokens"):
+        return path
+    take_data = doc.GetTakeData()
+    rp_data = {
+        "_doc": doc,
+        "_rData": render_data,
+        "_rBc": render_bc,
+        "_frame": frame,
+        "_take": take_data.GetCurrentTake() if take_data else None,
+    }
+    try:
+        return tokensystem.FilenameConvertTokens(path, rp_data)
+    except Exception:
+        return path
+
+
+def bake_full_frame_beauty(
+    bm: Any,
+    rd: Any,
+    render_data: Any,
+    doc: Any,
+    frame: int,
+    render_start_time: float,
+) -> None:
+    """Bake the OCIO view transform into a single non-tiled beauty frame.
+
+    Works around a Cinema 4D SDK bug: ``RenderDocument``'s internal save does not
+    apply the OCIO View Transform, so the beauty image is written un-tone-mapped
+    (dark/"Raw"). Requires the render to have run with
+    ``RDATA_BAKE_OCIO_VIEW_TRANSFORM_RENDER`` disabled so ``bm`` holds render-space
+    data. No-op on pre-2025.2 Cinema 4D or non-8-bit output (float EXR etc. must stay
+    scene-linear).
+
+    Call once per rendered frame (``bm`` holds one frame). The target file is found by
+    resolving the render output path's tokens with C4D's own token system and matching
+    only files under that exact base name -- so we never touch an unrelated file in the
+    folder. C4D's ``A_`` alpha file is excluded for free (it does not start with the
+    beauty base); multi-pass files are excluded by their own resolved base. Among
+    matches, the file written by this render (newest mtime at/after
+    ``render_start_time``) is baked, which is retry-safe.
+
+    Args:
+        bm: The rendered MultipassBitmap for one frame (render-space).
+        rd: The live render data instance (from GetDataInstance).
+        render_data: The render data object (output path / format / tokens).
+        doc: The active document (for token resolution).
+        frame: The frame number this render produced (for $frame resolution).
+        render_start_time: ``time.time()`` captured just before this frame's render.
+    """
+    if not (
+        hasattr(c4d, "RDATA_BAKE_OCIO_VIEW_TRANSFORM_RENDER")
+        and hasattr(c4d.documents, "BakeOcioViewToBitmap")
+    ):
+        return
+    if rd[c4d.RDATA_FORMATDEPTH] != c4d.RDATA_FORMATDEPTH_8:
+        return  # only display-referred 8-bit output needs the view transform baked in
+
+    beauty_path = render_data[c4d.RDATA_PATH] or ""
+    if not beauty_path:
+        return
+    # Resolve tokens ($take, $frame, ...) with C4D's own resolver, then anchor on the
+    # exact base name C4D derives -- C4D appends the frame number + extension to it.
+    resolved_base = _resolve_render_path(doc, render_data, rd, frame, beauty_path)
+    beauty_dir = os.path.dirname(resolved_base) or "."
+    beauty_prefix = os.path.basename(resolved_base)
+    if not beauty_prefix or not os.path.isdir(beauty_dir):
+        return
+    ext, save_filter = get_format_info(render_data[c4d.RDATA_FORMAT])
+
+    # Multi-pass files can share the beauty prefix (e.g. "beauty" vs "beauty_mp"), so
+    # exclude them by their own resolved base -- but only when that base is a MORE
+    # specific (longer) match than the beauty base (see the loop below). The "A_" alpha
+    # file needs no explicit exclusion -- it does not start with the beauty base.
+    mp_prefix = ""
+    if render_data[c4d.RDATA_MULTIPASS_SAVEIMAGE] and render_data[c4d.RDATA_MULTIPASS_FILENAME]:
+        mp_resolved = _resolve_render_path(
+            doc, render_data, rd, frame, render_data[c4d.RDATA_MULTIPASS_FILENAME]
+        )
+        mp_prefix = os.path.basename(mp_resolved)
+
+    # The beauty file this render wrote: derived from C4D's resolved output base,
+    # correct extension, not a multi-pass file, and modified at/after this render's
+    # start (never re-bakes a stale file; a retry that overwrites in place is caught).
+    target = None
+    target_mtime = render_start_time
+    for fn in os.listdir(beauty_dir):
+        if not fn.startswith(beauty_prefix):
+            continue
+        if not fn.lower().endswith(ext.lower()):
+            continue
+        # A file is multi-pass only when the multi-pass base is a longer (more
+        # specific) prefix than the beauty base. Guarding on length -- not just
+        # inequality -- keeps a beauty file whose base merely starts with a shorter
+        # multi-pass base (e.g. beauty "render_beauty", mp "render") from being
+        # wrongly skipped, and still excludes real multi-pass files whose base
+        # extends the beauty base (e.g. beauty "render", mp "render_mp").
+        if mp_prefix and len(mp_prefix) > len(beauty_prefix) and fn.startswith(mp_prefix):
+            continue  # multi-pass file -- leave as-is
+        full = os.path.join(beauty_dir, fn)
+        try:
+            mtime = os.path.getmtime(full)
+        except OSError:
+            continue
+        if mtime >= target_mtime:
+            target = full
+            target_mtime = mtime
+
+    if target is None:
+        print("OCIO view transform NOT baked: no beauty file found from this render")
+        return
+
+    baked = c4d.documents.BakeOcioViewToBitmap(bm, rd, c4d.SAVEBIT_NONE)
+    bm = baked or bm
+    if c4d.GetC4DVersion() >= C4D_VERSION_2025_2:
+        bm.SetColorProfile(c4d.bitmaps.ColorProfile(), c4d.COLORPROFILE_INDEX_DISPLAYSPACE)
+        bm.SetColorProfile(c4d.bitmaps.ColorProfile(), c4d.COLORPROFILE_INDEX_VIEW_TRANSFORM)
+    bm.Save(target, save_filter)
+    print(f"OCIO view transform baked into beauty output: {os.path.basename(target)}")

test/unit/deadline_adaptor_for_cinema4d/Cinema4DClient/test_cinema4d_handler.py

@@ -82,7 +82,7 @@ def test_set_take_not_found_raises_error(self, mock_get_doc: Mock):
         mock_take_a.GetChildren.return_value = []
 
         mock_take_data = Mock()
-        mock_take_data.GetCurrentTake.return_value = mock_main_take
+        mock_take_data.GetMainTake.return_value = mock_main_take
         mock_main_take.GetChildren.return_value = [mock_take_a]
 
         mock_doc = Mock()
@@ -109,7 +109,7 @@ def test_set_take_found_sets_take(self, mock_get_doc: Mock):
         mock_take_a.GetChildren.return_value = []
 
         mock_take_data = Mock()
-        mock_take_data.GetCurrentTake.return_value = mock_main_take
+        mock_take_data.GetMainTake.return_value = mock_main_take
         mock_main_take.GetChildren.return_value = [mock_take_a]
 
         mock_doc = Mock()
@@ -119,6 +119,50 @@ def test_set_take_found_sets_take(self, mock_get_doc: Mock):
         handler.set_take({"take": "A"})
         mock_take_data.SetCurrentTake.assert_called_once_with(mock_take_a)
 
+    @patch(
+        "deadline.cinema4d_adaptor.Cinema4DClient.cinema4d_handler.c4d.documents.GetActiveDocument"
+    )
+    def test_set_take_from_non_parent_current_take(self, mock_get_doc: Mock):
+        """Verify that set_take finds and sets a take even if the active take is not an ancestor of the target take."""
+        handler = Cinema4DHandler(mock_map_path)
+
+        # Hierarchy:
+        #           Main
+        #          /    \
+        #     Take A   Take B
+        #       |
+        #    Take A1 (current active take)
+        mock_main_take = Mock()
+        mock_main_take.GetName.return_value = "Main"
+
+        mock_take_a = Mock()
+        mock_take_a.GetName.return_value = "Take A"
+
+        mock_take_a1 = Mock()
+        mock_take_a1.GetName.return_value = "Take A1"
+        mock_take_a1.GetChildren.return_value = []
+
+        mock_take_b = Mock()
+        mock_take_b.GetName.return_value = "Take B"
+        mock_take_b.GetChildren.return_value = []
+
+        mock_main_take.GetChildren.return_value = [mock_take_a, mock_take_b]
+        mock_take_a.GetChildren.return_value = [mock_take_a1]
+
+        mock_take_data = Mock()
+        # Current active take is Take A1 (which has no children)
+        mock_take_data.GetCurrentTake.return_value = mock_take_a1
+        # GetMainTake returns Main take, which roots the entire hierarchy
+        mock_take_data.GetMainTake.return_value = mock_main_take
+
+        mock_doc = Mock()
+        mock_doc.GetTakeData.return_value = mock_take_data
+        mock_get_doc.return_value = mock_doc
+
+        # Setting take to "Take B" should succeed because search starts from GetMainTake()
+        handler.set_take({"take": "Take B"})
+        mock_take_data.SetCurrentTake.assert_called_once_with(mock_take_b)
+
 
 class TestShouldCacheText:
     """Tests for the use_cached_text method"""