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