Merge pull request #52 from ynput/AY-6643_project_settings

AY-6643 Report AYON project resolution and fps within Resolve project settings.

Author: rdelillo

client/ayon_resolve/api/__init__.py

@@ -45,7 +45,11 @@
     get_pype_clip_metadata,
     set_project_manager_to_folder_name,
     get_otio_clip_instance_data,
-    get_reformated_path
+    get_reformated_path,
+    detect_project_fps_mismatch,
+    detect_project_resolution_mismatch,
+    set_project_fps,
+    set_project_resolution,
 )
 
 from .menu import launch_ayon_menu
@@ -126,6 +130,10 @@
     "set_project_manager_to_folder_name",
     "get_otio_clip_instance_data",
     "get_reformated_path",
+    "detect_project_fps_mismatch",
+    "detect_project_resolution_mismatch",
+    "set_project_fps",
+    "set_project_resolution",
 
     # menu
     "launch_ayon_menu",

client/ayon_resolve/api/lib.py

@@ -13,7 +13,10 @@
     is_overlapping_otio_ranges,
     frames_to_timecode
 )
-from ayon_core.pipeline.context_tools import get_current_project_name
+from ayon_core.pipeline.context_tools import (
+    get_current_project_name,
+    get_current_task_entity
+)
 from ayon_core.pipeline.tempdir import create_custom_tempdir
 
 from . import constants
@@ -1226,3 +1229,162 @@ def export_timeline_otio_native(timeline, filepath):
         log.error(f"Failed to export timeline otio: {e}")
         return False
     return True
+
+
+def detect_project_fps_mismatch(task_entity=None):
+    """ Detect potential fps mismatch between project settings
+    and task entity. Return any mismatch as a information
+    string to be displayed to the user.
+    """
+    task_entity = task_entity or get_current_task_entity()
+    attributes = task_entity["attrib"]
+    task_fps = attributes["fps"]
+
+    resolve_project = get_current_resolve_project()
+    resolve_fps = resolve_project.GetSetting("timelineFrameRate")
+
+    if task_fps != resolve_fps:
+        return (
+            f"Project current fps is {resolve_fps} "
+            f"while task fps is {task_fps}."
+        )
+
+    return None
+
+
+def detect_project_resolution_mismatch(task_entity=None):
+    """ Detect potential resolution mismatch between project settings
+    and task entity. Return any mismatch as a information
+    string to be displayed to the user.
+    """
+    task_entity = task_entity or get_current_task_entity()
+    attributes = task_entity["attrib"]
+    width = attributes["resolutionWidth"]
+    height = attributes["resolutionHeight"]
+
+    resolve_project = get_current_resolve_project()
+    resolve_width = resolve_project.GetSetting("timelineResolutionWidth")
+    resolve_height = resolve_project.GetSetting("timelineResolutionHeight")
+
+    if (str(width), str(height)) != (resolve_width, resolve_height):
+        return (
+            f"Project current resolution is {resolve_width}x{resolve_height} "
+            f"while task resolution is {width}x{height}."
+        )
+
+    return None
+
+
+def set_project_fps(task_entity=None):
+    """ Attempt to set project frame rate from AYON current task.
+    This might not be possible if a timeline already exists within the project.
+    Return a error string if any issue so it can be displayed to the user.
+    """
+    task_entity = task_entity or get_current_task_entity()
+    attributes = task_entity["attrib"]
+
+    # Set project frame rate and resolution
+    resolve_project = get_current_resolve_project()
+    project_fps = attributes["fps"]
+
+    SUPPORTED_FPS = {
+        16.0: "16",
+        18.0: "18",
+        23.976: "23.976",
+        24.0: "24",
+        25.0: "25",
+        29.97: "29.97",
+        30.0: "30",
+        47.952: "47.952",
+        48.0: "48",
+        50.0: "50"
+    }
+
+    if float(project_fps) in SUPPORTED_FPS:
+        if not resolve_project.SetSetting(
+            "timelineFrameRate",
+            SUPPORTED_FPS[float(project_fps)]
+        ):
+            # Resolve does not allow to edit timeline fps
+            # project settings once a timeline has been created.
+            return (
+                "Cannot override Project fps from AYON."
+                " This could be because a timeline already exists."
+            )
+
+        return None
+
+    else:
+        return (
+            "Fps set in AYON project is not supported by Resolve"
+            f" attempt to set {project_fps},"
+            f" supported are {tuple(SUPPORTED_FPS.keys())}."
+        )
+
+
+def set_project_resolution(task_entity=None):
+    """ Attempt to set project resolution from AYON current task.
+    Return a error string if any issue so it can be displayed to the user.
+    """
+    task_entity = task_entity or get_current_task_entity()
+    attributes = task_entity["attrib"]
+
+    resolve_project = get_current_resolve_project()
+    width = attributes["resolutionWidth"]
+    height = attributes["resolutionHeight"]
+
+    resolution_params = {
+        "timelineResolutionHeight": height,
+        "timelineResolutionWidth": width,
+    }
+
+    # In order to set vertical resolution in resolve,
+    # the "Use vertical resolution" option need to be enabled.
+    # This is not exposed from the Python API.
+    if height > width:
+            return (
+                "Cannot override Project resolution from AYON."
+                f" Vertical resolution {width}x{height}"
+                " is unsupported from the API."
+            )
+
+    for resolve_param, value in resolution_params.items():
+        if not resolve_project.SetSetting(
+            resolve_param,
+            str(int(value))
+        ):
+            return (
+                "Cannot override Project resolution from AYON."
+                f" trying to set {resolve_param} = {value}"
+            )
+
+    SUPPORTED_PIXEL_ASPECTS = {
+        1.0: "Square",
+        16/9: "16:9 anamorphic",
+        4/3: "4:3 standard definition",
+        2.0: "Cinemascope",
+    }
+    pixel_aspect_ratio = round(attributes["pixelAspect"], 2)
+
+    for supported_pa in SUPPORTED_PIXEL_ASPECTS:
+        if round(supported_pa, 2) != pixel_aspect_ratio:
+            continue
+
+        if not resolve_project.SetSetting(
+            "timelinePixelAspectRatio",
+            SUPPORTED_PIXEL_ASPECTS[supported_pa]
+        ):
+            return (
+                "Cannot override Project pixel aspect ratio from AYON."
+                " trying to set timelinePixelAspectRatio = "
+                f"{SUPPORTED_PIXEL_ASPECTS[supported_pa]}"
+            )
+
+        return None
+
+    else:
+        return (
+            "Pixel Aspect Ratio set in AYON project is not supported"
+            f" by Resolve, attempt to set {pixel_aspect_ratio},"
+            f" supported are {tuple(SUPPORTED_PIXEL_ASPECTS.keys())}."
+        )

client/ayon_resolve/api/pipeline.py

@@ -5,8 +5,10 @@
 import json
 import contextlib
 from collections import OrderedDict
+import sys
 
 from pyblish import api as pyblish
+from qtpy import QtWidgets
 
 from ayon_core.lib import Logger
 from ayon_core.pipeline import (
@@ -16,6 +18,11 @@
     register_inventory_action_path,
     AVALON_CONTAINER_ID,
 )
+from ayon_core.pipeline.context_tools import (
+    get_current_task_entity,
+    get_current_project_name
+)
+from ayon_core.settings import get_project_settings
 from ayon_core.host import (
     HostBase,
     IWorkfileHost,
@@ -79,9 +86,14 @@ def install(self):
         get_resolve_module()
 
     def open_workfile(self, filepath):
-        return open_file(filepath)
+        success = open_file(filepath)
+        if success:
+            self._show_ayon_settings_confirmation_windows()
+
+        return success
 
     def save_workfile(self, filepath=None):
+        self._show_ayon_settings_confirmation_windows()
         return save_file(filepath)
 
     def work_root(self, session):
@@ -107,6 +119,49 @@ def update_context_data(self, data, changes):
         # TODO: implement to support persisting context attributes
         pass
 
+    @staticmethod
+    def _show_ayon_settings_confirmation_windows():
+        """
+        """
+        settings = get_project_settings(
+            get_current_project_name()
+        )
+
+        # Only display this confirmation window if relevant setting is enabled.
+        if not settings["resolve"]["report_fps_resolution"]:
+            return
+
+        current_task = get_current_task_entity()
+        mismatch_fps = lib.detect_project_fps_mismatch(current_task)
+        mismatch_res = lib.detect_project_resolution_mismatch(current_task)
+
+        if not mismatch_fps and not mismatch_res:
+            log.info("Current resolve project matches task settings.")
+            return
+
+        app = QtWidgets.QApplication.instance() or QtWidgets.QApplication(sys.argv)
+        if QtWidgets.QMessageBox.information(
+            app.activeWindow(),
+            "Report project settings from AYON task ?",
+            (
+                "Your project settings mismatch the current task context. "
+                "Would you like to reset it to match the task attributes?\n"
+            ) + "".join([f"\n - {info}" for info in [mismatch_fps, mismatch_res] if info]),
+            QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
+        ) == QtWidgets.QMessageBox.Yes:
+
+            issues_fps = lib.set_project_fps(current_task) or ""
+            issues_resolution = lib.set_project_resolution(current_task) or ""
+            if issues_fps or issues_resolution:
+                QtWidgets.QMessageBox.warning(
+                    app.activeWindow(),
+                    "Cannot edit settings from AYON task.",
+                    (
+                        f"{issues_fps}\n{issues_resolution}\n\nMore information available at: "
+                        "https://docs.ayon.dev/docs/addon_resolve_artist#report-fps-and-resolution-from-ayon-task"
+                    )
+                )
+
 
 def containerise(timeline_item,
                  name,

client/ayon_resolve/startup.py

@@ -54,12 +54,13 @@ def main():
     else:
         log.info("No last workfile set to open. Skipping..")
 
-    # Launch AYON menu
+    # Gathered project settings
     from ayon_core.settings import get_project_settings
     from ayon_core.pipeline.context_tools import get_current_project_name
     project_name = get_current_project_name()
     log.info(f"Current project name in context: {project_name}")
 
+    # Launch AYON menu
     settings = get_project_settings(project_name)
     if settings.get("resolve", {}).get("launch_openpype_menu_on_start", True):
         log.info("Launching AYON menu..")

server/settings.py

@@ -141,6 +141,9 @@ class ResolveSettings(BaseSettingsModel):
     launch_openpype_menu_on_start: bool = SettingsField(
         False, title="Launch OpenPype menu on start of Resolve"
     )
+    report_fps_resolution: bool = SettingsField(
+        False, title="Set FPS and Resolution from current task"
+    )
     imageio: ResolveImageIOModel = SettingsField(
         default_factory=ResolveImageIOModel,
         title="Color Management (ImageIO)"
@@ -157,6 +160,7 @@ class ResolveSettings(BaseSettingsModel):
 
 DEFAULT_VALUES = {
     "launch_openpype_menu_on_start": False,
+    "report_fps_resolution": False,
     "create": {
         "CreateShotClip": {
             "hierarchy": "{folder}/{sequence}",