def render_frame(tokens):
try:
clip_path = tokens[1]
frame = int(tokens[2])
except:
return ERROR + " malformed command " + RENDER_FRAME + NEW_LINE
try:
frame_source = get_frame_source(clip_path)
consumer = get_img_seq_render_consumer(frame_source.profile)
except:
return ERROR + " creating consumer failed " + NEW_LINE
# Check frame range
clear_temp_frames()
renderer = renderconsumer.FileRenderPlayer(None, frame_source.producer, consumer, frame, frame + 1)
renderer.wait_for_producer_end_stop = False
renderer.consumer_pos_stop_add = 2 # Hack, see FileRenderPlayer
renderer.start()
while renderer.has_started_running == False:
time.sleep(0.05)
while renderer.stopped == False:
time.sleep(0.05)
copy_frames_from_temp_folder(frame_source, frame)
return OK
def render_single_track_transition_clip(transition_producer, encoding_option_index, quality_option_index, file_ext, transition_render_complete_cb, window_text):
# Set render complete callback to availble render stop callback using global variable
global transition_render_done_callback
transition_render_done_callback = transition_render_complete_cb
# Profile
profile = PROJECT().profile
folder = editorpersistance.prefs.render_folder
file_name = md5.new(str(os.urandom(32))).hexdigest()
write_file = folder + "/"+ file_name + file_ext
# Render consumer
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 = transition_producer.get_length() - 1
# Launch render
# TODO: fix naming this isn't motion renderer
global motion_renderer, motion_progress_update
motion_renderer = renderconsumer.FileRenderPlayer(write_file, transition_producer, consumer, start_frame, end_frame)
motion_renderer.start()
title = _("Rendering Transition Clip")
progress_bar = Gtk.ProgressBar()
dialog = rendergui.clip_render_progress_dialog(_transition_render_stop, title, window_text, progress_bar, gui.editor_window.window)
motion_progress_update = renderconsumer.ProgressWindowThread(dialog, progress_bar, motion_renderer, _transition_render_stop)
motion_progress_update.start()
def run(self):
# Image produceer
img_producer = current_sequence().create_file_producer_clip(
str(self.image_file)
) # , new_clip_name=None, novalidate=False, ttl=None):
# Create tractor and track to get right length
tractor = mlt.Tractor()
multitrack = tractor.multitrack()
track0 = mlt.Playlist()
multitrack.connect(track0, 0)
track0.insert(img_producer, 0, 0, self.length)
# Consumer
write_file = userfolders.get_cache_dir() + "/unrendered_clip.mp4"
# Delete earlier created files
if os.path.exists(write_file):
os.remove(write_file)
consumer = renderconsumer.get_default_render_consumer(
write_file,
PROJECT().profile)
clip_renderer = renderconsumer.FileRenderPlayer(
write_file, tractor, consumer, 0, self.length)
clip_renderer.wait_for_producer_end_stop = True
clip_renderer.start()
Gdk.threads_enter()
info_text = _("<b>Rendering Placeholder Media For:</b> "
) + self.data.get_program_name() + ".blend"
progress_bar = Gtk.ProgressBar()
dialog = rendergui.clip_render_progress_dialog(
None, self.window_text, info_text, progress_bar,
gui.editor_window.window, True)
motion_progress_update = renderconsumer.ProgressWindowThread(
dialog, progress_bar, clip_renderer, self.progress_thread_complete)
motion_progress_update.start()
Gdk.threads_leave()
while clip_renderer.stopped == False:
time.sleep(0.5)
Gdk.threads_enter()
self.callback(write_file, self.data)
Gdk.threads_leave()
def run(self):
self.start_time = time.monotonic()
profile = mltprofiles.get_profile(self.profile_desc)
motion_producer = mlt.Producer(
profile, None,
str("timewarp:" + str(self.speed) + ":" + str(self.source_path)))
# Create tractor and track to get right length
tractor = mlt.Tractor()
multitrack = tractor.multitrack()
track0 = mlt.Playlist()
multitrack.connect(track0, 0)
track0.insert(motion_producer, 0, 0, motion_producer.get_length() - 1)
consumer = renderconsumer.get_render_consumer_for_encoding_and_quality(
self.write_file, profile, self.encoding_option_index,
self.quality_option_index)
# start and end frames, renderer stop behaviour
start_frame = self.start_frame
end_frame = self.end_frame
wait_for_producer_stop = True
if self.render_full_range == False:
wait_for_producer_stop = False # consumer wont stop automatically and needs to stopped explicitly
# Launch render
self.render_player = renderconsumer.FileRenderPlayer(
self.write_file, tractor, consumer, start_frame, end_frame)
self.render_player.wait_for_producer_end_stop = False
self.render_player.start()
while self.render_player.stopped == False:
self.check_abort_requested()
if self.abort == True:
self.render_player.shutdown()
return
fraction = self.render_player.get_render_fraction()
self.render_update(fraction)
time.sleep(0.3)
# Write out completed flag file.
ccrutils.write_completed_message()
def render_screen_shot(frame, render_path, vcodec):
producer = current_sequence().tractor
consumer = mlt.Consumer(PROJECT().profile, "avformat", str(render_path))
consumer.set("real_time", -1)
consumer.set("rescale", "bicubic")
consumer.set("vcodec", str(vcodec))
renderer = renderconsumer.FileRenderPlayer(None, producer, consumer, frame, frame + 1)
renderer.wait_for_producer_end_stop = False
renderer.consumer_pos_stop_add = 2 # Hack, see FileRenderPlayer
renderer.start()
while renderer.has_started_running == False:
time.sleep(0.05)
while renderer.stopped == False:
time.sleep(0.05)
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()
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 _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 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):
self.running = True
items = 0
global render_queue, batch_window
for render_item in render_queue.queue:
if self.running == False:
break
if render_item.render_this_item == False:
continue
current_render_time = 0
# Create render objects
identifier = render_item.generate_identifier()
project_file_path = get_projects_dir() + identifier + ".flb"
persistance.show_messages = False
project = persistance.load_project(project_file_path, False)
producer = project.c_seq.tractor
consumer = renderconsumer.get_mlt_render_consumer(
render_item.render_path, project.profile,
render_item.args_vals_list)
# Get render range
start_frame, end_frame, wait_for_stop_render = get_render_range(
render_item)
# Create and launch render thread
global render_thread
render_thread = renderconsumer.FileRenderPlayer(
None, producer, consumer, start_frame, end_frame
) # None == file name not needed this time when using FileRenderPlayer because callsite keeps track of things
render_thread.wait_for_producer_end_stop = wait_for_stop_render
render_thread.start()
# Set render start time and item state
render_item.render_started()
gtk.gdk.threads_enter()
batch_window.update_queue_view()
batch_window.current_render.set_text(
" " + render_item.get_display_name())
gtk.gdk.threads_leave()
# Make sure that render thread is actually running before
# testing render_thread.running value later
while render_thread.has_started_running == False:
time.sleep(0.05)
# 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()
current_render_time = now - render_item.start_time
gtk.gdk.threads_enter()
batch_window.update_render_progress(
render_fraction, items, render_item.get_display_name(),
current_render_time)
gtk.gdk.threads_leave()
if render_thread.running == False: # Rendering has reached end
self.thread_running = False
gtk.gdk.threads_enter()
batch_window.render_progress_bar.set_fraction(1.0)
gtk.gdk.threads_leave()
render_item.render_completed()
else:
time.sleep(0.33)
if not self.aborted:
items = items + 1
gtk.gdk.threads_enter()
batch_window.update_render_progress(
0, items, render_item.get_display_name(), 0)
gtk.gdk.threads_leave()
else:
if render_item != None:
render_item.render_aborted()
break
render_thread.shutdown()
# Update view for render end
gtk.gdk.threads_enter()
batch_window.reload_queue(
) # item may havee added to queue while rendering
batch_window.render_queue_stopped()
gtk.gdk.threads_leave()
def run(self):
self.start_time = time.monotonic()
if self.lookup_path == "None":
# Video clips
proxy_profile = mltprofiles.get_profile(self.proxy_profile_desc)
# App wrote the temp profile when launching proxy render.
# NOTE: this needs to be created here for future
proxy_profile_path = userfolders.get_cache_dir(
) + "temp_proxy_profile"
proxy_profile = mlt.Profile(proxy_profile_path)
renderconsumer.performance_settings_enabled = False # uuh...we're obivously disabling something momentarily.
consumer = renderconsumer.get_render_consumer_for_encoding(
self.proxy_file_path, proxy_profile,
renderconsumer.proxy_encodings[self.enc_index])
renderconsumer.performance_settings_enabled = True
consumer.set("vb", str(int(self.proxy_rate)) + "k")
consumer.set("rescale", "nearest")
file_producer = mlt.Producer(proxy_profile,
str(self.media_file_path))
start_frame = 0
end_frame = file_producer.get_length() - 1
self.render_player = renderconsumer.FileRenderPlayer(
None, file_producer, consumer, 0, end_frame)
self.render_player.wait_for_producer_end_stop = False
self.render_player.start()
while self.render_player.stopped == False:
self.check_abort_requested()
if self.abort == True:
self.render_player.shutdown()
return
fraction = self.render_player.get_render_fraction()
self.render_update(fraction)
time.sleep(0.3)
else:
# Image Sequences
copyfolder, copyfilename = os.path.split(self.proxy_file_path)
if not os.path.isdir(copyfolder):
os.makedirs(copyfolder)
listing = glob.glob(self.lookup_path)
size = self.proxy_w, self.proxy_h
done = 0
for orig_path in listing:
orig_folder, orig_file_name = os.path.split(orig_path)
try:
im = Image.open(orig_path)
im.thumbnail(size, Image.ANTIALIAS)
im.save(copyfolder + "/" + orig_file_name, "PNG")
except IOError:
print("proxy img seq frame failed for '%s'" % orig_path)
done = done + 1
if done % 5 == 0:
fraction = float(done) / float(len(listing))
self.render_update(fraction)
# Write out completed flag file.
ccrutils.write_completed_message()
