def create_mlt_producer(self, profile):
width = profile.width()
height = profile.height()
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
cr = cairo.Context(surface)
cr.set_source_rgb(
*utils.gdk_color_str_to_cairo_rgb(self.gdk_color_str))
cr.rectangle(0, 0, width + 1, height + 1)
cr.fill()
file_name = md5.new(self.gdk_color_str + str(width) +
str(height)).hexdigest()
write_file_path = utils.get_hidden_user_dir_path(
) + appconsts.RENDERED_CLIPS_DIR + "/" + file_name + ".png"
surface.write_to_png(write_file_path)
producer = mlt.Producer(profile, write_file_path)
mltrefhold.hold_ref(producer)
return producer
def create_mlt_producer(self, profile):
width = profile.width()
height = profile.height()
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
cr = cairo.Context(surface)
cr.set_source_rgb(
*utils.gdk_color_str_to_cairo_rgb(self.gdk_color_str))
cr.rectangle(0, 0, width + 1, height + 1)
cr.fill()
file_name = hashlib.md5((self.gdk_color_str + str(width) +
str(height)).encode('utf-8')).hexdigest()
write_file_path = userfolders.get_render_dir(
) + "/" + file_name + ".png"
surface.write_to_png(write_file_path)
producer = mlt.Producer(profile, write_file_path)
mltrefhold.hold_ref(producer)
return producer
def create_slowmotion_producer(self, path, speed):
"""
Creates MLT Producer and adds attributes to it, but does
not add it to track/playlist object.
"""
fr_path = "framebuffer:" + path + "?" + str(speed)
producer = mlt.Producer(self.profile, None, str(fr_path)) # this runs 0.5s+ on some clips
mltrefhold.hold_ref(producer)
(folder, file_name) = os.path.split(path)
(name, ext) = os.path.splitext(file_name)
producer.name = name
producer.path = path
producer.speed = speed
producer.media_type = get_media_type(path)
if producer.media_type == FILE_DOES_NOT_EXIST:
return None
self.add_clip_attr(producer)
return producer
def run(self):
"""
Writes thumbnail image from file producer
"""
# Create consumer
matchframe_path = utils.get_hidden_user_dir_path(
) + appconsts.TRIM_VIEW_DIR + "/" + self.frame_name
consumer = mlt.Consumer(PROJECT().profile, "avformat", matchframe_path)
consumer.set("real_time", 0)
consumer.set("vcodec", "png")
# Create one frame producer
producer = mlt.Producer(PROJECT().profile, str(self.clip_path))
producer.set("mlt_service", "avformat-novalidate")
producer = producer.cut(int(self.clip_frame), int(self.clip_frame))
# Delete match frame
try:
os.remove(matchframe_path)
except:
# This fails when done first time ever
pass
# Save producer and consumer for view needing continues match frame update
global _producer, _consumer
if _widget.view != START_TRIM_VIEW and _widget.view != END_TRIM_VIEW:
_producer = producer
_consumer = consumer
# Connect and write image
consumer.connect(producer)
consumer.run()
# Wait until new file exists
while os.path.isfile(matchframe_path) != True:
time.sleep(0.1)
# Do completion callback
self.completion_callback(self.frame_name)
def create_file_producer_clip(self,
path,
new_clip_name=None,
novalidate=False,
ttl=None):
"""
Creates MLT Producer and adds attributes to it, but does
not add it to track/playlist object.
"""
#producer = mlt.Producer(self.profile, "avformat-novalidate", str(path)) # this runs 0.5s+ on some clips
#t = time.monotonic()
producer = mlt.Producer(self.profile,
str(path)) # this runs 0.5s+ on some clips
#print(time.monotonic() - t)
#if novalidate == True:
# producer.set("mlt_service", "avformat-novalidate")
mltrefhold.hold_ref(producer)
producer.path = path
producer.filters = []
(dir, file_name) = os.path.split(path)
(name, ext) = os.path.splitext(file_name)
producer.name = name
if new_clip_name != None:
producer.name = new_clip_name
producer.media_type = get_media_type(path)
if producer.media_type == FILE_DOES_NOT_EXIST:
print("file does not exist")
return None
self.add_clip_attr(producer)
# Img seq ttl value
producer.ttl = ttl
if ttl != None:
producer.set("ttl", int(ttl))
return producer
def create_file_producer_clip(self, path, new_clip_name=None):
"""
Creates MLT Producer and adds attributes to it, but does
not add it to track/playlist object.
"""
producer = mlt.Producer(self.profile, str(path)) # this runs 0.5s+ on some clips
mltrefhold.hold_ref(producer)
producer.path = path
producer.filters = []
(dir, file_name) = os.path.split(path)
(name, ext) = os.path.splitext(file_name)
producer.name = name
if new_clip_name != None:
producer.name = new_clip_name
producer.media_type = get_media_type(path)
if producer.media_type == FILE_DOES_NOT_EXIST:
print "file does not exist"
return None
self.add_clip_attr(producer)
return producer
def play_program(self, program=None, resume_offset=0):
self.still = None
producer = None
if program is not None:
#self.player.video_set_logo_int(vlc.VideoLogoOption.delay, 0)
#self.player.video_set_logo_string(vlc.VideoLogoOption.file, "stills/screenbug.png")
self.state = "video"
# TODO: Fallback if the folder is empty
media_path = program.get_filename()
if os.path.exists(media_path):
producer = mlt.Producer(self.profile, media_path)
producer.set("force_aspect_ratio", 1.0)
#producer.set("video_delay", "2.5")
if program.loop:
producer.set("eof", "loop")
watermarked = self._mlt_watermark(producer)
self.mlt_consumer.connect(watermarked)
#self.playing_producer = producer
# Kill overlays
#if self.overlay_call:
# self.overlay_call.cancel()
# self.overlay_call = None
else:
logging.error("Didn't find file. Playback never started: %s" %
media_path)
else:
# Reset & show overlays
#self._swap_overlay()
#if not self.playing_consumer:
watermarked = self._mlt_watermark(self.loop)
self.mlt_consumer.connect(watermarked)
# Handle playback and resume offset
offset = resume_offset
if program and program.playback_offset:
offset += program.playback_offset
if producer and offset:
producer.seek(int(offset * 25))
def create_overlay_screen():
global profile
scene = mlt.Producer(profile, "colour:#E53B07")
f = mlt.Filter(profile, "affine")
f.set('transition.distort', 1)
f.set('transitioLD_PRELOAD=n.fill', 1)
f.set('transition.scale_y', 1)
if profile.width() == 1920:
f.set('transition.fix_rotate_x', 0)
f.set('transition.fix_shear_y', 45)
f.set(
'transition.geometry',
"0=-50%/0%:120%x100%;5=-10%/0:120%x100%;25=-10%/0:120%x100%;30=150%/0%:120%x100%;"
)
else:
f.set('transition.fix_rotate_x', 40)
f.set('transition.fix_shear_y', 60)
f.set(
'transition.geometry',
"0=-0/-150%:160%x200%;5=0/-70%:160%x200%;25=0/-70%:160%x200%;35=50%/150%:150%x200%;"
)
scene.attach(f)
scene.set('out', 30)
return scene
def _create_noise_producer(profile):
producer = mlt.Producer(profile, "frei0r.nois0r")
mltrefhold.hold_ref(producer)
return producer
def _render_reverse_clip_dialog_callback(dialog, response_id, fb_widgets,
media_file):
if response_id == Gtk.ResponseType.ACCEPT:
print("_render_reverse_clip_dialog_callback")
# speed, filename folder
speed = float(int(fb_widgets.hslider.get_value())) / 100.0
file_name = fb_widgets.file_name.get_text()
filenames = fb_widgets.out_folder.get_filenames()
folder = filenames[0]
write_file = folder + "/" + file_name + fb_widgets.extension_label.get_text(
)
if os.path.exists(write_file):
primary_txt = _("A File with given path exists!")
secondary_txt = _(
"It is not allowed to render Motion Files with same paths as existing files.\nSelect another name for file."
)
dialogutils.warning_message(primary_txt, secondary_txt, dialog)
return
# Profile
profile_desc = fb_widgets.categories_combo.get_selected()
profile = mltprofiles.get_profile(profile_desc)
profile_desc = profile_desc.replace(" ", "_")
# Render consumer properties
encoding_option_index = fb_widgets.encodings_cb.get_active()
quality_option_index = fb_widgets.quality_cb.get_active()
# Range
range_selection = fb_widgets.render_range.get_active()
dialog.destroy()
# Create motion producer
source_path = media_file.path
if media_file.is_proxy_file == True:
source_path = media_file.second_file_path
motion_producer = mlt.Producer(
profile, None,
str("timewarp:" + str(speed) + ":" + str(source_path)))
# start and end frames
start_frame = 0
end_frame = motion_producer.get_length() - 1
render_full_range = True
if range_selection == 1:
start_frame = int(
float(media_file.length - media_file.mark_out - 1) *
(1.0 / -speed))
end_frame = int(
float(media_file.length - media_file.mark_out +
(media_file.mark_out - media_file.mark_in) + 1) *
(1.0 / -speed)) + int(1.0 / -speed)
if end_frame > motion_producer.get_length() - 1:
end_frame = motion_producer.get_length() - 1
if start_frame < 0:
start_frame = 0
render_full_range = False # consumer wont stop automatically and needs to stopped explicitly
session_id = hashlib.md5(str(
os.urandom(32)).encode('utf-8')).hexdigest()
args = ("session_id:" + str(session_id), "speed:" + str(speed),
"write_file:" + str(write_file),
"profile_desc:" + str(profile_desc),
"encoding_option_index:" + str(encoding_option_index),
"quality_option_index:" + str(quality_option_index),
"source_path:" + str(source_path), "render_full_range:" +
str(render_full_range), "start_frame:" + str(start_frame),
"end_frame:" + str(end_frame))
job_queue_object = jobs.MotionRenderJobQueueObject(
session_id, write_file, args)
job_queue_object.add_to_queue()
else:
dialog.destroy()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import mlt
import sys
from PIL import Image
# setup
mlt.Factory.init()
profile = mlt.Profile('square_pal_wide')
prod = mlt.Producer(profile, sys.argv[1])
# This builds a profile from the attributes of the producer: auto-profile.
profile.from_producer(prod)
# Ensure the image is square pixels - optional.
profile.set_width(int(profile.width() * profile.sar()))
profile.set_sample_aspect(1, 0)
# Seek to 10% and get a Mlt frame.
prod.seek(int(prod.get_length() * 0.1))
frame = prod.get_frame()
# And make sure we deinterlace if input is interlaced - optional.
frame.set("consumer_deinterlace", 1)
# Now we are ready to get the image and save it.
size = (profile.width(), profile.height())
rgb = frame.get_image(mlt.mlt_image_rgb24, *size)
img = Image.fromstring('RGB', size, rgb)
img.save(sys.argv[1] + '.png')
def get_thumb_at_frame(self,
filename,
frame=1,
new_name="",
full_size=True):
""" if new_name = None, it will default to 'name_fileext + "_%d.ext' in the thumbnail folder.
if full_size is True, a full size frame will be extracted (based on the project profile).
Else: quarter_ntsc"""
self.file_name = filename
project_path = self.project.folder
myPath = self.file_name
(dirName, fileName) = os.path.split(myPath)
(fileBaseName, fileExtension) = os.path.splitext(fileName)
fileExtension = fileExtension.replace(".", "")
# Init mlt factory
mlt.Factory.init()
# set the profile
if full_size:
self.profile = profiles.mlt_profiles(self.project).get_profile(
self.project.project_type)
else:
self.profile = mlt.Profile("quarter_ntsc")
# Create the producer
self.p = mlt.Producer(self.profile, '%s' % self.file_name)
# Check if clip is valid (otherwise a seg fault)
if self.p.is_valid() == False:
return None
if new_name == "":
# just get 1 thumbnail frame
self.thumbnail_path = project_path + "/thumbnail/" + fileBaseName + "_" + fileExtension + "_%d.png"
else:
#for snapshots, use the new file name
#don't use the thumbnail path for the new file
self.thumbnail_path = project_path + "/" + new_name
# create the consumer
self.c = mlt.Consumer(self.profile, "avformat", self.thumbnail_path)
# set some consumer properties
self.c.set("real_time", 0)
self.c.set("vcodec", "png")
#get the frame
self.p = self.p.cut(frame, frame)
# Check if clip is valid (otherwise a seg fault)
if self.p.is_valid() == False:
return None
# connect the producer and consumer
self.c.connect(self.p)
# Only start if the media item has a thumbnail location (i.e. no audio thumbnails)
if self.thumbnail_path:
self.c.run()
def GetFile(self,
file_location,
only_thumbnail=True,
new_file_base_name=None,
start_time=0.00,
end_time=None):
""" Use this method to generate an LibreShotFile object based on the URL (or file location)
of a video or audio file. Each time you call this method, it will lock this thread (and LibreShot's
main thread) until it has finished. """
"""
file_location: The location of the file on the hard drive, including the name and extension.
only_thumbnail: True if only a thumbnail should be grabbed from the file, False if image sequence.
new_file_base_name: The name of the folder and the base for the image sequence name, not including the path.
start_time: The time to start grabbing frames from the file, in seconds.
end_time: The time to end grabbing frames from the file, in seconds. None = To the last frame.
"""
try:
# determine name and location of thumbnail image
self.file_name = file_location
self.thumbnail_path = ""
self.file_type = "video"
self.label = ""
self.unique_id = str(uuid.uuid1())
project_path = self.project.folder
(dirName, fileName) = os.path.split(file_location)
(fileBaseName, fileExtension) = os.path.splitext(fileName)
fileExtension = fileExtension.replace(".", "")
uniqueFileBaseName = self.unique_id
actual_thumbnail_path = project_path + "/thumbnail/" + uniqueFileBaseName + "_" + fileExtension + "_1.png"
if only_thumbnail:
# just get 1 thumbnail frame
self.thumbnail_path = project_path + "/thumbnail/" + uniqueFileBaseName + "_" + fileExtension + "_%d.png"
# set the profile
self.profile = mlt.Profile("quarter_ntsc")
else:
if new_file_base_name == None or new_file_base_name == fileBaseName:
# choose the same folder as the name (without extension) as default
self.thumbnail_path = os.path.join(
dirName, fileBaseName, fileBaseName + "_%d.png")
else:
# export a part of the video to a folder under the folder with the same name as the file.
self.thumbnail_path = os.path.join(
dirName, fileBaseName, new_file_base_name,
new_file_base_name + "_%d.png")
# re-init the mlt factory
mlt.Factory.init()
# Create the producer
self.p = mlt.Producer(self.profile, '%s' % file_location)
# Check if clip is valid (otherwise a seg fault)
if self.p.is_valid() == False:
return None
# Check for invalid files - badly generated video files can have
# a length of 0 or -1, e.g.
# https://bugs.launchpad.net/ubuntu/+source/libreshot/+bug/927755, https://bugs.launchpad.net/kazam/+bug/925238
if self.p.get_length() < 1 or self.p.get_length() == 0x7fffffff:
return None
# check the 'seekable' property
# If it is zero, then MLT is likely to have problems with this file.
if self.p.get("seekable") == '0':
messagebox.show(
_("Warning!"),
_("The file %s has properties that may prevent it working properly in LibreShot.\nYou may need to transcode it to another format."
) % (self.file_name))
# create the consumer
self.c = mlt.Consumer(self.profile, "avformat",
self.thumbnail_path)
# set some consumer properties
self.c.set("real_time", 0)
self.c.set("vcodec", "png")
# determine length of clip in seconds
producer_fps = float(self.p.get_fps())
first_frame = int(round(producer_fps * start_time))
# Whole clip if end_time = None
if end_time == None:
last_frame = self.p.get_length()
else:
last_frame = int(round(producer_fps * end_time))
max_frames = last_frame - first_frame
# determine dimensions
height = 0
width = 0
if self.p.get("height"):
height = int(self.p.get("height"))
if self.p.get("width"):
width = int(self.p.get("width"))
audio_index = self.p.get_int("audio_index")
video_index = self.p.get_int("video_index")
audio_property = "meta.media.%s.codec.long_name" % audio_index
if self.p.get(audio_property):
self.audio_codec = self.p.get(audio_property)
else:
self.audio_codec = ""
video_property = "meta.media.%s.codec.long_name" % video_index
if self.p.get(video_property):
self.video_codec = self.p.get(video_property)
else:
self.video_codec = ""
if self.p.get_frame():
frame = self.p.get_frame()
self.audio_frequency = frame.get_int("frequency")
self.audio_channels = frame.get_int("channels")
# determine if this is an image
is_image = False
if self.p.get_length(
) == 15000 and video_index == 0 and audio_index == 0:
# images always have exactly 15000 frames
is_image = True
self.file_type = "image"
# set the max length of the image to 300 seconds (i.e. 5 minutes)
max_frames = producer_fps * 300
# get actual height & width of image (since MLT defaults to 1 x 1)
width, height = self.get_image_size(file_location)
# determine length
if only_thumbnail:
calculate_length = self.p.get_length() / producer_fps
else:
calculate_length = max_frames / producer_fps
if is_image:
# set the length to 300 seconds (i.e. 5 minutes)
calculate_length = float(300)
# set thumbnail image (if no height & width are detected)
if (height == False or width == False) and (is_image == False):
self.thumbnail_path = ""
self.file_type = "audio"
# get the 1st frame (if not exporting all frames)
if only_thumbnail:
max_frames = float(self.p.get_length()) - 1.0
self.p = self.p.cut(1, 1)
# get the frames in an interval
else:
self.p = self.p.cut(first_frame, last_frame)
# mark as image seq
self.label = "Image Sequence"
self.file_type = "image sequence"
# Check if clip is valid (otherwise a seg fault)
if self.p.is_valid() == False:
return None
# connect the producer and consumer
self.c.connect(self.p)
# Start the consumer, and lock the thread until it's done (to prevent crazy seg fault errors)
# Only start if the media item has a thumbnail location (i.e. no audio thumbnails)
if self.thumbnail_path:
self.c.run()
# create an libreshot file object
newFile = files.LibreShotFile(self.project)
# thumbnails and image sequences are stored at different locations
if only_thumbnail:
newFile.name = file_location
else:
newFile.name = self.thumbnail_path
newFile.length = calculate_length
newFile.thumb_location = actual_thumbnail_path
newFile.videorate = (self.p.get_fps(), 0)
newFile.height = height
newFile.width = width
newFile.max_frames = max_frames
newFile.fps = producer_fps
newFile.file_type = self.file_type
newFile.label = self.label
newFile.audio_channels = self.audio_channels
newFile.audio_codec = self.audio_codec
newFile.audio_frequency = self.audio_frequency
newFile.video_codec = self.video_codec
# return the LibreShotFile object
return newFile
except Exception:
print "Failed to import file: %s" % file_location
def run(self):
self.start_time = time.monotonic()
args_vals_list = toolsencoding.get_args_vals_list_for_render_data(
self.render_data)
profile = mltprofiles.get_profile_for_index(
self.render_data.profile_index)
producer = mlt.Producer(profile, str(self.xml_file_path))
# Video clip consumer
if self.render_data.do_video_render == True:
if self.render_data.save_internally == True:
file_path = ccrutils.session_folder(
) + "/" + appconsts.CONTAINER_CLIP_VIDEO_CLIP_NAME + self.render_data.file_extension
else:
file_path = self.render_data.render_dir + "/" + self.render_data.file_name + self.render_data.file_extension
consumer = renderconsumer.get_mlt_render_consumer(
file_path, profile, args_vals_list)
ccrutils.delete_rendered_frames(
) # in case we switched from img seq consumer we can now delete those frames to save space
# img seq consumer
else:
# Image sequence gets project profile
project_profile = mltprofiles.get_profile(self.profile_desc)
if self.render_data.save_internally == True:
frame_name = "frame"
else:
frame_name = self.render_data.frame_name
render_path = ccrutils.rendered_frames_folder(
) + frame_name + "_%04d." + "png"
consumer = mlt.Consumer(project_profile, "avformat",
str(render_path))
consumer.set("real_time", -1)
consumer.set("rescale", "bicubic")
consumer.set("vcodec", "png")
self.render_player = renderconsumer.FileRenderPlayer(
"", producer, consumer, self.range_in, self.range_out)
self.render_player.wait_for_producer_end_stop = False
self.render_player.start()
while self.render_player.stopped == False:
self.abort_requested()
if self.abort == True:
self.render_player.shutdown()
return
fraction = self.render_player.get_render_fraction()
self.render_update_callback(fraction)
time.sleep(0.3)
# Write out completed flag file.
ccrutils.write_completed_message()
def run(self):
# FIXME: Is this relevant - doesn't seem to be used in this method?
self.override_path = None
self.alternate_progress_bar = None
# track wheather the thread is playing or not
self.isPlaying = False
# track if this thread should die
self.amAlive = True
# Start the mlt system
self.f = mlt.Factory().init()
# set the MLT profile object... specific in the project properties
self.profile = profiles.mlt_profiles(self.project).get_profile(
self.project.project_type)
# Create the producer
self.p = mlt.Producer(self.profile, 'xml:%s' % self.file_name)
if self.p.is_valid():
# set speed to zero (i.e. pause)
self.pause()
# PREVIEW mode
self.c = mlt.Consumer(
self.profile,
str(self.main_form.settings.general["output_mode"]))
self.c.set("real_time", 1)
# Connect the producer to the consumer
self.c.connect(self.p)
# Start the consumer
self.c.start()
# Get the FPS
self.fps = self.project.fps()
# init the render percentage
self.fraction_complete = 0.0
# Wait until the user stops the consumer
while self.amAlive:
# get current frame
current_frame = float(self.p.position())
total_frames = float(self.p.get_length() - 1)
decimal_complete = current_frame / total_frames
percentage_complete = decimal_complete * 100.0
# only calculate position / percentage when playing
if self.c.is_stopped() == False:
# move play head
new_time = current_frame / float(self.fps)
if self.mode == "render":
# update Export Dialog Progress Bar
self.fraction_complete = decimal_complete
if self.project.form.frmExportVideo:
gobject.idle_add(
self.project.form.frmExportVideo.
update_progress, self.fraction_complete)
elif self.mode == "preview":
if self.alternate_progress_bar:
# update alternateive progress bar (if any) of video
# this is used by the clip properties window
if self.alternate_progress_bar:
gobject.idle_add(
self.alternate_progress_bar.set_value,
percentage_complete)
else:
# update play-head
if self.project.sequences[0]:
gobject.idle_add(
self.project.sequences[0].move_play_head,
new_time)
# update progress bar of video
if self.main_form.hsVideoProgress:
gobject.idle_add(
self.main_form.hsVideoProgress.set_value,
percentage_complete)
gobject.idle_add(
self.main_form.scroll_to_playhead)
# pause video when 100%
if percentage_complete == 100:
self.pause()
elif self.mode == "override":
# update progress bar of video
if self.main_form.hsVideoProgress:
gobject.idle_add(
self.main_form.hsVideoProgress.set_value,
percentage_complete)
# wait 1/5 of a second
time.sleep(0.1)
else:
if self.mode == "render":
# update Export Dialog Progress Bar
if self.fraction_complete > 0.0:
# update progress bar to 100%
if self.project.form.frmExportVideo:
gobject.idle_add(
self.project.form.frmExportVideo.
update_progress, 1.0)
# reset the fraction
self.fraction_complete = 0.0
# wait a bit... to cool off the CPU
time.sleep(0.1)
# clear all the MLT objects
self.consumer_stop()
self.p = None
self.c = None
self.profile = None
self.f = None
else:
# Diagnostics
print "ERROR WITH %s" % self.file_name
def __init__(self, file_path, callback):
self.producer = mlt.Producer(_current_profile, str(file_path))
self.callback = callback
self.running = True
def _render_frame_buffer_clip_dialog_callback(dialog, response_id, fb_widgets,
media_file):
if response_id == Gtk.ResponseType.ACCEPT:
# Get data needed for render.
speed = float(int(fb_widgets.adjustment.get_value())) / 100.0
file_name = fb_widgets.file_name.get_text()
filenames = fb_widgets.out_folder.get_filenames()
folder = filenames[0]
write_file = folder + "/" + file_name + fb_widgets.extension_label.get_text(
)
if os.path.exists(write_file):
primary_txt = _("A File with given path exists!")
secondary_txt = _(
"It is not allowed to render Motion Files with same paths as existing files.\nSelect another name for file."
)
dialogutils.warning_message(primary_txt, secondary_txt, dialog)
return
profile_index = fb_widgets.out_profile_combo.get_active()
if profile_index == 0:
# project_profile is first selection in combo box
profile = PROJECT().profile
else:
profile = mltprofiles.get_profile_for_index(profile_index - 1)
profile_desc = profile.description().replace(" ", "_")
encoding_option_index = fb_widgets.encodings_cb.get_active()
quality_option_index = fb_widgets.quality_cb.get_active()
range_selection = fb_widgets.render_range.get_active()
dialog.destroy()
source_path = media_file.path
if media_file.is_proxy_file == True:
source_path = media_file.second_file_path
# start and end frames
motion_producer = mlt.Producer(
profile, None,
str("timewarp:" + str(speed) + ":" + str(source_path)))
start_frame = 0
end_frame = motion_producer.get_length() - 1
render_full_range = True # REMOVE THIS DONW THE LINE, NOT USED.
if range_selection == 1:
start_frame = int(float(media_file.mark_in) * (1.0 / speed))
end_frame = int(float(media_file.mark_out + 1) *
(1.0 / speed)) + int(1.0 / speed)
if end_frame > motion_producer.get_length() - 1:
end_frame = motion_producer.get_length() - 1
render_full_range = False # consumer wont stop automatically and needs to stopped explicitly
session_id = hashlib.md5(str(
os.urandom(32)).encode('utf-8')).hexdigest()
args = ("session_id:" + str(session_id), "speed:" + str(speed),
"write_file:" + str(write_file).replace(" ", "\ "),
"profile_desc:" + str(profile_desc),
"encoding_option_index:" + str(encoding_option_index),
"quality_option_index:" + str(quality_option_index),
"source_path:" + str(source_path).replace(" ", "\ "),
"render_full_range:" + str(render_full_range), "start_frame:" +
str(start_frame), "end_frame:" + str(end_frame))
job_queue_object = jobs.MotionRenderJobQueueObject(
session_id, write_file, args)
job_queue_object.add_to_queue()
else:
dialog.destroy()
def get_clip_profile_index(clip_path):
profile = mltprofiles.get_default_profile()
producer = mlt.Producer(profile, str(clip_path))
profile_index = mltprofiles.get_closest_matching_profile_index(utils.get_file_producer_info(producer))
return profile_index
import tempfile
import os
import os.path
# Start the mlt system
mlt.mlt_log_set_level(40) # verbose
mlt.Factory.init()
# Establish a pipeline
profile = mlt.Profile("atsc_1080i_5994")
#profile = mlt.Profile('square_ntsc_wide')
profile.set_explicit(1)
tractor = mlt.Tractor()
tractor.set('eof', 'loop')
playlist = mlt.Playlist()
playlist.append(mlt.Producer(profile, 'color:'))
# Setup the consumer
consumer = 'decklink:0'
if len(sys.argv) > 1:
consumer = sys.argv[1]
consumer = mlt.Consumer(profile, consumer)
consumer.connect(playlist)
#consumer.set("real_time", -2)
consumer.start()
def switch(resource):
global playlist
resource = resource
playlist.lock()
playlist.append(mlt.Producer(profile, str(resource)))
def _render_reverse_clip_dialog_callback(dialog, response_id, fb_widgets, media_file):
if response_id == Gtk.ResponseType.ACCEPT:
# speed, filename folder
speed = float(int(fb_widgets.hslider.get_value())) / 100.0
file_name = fb_widgets.file_name.get_text()
filenames = fb_widgets.out_folder.get_filenames()
folder = filenames[0]
write_file = folder + "/"+ file_name + fb_widgets.extension_label.get_text()
if os.path.exists(write_file):
primary_txt = _("A File with given path exists!")
secondary_txt = _("It is not allowed to render Motion Files with same paths as existing files.\nSelect another name for file.")
dialogutils.warning_message(primary_txt, secondary_txt, dialog)
return
# Profile
profile_index = fb_widgets.out_profile_combo.get_active()
if profile_index == 0:
# project_profile is first selection in combo box
profile = PROJECT().profile
else:
profile = mltprofiles.get_profile_for_index(profile_index - 1)
# Render consumer properties
encoding_option_index = fb_widgets.encodings_cb.get_active()
quality_option_index = fb_widgets.quality_cb.get_active()
# Range
range_selection = fb_widgets.render_range.get_active()
dialog.destroy()
# Create motion producer
source_path = media_file.path
if media_file.is_proxy_file == True:
source_path = media_file.second_file_path
motion_producer = mlt.Producer(profile, None, str("timewarp:" + str(speed) + ":" + str(source_path)))
mltrefhold.hold_ref(motion_producer)
# Create sequence and add motion producer into it
seq = sequence.Sequence(profile)
seq.create_default_tracks()
track = seq.tracks[seq.first_video_index]
track.append(motion_producer, 0, motion_producer.get_length() - 1)
print "motion clip render starting..."
consumer = renderconsumer.get_render_consumer_for_encoding_and_quality(write_file, profile, encoding_option_index, quality_option_index)
# start and end frames
start_frame = 0
end_frame = motion_producer.get_length() - 1
wait_for_producer_stop = True
if range_selection == 1:
start_frame = int(float(media_file.length - media_file.mark_out - 1) * (1.0 / -speed))
end_frame = int(float(media_file.length - media_file.mark_out + (media_file.mark_out - media_file.mark_in) + 1) * (1.0 / -speed)) + int(1.0 / -speed)
if end_frame > motion_producer.get_length() - 1:
end_frame = motion_producer.get_length() - 1
if start_frame < 0:
start_frame = 0
wait_for_producer_stop = False # consumer wont stop automatically and needs to stopped explicitly
# Launch render
global motion_renderer, motion_progress_update
motion_renderer = renderconsumer.FileRenderPlayer(write_file, seq.tractor, consumer, start_frame, end_frame)
motion_renderer.wait_for_producer_end_stop = wait_for_producer_stop
motion_renderer.start()
title = _("Rendering Reverse Clip")
text = "<b>Motion Clip File: </b>" + write_file
progress_bar = Gtk.ProgressBar()
dialog = rendergui.clip_render_progress_dialog(_FB_render_stop, title, text, progress_bar, gui.editor_window.window)
motion_progress_update = renderconsumer.ProgressWindowThread(dialog, progress_bar, motion_renderer, _REVERSE_render_stop)
motion_progress_update.start()
else:
dialog.destroy()
def run(self):
self.start_time = time.monotonic()
if self.render_data.save_internally == True:
frame_name = "frame"
else:
frame_name = self.render_data.frame_name
rendered_frames_folder = ccrutils.rendered_frames_folder()
# Delete old rendered frames
for frame_file in os.listdir(rendered_frames_folder):
file_path = os.path.join(rendered_frames_folder, frame_file)
os.remove(file_path)
if self.abort == True:
return
script_file = open(self.script_path)
user_script = script_file.read()
profile_file_path = mltprofiles.get_profile_file_path(
self.profile_desc)
editors_data_json = json.dumps(
self.fluxity_plugin_edit_data["editors_list"]
) # See fluxity.FluxityContext.get_script_data()
fluxity.render_frame_sequence(user_script, self.range_in,
self.range_out, rendered_frames_folder,
profile_file_path, self.frames_update,
editors_data_json, True)
render_length = self.range_out - self.range_in
while len(os.listdir(rendered_frames_folder)) != render_length:
if self.abort == True:
return
time.sleep(0.5)
# Render video
if self.render_data.do_video_render == True:
# Render consumer
args_vals_list = toolsencoding.get_args_vals_list_for_render_data(
self.render_data)
profile = mltprofiles.get_profile_for_index(
self.render_data.profile_index)
if self.render_data.save_internally == True:
file_path = ccrutils.session_folder(
) + "/" + appconsts.CONTAINER_CLIP_VIDEO_CLIP_NAME + self.render_data.file_extension
else:
file_path = self.render_data.render_dir + "/" + self.render_data.file_name + self.render_data.file_extension
consumer = renderconsumer.get_mlt_render_consumer(
file_path, profile, args_vals_list)
# Render producer
num_part = str(1).zfill(5)
frame_file = rendered_frames_folder + "/" + frame_name + "_" + num_part + ".png"
resource_name_str = utils.get_img_seq_resource_name(
frame_file, True)
resource_path = rendered_frames_folder + "/" + resource_name_str
producer = mlt.Producer(profile, str(resource_path))
frames_length = len(os.listdir(rendered_frames_folder))
self.render_player = renderconsumer.FileRenderPlayer(
"", producer, consumer, 0, frames_length - 1)
self.render_player.wait_for_producer_end_stop = False
self.render_player.start()
while self.render_player.stopped == False:
self.abort_requested()
if self.abort == True:
self.render_player.shutdown()
return
fraction = self.render_player.get_render_fraction()
self.video_render_update_callback(fraction)
time.sleep(0.3)
ccrutils.delete_rendered_frames()
# Write out completed flag file.
ccrutils.write_completed_message()
def main(root_path, session_id, project_path, range_in, range_out,
profile_desc):
project_path = utils.escape_shell_path(project_path)
try:
editorstate.mlt_version = mlt.LIBMLT_VERSION
except:
editorstate.mlt_version = "0.0.99" # magic string for "not found"
# Set paths.
respaths.set_paths(root_path)
userfolders.init()
editorpersistance.load()
# Init translations module with translations data
translations.init_languages()
translations.load_filters_translations()
mlttransitions.init_module()
repo = mlt.Factory().init()
processutils.prepare_mlt_repo(repo)
# Set numeric locale to use "." as radix, MLT initilizes this to OS locale and this causes bugs
locale.setlocale(locale.LC_NUMERIC, 'C')
# Check for codecs and formats on the system
mltenv.check_available_features(repo)
renderconsumer.load_render_profiles()
# Load filter and compositor descriptions from xml files.
mltfilters.load_filters_xml(mltenv.services)
mlttransitions.load_compositors_xml(mltenv.transitions)
# Create list of available mlt profiles
mltprofiles.load_profile_list()
ccrutils.init_session_folders(session_id)
ccrutils.load_render_data()
log_path = GLib.get_user_cache_dir() + "/blenderrenderlog"
FLOG = open(log_path, 'w')
render_setup_script = respaths.ROOT_PATH + "/tools/blenderrendersetup.py"
blender_launch = "/usr/bin/blender -b " + project_path + " -P " + utils.escape_shell_path(
render_setup_script)
global _start_time
_start_time = time.monotonic()
render_data = ccrutils.get_render_data()
# Delete old rendered frames for non-preview renders.
if render_data.is_preview_render == False:
rendered_frames_folder = ccrutils.rendered_frames_folder()
for frame_file in os.listdir(rendered_frames_folder):
file_path = os.path.join(rendered_frames_folder, frame_file)
os.remove(file_path)
else:
# For preview render delete preview frames
preview_frames_folder = ccrutils.preview_frames_folder()
for frame_file in os.listdir(preview_frames_folder):
file_path = os.path.join(preview_frames_folder, frame_file)
os.remove(file_path)
p = subprocess.Popen(blender_launch,
shell=True,
stdin=FLOG,
stdout=FLOG,
stderr=FLOG,
preexec_fn=os.setsid)
manager_thread = ProgressPollingThread(range_in, range_out, p,
render_data.is_preview_render)
manager_thread.start()
p.wait()
if manager_thread.abort == True:
return
# Render video
if render_data.do_video_render == True:
# Change file numbering to start from 0000 to please ffmpeg
rendered_folder = ccrutils.rendered_frames_folder() + "/"
files = [
f for f in listdir(rendered_folder)
if isfile(join(rendered_folder, f))
]
files.sort(key=lambda var: [
int(x) if x.isdigit() else x
for x in re.findall(r'[^0-9]|[0-9]+', var)
])
number = 0
for rendered_file in files:
source_file = rendered_folder + rendered_file
file_number = '{0:04d}'.format(number)
dst_file = rendered_folder + "videoframe" + file_number + ".png"
Path(source_file).rename(dst_file)
number += 1
# Render consumer
args_vals_list = toolsencoding.get_args_vals_list_for_render_data(
render_data)
profile = mltprofiles.get_profile_for_index(render_data.profile_index)
if ccrutils.get_render_data().save_internally == True:
file_path = ccrutils.session_folder(
) + "/" + appconsts.CONTAINER_CLIP_VIDEO_CLIP_NAME + render_data.file_extension
else:
file_path = render_data.render_dir + "/" + render_data.file_name + render_data.file_extension
consumer = renderconsumer.get_mlt_render_consumer(
file_path, profile, args_vals_list)
# Render producer
rendered_frames_folder = ccrutils.rendered_frames_folder()
frames_info = gmicplayer.FolderFramesInfo(rendered_frames_folder)
frame_file = frames_info.get_lowest_numbered_file()
if editorstate.mlt_version_is_equal_or_greater("0.8.5"):
resource_name_str = utils.get_img_seq_resource_name(
frame_file, True)
else:
resource_name_str = utils.get_img_seq_resource_name(
frame_file, False)
resource_path = rendered_frames_folder + "/" + resource_name_str
producer = mlt.Producer(profile, str(resource_path))
frames_length = len(os.listdir(rendered_frames_folder))
render_player = renderconsumer.FileRenderPlayer(
"", producer, consumer, 0, frames_length - 1)
render_player.wait_for_producer_end_stop = False
render_player.start()
abort = False
while render_player.stopped == False and abort == False:
abort = ccrutils.abort_requested()
if abort == True:
render_player.shutdown()
return
else:
fraction = render_player.get_render_fraction()
elapsed = time.monotonic() - _start_time
msg = "2 " + str(fraction) + " " + str(elapsed)
ccrutils.write_status_message(msg)
time.sleep(1.0)
else:
manager_thread.abort = True # to exit while loop and end thread
ccrutils.write_completed_message()
print("Blender render complete.")
def create_mlt_producer(self, profile):
producer = mlt.Producer(profile, "frei0r.nois0r")
mltrefhold.hold_ref(producer)
return producer
def load_xml(self):
# get reference to translate gettext method
_ = self._
# re-init the mlt factory
mlt.Factory.init()
# Create the consumer
if self.mode == "render":
# RENDER MOVIE mode
# stop the consumer
self.consumer_stop()
# Create the producer
self.p = mlt.Producer(self.profile, 'xml:%s' % self.file_name)
if self.p.is_valid() == False:
print "ERROR WITH %s" % self.file_name
return
# get export file path
folder = self.render_options["folder"]
file = self.render_options["file"]
format = self.render_options["f"]
export_path = "%s.%s" % (os.path.join(folder, file), format)
# create consumer
self.c = mlt.Consumer(self.profile, "avformat", export_path)
# set some RENDER specific options
self.c.set("real_time", -1)
# set render options
if self.render_options["export_to"] == _("Image Sequence"):
# image seq
self.c.set("vcodec", self.render_options["vcodec"])
else:
# video & audio
self.c.set("f", format)
self.c.set("vcodec", self.render_options["vcodec"])
self.c.set("b", self.render_options["b"])
self.c.set("acodec", self.render_options["acodec"])
self.c.set("ar", self.render_options["ar"])
self.c.set("ac", self.render_options["ac"])
self.c.set("ab", self.render_options["ab"])
if self.render_options["vcodec"] == "libx264":
self.c.set("minrate", "0")
self.c.set("b_strategy", "1")
self.c.set("subcmp", "2")
self.c.set("cmp", "2")
self.c.set("coder", "1")
self.c.set("flags", "+loop")
self.c.set("flags2", "dct8x8")
self.c.set("qmax", "51")
self.c.set("subq", "7")
self.c.set("qmin", "10")
self.c.set("qcomp", locale.str(float("0.6")))
self.c.set("qdiff", "4")
self.c.set("trellis", "1")
if format == "dvd":
# stolen from ffmpeg.c, void opt_target(const char *arg)
self.c.set("maxrate", "9000000")
self.c.set("minrate", "0")
self.c.set("bufsize", "1835008")
self.c.set("packetsize", "2048")
self.c.set("muxrate", "10080000")
else:
# stop the consumer (if sdl_preview mode and an older version of MLT)
if self.check_version(0, 6, 0) == False and str(
self.main_form.settings.general["output_mode"]
) == "sdl_preview":
# stop the consumer
self.consumer_stop()
# Create the producer
self.p = mlt.Producer(self.profile, 'xml:%s' % self.file_name)
if self.p.is_valid() == False:
print "ERROR WITH %s" % self.file_name
return
# refresh sdl and pause video
self.pause()
# connect the producer and consumer
self.c.connect(self.p)
# start consumer
if self.c.is_stopped:
self.c.start()
def create_mlt_producer(self, profile):
producer = mlt.Producer(profile,
respaths.PATTERN_PRODUCER_PATH + "ebubars.png")
mltrefhold.hold_ref(producer)
return producer
def __init__(self, clip_path):
self.producer = mlt.Producer(_current_profile, str(clip_path))
self.producer.mark_in = -1
self.producer.mark_out = -1
def run(self):
items = 1
global progress_window
start = time.time()
elapsed = 0
proxy_w, proxy_h = _get_proxy_dimensions(
self.proxy_profile,
editorstate.PROJECT().proxy_data.size)
proxy_encoding = _get_proxy_encoding()
self.current_render_file_path = None
print "proxy render started, items: " + str(len(
self.files_to_render)) + ", dim: " + str(proxy_w) + "x" + str(
proxy_h)
for media_file in self.files_to_render:
if self.aborted == True:
break
if media_file.type == appconsts.IMAGE_SEQUENCE:
self._create_img_seq_proxy(media_file, proxy_w, proxy_h, items,
start)
continue
# Create render objects
proxy_file_path = media_file.create_proxy_path(
proxy_w, proxy_h, proxy_encoding.extension)
self.current_render_file_path = proxy_file_path
renderconsumer.performance_settings_enabled = False
consumer = renderconsumer.get_render_consumer_for_encoding(
proxy_file_path, self.proxy_profile, proxy_encoding)
renderconsumer.performance_settings_enabled = True
# Bit rates for proxy files are counted using 2500kbs for
# PAL size image as starting point.
pal_pix_count = 720.0 * 576.0
pal_proxy_rate = 2500.0
proxy_pix_count = float(proxy_w * proxy_h)
proxy_rate = pal_proxy_rate * (proxy_pix_count / pal_pix_count)
proxy_rate = int(
proxy_rate / 100) * 100 # Make proxy rate even hundred
# There are no practical reasons to have bitrates lower than 500kbs.
if proxy_rate < 500:
proxy_rate = 500
consumer.set("vb", str(int(proxy_rate)) + "k")
consumer.set("rescale", "nearest")
file_producer = mlt.Producer(self.proxy_profile,
str(media_file.path))
mltrefhold.hold_ref(
file_producer
) # this may or may not be needed to avoid crashes
stop_frame = file_producer.get_length() - 1
# Create and launch render thread
global render_thread
render_thread = renderconsumer.FileRenderPlayer(
None, file_producer, consumer, 0, stop_frame)
render_thread.start()
# Render view update loop
self.thread_running = True
self.aborted = False
while self.thread_running:
if self.aborted == True:
break
render_fraction = render_thread.get_render_fraction()
now = time.time()
elapsed = now - start
Gdk.threads_enter()
progress_window.update_render_progress(
render_fraction, media_file.name, items,
len(self.files_to_render), elapsed)
Gdk.threads_leave()
render_thread.producer.get_length()
if render_thread.producer.frame() >= stop_frame:
self.thread_running = False
media_file.add_proxy_file(proxy_file_path)
if self.set_as_proxy_immediately: # When proxy mode is USE_PROXY_MEDIA all proxy files are used all the time
media_file.set_as_proxy_media_file()
self.current_render_file_path = None
else:
time.sleep(0.1)
if not self.aborted:
items = items + 1
Gdk.threads_enter()
progress_window.update_render_progress(
0, media_file.name, items, len(self.files_to_render),
elapsed)
Gdk.threads_leave()
else:
print "proxy render aborted"
render_thread.shutdown()
break
render_thread.shutdown()
Gdk.threads_enter()
_proxy_render_stopped()
Gdk.threads_leave()
# Remove unfinished proxy files
if self.current_render_file_path != None:
os.remove(self.current_render_file_path)
# If we're currently proxy editing, we need to update
# all the clips on the timeline to use proxy media.
if editorstate.PROJECT(
).proxy_data.proxy_mode == appconsts.USE_PROXY_MEDIA:
_auto_re_convert_after_proxy_render_in_proxy_mode()
print "proxy render done"
def run(self):
editorpersistance.load(
) # to apply possible chnages on timeline rendering
start_time = time.monotonic()
width, height = _get_render_dimensions(
self.profile, editorpersistance.prefs.tline_render_size)
encoding = _get_render_encoding()
self.render_profile = _get_render_profile(
self.profile, editorpersistance.prefs.tline_render_size,
self.render_folder)
self.current_render_file_path = None
sequence_xml_producer = mlt.Producer(self.profile,
str(self.sequence_xml_path))
for segment in self.segments:
if self.aborted == True:
break
clip_file_path, clip_range_in, clip_range_out = segment
# Create render objects
self.current_render_file_path = clip_file_path
renderconsumer.performance_settings_enabled = False
consumer = renderconsumer.get_render_consumer_for_encoding(
clip_file_path, self.render_profile, encoding)
renderconsumer.performance_settings_enabled = True
# We are using proxy file rendering code here mostly, didn't vhange all names.
# Bit rates for proxy files are counted using 2500kbs for
# PAL size image as starting point.
pal_pix_count = 720.0 * 576.0
pal_proxy_rate = 2500.0
proxy_pix_count = float(width * height)
proxy_rate = pal_proxy_rate * (proxy_pix_count / pal_pix_count)
proxy_rate = int(
proxy_rate / 100) * 100 # Make proxy rate even hundred
# There are no practical reasons to have bitrates lower than 500kbs.
if proxy_rate < 500:
proxy_rate = 500
consumer.set("vb", str(int(proxy_rate)) + "k")
consumer.set("rescale", "nearest")
start_frame = clip_range_in
stop_frame = clip_range_out + RENDERING_PAD_FRAMES
if stop_frame > sequence_xml_producer.get_length() - 1:
stop_frame = sequence_xml_producer.get_length() - 1
# Create and launch render thread
self.render_thread = renderconsumer.FileRenderPlayer(
None, sequence_xml_producer, consumer, start_frame, stop_frame)
self.render_thread.wait_for_producer_end_stop = False
self.render_thread.start()
# Render view update loop
self.render_in_progress = True
self.aborted = False
while self.render_in_progress:
if self.aborted == True:
break
if self.render_thread.running == False: # Rendering has reached end
self.render_in_progress = False
self.current_render_file_path = None
else:
time.sleep(0.1)
if self.aborted:
self.render_thread.shutdown()
break
self.completed_segments.append(clip_file_path)
self.render_thread.shutdown()
self.render_complete = True
print("tline render done, time:", time.monotonic() - start_time)
def run(self):
self.start_time = time.monotonic()
self.render_player = None
self.frames_range_writer = None
self.script_renderer = None
if self.render_data.save_internally == True:
frame_name = "frame"
else:
frame_name = self.render_data.frame_name
clip_frames_folder = ccrutils.clip_frames_folder()
rendered_frames_folder = ccrutils.rendered_frames_folder()
profile = mltprofiles.get_profile(self.profile_desc)
# Delete old clip frames
for frame_file in os.listdir(clip_frames_folder):
file_path = os.path.join(clip_frames_folder, frame_file)
os.remove(file_path)
# Delete old rendered frames
for frame_file in os.listdir(rendered_frames_folder):
file_path = os.path.join(rendered_frames_folder, frame_file)
os.remove(file_path)
self.frames_range_writer = gmicplayer.FramesRangeWriter(
self.clip_path, self.frames_update, profile)
self.frames_range_writer.write_frames(clip_frames_folder + "/",
frame_name, self.range_in,
self.range_out)
if self.abort == True:
return
script_file = open(self.script_path)
user_script = script_file.read()
while len(os.listdir(clip_frames_folder)) != self.length:
time.sleep(0.5)
# Render frames with gmic script
self.script_renderer = gmicplayer.FolderFramesScriptRenderer(
user_script,
clip_frames_folder,
rendered_frames_folder + "/",
frame_name,
self.script_render_update_callback,
self.script_render_output_callback,
10,
False, # this is not useful until we get MLT to fin frames sequences not startin from 0001
0)
self.script_renderer.write_frames()
ccrutils.delete_clip_frames()
if self.abort == True:
return
# Render video
if self.render_data.do_video_render == True:
# Render consumer
args_vals_list = toolsencoding.get_args_vals_list_for_render_data(
self.render_data)
profile = mltprofiles.get_profile_for_index(
self.render_data.profile_index)
if self.render_data.save_internally == True:
file_path = ccrutils.session_folder(
) + "/" + appconsts.CONTAINER_CLIP_VIDEO_CLIP_NAME + self.render_data.file_extension
else:
file_path = self.render_data.render_dir + "/" + self.render_data.file_name + self.render_data.file_extension
consumer = renderconsumer.get_mlt_render_consumer(
file_path, profile, args_vals_list)
# Render producer
frame_file = rendered_frames_folder + "/" + frame_name + "_0000.png"
resource_name_str = utils.get_img_seq_resource_name(
frame_file, True)
resource_path = rendered_frames_folder + "/" + resource_name_str
producer = mlt.Producer(profile, str(resource_path))
frames_length = len(os.listdir(rendered_frames_folder))
self.render_player = renderconsumer.FileRenderPlayer(
"", producer, consumer, 0, frames_length - 1)
self.render_player.wait_for_producer_end_stop = False
self.render_player.start()
while self.render_player.stopped == False:
self.abort_requested()
if self.abort == True:
self.render_player.shutdown()
return
fraction = self.render_player.get_render_fraction()
self.video_render_update_callback(fraction)
time.sleep(0.3)
ccrutils.delete_rendered_frames()
# Write out completed flag file.
ccrutils.write_completed_message()
# Start the mlt system
mlt.mlt_log_set_level(40) # verbose
mlt.Factory.init()
# Establish a pipeline
profile = mlt.Profile("atsc_1080i_5994")
profile.set_explicit(1)
tractor = mlt.Tractor()
tractor.set("eof", "loop")
fg_resource = "decklink:0"
bg_resource = "decklink:1"
if len(sys.argv) > 2:
fg_resource = sys.argv[1]
bg_resource = sys.argv[2]
fg = mlt.Producer(profile, fg_resource)
bg = mlt.Producer(profile, bg_resource)
tractor.set_track(bg, 0)
tractor.set_track(fg, 1)
composite = mlt.Transition(profile, "composite")
composite.set("fill", 1)
tractor.plant_transition(composite)
# Setup the consumer
consumer = "decklink:2"
if len(sys.argv) > 3:
consumer = sys.argv[3]
consumer = mlt.Consumer(profile, consumer)
consumer.connect(tractor)
consumer.set("real_time", -2)
consumer.start()
