code_gallery

Web News Blog Press Pricing

Learn

Training

Profiles

Executive

Templates

VFX

Code

Code Gallery Designer

v5.20

Maya

Playblast Export

Jorge Hernandez Ibañez 22/08/2025

Tags

Playblast Export

Jorge Herna…

Action v2

22/08/2025

Maya

Pseudo-Code

Parameters

Talk with TD Support

Import to my Pipeline

Code

import maya.cmds as cmds
import maya.OpenMayaUI as omui
import os
import requests
import json
import datetime

# Try to import PySide6 first, fallback to PySide2
try:
    from PySide6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel, 
                                  QComboBox, QPushButton, QFormLayout, QMessageBox, 
                                  QCheckBox, QSpinBox, QSlider, QGroupBox, QLineEdit)
    from PySide6.QtCore import Qt
    from shiboken6 import wrapInstance
    PYSIDE_VERSION = 6
except ImportError:
    try:
        from PySide2.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel, 
                                      QComboBox, QPushButton, QFormLayout, QMessageBox, 
                                      QCheckBox, QSpinBox, QSlider, QGroupBox, QLineEdit)
        from PySide2.QtCore import Qt
        from shiboken2 import wrapInstance
        PYSIDE_VERSION = 2
    except ImportError:
        raise ImportError("Neither PySide6 nor PySide2 is available")

# Import your pipeline module (assuming it exists)
try:
    import pipelinepro as pipeline
except ImportError:
    print("Warning: pipeline module not found. Some functionality may not work.")
    pipeline = None

def maya_main_window():
    """
    Return the Maya main window widget as a Python object
    """
    main_window_ptr = omui.MQtUtil.mainWindow()
    return wrapInstance(int(main_window_ptr), QDialog)

def get_scene_data():
    """
    Get scene data from the pipeline database
    """
    if not pipeline:
        print("Pipeline module not available")
        return None
        
    query = """
        query {
        file(fileName: "{filename}", token:"{token}"){
          fileName
          uploadLink
          folder{
            key
            code
            relTaskFolder{
              name
              code
            }
          }
        }
      }
    """
    
    # Get current Maya scene file
    filepath = cmds.file(query=True, sceneName=True)
    if not filepath:
        print("No scene file is currently open")
        return None
        
    filename = os.path.basename(filepath)
    query = query.replace("{filename}", filename)
    
    try:
        response = pipeline.query(query)
    except Exception as e:
        print("Error on DB query: ", e)
        return None
        
    print(response)
    file_props = response["file"]
    if not file_props:
        print(f"No data found for file {filename}.")
        return None
        
    return file_props

def create_output_folder(src_folder_key, folder_name='playblast'):
    """
    Create output folder in the pipeline system
    """
    if not pipeline:
        print("Pipeline module not available")
        return None
        
    mutation = '''
    mutation{
      createSubfolder(token:"{token}", folderKey:"{folder_key}", type:"{folder_name}"){
        folder{
          name
          code
          key
          folderLocal
        }
      }
    }
    '''
    mutation = mutation.replace('{folder_key}', src_folder_key)
    mutation = mutation.replace('{folder_name}', folder_name)
    
    try:
        response = pipeline.query(mutation)
    except Exception as e:
        print("Error on DB query: ", e)
        return None
        
    return response['createSubfolder']

def create_file(filename, folder_key):
    """
    Create file entry in the pipeline database
    """
    if not pipeline:
        print("Pipeline module not available")
        return None
        
    mutation = '''
    mutation{
      newFile(token:"{token}", fileName:"{fileName}", folderKey:"{folderKey}"){
        file{
          fileName
          key
          uploadLink
        }
      }
    }
    '''
    mutation = mutation.replace("{fileName}", filename)
    mutation = mutation.replace("{folderKey}", folder_key)
    
    try:
        response = pipeline.query(mutation)
    except Exception as e:
        print("Error on DB query: ", e)
        return None
        
    return response['newFile']

def mark_file_complete(file_key, filepath, file_size=0):
    """
    Mark file as completed in the pipeline database
    """
    if not pipeline:
        print("Pipeline module not available")
        return None
        
    mutation = '''
    mutation{
      completedFile(token:"{token}", fileKey:"{fileKey}", fileSize: {fileSize}, pathToFile:"{pathToFile}"){
        file{
          fileName
        }
      }
    }
    '''
    mutation = mutation.replace("{fileSize}", str(file_size))
    mutation = mutation.replace("{pathToFile}", os.path.normpath(filepath).replace("\\", "/"))
    mutation = mutation.replace("{fileKey}", file_key)
    
    try:
        response = pipeline.query(mutation)
        print(f"File marked as complete successfully.")
        return response['completedFile']
    except Exception as e:
        print(f"Error marking file as complete: {e}")
        return None

def data_write(model, key, field, value):
    """
    Write metadata to the pipeline database for a given model and key
    
    Args:
        model (str): The model type (e.g., 'File', 'Folder')
        key (str): The unique key for the model instance
        field (str): The field name for the metadata
        value (dict): The metadata value to store
    
    Returns:
        dict: The response from the pipeline query
    """
    if not pipeline:
        print("Pipeline module not available")
        return None
        
    mutation = """
    mutation{
      dataWrite(token:"{token}", model:"{model}", key:"{key}", value:{value}){
        data
      }
    }
    """
    mutation = (
        mutation.replace("{model}", model)
        .replace("{key}", key)
        .replace("{value}", json.dumps(json.dumps({field: value})))
    )
    
    try:
        response = pipeline.query(mutation)
        print(f"Metadata written successfully for {model} {key}")
        return response
    except Exception as e:
        print(f"Error writing metadata: {e}")
        return None

def get_current_scene_name():
    """
    Get the current scene name without extension for use in output filename
    """
    try:
        current_scene_path = cmds.file(query=True, sceneName=True)
        if not current_scene_path:
            return "untitled"
        
        scene_filename = os.path.basename(current_scene_path)
        scene_name_without_ext = os.path.splitext(scene_filename)[0]
        return scene_name_without_ext
    except Exception as e:
        print(f"Error getting scene name: {e}")
        return "untitled"

def get_timeline_range():
    """
    Get the current timeline playback range
    """
    try:
        start_frame = int(cmds.playbackOptions(query=True, minTime=True))
        end_frame = int(cmds.playbackOptions(query=True, maxTime=True))
        return start_frame, end_frame
    except Exception as e:
        print(f"Error getting timeline range: {e}")
        return 1, 100

def get_maya_colorspace():
    """
    Get the current Maya colorspace settings
    
    Returns:
        dict: Dictionary containing colorspace information
    """
    try:
        colorspace_info = {}
        
        # Try to get color management settings if available
        if cmds.objExists("defaultColorMgtGlobals"):
            colorspace_info["color_management_enabled"] = cmds.getAttr("defaultColorMgtGlobals.cmEnabled")
            if colorspace_info["color_management_enabled"]:
                colorspace_info["rendering_space"] = cmds.getAttr("defaultColorMgtGlobals.renderingSpace", asString=True)
                colorspace_info["display_space"] = cmds.getAttr("defaultColorMgtGlobals.displayName", asString=True)
                colorspace_info["view_transform"] = cmds.getAttr("defaultColorMgtGlobals.viewName", asString=True)
        
        # Get viewport color settings
        try:
            # Get active viewport
            active_panel = cmds.getPanel(withFocus=True)
            if cmds.getPanel(typeOf=active_panel) == "modelPanel":
                colorspace_info["viewport_color_mode"] = cmds.modelEditor(active_panel, query=True, colorMap=True)
        except:
            pass
            
        return colorspace_info
        
    except Exception as e:
        print(f"Error getting Maya colorspace: {e}")
        return {"error": str(e)}

def get_maya_camera():
    """
    Get the current viewport camera information
    
    Returns:
        str: Camera name or None if not available
    """
    try:
        # Get active viewport
        active_panel = cmds.getPanel(withFocus=True)
        if cmds.getPanel(typeOf=active_panel) == "modelPanel":
            camera = cmds.modelPanel(active_panel, query=True, camera=True)
            return camera
        return None
    except Exception as e:
        print(f"Error getting Maya camera: {e}")
        return None

def get_render_camera():
    """
    Get the current render camera from render settings
    
    Returns:
        str: Render camera name or None if not available
    """
    try:
        # Get all camera shapes in the scene
        camera_shapes = cmds.ls(type='camera')
        
        render_cameras = []
        for camera_shape in camera_shapes:
            try:
                # Check if camera is renderable
                if cmds.getAttr(f"{camera_shape}.renderable"):
                    # Get the transform node (parent) of the camera shape
                    camera_transform = cmds.listRelatives(camera_shape, parent=True, type='transform')
                    if camera_transform:
                        render_cameras.append(camera_transform[0])
            except:
                # Skip cameras that don't have renderable attribute or other issues
                continue
        
        # Return the first renderable camera found
        if render_cameras:
            print(f"Found renderable cameras: {render_cameras}")
            return render_cameras[0]
        
        # If no renderable cameras found, fall back to persp camera
        if cmds.objExists("persp"):
            print("No renderable cameras found, using persp camera")
            return "persp"
        
        # If persp doesn't exist, try to find any camera
        all_cameras = get_all_cameras()
        if all_cameras:
            print(f"No persp camera found, using first available camera: {all_cameras[0]}")
            return all_cameras[0]
        
        print("No cameras found in scene")
        return None
        
    except Exception as e:
        print(f"Error getting render camera: {e}")
        return None

def get_all_cameras():
    """
    Get all camera transforms in the scene
    
    Returns:
        list: List of camera transform names
    """
    try:
        # Get all camera shapes
        camera_shapes = cmds.ls(type='camera')
        
        # Get their transform nodes
        camera_transforms = []
        for shape in camera_shapes:
            # Get the parent transform
            parent = cmds.listRelatives(shape, parent=True, type='transform')
            if parent:
                camera_transforms.append(parent[0])
        
        # Remove duplicates and sort
        camera_transforms = sorted(list(set(camera_transforms)))
        
        return camera_transforms
    except Exception as e:
        print(f"Error getting all cameras: {e}")
        return []

def get_active_render_layer():
    """
    Get the current active render layer
    
    Returns:
        str: Render layer name
    """
    try:
        # Get current render layer
        current_layer = cmds.editRenderLayerGlobals(query=True, currentRenderLayer=True)
        if current_layer:
            return current_layer
        
        # Fallback to default layer
        return "defaultRenderLayer"
    except Exception as e:
        print(f"Error getting active render layer: {e}")
        return "defaultRenderLayer"

def get_render_resolution():
    """
    Get the current render resolution from render settings
    
    Returns:
        tuple: (width, height) or (1280, 720) as fallback
    """
    try:
        # Get render resolution from defaultResolution node
        width = cmds.getAttr("defaultResolution.width")
        height = cmds.getAttr("defaultResolution.height")
        
        # Validate resolution values
        if width and height and width > 0 and height > 0:
            return int(width), int(height)
        
        # Fallback to HD 720p if no valid resolution found
        return 1280, 720
        
    except Exception as e:
        print(f"Error getting render resolution: {e}")
        # Fallback to HD 720p
        return 1280, 720

def get_playblast_metadata(format_type, start_frame, end_frame, width, height, quality, scene_name, output_path=None, camera=None):
    """
    Collect playblast metadata for storage in pipeline database
    
    Args:
        format_type (str): Output format ('png', 'avi', 'mov')
        start_frame (int): Start frame of the playblast
        end_frame (int): End frame of the playblast
        width (int): Output width
        height (int): Output height
        quality (int): Quality setting
        scene_name (str): Name of the source scene
        output_path (str): Output file path (optional)
        camera (str): Camera used for playblast (optional)
    
    Returns:
        dict: Dictionary containing playblast metadata
    """
    try:
        # Determine if this is a sequence
        is_sequence = format_type.lower() == 'png'
        frame_format = "%04d" if is_sequence else None
        
        # Get current timestamp
        export_date = datetime.datetime.now().isoformat()
        
        # Collect Maya-specific information
        maya_colorspace = get_maya_colorspace()
        viewport_camera = get_maya_camera()
        render_layer = get_active_render_layer()
        
        # Build metadata dictionary
        metadata = {
            "is_sequence": is_sequence,
            "frame_range": [start_frame, end_frame],
            "frame_format": frame_format,
            "format": format_type.lower(),
            "resolution": [width, height],
            "quality": quality,
            "colorspace": maya_colorspace,
            "scene_name": scene_name,
            "export_date": export_date,
            "total_frames": end_frame - start_frame + 1,
            "viewport_camera": viewport_camera,
            "playblast_camera": camera or viewport_camera,
            "render_layer": render_layer
        }
        
        # Add output path if provided
        if output_path:
            metadata["output_path"] = os.path.normpath(output_path).replace("\\", "/")
        
        # Add Maya version info
        try:
            metadata["maya_version"] = cmds.about(version=True)
        except:
            pass
            
        return metadata
        
    except Exception as e:
        print(f"Error collecting playblast metadata: {e}")
        return {"error": str(e)}

def export_playblast(output_path, format_type, start_frame, end_frame, width=1280, height=720, quality=100, show_ornaments=True, camera=None):
    """
    Export playblast using Maya's playblast command with industry standard settings
    
    Args:
        output_path (str): Full path where to save the playblast
        format_type (str): 'png', 'avi', 'mov' 
        start_frame (int): Start frame for playblast
        end_frame (int): End frame for playblast
        width (int): Output width
        height (int): Output height
        quality (int): Quality setting (1-100)
        show_ornaments (bool): Show viewport ornaments
        camera (str): Camera to use for playblast (optional)
    """
    try:
        # Store original camera if we need to switch
        original_camera = None
        if camera:
            print(f"Switching to camera: {camera}")
            cmds.lookThru(camera)
        
        # Prepare playblast parameters based on format
        if format_type.lower() == 'png':
            # PNG image sequence
            format_setting = 'image'
            compression = 'png'
            # For image sequence, Maya expects filename without extension
            output_path_no_ext = os.path.splitext(output_path)[0]
        elif format_type.lower() in ['avi', 'mov']:
            # Video formats
            format_setting = 'qt' if format_type.lower() == 'mov' else 'avi'
            compression = 'H.264' if format_type.lower() == 'mov' else 'none'
            output_path_no_ext = output_path
        else:
            raise ValueError(f"Unsupported format: {format_type}")
        
        # Execute playblast with industry standard settings
        result = cmds.playblast(
            filename=output_path_no_ext,
            format=format_setting,
            compression=compression,
            quality=quality,
            percent=100,  # Full resolution
            widthHeight=[width, height],
            startTime=start_frame,
            endTime=end_frame,
            framePadding=4,  # Industry standard 4-digit padding
            showOrnaments=show_ornaments,
            viewer=False,  # Don't auto-launch viewer
            offScreen=False,  # Use viewport rendering
            forceOverwrite=True
        )
        
        print(f"Playblast exported successfully to: {output_path}")
        return True
        
    except Exception as e:
        print(f"Error exporting playblast: {e}")
        return False
    finally:
        # Restore original camera if we switched
        if camera and original_camera:
            try:
                cmds.lookThru(original_camera)
            except:
                pass  # Don't fail if camera restoration fails

class PlayblastExportDialog(QDialog):
    """
    Dialog for exporting playblasts from Maya with industry standard options
    """
    
    def __init__(self, parent=maya_main_window()):
        super(PlayblastExportDialog, self).__init__(parent)
        
        # Initialize UI
        self.setWindowTitle("Playblast Export")
        self.setMinimumSize(450, 400)
        self.setMaximumSize(600, 500)
        
        # Store scene data
        self.scene_data = None
        self.output_folder = None
        
        self.create_widgets()
        self.create_layout()
        self.create_connections()
        
        # Load scene data and initialize values
        self.load_data()
    
    def create_widgets(self):
        """
        Create all UI widgets
        """
        # Format selection group
        self.format_group = QGroupBox("Output Format")
        self.format_combo = QComboBox()
        self.format_combo.addItems(["PNG (Image Sequence)", "AVI (Video)", "MOV (Video)"])
        self.format_combo.setCurrentText("PNG (Image Sequence)")  # Default to PNG
        self.format_combo.setToolTip("Choose output format: PNG for image sequence, AVI/MOV for video")
        
        # Frame range group
        self.range_group = QGroupBox("Frame Range")
        start_frame, end_frame = get_timeline_range()
        
        self.start_frame_label = QLabel("Start Frame:")
        self.start_frame_spin = QSpinBox()
        self.start_frame_spin.setRange(-999999, 999999)
        self.start_frame_spin.setValue(start_frame)
        
        self.end_frame_label = QLabel("End Frame:")
        self.end_frame_spin = QSpinBox()
        self.end_frame_spin.setRange(-999999, 999999)
        self.end_frame_spin.setValue(end_frame)
        
        self.frame_count_label = QLabel(f"Total Frames: {end_frame - start_frame + 1}")
        
        # Resolution group
        self.resolution_group = QGroupBox("Resolution")
        self.resolution_combo = QComboBox()
        
        # Get current render resolution for dynamic preset
        render_width, render_height = get_render_resolution()
        current_render_preset = f"Current Render ({render_width}x{render_height})"
        
        self.resolution_combo.addItems([
            current_render_preset,
            "HD 720p (1280x720)",
            "HD 1080p (1920x1080)", 
            "HD 540p (960x540)",
            "Custom"
        ])
        self.resolution_combo.setCurrentText(current_render_preset)  # Default to current render resolution
        
        self.width_label = QLabel("Width:")
        self.width_spin = QSpinBox()
        self.width_spin.setRange(64, 7680)
        self.width_spin.setValue(render_width)  # Set to current render width
        
        self.height_label = QLabel("Height:")
        self.height_spin = QSpinBox()
        self.height_spin.setRange(64, 4320)
        self.height_spin.setValue(render_height)  # Set to current render height
        
        # Initially hide custom resolution fields
        self.width_label.setVisible(False)
        self.width_spin.setVisible(False)
        self.height_label.setVisible(False)
        self.height_spin.setVisible(False)
        
        # Quality group
        self.quality_group = QGroupBox("Quality Settings")
        self.quality_label = QLabel("Quality:")
        self.quality_slider = QSlider(Qt.Horizontal)
        self.quality_slider.setRange(1, 100)
        self.quality_slider.setValue(100)  # Industry standard high quality
        self.quality_value_label = QLabel("100")
        
        # Display options
        self.options_group = QGroupBox("Display Options")
        self.show_ornaments_cb = QCheckBox("Show viewport ornaments (HUD, frame counter)")
        self.show_ornaments_cb.setChecked(True)  # Default enabled
        
        # Camera and render layer group
        self.camera_group = QGroupBox("Camera & Render Settings")
        self.camera_label = QLabel("Camera:")
        self.camera_combo = QComboBox()
        self.camera_combo.setToolTip("Select camera for playblast rendering")
        
        self.refresh_camera_button = QPushButton("Refresh")
        self.refresh_camera_button.setMaximumWidth(80)
        self.refresh_camera_button.setToolTip("Refresh camera list")
        
        self.render_layer_label = QLabel("Render Layer:")
        self.render_layer_display = QLineEdit()
        self.render_layer_display.setReadOnly(True)
        self.render_layer_display.setToolTip("Current active render layer (read-only)")
        self.render_layer_display.setStyleSheet("background-color: #f0f0f0; color: #666;")
        
        # Populate camera list and set defaults
        self.refresh_camera_list()
        self.update_render_layer_display()
        
        # Output filename preview
        self.filename_group = QGroupBox("Output Filename")
        scene_name = get_current_scene_name()
        self.filename_preview = QLineEdit()
        self.filename_preview.setReadOnly(True)
        self.update_filename_preview()
        
        # MP4 conversion option
        self.publish_mp4_cb = QCheckBox("Publish mp4 for review")
        self.publish_mp4_cb.setChecked(True)  # Default enabled as requested
        self.publish_mp4_cb.setToolTip("Create an MP4 version optimized for review")
        
        # Scene information
        self.info_label = QLabel("Scene Information:")
        self.scene_info_label = QLabel("Loading scene data...")
        self.scene_info_label.setWordWrap(True)
        
        # Buttons
        self.export_button = QPushButton("Export Playblast")
        self.cancel_button = QPushButton("Cancel")
        
        # Initially disable export button until scene data loads
        self.export_button.setEnabled(False)
    
    def create_layout(self):
        """
        Create and set the layout for the dialog
        """
        main_layout = QVBoxLayout(self)
        
        # Format group layout
        format_layout = QFormLayout(self.format_group)
        format_layout.addRow("Format:", self.format_combo)
        
        # Frame range group layout
        range_layout = QFormLayout(self.range_group)
        range_layout.addRow(self.start_frame_label, self.start_frame_spin)
        range_layout.addRow(self.end_frame_label, self.end_frame_spin)
        range_layout.addRow("", self.frame_count_label)
        
        # Resolution group layout
        resolution_layout = QFormLayout(self.resolution_group)
        resolution_layout.addRow("Preset:", self.resolution_combo)
        
        resolution_custom_layout = QHBoxLayout()
        resolution_custom_layout.addWidget(self.width_label)
        resolution_custom_layout.addWidget(self.width_spin)
        resolution_custom_layout.addWidget(self.height_label)
        resolution_custom_layout.addWidget(self.height_spin)
        resolution_layout.addRow("Custom:", resolution_custom_layout)
        
        # Quality group layout
        quality_layout = QHBoxLayout(self.quality_group)
        quality_layout.addWidget(self.quality_label)
        quality_layout.addWidget(self.quality_slider)
        quality_layout.addWidget(self.quality_value_label)
        
        # Options group layout
        options_layout = QVBoxLayout(self.options_group)
        options_layout.addWidget(self.show_ornaments_cb)
        
        # Camera group layout
        camera_layout = QFormLayout(self.camera_group)
        
        camera_row_layout = QHBoxLayout()
        camera_row_layout.addWidget(self.camera_combo)
        camera_row_layout.addWidget(self.refresh_camera_button)
        camera_layout.addRow(self.camera_label, camera_row_layout)
        
        camera_layout.addRow(self.render_layer_label, self.render_layer_display)
        
        # Filename group layout
        filename_layout = QFormLayout(self.filename_group)
        filename_layout.addRow("Filename:", self.filename_preview)
        
        # MP4 option
        mp4_layout = QVBoxLayout()
        mp4_layout.addWidget(self.publish_mp4_cb)
        
        # Scene info layout
        info_layout = QVBoxLayout()
        info_layout.addWidget(self.info_label)
        info_layout.addWidget(self.scene_info_label)
        
        # Button layout
        button_layout = QHBoxLayout()
        button_layout.addWidget(self.cancel_button)
        button_layout.addWidget(self.export_button)
        
        # Add all layouts to main layout
        main_layout.addWidget(self.format_group)
        main_layout.addWidget(self.range_group)
        main_layout.addWidget(self.resolution_group)
        main_layout.addWidget(self.quality_group)
        main_layout.addWidget(self.options_group)
        main_layout.addWidget(self.camera_group)
        main_layout.addWidget(self.filename_group)
        main_layout.addLayout(mp4_layout)
        main_layout.addLayout(info_layout)
        main_layout.addLayout(button_layout)
    
    def create_connections(self):
        """
        Connect signals to slots
        """
        self.export_button.clicked.connect(self.export_playblast_action)
        self.cancel_button.clicked.connect(self.reject)
        
        # Update UI when settings change
        self.format_combo.currentTextChanged.connect(self.update_filename_preview)
        self.start_frame_spin.valueChanged.connect(self.update_frame_count)
        self.end_frame_spin.valueChanged.connect(self.update_frame_count)
        self.resolution_combo.currentTextChanged.connect(self.update_resolution)
        self.quality_slider.valueChanged.connect(self.update_quality_label)
        
        # Camera refresh button
        self.refresh_camera_button.clicked.connect(self.refresh_camera_list)
    
    def load_data(self):
        """
        Load scene data from pipeline
        """
        self.scene_data = get_scene_data()
        self.update_scene_info()
        
        # Refresh resolution presets to ensure current render resolution is up-to-date
        self.refresh_resolution_presets()
    
    def update_scene_info(self):
        """
        Update the scene information display
        """
        if self.scene_data:
            folder_info = self.scene_data.get('folder', {})
            task_folder = folder_info.get('relTaskFolder', [{}])[0]
            
            info_text = f"File: {self.scene_data.get('fileName', 'Unknown')}\n"
            info_text += f"Task: {task_folder.get('name', 'Unknown')} ({task_folder.get('code', 'Unknown')})\n"
            info_text += f"Folder: {folder_info.get('code', 'Unknown')}"
            
            self.scene_info_label.setText(info_text)
            self.scene_info_label.setStyleSheet("color: green;")
            self.export_button.setEnabled(True)
        else:
            self.scene_info_label.setText("Failed to load scene data. Export may not work correctly.")
            self.scene_info_label.setStyleSheet("color: red;")
    
    def update_filename_preview(self):
        """
        Update filename preview based on current settings
        """
        scene_name = get_current_scene_name()
        format_text = self.format_combo.currentText()
        
        if "PNG" in format_text:
            # Image sequence format
            filename = f"{scene_name}.%04d.png"
        elif "AVI" in format_text:
            filename = f"{scene_name}.avi"
        elif "MOV" in format_text:
            filename = f"{scene_name}.mov"
        else:
            filename = f"{scene_name}.mov"  # Default fallback
            
        self.filename_preview.setText(filename)
    
    def update_frame_count(self):
        """
        Update frame count display when range changes
        """
        start = self.start_frame_spin.value()
        end = self.end_frame_spin.value()
        count = max(0, end - start + 1)
        self.frame_count_label.setText(f"Total Frames: {count}")
    
    def update_resolution(self):
        """
        Update width/height spinboxes when resolution preset changes
        """
        preset = self.resolution_combo.currentText()
        
        # Show/hide custom resolution fields based on selection
        is_custom = preset == "Custom"
        self.width_label.setVisible(is_custom)
        self.width_spin.setVisible(is_custom)
        self.height_label.setVisible(is_custom)
        self.height_spin.setVisible(is_custom)
        
        # Update resolution values for presets
        if "Current Render" in preset:
            # Extract resolution from the preset text or get fresh from Maya
            render_width, render_height = get_render_resolution()
            self.width_spin.setValue(render_width)
            self.height_spin.setValue(render_height)
        elif "720p" in preset:
            self.width_spin.setValue(1280)
            self.height_spin.setValue(720)
        elif "1080p" in preset:
            self.width_spin.setValue(1920)
            self.height_spin.setValue(1080)
        elif "540p" in preset:
            self.width_spin.setValue(960)
            self.height_spin.setValue(540)
        # For "Custom", don't change the values - user can set them manually
    
    def update_quality_label(self):
        """
        Update quality value label when slider changes
        """
        value = self.quality_slider.value()
        self.quality_value_label.setText(str(value))
    
    def refresh_camera_list(self):
        """
        Refresh the camera list and set default to render camera
        """
        # Clear current items
        self.camera_combo.clear()
        
        # Get all cameras in scene
        all_cameras = get_all_cameras()
        
        if not all_cameras:
            self.camera_combo.addItem("No cameras found")
            self.camera_combo.setEnabled(False)
            return
        
        # Enable combo box
        self.camera_combo.setEnabled(True)
        
        # Add cameras to combo box
        for camera in all_cameras:
            self.camera_combo.addItem(camera)
        
        # Set default to render camera
        render_camera = get_render_camera()
        if render_camera and render_camera in all_cameras:
            index = all_cameras.index(render_camera)
            self.camera_combo.setCurrentIndex(index)
        else:
            # Fallback to first camera if render camera not found
            self.camera_combo.setCurrentIndex(0)
    
    def update_render_layer_display(self):
        """
        Update the render layer display
        """
        render_layer = get_active_render_layer()
        self.render_layer_display.setText(render_layer)
    
    def refresh_resolution_presets(self):
        """
        Refresh the resolution presets with current render resolution
        """
        # Store current selection
        current_selection = self.resolution_combo.currentText()
        
        # Get current render resolution
        render_width, render_height = get_render_resolution()
        current_render_preset = f"Current Render ({render_width}x{render_height})"
        
        # Clear and repopulate combo box
        self.resolution_combo.clear()
        self.resolution_combo.addItems([
            current_render_preset,
            "HD 720p (1280x720)",
            "HD 1080p (1920x1080)", 
            "HD 540p (960x540)",
            "Custom"
        ])
        
        # Try to restore previous selection, fallback to current render
        if "Current Render" in current_selection:
            self.resolution_combo.setCurrentText(current_render_preset)
        else:
            # Try to find and restore the previous selection
            index = self.resolution_combo.findText(current_selection)
            if index >= 0:
                self.resolution_combo.setCurrentIndex(index)
            else:
                self.resolution_combo.setCurrentText(current_render_preset)
        
        # Update resolution values
        self.update_resolution()
    
    def show_message(self, title, message, message_type="information"):
        """
        Show a message dialog
        """
        msg_box = QMessageBox(self)
        msg_box.setWindowTitle(title)
        msg_box.setText(message)
        
        if message_type == "warning":
            msg_box.setIcon(QMessageBox.Warning)
        elif message_type == "critical":
            msg_box.setIcon(QMessageBox.Critical)
        else:
            msg_box.setIcon(QMessageBox.Information)
        
        msg_box.exec_()
    
    def export_playblast_action(self):
        """
        Export playblast with current settings
        """
        if not self.scene_data:
            self.show_message("Error", "No scene data available. Cannot export playblast.", "critical")
            return
        
        try:
            # Disable export button during processing
            self.export_button.setEnabled(False)
            self.export_button.setText("Exporting...")
            
            # Create playblast subfolder
            self.output_folder = create_output_folder(self.scene_data["folder"]["key"], folder_name='playblast')
            if not self.output_folder:
                self.show_message("Error", "Failed to create playblast folder in the platform.", "critical")
                return
            
            # Get folder information
            out_folder_path = self.output_folder['folder']['folderLocal']
            folder_key = self.output_folder['folder']['key']
            
            # Create local directory
            os.makedirs(out_folder_path, exist_ok=True)
            
            # Get export parameters
            format_text = self.format_combo.currentText()
            if "PNG" in format_text:
                format_type = "png"
                file_extension = "png"
            elif "AVI" in format_text:
                format_type = "avi" 
                file_extension = "avi"
            else:
                format_type = "mov"
                file_extension = "mov"
            
            start_frame = self.start_frame_spin.value()
            end_frame = self.end_frame_spin.value()
            width = self.width_spin.value()
            height = self.height_spin.value()
            quality = self.quality_slider.value()
            show_ornaments = self.show_ornaments_cb.isChecked()
            
            # Get selected camera
            selected_camera = None
            if self.camera_combo.isEnabled() and self.camera_combo.currentText() != "No cameras found":
                selected_camera = self.camera_combo.currentText()
            
            # Create filename and path
            scene_name = get_current_scene_name()
            if format_type == "png":
                # For PNG sequences, create a subfolder with the same name as the file
                sequence_folder_name = scene_name
                sequence_folder_path = os.path.join(out_folder_path, sequence_folder_name)
                os.makedirs(sequence_folder_path, exist_ok=True)  # Create subfolder
                
                playblast_filename = f"{scene_name}.%04d.{file_extension}"  # For publishing with frame pattern
                playblast_output_path = os.path.join(sequence_folder_path, scene_name)  # Export path (no extension for Maya)
                actual_output_folder = sequence_folder_path  # Track actual output location
                playblast_complete_path = os.path.join(sequence_folder_path, playblast_filename)  # Full path with pattern
            else:
                # For video formats, use main folder
                playblast_filename = f"{scene_name}.{file_extension}"
                playblast_output_path = os.path.join(out_folder_path, playblast_filename)
                actual_output_folder = out_folder_path  # Track actual output location
                playblast_complete_path = playblast_output_path  # Full path is the same as output path for videos
            
            # Export playblast
            if not export_playblast(playblast_output_path, format_type, start_frame, end_frame, 
                                  width, height, quality, show_ornaments, selected_camera):
                self.show_message("Error", f"Failed to export playblast.", "critical")
                return
            
            # Create file entry in database (but don't upload to S3 as requested)
            file_data = create_file(playblast_filename, folder_key)
            if not file_data:
                self.show_message("Warning", "Playblast exported locally but failed to create file entry in pipeline.", "warning")
            else:
                # Mark file as complete with size 0 since we're not uploading content
                file_key = file_data['file']['key']
                mark_result = mark_file_complete(file_key, playblast_complete_path, file_size=0)
                if not mark_result:
                    self.show_message("Warning", "File created but failed to mark as complete in pipeline.", "warning")
                else:
                    # Add playblast metadata to the file in the database
                    try:
                        playblast_metadata = get_playblast_metadata(
                            format_type, start_frame, end_frame, width, height, 
                            quality, scene_name, playblast_output_path, selected_camera
                        )
                        
                        metadata_result = data_write("File", file_key, "playblast", playblast_metadata)
                        if metadata_result:
                            print("Playblast metadata stored successfully in pipeline database")
                        else:
                            print("Warning: Failed to store playblast metadata in pipeline database")
                    except Exception as e:
                        print(f"Error storing playblast metadata: {e}")
                        # Don't fail the entire export if metadata storage fails
            
            # Success message
            success_msg = f"Playblast exported successfully!\n\n"
            success_msg += f"Format: {format_text}\n"
            success_msg += f"Filename: {playblast_filename}\n"
            success_msg += f"Location: {actual_output_folder}\n"
            success_msg += f"Frames: {start_frame}-{end_frame} ({end_frame-start_frame+1} frames)\n"
            success_msg += f"Resolution: {width}x{height}\n"
            success_msg += f"Camera: {selected_camera or 'Current viewport camera'}\n"
            success_msg += f"Render Layer: {get_active_render_layer()}"
            
            # Check if MP4 conversion is requested
            if self.publish_mp4_cb.isChecked():
                success_msg += f"\n\nNote: MP4 conversion for review will be processed separately."
                # Render a mp4 for preview
                query_preview = '''
                mutation{
                  executeLogic(token: "{token}" , logicName:"PlayblastMP4Preview", data: {data}){
                    success
                    message
                  }
                }
                '''
                data = {}
                file_process_data = file_data['file']
                file_process_data['pathToFile'] = playblast_complete_path
                data["file_list"] = [file_process_data]
                query_preview = query_preview.replace("{data}", json.dumps(json.dumps(data)))
                response = pipeline.query(query_preview)
            
            self.show_message("Success", success_msg)
            self.accept()
            
        except Exception as e:
            error_msg = f"An error occurred while exporting playblast: {str(e)}"
            self.show_message("Error", error_msg, "critical")
            print(f"Error exporting playblast: {e}")
            
        finally:
            # Re-enable export button
            self.export_button.setEnabled(True)
            self.export_button.setText("Export Playblast")

def show_playblast_export_dialog():
    """
    Main function to show the playblast export dialog
    
    Returns:
        PlayblastExportDialog: The dialog instance
    """
    dialog = PlayblastExportDialog()
    dialog.show()
    return dialog

# Execute the playblast export dialog
print("=" * 60)
print("MAYA PLAYBLAST EXPORT")
print("=" * 60)
show_playblast_export_dialog()

Import Action

1. Copy Key

Copy

2. Go to your Action pannel

Go