Frame13/ayon-core
1
0
Fork 1
mirror of https://github.com/ynput/ayon-core.git synced 2026-01-01 16:34:53 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

resolve: sequence loading done

Browse source
This commit is contained in:
Jakub Jezek 2021-01-27 20:03:01 +01:00
parent 5174eed16d
commit a64ddded96
No known key found for this signature in database
GPG key ID: C4B96E101D2A47F3
2 changed files with 62 additions and 180 deletions
Download patch file Download diff file Expand all files Collapse all files

151
pype/hosts/resolve/plugin.py
View file

@ -1,5 +1,6 @@
import re import re
from avalon import api from avalon import api
import pype.api as pype
from pype.hosts import resolve from pype.hosts import resolve
from avalon.vendor import qargparse from avalon.vendor import qargparse
from . import lib from . import lib
@ -303,16 +304,6 @@ class SequenceLoader(api.Loader):
], ],
default=0, default=0,
help="Where do you want clips to be loaded?" help="Where do you want clips to be loaded?"
),
qargparse.Choice(
"load_how",
label="How to load clips",
items=[
"original timing",
"sequential in order"
],
default=0,
help="Would you like to place it at orignal timing?"
) )
] ]
@ -358,9 +349,6 @@ class ClipLoader:
# try to get value from options or evaluate key value for `handles` # try to get value from options or evaluate key value for `handles`
self.with_handles = options.get("handles") or bool( self.with_handles = options.get("handles") or bool(
options.get("handles") is True) options.get("handles") is True)
# try to get value from options or evaluate key value for `load_how`
self.sequencial_load = options.get("sequencially") or bool(
"Sequentially in order" in options.get("load_how", ""))
# try to get value from options or evaluate key value for `load_to` # try to get value from options or evaluate key value for `load_to`
self.new_timeline = options.get("newTimeline") or bool( self.new_timeline = options.get("newTimeline") or bool(
"New timeline" in options.get("load_to", "")) "New timeline" in options.get("load_to", ""))
@ -384,12 +372,7 @@ class ClipLoader:
else: else:
self.active_timeline = lib.get_current_sequence() self.active_timeline = lib.get_current_sequence()
if options.get("track"): cls.timeline = self.active_timeline
# if multiselection is set then use options track
self.active_track = options["track"]
else:
self.active_track = lib.get_current_track(
self.active_timeline, self.data["track_name"])
def _populate_data(self): def _populate_data(self):
""" Gets context and convert it to self.data """ Gets context and convert it to self.data
@ -407,7 +390,6 @@ class ClipLoader:
subset = str(repr_cntx["subset"]) subset = str(repr_cntx["subset"])
representation = str(repr_cntx["representation"]) representation = str(repr_cntx["representation"])
self.data["clip_name"] = "_".join([asset, subset, representation]) self.data["clip_name"] = "_".join([asset, subset, representation])
self.data["track_name"] = "_".join([subset, representation])
self.data["versionData"] = self.context["version"]["data"] self.data["versionData"] = self.context["version"]["data"]
# gets file path # gets file path
file = self.fname file = self.fname
@ -418,10 +400,6 @@ class ClipLoader:
return None return None
self.data["path"] = file.replace("\\", "/") self.data["path"] = file.replace("\\", "/")
# convert to hashed path
if repr_cntx.get("frame"):
self._fix_path_hashes()
# solve project bin structure path # solve project bin structure path
hierarchy = str("/".join(( hierarchy = str("/".join((
"Loader", "Loader",
@ -433,16 +411,6 @@ class ClipLoader:
return True return True
def _fix_path_hashes(self):
""" Convert file path where it is needed padding with hashes
"""
file = self.data["path"]
if "#" not in file:
frame = self.context["representation"]["context"].get("frame")
padding = len(frame)
file = file.replace(frame, "#" * padding)
self.data["path"] = file
def _get_asset_data(self): def _get_asset_data(self):
""" Get all available asset data """ Get all available asset data
@ -452,117 +420,40 @@ class ClipLoader:
asset_name = self.context["representation"]["context"]["asset"] asset_name = self.context["representation"]["context"]["asset"]
self.data["assetData"] = pype.get_asset(asset_name)["data"] self.data["assetData"] = pype.get_asset(asset_name)["data"]
def _make_track_item(self, source_bin_item, audio=False):
""" Create track item with """
clip = source_bin_item.activeItem()
# add to track as clip item
if not audio:
track_item = hiero.core.TrackItem(
self.data["clip_name"], hiero.core.TrackItem.kVideo)
else:
track_item = hiero.core.TrackItem(
self.data["clip_name"], hiero.core.TrackItem.kAudio)
track_item.setSource(clip)
track_item.setSourceIn(self.handle_start)
track_item.setTimelineIn(self.timeline_in)
track_item.setSourceOut(self.media_duration - self.handle_end)
track_item.setTimelineOut(self.timeline_out)
track_item.setPlaybackSpeed(1)
self.active_track.addTrackItem(track_item)
return track_item
def load(self): def load(self):
# create project bin for the media to be imported into # create project bin for the media to be imported into
self.active_bin = lib.create_bin(self.data["binPath"]) self.active_bin = lib.create_bin(self.data["binPath"])
# create mediaItem in active project bin # create mediaItem in active project bin
# create clip media # create clip media
self.media = hiero.core.MediaSource(self.data["path"]) media_pool_item = lib.create_media_pool_item(
self.media_duration = int(self.media.duration()) self.data["path"], self.active_bin)
clip_property = media_pool_item.GetClipProperty()
source_in = int(clip_property["Start"])
source_out = int(clip_property["End"])
# get handles # get handles
self.handle_start = self.data["versionData"].get("handleStart") handle_start = self.data["versionData"].get("handleStart")
self.handle_end = self.data["versionData"].get("handleEnd") handle_end = self.data["versionData"].get("handleEnd")
if self.handle_start is None: if handle_start is None:
self.handle_start = int(self.data["assetData"]["handleStart"]) handle_start = int(self.data["assetData"]["handleStart"])
if self.handle_end is None: if handle_end is None:
self.handle_end = int(self.data["assetData"]["handleEnd"]) handle_end = int(self.data["assetData"]["handleEnd"])
if self.sequencial_load:
last_track_item = lib.get_current_track_items(
track_name=self.active_track.name())
if len(last_track_item) == 0:
last_timeline_out = 0
else:
last_track_item = last_track_item[-1]
last_timeline_out = int(last_track_item.timelineOut()) + 1
self.timeline_in = last_timeline_out
self.timeline_out = last_timeline_out + int(
self.data["assetData"]["clipOut"]
- self.data["assetData"]["clipIn"])
else:
self.timeline_in = int(self.data["assetData"]["clipIn"])
self.timeline_out = int(self.data["assetData"]["clipOut"])
# check if slate is included
# either in version data families or by calculating frame diff
slate_on = next(
# check iterate if slate is in families
(f for f in self.context["version"]["data"]["families"]
if "slate" in f),
# if nothing was found then use default None
# so other bool could be used
None) or bool(((
# put together duration of clip attributes
self.timeline_out - self.timeline_in + 1) \
+ self.handle_start \
+ self.handle_end
# and compare it with meda duration
) > self.media_duration)
print("__ slate_on: `{}`".format(slate_on))
# if slate is on then remove the slate frame from begining
if slate_on:
self.media_duration -= 1
self.handle_start += 1
# create Clip from Media
clip = hiero.core.Clip(self.media)
clip.setName(self.data["clip_name"])
# add Clip to bin if not there yet
if self.data["clip_name"] not in [
b.name() for b in self.active_bin.items()]:
bin_item = hiero.core.BinItem(clip)
self.active_bin.addItem(bin_item)
# just make sure the clip is created
# there were some cases were hiero was not creating it
source_bin_item = None
for item in self.active_bin.items():
if self.data["clip_name"] in item.name():
source_bin_item = item
if not source_bin_item:
print("Problem with created Source clip: `{}`".format(
self.data["clip_name"]))
# include handles # include handles
if self.with_handles: if self.with_handles:
self.timeline_in -= self.handle_start source_in -= handle_start
self.timeline_out += self.handle_end source_out += handle_end
self.handle_start = 0 handle_start = 0
self.handle_end = 0 handle_end = 0
# make track item from source in bin as item # make track item from source in bin as item
track_item = self._make_track_item(source_bin_item) timeline_item = lib.create_timeline_item(
media_pool_item, self.active_timeline, source_in, source_out)
print("Loading clips: `{}`".format(self.data["clip_name"])) print("Loading clips: `{}`".format(self.data["clip_name"]))
return track_item return timeline_item
class Creator(api.Creator): class Creator(api.Creator):

91
pype/plugins/resolve/load/load_sequence.py
View file

@ -19,24 +19,23 @@ class LoadClip(resolve.SequenceLoader):
# for loader multiselection # for loader multiselection
timeline = None timeline = None
track = None
# presets # presets
clip_color_last = "green" clip_color_last = "Olive"
clip_color = "red" clip_color = "Orange"
def load(self, context, name, namespace, options): def load(self, context, name, namespace, options):
# in case loader uses multiselection # in case loader uses multiselection
if self.track and self.timeline: if self.timeline:
options.update({ options.update({
"timeline": self.timeline, "timeline": self.timeline,
"track": self.track
}) })
# load clip to timeline and get main variables # load clip to timeline and get main variables
track_item = phiero.ClipLoader(self, context, **options).load() timeline_item = resolve.plugin.ClipLoader(
namespace = namespace or track_item.name() self, context, **options).load()
namespace = namespace or timeline_item.GetName()
version = context['version'] version = context['version']
version_data = version.get("data", {}) version_data = version.get("data", {})
version_name = version.get("name", None) version_name = version.get("name", None)
@ -64,15 +63,12 @@ class LoadClip(resolve.SequenceLoader):
}) })
# update color of clip regarding the version order # update color of clip regarding the version order
self.set_item_color(track_item, version) self.set_item_color(timeline_item, version)
# deal with multiselection
self.multiselection(track_item)
self.log.info("Loader done: `{}`".format(name)) self.log.info("Loader done: `{}`".format(name))
return resolve.containerise( return resolve.containerise(
track_item, timeline_item,
name, namespace, context, name, namespace, context,
self.__class__.__name__, self.__class__.__name__,
data_imprint) data_imprint)
@ -87,7 +83,7 @@ class LoadClip(resolve.SequenceLoader):
# load clip to timeline and get main variables # load clip to timeline and get main variables
name = container['name'] name = container['name']
namespace = container['namespace'] namespace = container['namespace']
track_item = resolve.get_track_item_by_name(namespace) timeline_item = resolve.lib.get_pype_track_item_by_name(namespace)
version = io.find_one({ version = io.find_one({
"type": "version", "type": "version",
"_id": representation["parent"] "_id": representation["parent"]
@ -98,43 +94,38 @@ class LoadClip(resolve.SequenceLoader):
object_name = "{}_{}".format(name, namespace) object_name = "{}_{}".format(name, namespace)
file = api.get_representation_path(representation).replace("\\", "/") file = api.get_representation_path(representation).replace("\\", "/")
# reconnect media to new path # TODO: implement update
track_item.source().reconnectMedia(file) # # reconnect media to new path
# track_item.source().reconnectMedia(file)
# add additional metadata from the version to imprint Avalon knob #
add_keys = [ # # add additional metadata from the version to imprint Avalon knob
"frameStart", "frameEnd", "source", "author", # add_keys = [
"fps", "handleStart", "handleEnd" # "frameStart", "frameEnd", "source", "author",
] # "fps", "handleStart", "handleEnd"
# ]
# move all version data keys to tag data #
data_imprint = {} # # move all version data keys to tag data
for key in add_keys: # data_imprint = {}
data_imprint.update({ # for key in add_keys:
key: version_data.get(key, str(None)) # data_imprint.update({
}) # key: version_data.get(key, str(None))
# })
# add variables related to version context #
data_imprint.update({ # # add variables related to version context
"representation": str(representation["_id"]), # data_imprint.update({
"version": version_name, # "representation": str(representation["_id"]),
"colorspace": colorspace, # "version": version_name,
"objectName": object_name # "colorspace": colorspace,
}) # "objectName": object_name
# })
# update color of clip regarding the version order #
self.set_item_color(track_item, version) # # update color of clip regarding the version order
# self.set_item_color(timeline_item, version)
return resolve.update_container(track_item, data_imprint) #
# return resolve.set_track_item_pype_tag(timeline_item, data_imprint)
@classmethod @classmethod
def multiselection(cls, track_item): def set_item_color(cls, timeline_item, version):
if not cls.track:
cls.track = track_item.parent()
cls.sequence = cls.track.parent()
@classmethod
def set_item_color(cls, track_item, version):
# define version name # define version name
version_name = version.get("name", None) version_name = version.get("name", None)
@ -148,6 +139,6 @@ class LoadClip(resolve.SequenceLoader):
# set clip colour # set clip colour
if version_name == max_version: if version_name == max_version:
track_item.source().binItem().setColor(cls.clip_color_last) timeline_item.SetClipColor(cls.clip_color_last)
else: else:
track_item.source().binItem().setColor(cls.clip_color) timeline_item.SetClipColor(cls.clip_color)