def get_render_consumer():
file_path = get_file_path()
if file_path == None:
return None
profile = get_current_profile()
if widgets.render_type_panel.type_combo.get_active() == 1: # Preset encodings
encoding_option = renderconsumer.non_user_encodings[
widgets.render_type_panel.presets_selector.widget.get_active()
]
if encoding_option.type != "img_seq":
consumer = renderconsumer.get_render_consumer_for_encoding(file_path, profile, encoding_option)
else: # Image Sequence rendering consumers need to be created a bit differently
consumer = renderconsumer.get_img_seq_render_consumer(file_path, profile, encoding_option)
return consumer
if widgets.args_panel.use_args_check.get_active() == False:
# Using options comboboxes
encoding_option_index = widgets.encoding_panel.encoding_selector.widget.get_active()
quality_option_index = widgets.encoding_panel.quality_selector.widget.get_active()
consumer = renderconsumer.get_render_consumer_for_encoding_and_quality(
file_path, profile, encoding_option_index, quality_option_index
)
else:
buf = widgets.args_panel.opts_view.get_buffer()
consumer, error = renderconsumer.get_render_consumer_for_text_buffer(file_path, profile, buf)
if error != None:
dialogutils.warning_message("FFMPeg Args Error", error, gui.editor_window.window)
return None
return consumer
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
# 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
consumer = renderconsumer.get_render_consumer_for_encoding(
proxy_file_path,
self.proxy_profile,
proxy_encoding)
# 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)
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
gtk.gdk.threads_enter()
progress_window.update_render_progress(render_fraction, media_file.name, items, len(self.files_to_render), elapsed)
gtk.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
gtk.gdk.threads_enter()
progress_window.update_render_progress(0, media_file.name, items, len(self.files_to_render), elapsed)
gtk.gdk.threads_leave()
else:
print "proxy render aborted"
render_thread.shutdown()
break
render_thread.shutdown()
gtk.gdk.threads_enter()
_proxy_render_stopped()
gtk.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_renconvert_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):
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):
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()
