def _add_image_sequence_callback(dialog, response_id, data):
if response_id == Gtk.ResponseType.CANCEL:
dialog.destroy()
return
file_chooser, spin = data
frame_file = file_chooser.get_filename()
dialog.destroy()
if frame_file == None:
dialogutils.info_message(_("No file was selected"), _("Select a numbered file to add an Image Sequence to Project."), gui.editor_window.window)
return
(folder, file_name) = os.path.split(frame_file)
try:
number_parts = re.findall("[0-9]+", file_name)
number_part = number_parts[-1] # we want the last number part
except:
dialogutils.info_message(_("Not a sequence file!"), _("Selected file does not have a number part in it,\nso it can't be an image sequence file."), gui.editor_window.window)
return
# Create resource name with MLT syntax for MLT producer
number_index = file_name.find(number_part)
path_name_part = file_name[0:number_index]
end_part = file_name[number_index + len(number_part):len(file_name)]
# The better version with "?begin=xxx" only available after 0.8.7
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)
# detect highest file
# FIX: this fails if two similarily numbered sequences in same dir and both have same substring in frame name
onlyfiles = [ f for f in listdir(folder) if isfile(join(folder,f)) ]
highest_number_part = int(number_part)
for f in onlyfiles:
try:
file_number_part = int(re.findall("[0-9]+", f)[-1]) # -1, we want the last number part
except:
continue
if f.find(path_name_part) == -1:
continue
if file_number_part > highest_number_part:
highest_number_part = file_number_part
dialog.destroy()
resource_path = folder + "/" + resource_name_str
length = highest_number_part - int(number_part)
PROJECT().add_image_sequence_media_object(resource_path, file_name + "(img_seq)", length)
gui.media_list_view.fill_data_model()
gui.bin_list_view.fill_data_model()
editorpersistance.prefs.last_opened_media_dir = os.path.dirname(resource_path)
editorpersistance.save()
def _select_relink_path_dialog_callback(file_select, response_id, media_asset):
filenames = file_select.get_filenames()
file_select.destroy()
if response_id != Gtk.ResponseType.OK:
return
if len(filenames) == 0:
return
media_asset.relink_path = filenames[0]
folder, file_name = os.path.split(filenames[0])
global last_media_dir
last_media_dir = folder
# Relink all the files in a same directory
for med_asset in media_assets:
med_link_name = os.path.basename(med_asset.orig_path)
link_path = os.path.join(folder, med_link_name)
if os.path.isfile(link_path):
if med_asset.media_type == appconsts.IMAGE_SEQUENCE: # img seqs need formatted path
if editorstate.mlt_version_is_equal_or_greater("0.8.5"):
new_style = True
else:
new_style = False
resource_name_str = utils.get_img_seq_resource_name(
link_path, new_style)
med_asset.relink_path = folder + "/" + resource_name_str
else:
med_asset.relink_path = link_path
linker_window.relink_list.fill_data_model()
def update_render_status(self):
if gmicheadless.session_render_complete(
self.get_container_program_id()) == True:
self.remove_as_status_polling_object()
if self.render_type == FULL_RENDER:
frame_file = self.get_lowest_numbered_file()
if frame_file == None:
# Something is quite wrong, maybe best to just print out message and give up.
print("No frame file found for gmic conatainer clip")
return
resource_name_str = utils.get_img_seq_resource_name(
frame_file, True)
resource_path = self.get_rendered_media_dir(
) + "/" + resource_name_str
rendered_clip = current_sequence().create_file_producer_clip(
resource_path, new_clip_name=None, novalidate=False, ttl=1)
track, clip_index = current_sequence(
).get_track_and_index_for_id(self.clip.id)
if track == None:
# clip was removed from timeline
# TODO: infowindow?
return
# "old_clip", "new_clip", "track", "index"
data = {
"old_clip": self.clip,
"new_clip": rendered_clip,
"rendered_media_path": resource_path,
"track": track,
"index": clip_index
}
action = edit.container_clip_full_render_replace(data)
action.do_edit()
else:
status = gmicheadless.get_session_status(
self.get_container_program_id())
if status != None:
step, frame, length, elapsed = status
msg = _("Step") + str(step) + "/3"
if step == "1":
msg += _("Writing frames")
else:
msg += _("Rendering G'Mic script")
job_proxy = self.get_job_proxy()
job_proxy.progress = float(frame) / float(length)
job_proxy.elapsed = float(elapsed)
job_proxy.text = msg
jobs.show_message(job_proxy)
else:
print("Miss")
def get_rendered_frame_sequence_resource_path(self):
frame_file = self.get_lowest_numbered_file() # Works for both external and internal
if frame_file == None:
# Something is quite wrong.
print("No frame file found for container clip at:", self.get_rendered_media_dir())
return None
resource_name_str = utils.get_img_seq_resource_name(frame_file, True)
return self.get_rendered_media_dir() + "/" + resource_name_str
def _select_relink_path_dialog_callback(file_select, response_id, media_asset):
filenames = file_select.get_filenames()
file_select.destroy()
if response_id != Gtk.ResponseType.OK:
return
if len(filenames) == 0:
return
media_asset.relink_path = filenames[0]
if media_asset.media_type == appconsts.IMAGE_SEQUENCE: # img seqs need formatted path
if editorstate.mlt_version_is_equal_or_greater("0.8.5"):
new_style = True
else:
new_style = False
resource_name_str = utils.get_img_seq_resource_name(filenames[0], new_style)
folder, file_name = os.path.split(filenames[0])
media_asset.relink_path = folder + "/" + resource_name_str
linker_window.relink_list.fill_data_model()
def _select_relink_path_dialog_callback(file_select, response_id, media_asset):
filenames = file_select.get_filenames()
file_select.destroy()
if response_id != Gtk.ResponseType.OK:
return
if len(filenames) == 0:
return
media_asset.relink_path = filenames[0]
if media_asset.media_type == appconsts.IMAGE_SEQUENCE: # img seqs need formatted path
if editorstate.mlt_version_is_equal_or_greater("0.8.5"):
new_style = True
else:
new_style = False
resource_name_str = utils.get_img_seq_resource_name(
filenames[0], new_style)
folder, file_name = os.path.split(filenames[0])
media_asset.relink_path = folder + "/" + resource_name_str
linker_window.relink_list.fill_data_model()
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):
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.render_player = None
self.frames_range_writer = None
self.abort = False
# Refuse to render into user home folder
out_folder = _window.out_folder.get_filenames()[0] + "/"
if out_folder == (os.path.expanduser("~") + "/"):
print "home folder"
return
start_time = time.time()
Gdk.threads_enter()
_window.render_status_info.set_markup("")
_window.set_widgets_sensitive(False)
_window.render_percentage.set_sensitive(True)
_window.render_status_info.set_sensitive(True)
_window.render_progress_bar.set_sensitive(True)
_window.stop_button.set_sensitive(True)
_window.render_button.set_sensitive(False)
_window.close_button.set_sensitive(False)
_window.encode_settings_button.set_sensitive(False)
_window.encode_desc.set_sensitive(False)
_window.hamburger_launcher.widget.set_sensitive(False)
_window.load_button.set_sensitive(False)
Gdk.threads_leave()
# Delete old preview frames
folder = get_render_frames_dir()
for frame_file in os.listdir(folder):
file_path = os.path.join(folder, frame_file)
os.remove(file_path)
# Render clipm frames for range
mark_in = _player.producer.mark_in
mark_out = _player.producer.mark_out
self.length = mark_out - mark_in + 1
self.mark_in = mark_in
self.mark_out = mark_out
frame_name = _window.frame_name.get_text()
# jotain controllii frame_namelle
self.frames_range_writer = gmicplayer.FramesRangeWriter(_current_path, self.frames_update)
self.frames_range_writer.write_frames(get_render_frames_dir() + "/", frame_name, mark_in, mark_out)
if self.abort == True:
return
# Render effect for frames
# Get user script
Gdk.threads_enter()
buf = _window.script_view.get_buffer()
user_script = buf.get_text(buf.get_start_iter(), buf.get_end_iter(), False)
_window.render_percentage.set_markup("<small>" + _("Waiting for frames write to complete...") + "</small>")
Gdk.threads_leave()
while len(os.listdir(folder)) != self.length:
time.sleep(0.5)
clip_frames = os.listdir(folder)
frame_count = 1
for clip_frame in clip_frames:
if self.abort == True:
return
update_info = _("Rendering frame: ") + str(frame_count) + "/" + str(self.length)
Gdk.threads_enter()
_window.render_percentage.set_markup("<small>" + update_info + "</small>")
_window.render_progress_bar.set_fraction(float(frame_count)/float(self.length))
Gdk.threads_leave()
file_numbers_list = re.findall(r'\d+', clip_frame)
filled_number_str = str(file_numbers_list[0]).zfill(3)
clip_frame_path = os.path.join(folder, clip_frame)
rendered_file_path = out_folder + frame_name + "_" + filled_number_str + ".png"
script_str = "gmic " + clip_frame_path + " " + user_script + " -output " + rendered_file_path
if frame_count == 1: # first frame displays shell output and does error checking
FLOG = open(utils.get_hidden_user_dir_path() + "log_gmic_preview", 'w')
p = subprocess.Popen(script_str, shell=True, stdin=FLOG, stdout=FLOG, stderr=FLOG)
p.wait()
FLOG.close()
# read log
f = open(utils.get_hidden_user_dir_path() + "log_gmic_preview", 'r')
out = f.read()
f.close()
Gdk.threads_enter()
_window.out_view.get_buffer().set_text(out + "Return code:" + str(p.returncode))
if p.returncode != 0:
_window.out_view.override_color((Gtk.StateFlags.NORMAL and Gtk.StateFlags.ACTIVE), Gdk.RGBA(red=1.0, green=0.0, blue=0.0))
_window.render_percentage.set_text(_("Render error!"))
Gdk.threads_leave()
return
else:
_window.out_view.override_color((Gtk.StateFlags.NORMAL and Gtk.StateFlags.ACTIVE), None)
Gdk.threads_leave()
else:
FLOG = open(utils.get_hidden_user_dir_path() + "log_gmic_preview", 'w')
p = subprocess.Popen(script_str, shell=True, stdin=FLOG, stdout=FLOG, stderr=FLOG)
p.wait()
FLOG.close()
frame_count = frame_count + 1
# Render video
if _window.encode_check.get_active() == True:
# Render consumer
args_vals_list = toolsencoding.get_args_vals_list_for_render_data(_render_data)
profile = mltprofiles.get_profile_for_index(_current_profile_index)
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
frame_file = out_folder + frame_name + "_0000.png"
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 = out_folder + "/" + resource_name_str
producer = mlt.Producer(profile, str(resource_path))
self.render_player = renderconsumer.FileRenderPlayer("", producer, consumer, 0, len(clip_frames) - 1)
self.render_player.wait_for_producer_end_stop = False
self.render_player.start()
while self.render_player.stopped == False:
if self.abort == True:
return
fraction = self.render_player.get_render_fraction()
update_info = _("Rendering video, ") + str(int(fraction * 100)) + _("% done")
Gdk.threads_enter()
_window.render_percentage.set_markup("<small>" + update_info + "</small>")
_window.render_progress_bar.set_fraction(fraction)
Gdk.threads_leave()
time.sleep(0.3)
Gdk.threads_enter()
_window.render_percentage.set_markup("<small>" + _("Render complete!") + "</small>")
self.set_render_stopped_gui_state()
Gdk.threads_leave()
