def _do_create_sync_compound_clip(dialog, response_id, data): if response_id != Gtk.ResponseType.ACCEPT: dialog.destroy() return sync_data, name_entry = data files_offsets, clips = sync_data video_file, audio_file, idstr = clips media_name = name_entry.get_text() dialog.destroy() # Create unique file path in hidden render folder folder = editorpersistance.prefs.render_folder uuid_str = md5.new(str(os.urandom(32))).hexdigest() write_file = folder + "/" + uuid_str + ".xml" # Create tractor tractor = mlt.Tractor() multitrack = tractor.multitrack() track_video = mlt.Playlist() track_audio = mlt.Playlist() track_audio.set("hide", 1) # video off, audio on as mlt "hide" value multitrack.connect(track_audio, 0) multitrack.connect(track_video, 0) # Create clips video_clip = mlt.Producer(PROJECT().profile, str(video_file)) audio_clip = mlt.Producer(PROJECT().profile, str(audio_file)) # Get offset offset = files_offsets[audio_file] print audio_file, offset # Add clips if offset > 0: offset_frames = int(float(offset) + 0.5) print "plus" track_video.append(video_clip, 0, video_clip.get_length() - 1) track_audio.insert_blank(0, offset_frames) track_audio.append(audio_clip, 0, audio_clip.get_length() - 1) elif offset < 0: offset_frames = int(float(offset) - 0.5) print "miinus" track_video.insert_blank(0, offset_frames) track_video.append(video_clip, 0, video_clip.get_length() - 1) track_audio.append(audio_clip, 0, audio_clip.get_length() - 1) else: track_video.append(video_clip, 0, video_clip.get_length() - 1) track_audio.append(audio_clip, 0, audio_clip.get_length() - 1) # render MLT XML, callback in projectaction.py creates media object render_player = renderconsumer.XMLCompoundRenderPlayer( write_file, media_name, projectaction._xml_compound_render_done_callback, tractor) render_player.start()
def add_track(self, track_type, is_hidden=False): """ Creates a MLT playlist object, adds project data and adds to tracks list. """ new_track = mlt.Playlist() self._add_track_attributes(new_track, track_type) new_track.is_sync_track = False # Connect to MLT multitrack self.multitrack.connect(new_track, len(self.tracks)) # Add to tracklist and set id to list index new_track.id = len(self.tracks) self.tracks.append(new_track) # Mix all audio to track 1 by combining them one after another # using an always active field transition. if ( (new_track.id > AUDIO_MIX_DOWN_TRACK ) # black bg or track1 it's self does not need to be mixed and (is_hidden == False) ): # We actually do want the hidden track to cover all audio below, which happens if it is not mixed. self._mix_audio_for_track(new_track) # Add method that returns track name new_track.get_name = lambda: utils.get_track_name(new_track, self) return new_track
def create_scene(media): if media.endswith(".gif"): tv = tempfile.NamedTemporaryFile(mode='w+b', suffix='.mp4', prefix='tmp', delete=False, dir=outdir) subprocess.call( ["ffmpeg", "-i", media, "-y", tv.name, "-loglevel", "quiet"]) ftodel.append(tv.name) tscene = mlt.Producer(profile, tv.name) if tscene.get_out() == 0: tp = tempfile.NamedTemporaryFile(mode='w+b', suffix='.gif', prefix='tmp', delete=False, dir=outdir) ftodel.append(tp.name) subprocess.call( ["ffmpeg", "-i", media, "-y", "-loglevel", "quiet", tp.name]) scene = mlt.Producer(profile, tp.name) elif tscene.get_out() < 150: scene = mlt.Playlist() lt = int(150 / tscene.get_out()) + 1 for x in range(0, lt): tscene = mlt.Producer(profile, tv.name) scene.append(tscene) scene.set('out', 150) else: scene = mlt.Producer(profile, tv.name) elif media.endswith(".mp3"): tv = tempfile.NamedTemporaryFile(mode='w+b', suffix='.wav', prefix='tmp', delete=False, dir=outdir) subprocess.call( ["ffmpeg", "-i", media, "-y", tv.name, "-loglevel", "quiet"]) ftodel.append(tv.name) scene = mlt.Producer(profile, tv.name) elif media.startswith("http"): extension = media[media.rfind("."):] tv = tempfile.NamedTemporaryFile(mode='w+b', suffix=extension, prefix='tmp', delete=False, dir=outdir) ftodel.append(tv.name) subprocess.call([ "ffmpeg", "-i", media, "-y", "-c:a", "copy", "-c:v", "copy", "-loglevel", "quiet", tv.name ]) #subprocess.call(["ffmpeg", "-i", media, "-y", tv.name]) scene = mlt.Producer(profile, tv.name) else: scene = mlt.Producer(profile, media) return scene
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()
import shutil 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()
def get_rendered_transition_tractor(current_sequence, orig_from, orig_to, action_from_out, action_from_in, action_to_out, action_to_in, transition_type_selection_index, wipe_luma_sorted_keys_index, gdk_color_str): name, transition_type = rendered_transitions[transition_type_selection_index] # New from clip if orig_from.media_type != appconsts.PATTERN_PRODUCER: from_clip = current_sequence.create_file_producer_clip(orig_from.path, None, False, orig_from.ttl)# File producer else: from_clip = current_sequence.create_pattern_producer(orig_from.create_data) # pattern producer current_sequence.clone_clip_and_filters(orig_from, from_clip) # New to clip if not(transition_type == RENDERED_FADE_IN or transition_type == RENDERED_FADE_OUT): # fades to not use to_clip if orig_to.media_type != appconsts.PATTERN_PRODUCER: to_clip = current_sequence.create_file_producer_clip(orig_to.path, None, False, orig_to.ttl)# File producer else: to_clip = current_sequence.create_pattern_producer(orig_to.create_data) # pattern producer current_sequence.clone_clip_and_filters(orig_to, to_clip) # Create tractor and tracks tractor = mlt.Tractor() multitrack = tractor.multitrack() track0 = mlt.Playlist() track1 = mlt.Playlist() multitrack.connect(track0, 0) multitrack.connect(track1, 1) # we'll set in and out points for images and pattern producers. if not(transition_type == RENDERED_FADE_IN or transition_type == RENDERED_FADE_OUT): # fades to not use to_clip or some other data used here if from_clip.media_type == appconsts.IMAGE or from_clip.media_type == appconsts.PATTERN_PRODUCER: length = action_from_out - action_from_in from_clip.clip_in = 0 from_clip.clip_out = length if to_clip.media_type == appconsts.IMAGE or to_clip.media_type == appconsts.PATTERN_PRODUCER: length = action_to_out - action_to_in to_clip.clip_in = 0 to_clip.clip_out = length else: length = action_from_out if from_clip.media_type == appconsts.IMAGE or from_clip.media_type == appconsts.PATTERN_PRODUCER: from_clip.clip_in = 0 from_clip.clip_out = length # Add clips to tracks and create keyframe string for mixing if transition_type == RENDERED_DISSOLVE or transition_type == RENDERED_WIPE: # Add clips. Images and pattern producers always fill full track. if from_clip.media_type != appconsts.IMAGE and from_clip.media_type != appconsts.PATTERN_PRODUCER: track0.insert(from_clip, 0, action_from_in, action_from_out) else: track0.insert(from_clip, 0, 0, action_from_out - action_from_in) if to_clip.media_type != appconsts.IMAGE and to_clip.media_type != appconsts.PATTERN_PRODUCER: track1.insert(to_clip, 0, action_to_in, action_to_out) else: track1.insert(to_clip, 0, 0, action_to_out - action_to_in) kf_str = "0=0/0:100%x100%:0.0;"+ str(tractor.get_length() - 1) + "=0/0:100%x100%:100.0" elif transition_type == RENDERED_COLOR_DIP: length = action_from_out - action_from_in first_clip_length = length // 2 second_clip_length = length - first_clip_length color_clip = patternproducer.create_color_producer(current_sequence.profile, gdk_color_str) track0.insert(color_clip, 0, 0, length) track1.insert(from_clip, 0, action_from_in, action_from_in + first_clip_length) track1.insert(to_clip, 1, action_to_out - second_clip_length, action_to_out) kf_str = "0=0/0:100%x100%:100.0;"+ str(first_clip_length) + "=0/0:100%x100%:0.0;" + str(tractor.get_length() - 1) + "=0/0:100%x100%:100.0" elif (transition_type == RENDERED_FADE_IN or transition_type == RENDERED_FADE_OUT): color_clip = patternproducer.create_color_producer(current_sequence.profile, gdk_color_str) track0.insert(color_clip, 0, 0, length) if transition_type == RENDERED_FADE_IN: track1.insert(from_clip, 0, orig_from.clip_in, orig_from.clip_in + length) kf_str = "0=0/0:100%x100%:0.0;"+ str(length) + "=0/0:100%x100%:100.0" else: # transition_type == RENDERED_FADE_OUT track1.insert(from_clip, 0, orig_from.clip_out - length, orig_from.clip_out) kf_str = "0=0/0:100%x100%:100.0;"+ str(length) + "=0/0:100%x100%:0.0" # Create transition transition = mlt.Transition(current_sequence.profile, "region") mltrefhold.hold_ref(transition) transition.set("composite.geometry", str(kf_str)) # controls mix over time transition.set("composite.automatic",1) transition.set("composite.aligned", 0) transition.set("composite.deinterlace",0) transition.set("composite.distort",0) transition.set("composite.fill",1) transition.set("composite.operator","over") transition.set("composite.luma_invert",0) transition.set("composite.progressive",1) transition.set("composite.softness",0) transition.set("in", 0) transition.set("out", tractor.get_length() - 1) transition.set("a_track", 0) transition.set("b_track", 1) # Setting luma resource file turns dissolve into wipe if transition_type == RENDERED_WIPE: wipe_resource_path = get_wipe_resource_path_for_sorted_keys_index(wipe_luma_sorted_keys_index) transition.set("composite.luma", str(wipe_resource_path)) # Add transition field = tractor.field() field.plant_transition(transition, 0,1) return tractor
profile.set_explicit(1) profile.set_sample_aspect(1, 1) profile.set_frame_rate(30000, 1000) profile.set_display_aspect(2, 3) profile.set_width(720) profile.set_height(1080) profile.set_colorspace(709) logo_max_size = 100 else: profile = mlt.Profile("atsc_1080p_30") logo_max_size = 160 profile.set_colorspace(709) tractor = mlt.Tractor() scenes = mlt.Playlist() oscenes = mlt.Playlist() sindex = 1 slength = 5 t_length = 0 frame_rate = 30 production = 0 if production: save_video = 1 outdir = s[0:s.rfind("/")] else: save_video = 0 outdir = s[0:s.rfind("/")] + "/Temp" #outdir="/home/prftp/html/docroot/backend/web/python" outroshow = int(config["27"][4]["display_outro__27"])