Skip to content

extract_playblast

ExtractPlayblast

Bases: MayaExtractorPlugin

Extract viewport playblast.

Takes review camera and creates review Quicktime video based on viewport capture.

Source code in client/ayon_maya/plugins/publish/extract_playblast.py 
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
class ExtractPlayblast(plugin.MayaExtractorPlugin):
    """Extract viewport playblast.

    Takes review camera and creates review Quicktime video based on viewport
    capture.

    """

    label = "Extract Playblast"
    families = ["review"]
    optional = True
    capture_preset = {}
    profiles = None

    def process(self, instance):
        self.log.debug("Extracting playblast..")

        # get scene fps
        fps = instance.data.get("fps") or instance.context.data.get("fps")

        # if start and end frames cannot be determined, get them
        # from Maya timeline
        start = instance.data.get("frameStartFtrack")
        end = instance.data.get("frameEndFtrack")
        if start is None:
            start = cmds.playbackOptions(query=True, animationStartTime=True)
        if end is None:
            end = cmds.playbackOptions(query=True, animationEndTime=True)

        self.log.debug("start: {}, end: {}".format(start, end))
        task_data = instance.data["anatomyData"].get("task", {})
        capture_preset = lib.get_capture_preset(
            task_data.get("name"),
            task_data.get("type"),
            instance.data["productName"],
            instance.context.data["project_settings"],
            self.log
        )
        stagingdir = self.staging_dir(instance)
        filename = instance.name
        path = os.path.join(stagingdir, filename)
        self.log.debug("Outputting images to %s" % path)
        # get cameras
        camera = instance.data["review_camera"]
        preset = lib.generate_capture_preset(
            instance, camera, path,
            start=start, end=end,
            capture_preset=capture_preset)
        lib.render_capture_preset(preset)

        # Find playblast sequence
        collected_files = os.listdir(stagingdir)
        patterns = [clique.PATTERNS["frames"]]
        collections, remainder = clique.assemble(collected_files,
                                                 minimum_items=1,
                                                 patterns=patterns)

        self.log.debug("Searching playblast collection for: %s", path)
        frame_collection = None
        for collection in collections:
            filebase = collection.format("{head}").rstrip(".")
            self.log.debug("Checking collection head: %s", filebase)
            if filebase in path:
                frame_collection = collection
                self.log.debug(
                    "Found playblast collection: %s", frame_collection
                )

        tags = ["review"]
        if not instance.data.get("keepImages"):
            tags.append("delete")

        # Add camera node name to representation data
        camera_node_name = cmds.listRelatives(camera, parent=True)[0]

        collected_files = list(frame_collection)
        # single frame file shouldn't be in list, only as a string
        if len(collected_files) == 1:
            collected_files = collected_files[0]

        if "representations" not in instance.data:
            instance.data["representations"] = []

        representation = {
            "name": capture_preset["Codec"]["compression"],
            "ext": capture_preset["Codec"]["compression"],
            "files": collected_files,
            "stagingDir": stagingdir,
            "frameStart": int(start),
            "frameEnd": int(end),
            "fps": fps,
            "tags": tags,
            "camera_name": camera_node_name
        }
        instance.data["representations"].append(representation)