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()