luna/devedeng-extended
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Passed autopep8

Browse source
This commit is contained in:
Sergio Costas 2017-01-06 19:36:01 +01:00
parent 27828d2dc5
commit fdf7f148c1
45 changed files with 3541 additions and 3338 deletions
Download patch file Download diff file Expand all files Collapse all files

20
setup.py
View file

@ -9,6 +9,7 @@ try:
except: except:
pass pass
def get_data_files(): def get_data_files():
data_files = [ data_files = [
(os.path.join('share', 'applications'), ['data/devedeng.desktop']), (os.path.join('share', 'applications'), ['data/devedeng.desktop']),
@ -18,15 +19,20 @@ def get_data_files():
(os.path.join('share', 'devedeng'), ['data/devedeng.svg']), (os.path.join('share', 'devedeng'), ['data/devedeng.svg']),
(os.path.join('share', 'devedeng'), ['data/codepages.lst']), (os.path.join('share', 'devedeng'), ['data/codepages.lst']),
(os.path.join('share', 'devedeng'), ['data/languages.lst']), (os.path.join('share', 'devedeng'), ['data/languages.lst']),
(os.path.join('share', 'devedeng', 'backgrounds'), glob('data/pixmaps/backgrounds/*')), (os.path.join('share', 'devedeng', 'backgrounds'),
glob('data/pixmaps/backgrounds/*')),
(os.path.join('share', 'doc', 'devedeng', 'html'), glob('doc/*')), (os.path.join('share', 'doc', 'devedeng', 'html'), glob('doc/*')),
(os.path.join('share', 'man', 'man1'), ['data/devede.1.gz']) (os.path.join('share', 'man', 'man1'), ['data/devede.1.gz'])
] ]
for lang_name in [f for f in os.listdir('locale')]: for lang_name in [f for f in os.listdir('locale')]:
mofile = os.path.join('locale', lang_name,'LC_MESSAGES','devedeng.mo') mofile = os.path.join('locale', lang_name,
# translations must be always in /usr/share because Gtk.builder only search there. If someone knows how to fix this... 'LC_MESSAGES', 'devedeng.mo')
target = os.path.join('/usr','share', 'locale', lang_name, 'LC_MESSAGES') # share/locale/fr/LC_MESSAGES/ # translations must be always in /usr/share because Gtk.builder only
# search there. If someone knows how to fix this...
# share/locale/fr/LC_MESSAGES/
target = os.path.join('/usr', 'share', 'locale',
lang_name, 'LC_MESSAGES')
data_files.append((target, [mofile])) data_files.append((target, [mofile]))
return data_files return data_files
@ -39,8 +45,10 @@ def compile_translations():
pofile = os.path.join('po', pofile) pofile = os.path.join('po', pofile)
lang = os.path.basename(pofile)[:-3] # len('.po') == 3 lang = os.path.basename(pofile)[:-3] # len('.po') == 3
modir = os.path.join('locale', lang, 'LC_MESSAGES') # e.g. locale/fr/LC_MESSAGES/ # e.g. locale/fr/LC_MESSAGES/
mofile = os.path.join(modir, 'devedeng.mo') # e.g. locale/fr/LC_MESSAGES/devedeng.mo modir = os.path.join('locale', lang, 'LC_MESSAGES')
# e.g. locale/fr/LC_MESSAGES/devedeng.mo
mofile = os.path.join(modir, 'devedeng.mo')
# create an architecture for these locales # create an architecture for these locales
if not os.path.isdir(modir): if not os.path.isdir(modir):

1
src/devedeng/__init__.py
View file

@ -16,4 +16,3 @@
# #
# You should have received a copy of the GNU General Public License # You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>. # along with this program. If not, see <http://www.gnu.org/licenses/>.

1
src/devedeng/about.py
View file

@ -19,6 +19,7 @@ from gi.repository import Gtk
import os import os
import devedeng.configuration_data import devedeng.configuration_data
class about_window: class about_window:
def __init__(self): def __init__(self):

1
src/devedeng/add_files.py
View file

@ -19,6 +19,7 @@ from gi.repository import Gtk
import os import os
import devedeng.configuration_data import devedeng.configuration_data
class add_files: class add_files:
last_path = None last_path = None

1
src/devedeng/ask.py
View file

@ -19,6 +19,7 @@ from gi.repository import Gtk
import os import os
import devedeng.configuration_data import devedeng.configuration_data
class ask_window: class ask_window:
def __init__(self): def __init__(self):

11
src/devedeng/ask_subtitles.py
View file

@ -20,6 +20,7 @@ import os
import devedeng.configuration_data import devedeng.configuration_data
import devedeng.add_files import devedeng.add_files
class ask_subtitles: class ask_subtitles:
def __init__(self): def __init__(self):
@ -31,7 +32,8 @@ class ask_subtitles:
builder = Gtk.Builder() builder = Gtk.Builder()
builder.set_translation_domain(self.config.gettext_domain) builder.set_translation_domain(self.config.gettext_domain)
builder.add_from_file(os.path.join(self.config.glade,"wask_subtitles.ui")) builder.add_from_file(os.path.join(
self.config.glade, "wask_subtitles.ui"))
builder.connect_signals(self) builder.connect_signals(self)
wask_window = builder.get_object("ask_subtitles") wask_window = builder.get_object("ask_subtitles")
self.wfilename = builder.get_object("subtitle_file") self.wfilename = builder.get_object("subtitle_file")
@ -42,7 +44,8 @@ class ask_subtitles:
wlanguage = builder.get_object("language_l") wlanguage = builder.get_object("language_l")
if (devedeng.add_files.add_files.last_path is not None): if (devedeng.add_files.add_files.last_path is not None):
self.wfilename.set_current_folder(devedeng.add_files.add_files.last_path) self.wfilename.set_current_folder(
devedeng.add_files.add_files.last_path)
lang_selection = 0 lang_selection = 0
enc_selection = 0 enc_selection = 0
@ -97,7 +100,8 @@ class ask_subtitles:
self.on_subtitle_file_set(None) self.on_subtitle_file_set(None)
retval = wask_window.run() retval = wask_window.run()
if (retval == 2): # accept if (retval == 2): # accept
self.put_upper = builder.get_object("put_subtitles_upper").get_active() self.put_upper = builder.get_object(
"put_subtitles_upper").get_active()
self.config.sub_codepage = wencoding.get_active_id() self.config.sub_codepage = wencoding.get_active_id()
self.config.sub_language = wlanguage.get_active_id() self.config.sub_language = wlanguage.get_active_id()
self.encoding = wencoding.get_active_id() self.encoding = wencoding.get_active_id()
@ -110,7 +114,6 @@ class ask_subtitles:
else: else:
return False return False
def on_subtitle_file_set(self, b): def on_subtitle_file_set(self, b):
f = self.wfilename.get_filename() f = self.wfilename.get_filename()

7
src/devedeng/avbase.py
View file

@ -20,12 +20,14 @@
import devedeng.executor import devedeng.executor
import subprocess import subprocess
class avbase(devedeng.executor.executor): class avbase(devedeng.executor.executor):
def check_version(self, cmd): def check_version(self, cmd):
try: try:
handle = subprocess.Popen(cmd, stdout = subprocess.PIPE, stderr = subprocess.PIPE) handle = subprocess.Popen(
cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdout, stderr) = handle.communicate() (stdout, stderr) = handle.communicate()
if 0 != handle.wait(): if 0 != handle.wait():
return False return False
@ -33,7 +35,6 @@ class avbase(devedeng.executor.executor):
return False return False
self.check_version_txt(stdout) self.check_version_txt(stdout)
def check_version_txt(self, vtext): def check_version_txt(self, vtext):
self.major_version = 0 self.major_version = 0
@ -60,5 +61,3 @@ class avbase(devedeng.executor.executor):
self.minor_version = minor self.minor_version = minor
return True return True
return False return False

54
src/devedeng/avconv.py
View file

@ -23,6 +23,7 @@ import devedeng.configuration_data
import devedeng.avbase import devedeng.avbase
import devedeng.mux_dvd_menu import devedeng.mux_dvd_menu
class avconv(devedeng.avbase.avbase): class avconv(devedeng.avbase.avbase):
supports_analize = False supports_analize = False
@ -34,11 +35,11 @@ class avconv(devedeng.avbase.avbase):
display_name = "AVCONV" display_name = "AVCONV"
disc_types = [] disc_types = []
@staticmethod @staticmethod
def check_is_installed(): def check_is_installed():
try: try:
handle = subprocess.Popen(["avconv","-codecs"], stdout = subprocess.PIPE, stderr = subprocess.PIPE) handle = subprocess.Popen(
["avconv", "-codecs"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdout, stderr) = handle.communicate() (stdout, stderr) = handle.communicate()
if 0 == handle.wait(): if 0 == handle.wait():
mp2 = False mp2 = False
@ -100,21 +101,21 @@ class avconv(devedeng.avbase.avbase):
except: except:
return False return False
def __init__(self): def __init__(self):
devedeng.executor.executor.__init__(self) devedeng.executor.executor.__init__(self)
self.config = devedeng.configuration_data.configuration.get_config() self.config = devedeng.configuration_data.configuration.get_config()
self.check_version(["avconv", "-version"]) self.check_version(["avconv", "-version"])
def convert_file(self, file_project, output_file, video_length, pass2=False): def convert_file(self, file_project, output_file, video_length, pass2=False):
if file_project.two_pass_encoding: if file_project.two_pass_encoding:
if pass2: if pass2:
self.text = _("Converting %(X)s (pass 2)") % {"X" : file_project.title_name} self.text = _("Converting %(X)s (pass 2)") % {
"X": file_project.title_name}
else: else:
self.text = _("Converting %(X)s (pass 1)") % {"X" : file_project.title_name} self.text = _("Converting %(X)s (pass 1)") % {
"X": file_project.title_name}
# Prepare the converting process for the second pass # Prepare the converting process for the second pass
tmp = devedeng.avconv.avconv() tmp = devedeng.avconv.avconv()
tmp.convert_file(file_project, output_file, video_length, True) tmp.convert_file(file_project, output_file, video_length, True)
@ -130,7 +131,9 @@ class avconv(devedeng.avbase.avbase):
second_pass = False second_pass = False
else: else:
# second_pass is TRUE in the second pass of a 2-pass codification, and also when not doing 2-pass codification # second_pass is TRUE in the second pass of a 2-pass codification, and also when not doing 2-pass codification
# It is used to remove unnecessary steps during the first pass, but that are needed on the second pass, or when not using 2-pass codification # It is used to remove unnecessary steps during the first pass, but
# that are needed on the second pass, or when not using 2-pass
# codification
second_pass = True second_pass = True
if (video_length == 0): if (video_length == 0):
@ -144,7 +147,8 @@ class avconv(devedeng.avbase.avbase):
if (file_project.volume != 100) and second_pass: if (file_project.volume != 100) and second_pass:
self.command_var.append("-vol") self.command_var.append("-vol")
self.command_var.append(str(int((256*file_project.volume)/100))) self.command_var.append(
str(int((256 * file_project.volume) / 100)))
if (file_project.audio_delay != 0.0) and (file_project.copy_sound == False) and (file_project.no_reencode_audio_video == False) and second_pass: if (file_project.audio_delay != 0.0) and (file_project.copy_sound == False) and (file_project.no_reencode_audio_video == False) and second_pass:
self.command_var.append("-itsoffset") self.command_var.append("-itsoffset")
@ -197,26 +201,33 @@ class avconv(devedeng.avbase.avbase):
if (file_project.width_midle != file_project.original_width) or (file_project.height_midle != file_project.original_height): if (file_project.width_midle != file_project.original_width) or (file_project.height_midle != file_project.original_height):
if (cmd_line != ""): if (cmd_line != ""):
cmd_line += ",fifo," cmd_line += ",fifo,"
x = int((file_project.width_midle - file_project.original_width) /2) x = int((file_project.width_midle -
y = int((file_project.height_midle - file_project.original_height) /2) file_project.original_width) / 2)
y = int((file_project.height_midle -
file_project.original_height) / 2)
if (x > 0) or (y > 0): if (x > 0) or (y > 0):
cmd_line+="pad="+str(file_project.width_midle)+":"+str(file_project.height_midle)+":"+str(x)+":"+str(y)+":0x000000" cmd_line += "pad=" + str(file_project.width_midle) + ":" + str(
file_project.height_midle) + ":" + str(x) + ":" + str(y) + ":0x000000"
else: else:
cmd_line+="crop="+str(file_project.width_midle)+":"+str(file_project.height_midle)+":"+str(x)+":"+str(y) cmd_line += "crop=" + str(file_project.width_midle) + ":" + str(
file_project.height_midle) + ":" + str(x) + ":" + str(y)
if (file_project.width_final != file_project.width_midle) or (file_project.height_final != file_project.height_midle): if (file_project.width_final != file_project.width_midle) or (file_project.height_final != file_project.height_midle):
if (cmd_line != ""): if (cmd_line != ""):
cmd_line += ",fifo," cmd_line += ",fifo,"
if self.major_version < 11: if self.major_version < 11:
cmd_line+="scale="+str(file_project.width_final)+":"+str(file_project.height_final) cmd_line += "scale=" + \
str(file_project.width_final) + ":" + \
str(file_project.height_final)
else: else:
cmd_line+="scale=w="+str(file_project.width_final)+":h="+str(file_project.height_final) cmd_line += "scale=w=" + \
str(file_project.width_final) + ":h=" + \
str(file_project.height_final)
if cmd_line != "": if cmd_line != "":
self.command_var.append("-vf") self.command_var.append("-vf")
self.command_var.append(cmd_line) self.command_var.append(cmd_line)
self.command_var.append("-y") self.command_var.append("-y")
vcd = False vcd = False
@ -278,7 +289,8 @@ class avconv(devedeng.avbase.avbase):
self.command_var.append("yuv420p") self.command_var.append("yuv420p")
self.command_var.append("-maxrate:v") self.command_var.append("-maxrate:v")
if maxrate > (devedeng.project.devede_project.dvd_max_bps_base[0] * 1000): if maxrate > (devedeng.project.devede_project.dvd_max_bps_base[0] * 1000):
maxrate = devedeng.project.devede_project.dvd_max_bps_base[0] * 1000 maxrate = devedeng.project.devede_project.dvd_max_bps_base[
0] * 1000
self.command_var.append(str(maxrate)) self.command_var.append(str(maxrate))
self.command_var.append("-minrate:v") self.command_var.append("-minrate:v")
if minrate < (devedeng.project.devede_project.dvd_min_bps * 1000): if minrate < (devedeng.project.devede_project.dvd_min_bps * 1000):
@ -373,7 +385,8 @@ class avconv(devedeng.avbase.avbase):
self.command_var.append("yuv420p") self.command_var.append("yuv420p")
self.command_var.append("-maxrate:v") self.command_var.append("-maxrate:v")
if maxrate > (devedeng.project.devede_project.svcd_max_bps_base[0] * 1000): if maxrate > (devedeng.project.devede_project.svcd_max_bps_base[0] * 1000):
maxrate = devedeng.project.devede_project.svcd_max_bps_base[0] * 1000 maxrate = devedeng.project.devede_project.svcd_max_bps_base[
0] * 1000
self.command_var.append(str(maxrate)) self.command_var.append(str(maxrate))
self.command_var.append("-minrate:v") self.command_var.append("-minrate:v")
if minrate < (devedeng.project.devede_project.svcd_min_bps * 1000): if minrate < (devedeng.project.devede_project.svcd_min_bps * 1000):
@ -446,7 +459,8 @@ class avconv(devedeng.avbase.avbase):
if (file_project.no_reencode_audio_video == False) and (vcd == False) and second_pass: if (file_project.no_reencode_audio_video == False) and (vcd == False) and second_pass:
self.command_var.append("-s") self.command_var.append("-s")
self.command_var.append(str(file_project.width_final)+"x"+str(file_project.height_final)) self.command_var.append(
str(file_project.width_final) + "x" + str(file_project.height_final))
if second_pass: if second_pass:
self.command_var.append("-trellis") self.command_var.append("-trellis")
@ -477,7 +491,6 @@ class avconv(devedeng.avbase.avbase):
self.command_var.append(output_file) self.command_var.append(output_file)
def create_menu_mpeg(self, n_page, background_music, sound_length, pal, video_rate, audio_rate, output_path, use_mp2): def create_menu_mpeg(self, n_page, background_music, sound_length, pal, video_rate, audio_rate, output_path, use_mp2):
self.n_page = n_page self.n_page = n_page
@ -493,7 +506,8 @@ class avconv(devedeng.avbase.avbase):
self.command_var.append("-f") self.command_var.append("-f")
self.command_var.append("image2") self.command_var.append("image2")
self.command_var.append("-i") self.command_var.append("-i")
self.command_var.append(os.path.join(output_path,"menu_"+str(n_page)+"_bg.png")) self.command_var.append(os.path.join(
output_path, "menu_" + str(n_page) + "_bg.png"))
self.command_var.append("-i") self.command_var.append("-i")
self.command_var.append(background_music) self.command_var.append(background_music)

47
src/devedeng/avprobe.py
View file

@ -23,6 +23,7 @@ import devedeng.executor
import os import os
import json import json
class avprobe(devedeng.avbase.avbase): class avprobe(devedeng.avbase.avbase):
supports_analize = True supports_analize = True
@ -36,7 +37,8 @@ class avprobe(devedeng.avbase.avbase):
@staticmethod @staticmethod
def check_is_installed(): def check_is_installed():
try: try:
handle = subprocess.Popen(["avprobe","-h"], stdout = subprocess.PIPE, stderr = subprocess.PIPE) handle = subprocess.Popen(
["avprobe", "-h"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdout, stderr) = handle.communicate() (stdout, stderr) = handle.communicate()
if 0 == handle.wait(): if 0 == handle.wait():
return True return True
@ -62,7 +64,8 @@ class avprobe(devedeng.avbase.avbase):
self.original_file_size = os.path.getsize(file_name) self.original_file_size = os.path.getsize(file_name)
command_line = ["avprobe",file_name,"-of","json","-show_streams", "-loglevel", "quiet"] command_line = ["avprobe", file_name, "-of",
"json", "-show_streams", "-loglevel", "quiet"]
(stdout, stderr) = self.launch_process(command_line, False) (stdout, stderr) = self.launch_process(command_line, False)
@ -73,7 +76,6 @@ class avprobe(devedeng.avbase.avbase):
self.config.append_static_log("AVProbe JSON data: " + str(stdout2)) self.config.append_static_log("AVProbe JSON data: " + str(stdout2))
return self.process_json(stdout2, file_name) return self.process_json(stdout2, file_name)
def process_json(self, stdout2, file_name): def process_json(self, stdout2, file_name):
self.audio_list = [] self.audio_list = []
@ -89,7 +91,8 @@ class avprobe(devedeng.avbase.avbase):
self.original_fps = 0 self.original_fps = 0
self.original_aspect_ratio = 0 self.original_aspect_ratio = 0
self.config.append_static_log("Getting data for {:s} with avprobe".format(file_name)) self.config.append_static_log(
"Getting data for {:s} with avprobe".format(file_name))
try: try:
video_data = json.loads(stdout2) video_data = json.loads(stdout2)
except: except:
@ -113,26 +116,34 @@ class avprobe(devedeng.avbase.avbase):
self.original_width = int(float(element["width"])) self.original_width = int(float(element["width"]))
self.original_height = int(float(element["height"])) self.original_height = int(float(element["height"]))
if ("bit_rate" in element): if ("bit_rate" in element):
self.original_videorate = int(float(element["bit_rate"]))/1000 self.original_videorate = int(
self.original_fps = self.get_division(element["avg_frame_rate"]) float(element["bit_rate"])) / 1000
self.original_fps = self.get_division(
element["avg_frame_rate"])
if ("display_aspect_ratio" in element): if ("display_aspect_ratio" in element):
self.original_aspect_ratio = self.get_division(element["display_aspect_ratio"]) self.original_aspect_ratio = self.get_division(
element["display_aspect_ratio"])
elif (element["codec_type"] == "audio"): elif (element["codec_type"] == "audio"):
self.audio_streams += 1 self.audio_streams += 1
self.audio_list.append(element["index"]) self.audio_list.append(element["index"])
if (self.audio_streams == 1): if (self.audio_streams == 1):
if ("bit_rate" in element): if ("bit_rate" in element):
self.original_audiorate = int(float(element["bit_rate"]))/1000 self.original_audiorate = int(
self.original_audiorate_uncompressed = int(float(element["sample_rate"])) float(element["bit_rate"])) / 1000
self.original_audiorate_uncompressed = int(
float(element["sample_rate"]))
self.original_size = str(self.original_width)+"x"+str(self.original_height) self.original_size = str(self.original_width) + \
"x" + str(self.original_height)
if (self.original_aspect_ratio is None) or (self.original_aspect_ratio <= 1.0): if (self.original_aspect_ratio is None) or (self.original_aspect_ratio <= 1.0):
if (self.original_height != 0): if (self.original_height != 0):
self.original_aspect_ratio = (float(self.original_width))/(float(self.original_height)) self.original_aspect_ratio = (
float(self.original_width)) / (float(self.original_height))
if (self.original_aspect_ratio is not None): if (self.original_aspect_ratio is not None):
self.original_aspect_ratio = (float(int(self.original_aspect_ratio*1000.0)))/1000.0 self.original_aspect_ratio = (
float(int(self.original_aspect_ratio * 1000.0))) / 1000.0
if (len(self.video_list) == 0): if (len(self.video_list) == 0):
return True # the file is not a video file; maybe an audio-only file or another thing return True # the file is not a video file; maybe an audio-only file or another thing
@ -141,15 +152,19 @@ class avprobe(devedeng.avbase.avbase):
command_line = ["avprobe", file_name] command_line = ["avprobe", file_name]
(stdout, stderr) = self.launch_process(command_line, False) (stdout, stderr) = self.launch_process(command_line, False)
try: try:
stdout2 = stdout.decode("utf-8") + "\n" + stderr.decode("utf-8") stdout2 = stdout.decode("utf-8") + \
"\n" + stderr.decode("utf-8")
except: except:
stdout2 = stdout.decode("latin1") + "\n" + stderr.decode("latin1") stdout2 = stdout.decode("latin1") + \
self.config.append_static_log("Using avprobe human readable format: "+str(stdout2)) "\n" + stderr.decode("latin1")
self.config.append_static_log(
"Using avprobe human readable format: " + str(stdout2))
for line in stdout2.split("\n"): for line in stdout2.split("\n"):
line = line.strip() line = line.strip()
if line.startswith("Duration: "): if line.startswith("Duration: "):
self.original_length = self.get_time(line[10:]) self.original_length = self.get_time(line[10:])
break break
self.config.append_static_log("Estimated length: {:d}; Resolution: {:s}".format(self.original_length,self.original_size)) self.config.append_static_log("Estimated length: {:d}; Resolution: {:s}".format(
self.original_length, self.original_size))
return False # no error return False # no error

4
src/devedeng/brasero.py
View file

@ -19,6 +19,7 @@ import subprocess
import devedeng.configuration_data import devedeng.configuration_data
import devedeng.executor import devedeng.executor
class brasero(devedeng.executor.executor): class brasero(devedeng.executor.executor):
supports_analize = False supports_analize = False
@ -32,7 +33,8 @@ class brasero(devedeng.executor.executor):
@staticmethod @staticmethod
def check_is_installed(): def check_is_installed():
try: try:
handle = subprocess.Popen(["brasero","-h"], stdout = subprocess.PIPE, stderr = subprocess.PIPE) handle = subprocess.Popen(
["brasero", "-h"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdout, stderr) = handle.communicate() (stdout, stderr) = handle.communicate()
if 0 == handle.wait(): if 0 == handle.wait():
return True return True

74
src/devedeng/choose_disc_type.py
View file

@ -21,6 +21,7 @@ import subprocess
import devedeng.configuration_data import devedeng.configuration_data
class choose_disc_type(GObject.GObject): class choose_disc_type(GObject.GObject):
def __init__(self): def __init__(self):
@ -30,7 +31,8 @@ class choose_disc_type(GObject.GObject):
builder = Gtk.Builder() builder = Gtk.Builder()
builder.set_translation_domain(self.config.gettext_domain) builder.set_translation_domain(self.config.gettext_domain)
builder.add_from_file(os.path.join(self.config.glade,"wselect_disk.ui")) builder.add_from_file(os.path.join(
self.config.glade, "wselect_disk.ui"))
builder.connect_signals(self) builder.connect_signals(self)
self.wask_window = builder.get_object("wselect_disk") self.wask_window = builder.get_object("wselect_disk")
@ -93,7 +95,8 @@ class choose_disc_type(GObject.GObject):
def check_program(self, command_line): def check_program(self, command_line):
try: try:
handle = subprocess.Popen(command_line, stdout = subprocess.PIPE, stderr = subprocess.PIPE) handle = subprocess.Popen(
command_line, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdout, stderr) = handle.communicate() (stdout, stderr) = handle.communicate()
retval = handle.wait() retval = handle.wait()
return True return True
@ -151,18 +154,24 @@ class choose_disc_type(GObject.GObject):
text = "" text = ""
for e in analizers: for e in analizers:
if analizers_i.count(e.display_name) == 0: if analizers_i.count(e.display_name) == 0:
text += _("\t%(program_name)s (not installed)\n") % {"program_name": e.display_name} text += _("\t%(program_name)s (not installed)\n") % {
"program_name": e.display_name}
else: else:
text += _("\t%(program_name)s (installed)\n") % {"program_name": e.display_name} text += _("\t%(program_name)s (installed)\n") % {
text1 = _("Movie identifiers (install at least one of these):\n\n%(program_list)s\n") % {"program_list" : text} "program_name": e.display_name}
text1 = _("Movie identifiers (install at least one of these):\n\n%(program_list)s\n") % {
"program_list": text}
text = "" text = ""
for e in players: for e in players:
if players_i.count(e.display_name) == 0: if players_i.count(e.display_name) == 0:
text += _("\t%(program_name)s (not installed)\n") % {"program_name": e.display_name} text += _("\t%(program_name)s (not installed)\n") % {
"program_name": e.display_name}
else: else:
text += _("\t%(program_name)s (installed)\n") % {"program_name": e.display_name} text += _("\t%(program_name)s (installed)\n") % {
text2 = _("Movie players (install at least one of these):\n\n%(program_list)s\n") % {"program_list" : text} "program_name": e.display_name}
text2 = _("Movie players (install at least one of these):\n\n%(program_list)s\n") % {
"program_list": text}
text = "" text = ""
for e in converters: for e in converters:
@ -172,49 +181,64 @@ class choose_disc_type(GObject.GObject):
sup += ", " sup += ", "
sup += s sup += s
if converters_i.count(e.display_name) == 0: if converters_i.count(e.display_name) == 0:
text += _("\t%(program_name)s (not installed)\n") % {"program_name": e.display_name + " ("+sup+")"} text += _("\t%(program_name)s (not installed)\n") % {
"program_name": e.display_name + " (" + sup + ")"}
else: else:
text += _("\t%(program_name)s (installed)\n") % {"program_name": e.display_name + " ("+sup+")"} text += _("\t%(program_name)s (installed)\n") % {
text3 = _("Movie Converters (install at least one of these):\n\n%(program_list)s\n") % {"program_list" : text} "program_name": e.display_name + " (" + sup + ")"}
text3 = _("Movie Converters (install at least one of these):\n\n%(program_list)s\n") % {
"program_list": text}
text = "" text = ""
for e in burners: for e in burners:
if burners_i.count(e.display_name) == 0: if burners_i.count(e.display_name) == 0:
text += _("\t%(program_name)s (not installed)\n") % {"program_name": e.display_name} text += _("\t%(program_name)s (not installed)\n") % {
"program_name": e.display_name}
else: else:
text += _("\t%(program_name)s (installed)\n") % {"program_name": e.display_name} text += _("\t%(program_name)s (installed)\n") % {
text4 = _("CD/DVD burners (install at least one of these):\n\n%(program_list)s\n") % {"program_list" : text} "program_name": e.display_name}
text4 = _(
"CD/DVD burners (install at least one of these):\n\n%(program_list)s\n") % {"program_list": text}
text = "" text = ""
for e in mkiso: for e in mkiso:
if mkiso_i.count(e.display_name) == 0: if mkiso_i.count(e.display_name) == 0:
text += _("\t%(program_name)s (not installed)\n") % {"program_name": e.display_name} text += _("\t%(program_name)s (not installed)\n") % {
"program_name": e.display_name}
else: else:
text += _("\t%(program_name)s (installed)\n") % {"program_name": e.display_name} text += _("\t%(program_name)s (installed)\n") % {
text5 = _("ISO creators (install at least one of these):\n\n%(program_list)s\n") % {"program_list" : text} "program_name": e.display_name}
text5 = _("ISO creators (install at least one of these):\n\n%(program_list)s\n") % {
"program_list": text}
text = "" text = ""
if self.check_program(["dvdauthor", "--help"]) == False: if self.check_program(["dvdauthor", "--help"]) == False:
text += _("\t%(program_name)s (not installed)\n") % {"program_name": "DVDAUTHOR (dvd)"} text += _("\t%(program_name)s (not installed)\n") % {
"program_name": "DVDAUTHOR (dvd)"}
else: else:
text += _("\t%(program_name)s (installed)\n") % {"program_name": "DVDAUTHOR (dvd)"} text += _("\t%(program_name)s (installed)\n") % {
"program_name": "DVDAUTHOR (dvd)"}
if self.check_program(["vcdimager", "--help"]) == False: if self.check_program(["vcdimager", "--help"]) == False:
text += _("\t%(program_name)s (not installed)\n") % {"program_name": "VCDIMAGER (vcd, svcd, cvd)"} text += _("\t%(program_name)s (not installed)\n") % {
"program_name": "VCDIMAGER (vcd, svcd, cvd)"}
else: else:
text += _("\t%(program_name)s (installed)\n") % {"program_name": "VCDIMAGER (vcd, svcd, cvd)"} text += _("\t%(program_name)s (installed)\n") % {
"program_name": "VCDIMAGER (vcd, svcd, cvd)"}
if self.check_program(["spumux", "--help"]) == False: if self.check_program(["spumux", "--help"]) == False:
text += _("\t%(program_name)s (not installed)\n") % {"program_name": "SPUMUX (dvd, vcd, svcd, cvd)"} text += _("\t%(program_name)s (not installed)\n") % {
"program_name": "SPUMUX (dvd, vcd, svcd, cvd)"}
else: else:
text += _("\t%(program_name)s (installed)\n") % {"program_name": "SPUMUX (dvd, vcd, svcd, cvd)"} text += _("\t%(program_name)s (installed)\n") % {
"program_name": "SPUMUX (dvd, vcd, svcd, cvd)"}
text6 = _("Other programs:\n\n%(program_list)s\n") % {"program_list" : text} text6 = _("Other programs:\n\n%(program_list)s\n") % {
"program_list": text}
final_text = text1 + text2 + text3 + text4 + text5 + text6 final_text = text1 + text2 + text3 + text4 + text5 + text6
textbuf.insert_at_cursor(final_text, len(final_text)) textbuf.insert_at_cursor(final_text, len(final_text))
window.run() window.run()
window.destroy() window.destroy()
def on_wselect_disk_destroy_event(self, w, b): def on_wselect_disk_destroy_event(self, w, b):
Gtk.main_quit() Gtk.main_quit()

53
src/devedeng/configuration_data.py
View file

@ -21,6 +21,7 @@ from gi.repository import GObject
import os import os
import pkg_resources import pkg_resources
class configuration(GObject.GObject): class configuration(GObject.GObject):
current_configuration = None current_configuration = None
@ -70,7 +71,8 @@ class configuration(GObject.GObject):
return True return True
else: else:
if (is_local): if (is_local):
# locales must be always at /usr/share/locale because Gtk.Builder always search there # locales must be always at /usr/share/locale because
# Gtk.Builder always search there
self.share_locale = "/usr/share/locale" self.share_locale = "/usr/share/locale"
self.glade = "/usr/local/share/devedeng" self.glade = "/usr/local/share/devedeng"
self.font_path = "/usr/local/share/devedeng" self.font_path = "/usr/local/share/devedeng"
@ -159,10 +161,12 @@ class configuration(GObject.GObject):
continue continue
if linea[:20] == "subtitle_fill_color:": if linea[:20] == "subtitle_fill_color:":
c = linea[20:].strip().split(",") c = linea[20:].strip().split(",")
self.subt_fill_color = (float(c[0]), float(c[1]), float(c[2]), 1.0) self.subt_fill_color = (
float(c[0]), float(c[1]), float(c[2]), 1.0)
if linea[:23] == "subtitle_outline_color:": if linea[:23] == "subtitle_outline_color:":
c = linea[23:].strip().split(",") c = linea[23:].strip().split(",")
self.subt_outline_color = (float(c[0]), float(c[1]), float(c[2]), 1.0) self.subt_outline_color = (
float(c[0]), float(c[1]), float(c[2]), 1.0)
if linea[:27] == "subtitle_outilne_thickness:": if linea[:27] == "subtitle_outilne_thickness:":
self.subt_outline_thickness = float(linea[27:].strip()) self.subt_outline_thickness = float(linea[27:].strip())
config_data.close() config_data.close()
@ -171,7 +175,6 @@ class configuration(GObject.GObject):
return False return False
def set_disc_type(self, disc_type): def set_disc_type(self, disc_type):
self.disc_type = disc_type self.disc_type = disc_type
@ -179,7 +182,6 @@ class configuration(GObject.GObject):
self.clear_log() self.clear_log()
self.emit('disc_type', disc_type) self.emit('disc_type', disc_type)
def save_config(self): def save_config(self):
config_path = os.path.join(os.environ.get("HOME"), ".devedeng") config_path = os.path.join(os.environ.get("HOME"), ".devedeng")
@ -194,44 +196,55 @@ class configuration(GObject.GObject):
config_data.write("temp_folder:" + str(self.tmp_folder) + "\n") config_data.write("temp_folder:" + str(self.tmp_folder) + "\n")
config_data.write("multicore:" + str(self.multicore) + "\n") config_data.write("multicore:" + str(self.multicore) + "\n")
if (self.final_folder is not None): if (self.final_folder is not None):
config_data.write("final_folder:"+str(self.final_folder)+"\n") config_data.write("final_folder:" +
str(self.final_folder) + "\n")
if (self.sub_language is not None): if (self.sub_language is not None):
config_data.write("sub_language:"+str(self.sub_language)+"\n") config_data.write("sub_language:" +
str(self.sub_language) + "\n")
if (self.sub_codepage is not None): if (self.sub_codepage is not None):
config_data.write("sub_codepage:"+str(self.sub_codepage)+"\n") config_data.write("sub_codepage:" +
str(self.sub_codepage) + "\n")
if (self.film_analizer is not None): if (self.film_analizer is not None):
config_data.write("film_analizer:"+str(self.film_analizer)+"\n") config_data.write("film_analizer:" +
str(self.film_analizer) + "\n")
if (self.film_player is not None): if (self.film_player is not None):
config_data.write("film_player:"+str(self.film_player)+"\n") config_data.write(
"film_player:" + str(self.film_player) + "\n")
if (self.film_converter is not None): if (self.film_converter is not None):
config_data.write("film_converter:"+str(self.film_converter)+"\n") config_data.write("film_converter:" +
str(self.film_converter) + "\n")
if (self.menu_converter is not None): if (self.menu_converter is not None):
config_data.write("menu_converter:"+str(self.menu_converter)+"\n") config_data.write("menu_converter:" +
str(self.menu_converter) + "\n")
if self.burner is not None: if self.burner is not None:
config_data.write("burner:" + str(self.burner) + "\n") config_data.write("burner:" + str(self.burner) + "\n")
if self.mkiso is not None: if self.mkiso is not None:
config_data.write("mkiso:" + str(self.mkiso) + "\n") config_data.write("mkiso:" + str(self.mkiso) + "\n")
if (self.sub_codepage is not None): if (self.sub_codepage is not None):
config_data.write("sub_codepage:"+str(self.sub_codepage)+"\n") config_data.write("sub_codepage:" +
str(self.sub_codepage) + "\n")
if (self.sub_language is not None): if (self.sub_language is not None):
config_data.write("sub_language:"+str(self.sub_language)+"\n") config_data.write("sub_language:" +
config_data.write("subtitle_font_size:"+str(self.subtitles_font_size)+"\n") str(self.sub_language) + "\n")
config_data.write("subtitle_fill_color:"+str(self.subt_fill_color[0])+","+str(self.subt_fill_color[1])+","+str(self.subt_fill_color[2])+"\n") config_data.write("subtitle_font_size:" +
config_data.write("subtitle_outline_color:"+str(self.subt_outline_color[0])+","+str(self.subt_outline_color[1])+","+str(self.subt_outline_color[2])+"\n") str(self.subtitles_font_size) + "\n")
config_data.write("subtitle_outilne_thickness:"+str(self.subt_outline_thickness)) config_data.write("subtitle_fill_color:" + str(self.subt_fill_color[0]) + "," + str(
self.subt_fill_color[1]) + "," + str(self.subt_fill_color[2]) + "\n")
config_data.write("subtitle_outline_color:" + str(self.subt_outline_color[0]) + "," + str(
self.subt_outline_color[1]) + "," + str(self.subt_outline_color[2]) + "\n")
config_data.write("subtitle_outilne_thickness:" +
str(self.subt_outline_thickness))
config_data.close() config_data.close()
except: except:
pass pass
def append_log(self, data, cr=True): def append_log(self, data, cr=True):
self.log += data self.log += data
if (cr): if (cr):
self.log += "\n" self.log += "\n"
def append_static_log(self, data, cr=True): def append_static_log(self, data, cr=True):
self.static_log += data self.static_log += data

11
src/devedeng/converter.py
View file

@ -28,6 +28,7 @@ import devedeng.mkisofs
import devedeng.genisoimage import devedeng.genisoimage
import devedeng.mpv import devedeng.mpv
class converter: class converter:
current_converter = None current_converter = None
@ -38,7 +39,6 @@ class converter:
converter.current_converter = converter() converter.current_converter = converter()
return converter.current_converter return converter.current_converter
def __init__(self): def __init__(self):
self.config = devedeng.configuration_data.configuration.get_config() self.config = devedeng.configuration_data.configuration.get_config()
@ -92,7 +92,6 @@ class converter:
if (self.default_burner is None): if (self.default_burner is None):
self.default_burner = element self.default_burner = element
def get_supported_programs(self): def get_supported_programs(self):
analizers = [] analizers = []
@ -118,7 +117,6 @@ class converter:
return (analizers, players, menuers, converters, burners, mkiso) return (analizers, players, menuers, converters, burners, mkiso)
def get_available_programs(self): def get_available_programs(self):
players = [] players = []
@ -143,7 +141,6 @@ class converter:
return (analizers, players, menuers, converters, burners, mkiso) return (analizers, players, menuers, converters, burners, mkiso)
def get_needed_programs(self): def get_needed_programs(self):
""" returns a tupla with six lists. When a list is NONE, there are installed in the system """ returns a tupla with six lists. When a list is NONE, there are installed in the system
programs that covers the needs for that group; when not, it contains the programs valid programs that covers the needs for that group; when not, it contains the programs valid
@ -221,13 +218,15 @@ class converter:
def get_disc_converter(self): def get_disc_converter(self):
""" returns a class for the desired disc converter, or the most priviledged if the desired is not installed """ """ returns a class for the desired disc converter, or the most priviledged if the desired is not installed """
# if there is a film converter chosen by the user, and it is installed in the system # if there is a film converter chosen by the user, and it is installed
# in the system
if (self.config.film_converter is not None) and (self.config.film_converter in self.converters): if (self.config.film_converter is not None) and (self.config.film_converter in self.converters):
# and that converter supports the current disc type # and that converter supports the current disc type
if self.converters[self.config.film_converter].disc_types.count(self.config.disc_type) != 0: if self.converters[self.config.film_converter].disc_types.count(self.config.disc_type) != 0:
# return that converter # return that converter
return self.converters[self.config.film_converter] return self.converters[self.config.film_converter]
# if not, return the first available converter that supports the current disc type # if not, return the first available converter that supports the
# current disc type
for converter in self.converters: for converter in self.converters:
if self.converters[converter].disc_types.count(self.config.disc_type) != 0: if self.converters[converter].disc_types.count(self.config.disc_type) != 0:
return self.converters[converter] return self.converters[converter]

1
src/devedeng/create_disk_window.py
View file

@ -19,6 +19,7 @@ from gi.repository import Gtk
import os import os
import devedeng.configuration_data import devedeng.configuration_data
class create_disk_window: class create_disk_window:
def __init__(self): def __init__(self):

174
src/devedeng/dvd_menu.py
View file

@ -23,6 +23,7 @@ import devedeng.interface_manager
import devedeng.message import devedeng.message
import devedeng.mux_dvd_menu import devedeng.mux_dvd_menu
class dvd_menu(devedeng.interface_manager.interface_manager): class dvd_menu(devedeng.interface_manager.interface_manager):
def __init__(self): def __init__(self):
@ -33,20 +34,26 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
devedeng.interface_manager.interface_manager.__init__(self) devedeng.interface_manager.interface_manager.__init__(self)
self.config = devedeng.configuration_data.configuration.get_config() self.config = devedeng.configuration_data.configuration.get_config()
self.default_background = os.path.join(self.config.pic_path,"backgrounds","default_bg.png") self.default_background = os.path.join(
self.config.pic_path, "backgrounds", "default_bg.png")
self.default_sound = os.path.join(self.config.pic_path, "silence.ogg") self.default_sound = os.path.join(self.config.pic_path, "silence.ogg")
self.add_colorbutton("title_color", (0, 0, 0, 1), self.update_preview) self.add_colorbutton("title_color", (0, 0, 0, 1), self.update_preview)
self.add_colorbutton("title_shadow", (0, 0, 0, 0), self.update_preview) self.add_colorbutton("title_shadow", (0, 0, 0, 0), self.update_preview)
self.add_colorbutton("unselected_color", (1,1,1,1), self.update_preview) self.add_colorbutton("unselected_color",
(1, 1, 1, 1), self.update_preview)
self.add_colorbutton("shadow_color", (0, 0, 0, 0), self.update_preview) self.add_colorbutton("shadow_color", (0, 0, 0, 0), self.update_preview)
self.add_colorbutton("selected_color", (0,1,1,1), self.update_preview) self.add_colorbutton(
self.add_colorbutton("background_color", (0,0,0,0.75), self.update_preview) "selected_color", (0, 1, 1, 1), self.update_preview)
self.add_colorbutton("background_color",
(0, 0, 0, 0.75), self.update_preview)
self.add_text("title_text", None, self.update_preview) self.add_text("title_text", None, self.update_preview)
self.add_group("position_horizontal", ["left", "center", "right"], "center", self.update_preview) self.add_group("position_horizontal", [
self.add_group("at_startup", ["menu_show_at_startup", "play_first_title_at_startup"], "menu_show_at_startup") "left", "center", "right"], "center", self.update_preview)
self.add_group("at_startup", [
"menu_show_at_startup", "play_first_title_at_startup"], "menu_show_at_startup")
self.add_toggle("play_all_c", False, self.update_preview) self.add_toggle("play_all_c", False, self.update_preview)
self.add_integer_adjustment("sound_length", 30) self.add_integer_adjustment("sound_length", 30)
@ -63,8 +70,10 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.add_fontbutton("title_font", "Sans 28", self.update_preview) self.add_fontbutton("title_font", "Sans 28", self.update_preview)
self.add_fontbutton("entry_font", "Sans 28", self.update_preview) self.add_fontbutton("entry_font", "Sans 28", self.update_preview)
self.add_filebutton("background_picture", self.default_background, self.update_preview) self.add_filebutton("background_picture",
self.add_filebutton("background_music", self.default_sound, self.update_music) self.default_background, self.update_preview)
self.add_filebutton("background_music",
self.default_sound, self.update_music)
self.cached_menu_font = None self.cached_menu_font = None
self.cached_menu_size = 0 self.cached_menu_size = 0
@ -77,47 +86,46 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
def get_estimated_size(self): def get_estimated_size(self):
estimated_size = ((self.video_rate + self.audio_rate) * self.sound_length) / 8 estimated_size = ((self.video_rate + self.audio_rate)
* self.sound_length) / 8
return estimated_size return estimated_size
def update_music(self, b=None): def update_music(self, b=None):
self.store_ui(self.builder) self.store_ui(self.builder)
cv = devedeng.converter.converter.get_converter() cv = devedeng.converter.converter.get_converter()
film_analizer = (cv.get_film_analizer())() film_analizer = (cv.get_film_analizer())()
(video, audio, length) = film_analizer.analize_film_data(self.background_music,True) (video, audio, length) = film_analizer.analize_film_data(
self.background_music, True)
if (video != 0): if (video != 0):
devedeng.message.message_window(_("The selected file is a video, not an audio file"),_("Error")) devedeng.message.message_window(
_("The selected file is a video, not an audio file"), _("Error"))
self.on_no_sound_clicked(None) self.on_no_sound_clicked(None)
elif (audio == 0): elif (audio == 0):
devedeng.message.message_window(_("The selected file is not an audio file"),_("Error")) devedeng.message.message_window(
_("The selected file is not an audio file"), _("Error"))
self.on_no_sound_clicked(None) self.on_no_sound_clicked(None)
else: else:
self.sound_length = length self.sound_length = length
def update_preview(self, b=None): def update_preview(self, b=None):
self.store_ui(self.builder) self.store_ui(self.builder)
self.sf = None # force to repaint the menu self.sf = None # force to repaint the menu
self.wdrawing_area.queue_draw() self.wdrawing_area.queue_draw()
def on_default_background_clicked(self, b): def on_default_background_clicked(self, b):
self.background_picture = self.default_background self.background_picture = self.default_background
self.update_ui(self.builder) self.update_ui(self.builder)
self.update_preview() self.update_preview()
def on_no_sound_clicked(self, b): def on_no_sound_clicked(self, b):
self.background_music = self.default_sound self.background_music = self.default_sound
self.sound_length = 30 self.sound_length = 30
self.update_ui(self.builder) self.update_ui(self.builder)
def show_configuration(self, file_list): def show_configuration(self, file_list):
self.builder = Gtk.Builder() self.builder = Gtk.Builder()
@ -130,7 +138,8 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.builder.connect_signals(self) self.builder.connect_signals(self)
self.wframe_preview = self.builder.get_object("frame_preview") self.wframe_preview = self.builder.get_object("frame_preview")
self.wframe_preview_controls = self.builder.get_object("frame_preview_controls") self.wframe_preview_controls = self.builder.get_object(
"frame_preview_controls")
self.wmenu = self.builder.get_object("menu") self.wmenu = self.builder.get_object("menu")
self.wpreview_menu = self.builder.get_object("preview_menu") self.wpreview_menu = self.builder.get_object("preview_menu")
self.wdrawing_area = self.builder.get_object("drawingarea_preview") self.wdrawing_area = self.builder.get_object("drawingarea_preview")
@ -138,7 +147,8 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.wshow_as_selected = self.builder.get_object("show_as_selected") self.wshow_as_selected = self.builder.get_object("show_as_selected")
self.wshow_as_selected.connect("toggled", self.update_preview) self.wshow_as_selected.connect("toggled", self.update_preview)
self.wbackground_picture = self.builder.get_object("background_picture") self.wbackground_picture = self.builder.get_object(
"background_picture")
self.wbackground_music = self.builder.get_object("background_music") self.wbackground_music = self.builder.get_object("background_music")
file_filter_pictures = Gtk.FileFilter() file_filter_pictures = Gtk.FileFilter()
@ -171,19 +181,16 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.update_ui(self.builder) self.update_ui(self.builder)
self.save_ui() self.save_ui()
def on_accept_clicked(self, b): def on_accept_clicked(self, b):
self.store_ui(self.builder) self.store_ui(self.builder)
self.wmenu.destroy() self.wmenu.destroy()
def on_cancel_clicked(self, b): def on_cancel_clicked(self, b):
self.restore_ui() self.restore_ui()
self.wmenu.destroy() self.wmenu.destroy()
def get_font_params(self, font_name): def get_font_params(self, font_name):
font_elements = font_name.split(" ") font_elements = font_name.split(" ")
@ -216,7 +223,6 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
return fontname, fontstyle, fontslant, fontsize return fontname, fontstyle, fontslant, fontsize
def paint_arrow(self, xl, xr, y, arrow_type, left): def paint_arrow(self, xl, xr, y, arrow_type, left):
if arrow_type == "menu_entry": if arrow_type == "menu_entry":
@ -224,7 +230,8 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
elif arrow_type == "menu_entry_selected": elif arrow_type == "menu_entry_selected":
fgcolor = self.selected_color fgcolor = self.selected_color
elif arrow_type == "menu_entry_activated": elif arrow_type == "menu_entry_activated":
fgcolor = ( 1.0 - self.selected_color[0], 1.0 - self.selected_color[1], 1.0 - self.selected_color[2], self.selected_color[3]) fgcolor = (1.0 - self.selected_color[0], 1.0 - self.selected_color[
1], 1.0 - self.selected_color[2], self.selected_color[3])
else: else:
return return
@ -250,7 +257,6 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.cr.set_font_options(fo) self.cr.set_font_options(fo)
self.cr.set_antialias(cairo.ANTIALIAS_DEFAULT) self.cr.set_antialias(cairo.ANTIALIAS_DEFAULT)
def write_text(self, text, text_type, xl, xr, y, alignment): def write_text(self, text, text_type, xl, xr, y, alignment):
""" Renders a line of text, in the rectangle delimited by xl,y-h;xr,y+h, with the specified alignment """ """ Renders a line of text, in the rectangle delimited by xl,y-h;xr,y+h, with the specified alignment """
@ -273,7 +279,8 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
hard_borders = True hard_borders = True
font = self.entry_font font = self.entry_font
elif text_type == "menu_entry_activated": elif text_type == "menu_entry_activated":
fgcolor = ( 1.0 - self.selected_color[0], 1.0 - self.selected_color[1], 1.0 - self.selected_color[2], self.selected_color[3]) fgcolor = (1.0 - self.selected_color[0], 1.0 - self.selected_color[
1], 1.0 - self.selected_color[2], self.selected_color[3])
bgcolor = None bgcolor = None
hard_borders = True hard_borders = True
font = self.entry_font font = self.entry_font
@ -299,8 +306,10 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
x = ((xl + xr) / 2.0) - (extents[2] / 2.0) x = ((xl + xr) / 2.0) - (extents[2] / 2.0)
if (bgcolor is not None): if (bgcolor is not None):
self.cr.move_to(x+extents[0]+2,y-(extents[3]/2.0)-extents[1]+2) self.cr.move_to(x + extents[0] + 2, y -
self.cr.set_source_rgba(bgcolor[0],bgcolor[1],bgcolor[2],bgcolor[3]) (extents[3] / 2.0) - extents[1] + 2)
self.cr.set_source_rgba(
bgcolor[0], bgcolor[1], bgcolor[2], bgcolor[3])
self.cr.show_text(text) self.cr.show_text(text)
self.cr.move_to(x + extents[0], y - (extents[3] / 2.0) - extents[1]) self.cr.move_to(x + extents[0], y - (extents[3] / 2.0) - extents[1])
@ -313,7 +322,6 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.cr.set_font_options(fo) self.cr.set_font_options(fo)
self.cr.set_antialias(cairo.ANTIALIAS_DEFAULT) self.cr.set_antialias(cairo.ANTIALIAS_DEFAULT)
def refresh_static_data(self): def refresh_static_data(self):
""" This method sets data that can't be changed from the dvd settings window. """ This method sets data that can't be changed from the dvd settings window.
It must be called before painting a menu """ It must be called before painting a menu """
@ -334,7 +342,6 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.current_shown_page = 0 self.current_shown_page = 0
self.wcurrent_page = None self.wcurrent_page = None
def paint_menu(self, paint_background, paint_selected, paint_activated, page_number): def paint_menu(self, paint_background, paint_selected, paint_activated, page_number):
coordinates = [] coordinates = []
@ -345,7 +352,8 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
if self.cached_menu_font != self.entry_font: if self.cached_menu_font != self.entry_font:
# memorize the font sizes # memorize the font sizes
(fontname, fontstyle, fontslant, fontsize) = self.get_font_params(self.entry_font) (fontname, fontstyle, fontslant,
fontsize) = self.get_font_params(self.entry_font)
self.cr.select_font_face(fontname, fontslant, fontstyle) self.cr.select_font_face(fontname, fontslant, fontstyle)
self.cr.set_font_size(fontsize) self.cr.set_font_size(fontsize)
extents = self.cr.font_extents() extents = self.cr.font_extents()
@ -353,19 +361,22 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.cached_menu_font = self.entry_font self.cached_menu_font = self.entry_font
if paint_background: if paint_background:
extra_pixbuf = GdkPixbuf.Pixbuf.new_from_file(self.background_picture) extra_pixbuf = GdkPixbuf.Pixbuf.new_from_file(
self.background_picture)
extra_x = float(extra_pixbuf.get_width()) extra_x = float(extra_pixbuf.get_width())
extra_y = float(extra_pixbuf.get_height()) extra_y = float(extra_pixbuf.get_height())
self.cr.save() self.cr.save()
self.cr.scale(720.0 / extra_x, self.y / extra_y) self.cr.scale(720.0 / extra_x, self.y / extra_y)
surface = Gdk.cairo_surface_create_from_pixbuf(extra_pixbuf,1,None) surface = Gdk.cairo_surface_create_from_pixbuf(
extra_pixbuf, 1, None)
self.cr.set_source_surface(surface, 0, 0) self.cr.set_source_surface(surface, 0, 0)
self.cr.paint() self.cr.paint()
self.cr.restore() self.cr.restore()
hmargin = self.title_horizontal * 720.0 / 100.0 hmargin = self.title_horizontal * 720.0 / 100.0
self.write_text(self.title_text, "title", 0 + hmargin, 720 + hmargin, self.title_vertical * self.y / 100.0, "center") self.write_text(self.title_text, "title", 0 + hmargin, 720 +
hmargin, self.title_vertical * self.y / 100.0, "center")
# else: # else:
# self.cr.set_source_rgb(1.0,1.0,1.0) # self.cr.set_source_rgb(1.0,1.0,1.0)
# self.cr.paint() # self.cr.paint()
@ -375,8 +386,10 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
left_margin_p = 720.0 * self.margin_left / 100.0 left_margin_p = 720.0 * self.margin_left / 100.0
right_margin_p = 720.0 * self.margin_right / 100.0 right_margin_p = 720.0 * self.margin_right / 100.0
entry_height = self.cached_menu_size + self.entry_vertical_margin * 2.0 + self.entry_separation entry_height = self.cached_menu_size + \
entries_per_page = int((self.y - top_margin_p - bottom_margin_p) / entry_height) self.entry_vertical_margin * 2.0 + self.entry_separation
entries_per_page = int(
(self.y - top_margin_p - bottom_margin_p) / entry_height)
if (self.play_all_c): if (self.play_all_c):
entries_per_page -= 1 entries_per_page -= 1
n_entries = len(self.title_list) n_entries = len(self.title_list)
@ -393,7 +406,8 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
page_number -= 1 page_number -= 1
if self.wcurrent_page is not None: if self.wcurrent_page is not None:
self.wcurrent_page.set_text(_("Page %(X)d of %(Y)d") % {"X":page_number+1 , "Y":self.pages}) self.wcurrent_page.set_text(_("Page %(X)d of %(Y)d") % {
"X": page_number + 1, "Y": self.pages})
xl = left_margin_p xl = left_margin_p
xr = 720.0 - right_margin_p xr = 720.0 - right_margin_p
y = top_margin_p + entry_height / 2.0 y = top_margin_p + entry_height / 2.0
@ -403,11 +417,14 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
coordinates.append([xl, y - height, xr, y + height, "play_all"]) coordinates.append([xl, y - height, xr, y + height, "play_all"])
if paint_background: if paint_background:
self.paint_base(xl, xr, y, 0) self.paint_base(xl, xr, y, 0)
self.write_text("Play All", "menu_entry", xl, xr, y, self.position_horizontal) self.write_text("Play All", "menu_entry", xl,
xr, y, self.position_horizontal)
if paint_selected: if paint_selected:
self.write_text("Play All", "menu_entry_selected", xl, xr, y, self.position_horizontal) self.write_text("Play All", "menu_entry_selected",
xl, xr, y, self.position_horizontal)
if paint_activated: if paint_activated:
self.write_text("Play All", "menu_entry_activated", xl, xr, y, self.position_horizontal) self.write_text("Play All", "menu_entry_activated",
xl, xr, y, self.position_horizontal)
y += entry_height y += entry_height
for entry in self.title_list[page_number * entries_per_page:(page_number + 1) * entries_per_page]: for entry in self.title_list[page_number * entries_per_page:(page_number + 1) * entries_per_page]:
@ -415,11 +432,14 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
text = entry[0].title_name text = entry[0].title_name
if paint_background: if paint_background:
self.paint_base(xl, xr, y, 0) self.paint_base(xl, xr, y, 0)
self.write_text(text, "menu_entry", xl, xr, y, self.position_horizontal) self.write_text(text, "menu_entry", xl, xr,
y, self.position_horizontal)
if paint_selected: if paint_selected:
self.write_text(text, "menu_entry_selected", xl, xr, y, self.position_horizontal) self.write_text(text, "menu_entry_selected", xl,
xr, y, self.position_horizontal)
if paint_activated: if paint_activated:
self.write_text(text, "menu_entry_activated", xl, xr, y, self.position_horizontal) self.write_text(text, "menu_entry_activated",
xl, xr, y, self.position_horizontal)
y += entry_height y += entry_height
if paint_arrows: if paint_arrows:
@ -458,7 +478,6 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.paint_arrow(xl, med, y, "menu_entry_activated", True) self.paint_arrow(xl, med, y, "menu_entry_activated", True)
return coordinates return coordinates
def paint_base(self, xl, xr, y, type_b): def paint_base(self, xl, xr, y, type_b):
height = self.cached_menu_size + self.entry_vertical_margin height = self.cached_menu_size + self.entry_vertical_margin
@ -472,15 +491,16 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
xl = (xl + xr) / 2.0 xl = (xl + xr) / 2.0
xl += radius xl += radius
self.cr.set_source_rgba(self.background_color[0],self.background_color[1],self.background_color[2],self.background_color[3]) self.cr.set_source_rgba(self.background_color[0], self.background_color[
1], self.background_color[2], self.background_color[3])
self.cr.move_to(xl, y) self.cr.move_to(xl, y)
self.cr.line_to(xr, y) self.cr.line_to(xr, y)
self.cr.curve_to(xr+radius,y,xr+radius,y+height,xr,y+height) self.cr.curve_to(xr + radius, y, xr + radius,
y + height, xr, y + height)
self.cr.line_to(xl, y + height) self.cr.line_to(xl, y + height)
self.cr.curve_to(xl - radius, y + height, xl - radius, y, xl, y) self.cr.curve_to(xl - radius, y + height, xl - radius, y, xl, y)
self.cr.fill() self.cr.fill()
def on_next_page_clicked(self, b): def on_next_page_clicked(self, b):
self.current_shown_page += 1 self.current_shown_page += 1
@ -488,7 +508,6 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.current_shown_page -= 1 self.current_shown_page -= 1
self.update_preview() self.update_preview()
def on_previous_page_clicked(self, b): def on_previous_page_clicked(self, b):
self.current_shown_page -= 1 self.current_shown_page -= 1
@ -496,23 +515,20 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.current_shown_page = 0 self.current_shown_page = 0
self.update_preview() self.update_preview()
def on_drawingarea_preview_draw(self, widget, cr): def on_drawingarea_preview_draw(self, widget, cr):
""" Callback to repaint the menu preview window when it """ Callback to repaint the menu preview window when it
sends the EXPOSE event """ sends the EXPOSE event """
if (self.sf is None): if (self.sf is None):
self.paint_menu(True, self.wshow_as_selected.get_active(), False, self.current_shown_page) self.paint_menu(True, self.wshow_as_selected.get_active(
), False, self.current_shown_page)
if (self.current_shown_page >= self.pages): if (self.current_shown_page >= self.pages):
self.current_shown_page = self.pages self.current_shown_page = self.pages
cr.set_source_surface(self.sf) cr.set_source_surface(self.sf)
cr.paint() cr.paint()
def create_menu_stream(self, path, n_page, coordinates): def create_menu_stream(self, path, n_page, coordinates):
""" Creates the menu XML file """ """ Creates the menu XML file """
file_name = os.path.join(path, "menu_" + str(n_page) + ".xml") file_name = os.path.join(path, "menu_" + str(n_page) + ".xml")
@ -522,10 +538,15 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
entry_data["left"] = None entry_data["left"] = None
xml_file = open(file_name, "w") xml_file = open(file_name, "w")
xml_file.write('<subpictures>\n\t<stream>\n\t\t<spu force="yes" start="00:00:00.00"')# transparent="000000"') # transparent="000000"')
xml_file.write(' image="'+os.path.join(path,"menu_"+str(n_page)+'_unselected_bg.png"')) xml_file.write(
xml_file.write(' highlight="'+os.path.join(path,"menu_"+str(n_page)+'_selected_bg.png"')) '<subpictures>\n\t<stream>\n\t\t<spu force="yes" start="00:00:00.00"')
xml_file.write(' select="'+os.path.join(path,"menu_"+str(n_page)+'_active_bg.png"')) xml_file.write(' image="' + os.path.join(path, "menu_" +
str(n_page) + '_unselected_bg.png"'))
xml_file.write(' highlight="' + os.path.join(path,
"menu_" + str(n_page) + '_selected_bg.png"'))
xml_file.write(' select="' + os.path.join(path,
"menu_" + str(n_page) + '_active_bg.png"'))
xml_file.write(' >\n') xml_file.write(' >\n')
n_elements = 0 n_elements = 0
has_next = False has_next = False
@ -560,12 +581,16 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
if (element[4] == "left"): if (element[4] == "left"):
entry_data["left"] = "boton" + str(n_page) + "x" + str(counter) entry_data["left"] = "boton" + str(n_page) + "x" + str(counter)
elif (element[4] == "right"): elif (element[4] == "right"):
entry_data["right"] = "boton"+str(n_page)+"x"+str(counter) entry_data["right"] = "boton" + \
str(n_page) + "x" + str(counter)
else: else:
entry_data["chapters"].append("boton"+str(n_page)+"x"+str(counter)) entry_data["chapters"].append(
"boton" + str(n_page) + "x" + str(counter))
xml_file.write('\t\t\t<button name="boton'+str(n_page)+"x"+str(counter)) xml_file.write('\t\t\t<button name="boton' +
xml_file.write('" x0="'+str(xl)+'" y0="'+str(yt)+'" x1="'+str(xr)+'" y1="'+str(yb)+'"') str(n_page) + "x" + str(counter))
xml_file.write('" x0="' + str(xl) + '" y0="' + str(yt) +
'" x1="' + str(xr) + '" y1="' + str(yb) + '"')
if counter > 0: if counter > 0:
xml_file.write(' up="boton' + str(n_page) + "x") xml_file.write(' up="boton' + str(n_page) + "x")
if counter >= n_elements: if counter >= n_elements:
@ -579,9 +604,11 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
xml_file.write(str(counter + 1)) xml_file.write(str(counter + 1))
xml_file.write('"') xml_file.write('"')
if (element[4] == "left") and (has_next): if (element[4] == "left") and (has_next):
xml_file.write(' right="boton'+str(n_page)+'x'+str(counter+1)+'"') xml_file.write(' right="boton' + str(n_page) +
'x' + str(counter + 1) + '"')
if (element[4] == "right") and (has_previous): if (element[4] == "right") and (has_previous):
xml_file.write(' left="boton'+str(n_page)+'x'+str(counter-1)+'"') xml_file.write(' left="boton' + str(n_page) +
'x' + str(counter - 1) + '"')
xml_file.write(' > </button>\n') xml_file.write(' > </button>\n')
counter += 1 counter += 1
@ -590,7 +617,6 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
return entry_data return entry_data
def create_dvd_menus(self, file_list, base_path): def create_dvd_menus(self, file_list, base_path):
self.file_list = file_list self.file_list = file_list
@ -609,19 +635,25 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
while n_page < self.pages: while n_page < self.pages:
self.sf = None self.sf = None
coordinates = self.paint_menu(True, False, False, n_page) coordinates = self.paint_menu(True, False, False, n_page)
self.sf.write_to_png(os.path.join(menu_folder,"menu_"+str(n_page)+"_bg.png")) self.sf.write_to_png(os.path.join(
menu_folder, "menu_" + str(n_page) + "_bg.png"))
self.sf = None self.sf = None
self.paint_menu(False, False, False, n_page) self.paint_menu(False, False, False, n_page)
self.sf.write_to_png(os.path.join(menu_folder,"menu_"+str(n_page)+"_unselected_bg.png")) self.sf.write_to_png(os.path.join(
menu_folder, "menu_" + str(n_page) + "_unselected_bg.png"))
self.sf = None self.sf = None
self.paint_menu(False, True, False, n_page) self.paint_menu(False, True, False, n_page)
self.sf.write_to_png(os.path.join(menu_folder,"menu_"+str(n_page)+"_selected_bg.png")) self.sf.write_to_png(os.path.join(
menu_folder, "menu_" + str(n_page) + "_selected_bg.png"))
self.sf = None self.sf = None
self.paint_menu(False, False, True, n_page) self.paint_menu(False, False, True, n_page)
self.sf.write_to_png(os.path.join(menu_folder,"menu_"+str(n_page)+"_active_bg.png")) self.sf.write_to_png(os.path.join(
entry_data = self.create_menu_stream(menu_folder, n_page, coordinates) menu_folder, "menu_" + str(n_page) + "_active_bg.png"))
entry_data = self.create_menu_stream(
menu_folder, n_page, coordinates)
converter = menu_converter() converter = menu_converter()
final_path = converter.create_menu_mpeg(n_page,self.background_music,self.sound_length,self.config.PAL,self.video_rate,self.audio_rate,menu_folder, self.audio_mp2) final_path = converter.create_menu_mpeg(
n_page, self.background_music, self.sound_length, self.config.PAL, self.video_rate, self.audio_rate, menu_folder, self.audio_mp2)
entry_data["filename"] = final_path entry_data["filename"] = final_path
menu_entries.append(entry_data) menu_entries.append(entry_data)
# add this process without dependencies # add this process without dependencies
@ -630,12 +662,10 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
return processes, menu_entries return processes, menu_entries
def store_menu(self): def store_menu(self):
return self.serialize() return self.serialize()
def restore_menu(self, data): def restore_menu(self, data):
self.unserialize(data) self.unserialize(data)

115
src/devedeng/dvdauthor_converter.py
View file

@ -21,6 +21,7 @@ import os
import devedeng.configuration_data import devedeng.configuration_data
import devedeng.executor import devedeng.executor
class dvdauthor_converter(devedeng.executor.executor): class dvdauthor_converter(devedeng.executor.executor):
def __init__(self): def __init__(self):
@ -28,7 +29,6 @@ class dvdauthor_converter(devedeng.executor.executor):
devedeng.executor.executor.__init__(self) devedeng.executor.executor.__init__(self)
self.config = devedeng.configuration_data.configuration.get_config() self.config = devedeng.configuration_data.configuration.get_config()
def create_dvd_project(self, path, name, file_movies, menu_entries, start_with_menu, play_all_opt): def create_dvd_project(self, path, name, file_movies, menu_entries, start_with_menu, play_all_opt):
movie_path = os.path.join(path, "dvd_tree") movie_path = os.path.join(path, "dvd_tree")
@ -37,7 +37,8 @@ class dvdauthor_converter(devedeng.executor.executor):
except: except:
pass pass
xml_file = self.create_dvdauthor_xml(path, file_movies, menu_entries, start_with_menu, play_all_opt) xml_file = self.create_dvdauthor_xml(
path, file_movies, menu_entries, start_with_menu, play_all_opt)
self.command_var = [] self.command_var = []
self.command_var.append("dvdauthor") self.command_var.append("dvdauthor")
@ -48,17 +49,14 @@ class dvdauthor_converter(devedeng.executor.executor):
self.use_pulse_mode = True self.use_pulse_mode = True
self.text = _("Creating DVD structure") self.text = _("Creating DVD structure")
def process_stdout(self, data): def process_stdout(self, data):
return return
def process_stderr(self, data): def process_stderr(self, data):
if (data is not None) and (data[0] != ""): if (data is not None) and (data[0] != ""):
self.progress_bar[1].set_text(data[0]) self.progress_bar[1].set_text(data[0])
return return
def create_dvdauthor_xml(self, movie_folder, file_movies, menu_entries, start_with_menu, play_all_opt): def create_dvdauthor_xml(self, movie_folder, file_movies, menu_entries, start_with_menu, play_all_opt):
xmlpath = os.path.join(movie_folder, "xml_data") xmlpath = os.path.join(movie_folder, "xml_data")
@ -100,7 +98,8 @@ class dvdauthor_converter(devedeng.executor.executor):
# MENU # MENU
# in the FPC we do a jump to the first menu in the first titleset if we wanted MENU # in the FPC we do a jump to the first menu in the first titleset if we wanted MENU
# or we jump to the second titleset if we didn't want MENU at startup # or we jump to the second titleset if we didn't want MENU at
# startup
xml_file.write('\t\t<fpc>\n') xml_file.write('\t\t<fpc>\n')
xml_file.write('\t\t\tg0=100;\n') xml_file.write('\t\t\tg0=100;\n')
@ -118,7 +117,6 @@ class dvdauthor_converter(devedeng.executor.executor):
xml_file.write('\t\t\tjump menu 1;\n') xml_file.write('\t\t\tjump menu 1;\n')
xml_file.write('\t\t</fpc>\n') xml_file.write('\t\t</fpc>\n')
# in the VMGM menu we create a code to jump to the title specified in G0 # in the VMGM menu we create a code to jump to the title specified in G0
# but if the title is 100, we jump to the menus. There we show the menu number # but if the title is 100, we jump to the menus. There we show the menu number
# contained in G1 # contained in G1
@ -138,7 +136,8 @@ class dvdauthor_converter(devedeng.executor.executor):
counter = 1 counter = 1
for element in file_movies: for element in file_movies:
xml_file.write('\t\t\t\t\tif (g0 eq ' + str(counter) + ') {\n') xml_file.write('\t\t\t\t\tif (g0 eq ' + str(counter) + ') {\n')
xml_file.write('\t\t\t\t\t\tjump titleset '+str(1+counter)+' menu;\n') xml_file.write('\t\t\t\t\t\tjump titleset ' +
str(1 + counter) + ' menu;\n')
xml_file.write('\t\t\t\t\t}\n') xml_file.write('\t\t\t\t\t}\n')
counter += 1 counter += 1
xml_file.write('\t\t\t\t\tif (g0 eq 100) {\n') xml_file.write('\t\t\t\t\tif (g0 eq 100) {\n')
@ -146,13 +145,16 @@ class dvdauthor_converter(devedeng.executor.executor):
xml_file.write('\t\t\t\t\t\tjump titleset 1 menu;\n') xml_file.write('\t\t\t\t\t\tjump titleset 1 menu;\n')
xml_file.write('\t\t\t\t\t}\n') xml_file.write('\t\t\t\t\t}\n')
xml_file.write('\t\t\t\t</pre>\n') xml_file.write('\t\t\t\t</pre>\n')
# fake video (one black picture with one second of sound) to ensure 100% compatibility # fake video (one black picture with one second of sound) to ensure
# 100% compatibility
xml_file.write('\t\t\t\t<vob file="') xml_file.write('\t\t\t\t<vob file="')
if self.config.PAL: if self.config.PAL:
xml_file.write(self.expand_xml(str(os.path.join(self.config.other_path,"base_pal.mpg")))) xml_file.write(self.expand_xml(
str(os.path.join(self.config.other_path, "base_pal.mpg"))))
else: else:
xml_file.write(self.expand_xml(str(os.path.join(self.config.other_path,"base_ntsc.mpg")))) xml_file.write(self.expand_xml(
str(os.path.join(self.config.other_path, "base_ntsc.mpg"))))
xml_file.write('"></vob>\n') xml_file.write('"></vob>\n')
xml_file.write('\t\t\t</pgc>\n') xml_file.write('\t\t\t</pgc>\n')
@ -161,8 +163,8 @@ class dvdauthor_converter(devedeng.executor.executor):
xml_file.write("\n") xml_file.write("\n")
# the first titleset contains all the menus. G1 allows us to jump
# the first titleset contains all the menus. G1 allows us to jump to the desired menu # to the desired menu
xml_file.write('\t<titleset>\n') xml_file.write('\t<titleset>\n')
xml_file.write('\t\t<menus>\n') xml_file.write('\t\t<menus>\n')
@ -190,18 +192,22 @@ class dvdauthor_converter(devedeng.executor.executor):
button_counter = 0 # A counter for all buttons on the actual page button_counter = 0 # A counter for all buttons on the actual page
xml_file.write('\t\t\t<pgc>\n') xml_file.write('\t\t\t<pgc>\n')
xml_file.write('\t\t\t\t<pre>\n') xml_file.write('\t\t\t\t<pre>\n')
xml_file.write('\t\t\t\t\ts8=g2;\n') # first we recover the currently selected button # first we recover the currently selected button
xml_file.write('\t\t\t\t\ts8=g2;\n')
xml_file.write('\t\t\t\t\tg3=0;\n') # turnoff play all xml_file.write('\t\t\t\t\tg3=0;\n') # turnoff play all
if first_entry: # here we add some code to jump to each menu if first_entry: # here we add some code to jump to each menu
for menu2 in range(nmenues - 1): for menu2 in range(nmenues - 1):
xml_file.write('\t\t\t\t\tif (g1 eq '+str(menu2+1)+') {\n') xml_file.write(
xml_file.write('\t\t\t\t\t\tjump menu '+str(menu2+2)+';\n') '\t\t\t\t\tif (g1 eq ' + str(menu2 + 1) + ') {\n')
xml_file.write(
'\t\t\t\t\t\tjump menu ' + str(menu2 + 2) + ';\n')
xml_file.write('\t\t\t\t\t}\n') xml_file.write('\t\t\t\t\t}\n')
# this code is to fix a bug in some players # this code is to fix a bug in some players
xml_file.write('\t\t\t\t\tif (g1 eq 100) {\n') xml_file.write('\t\t\t\t\tif (g1 eq 100) {\n')
xml_file.write('\t\t\t\t\t\tjump title 1;\n') #menu '+str(self.nmenues+1)+';\n') # menu '+str(self.nmenues+1)+';\n')
xml_file.write('\t\t\t\t\t\tjump title 1;\n')
xml_file.write('\t\t\t\t\t}\n') xml_file.write('\t\t\t\t\t}\n')
first_entry = False first_entry = False
@ -213,7 +219,8 @@ class dvdauthor_converter(devedeng.executor.executor):
for nbutton in menu_page["chapters"]: for nbutton in menu_page["chapters"]:
#xml_file.write('\t\t\t\t<button name="'+nbutton+'"> g0='+str(title_list[button_counter])+'; jump vmgm menu; </button>\n') #xml_file.write('\t\t\t\t<button name="'+nbutton+'"> g0='+str(title_list[button_counter])+'; jump vmgm menu; </button>\n')
xml_file.write('\t\t\t\t<button name="'+nbutton+'">\n') xml_file.write(
'\t\t\t\t<button name="' + nbutton + '">\n')
# If PlayAll option is set, the first button on each page # If PlayAll option is set, the first button on each page
# will be the PlayAll button # will be the PlayAll button
if play_all_opt and button_counter == 0: if play_all_opt and button_counter == 0:
@ -221,21 +228,24 @@ class dvdauthor_converter(devedeng.executor.executor):
xml_file.write('\t\t\t\t\tg0=1;\n') xml_file.write('\t\t\t\t\tg0=1;\n')
xml_file.write('\t\t\t\t\tjump vmgm menu;\n') xml_file.write('\t\t\t\t\tjump vmgm menu;\n')
else: else:
xml_file.write('\t\t\t\t\tg0='+str(title_list[title_counter])+';\n') xml_file.write(
'\t\t\t\t\tg0=' + str(title_list[title_counter]) + ';\n')
xml_file.write('\t\t\t\t\tjump vmgm menu;\n') xml_file.write('\t\t\t\t\tjump vmgm menu;\n')
title_counter += 1 title_counter += 1
button_counter += 1 button_counter += 1
xml_file.write('\t\t\t\t</button>\n') xml_file.write('\t\t\t\t</button>\n')
if (menu_page["left"] is not None): if (menu_page["left"] is not None):
xml_file.write('\t\t\t\t<button name="'+menu_page["left"]+'"> g1=') xml_file.write('\t\t\t\t<button name="' +
menu_page["left"] + '"> g1=')
xml_file.write(str(menu_number - 1)) xml_file.write(str(menu_number - 1))
xml_file.write('; g2=1024; jump menu ') xml_file.write('; g2=1024; jump menu ')
xml_file.write(str(menu_number)) xml_file.write(str(menu_number))
xml_file.write('; </button>\n') xml_file.write('; </button>\n')
if (menu_page["right"] is not None): if (menu_page["right"] is not None):
xml_file.write('\t\t\t\t<button name="'+menu_page["right"]+'"> g1=') xml_file.write('\t\t\t\t<button name="' +
menu_page["right"] + '"> g1=')
xml_file.write(str(menu_number + 1)) xml_file.write(str(menu_number + 1))
xml_file.write('; g2=1024; jump menu ') xml_file.write('; g2=1024; jump menu ')
xml_file.write(str(menu_number + 2)) xml_file.write(str(menu_number + 2))
@ -244,7 +254,8 @@ class dvdauthor_converter(devedeng.executor.executor):
xml_file.write('\t\t\t\t<post>\n') xml_file.write('\t\t\t\t<post>\n')
xml_file.write('\t\t\t\t\tg2=s8;\n') xml_file.write('\t\t\t\t\tg2=s8;\n')
xml_file.write('\t\t\t\t\tg1=' + str(menu_number) + ';\n') xml_file.write('\t\t\t\t\tg1=' + str(menu_number) + ';\n')
xml_file.write('\t\t\t\t\tjump menu '+str(menu_number+1)+';\n') xml_file.write('\t\t\t\t\tjump menu ' +
str(menu_number + 1) + ';\n')
xml_file.write('\t\t\t\t</post>\n') xml_file.write('\t\t\t\t</post>\n')
xml_file.write('\t\t\t</pgc>\n') xml_file.write('\t\t\t</pgc>\n')
menu_number += 1 menu_number += 1
@ -258,15 +269,18 @@ class dvdauthor_converter(devedeng.executor.executor):
# this code is to fix a bug in some players # this code is to fix a bug in some players
xml_file.write('\t\t\t\t\tif (g1 eq 100) {\n') xml_file.write('\t\t\t\t\tif (g1 eq 100) {\n')
xml_file.write('\t\t\t\t\t\tjump title 1;\n') #menu '+str(self.nmenues+1)+';\n') # menu '+str(self.nmenues+1)+';\n')
xml_file.write('\t\t\t\t\t\tjump title 1;\n')
xml_file.write('\t\t\t\t\t}\n') xml_file.write('\t\t\t\t\t}\n')
xml_file.write('\t\t\t\t</pre>\n') xml_file.write('\t\t\t\t</pre>\n')
xml_file.write('\t\t\t\t<vob file="') xml_file.write('\t\t\t\t<vob file="')
if self.config.PAL: if self.config.PAL:
xml_file.write(self.expand_xml(str(os.path.join(self.config.other_path,"base_pal.mpg")))) xml_file.write(self.expand_xml(
str(os.path.join(self.config.other_path, "base_pal.mpg"))))
else: else:
xml_file.write(self.expand_xml(str(os.path.join(self.config.other_path,"base_ntsc.mpg")))) xml_file.write(self.expand_xml(
str(os.path.join(self.config.other_path, "base_ntsc.mpg"))))
xml_file.write('"></vob>\n') xml_file.write('"></vob>\n')
xml_file.write('\t\t\t\t<post>\n') xml_file.write('\t\t\t\t<post>\n')
@ -288,9 +302,11 @@ class dvdauthor_converter(devedeng.executor.executor):
xml_file.write('\t\t\t<pgc>\n') xml_file.write('\t\t\t<pgc>\n')
xml_file.write('\t\t\t\t<vob file="') xml_file.write('\t\t\t\t<vob file="')
if self.config.PAL: if self.config.PAL:
xml_file.write(self.expand_xml(str(os.path.join(self.config.other_path,"base_pal.mpg")))) xml_file.write(self.expand_xml(
str(os.path.join(self.config.other_path, "base_pal.mpg"))))
else: else:
xml_file.write(self.expand_xml(str(os.path.join(self.config.other_path,"base_ntsc.mpg")))) xml_file.write(self.expand_xml(
str(os.path.join(self.config.other_path, "base_ntsc.mpg"))))
xml_file.write('"></vob>\n') xml_file.write('"></vob>\n')
xml_file.write('\t\t\t\t<post>\n') xml_file.write('\t\t\t\t<post>\n')
xml_file.write('\t\t\t\t\tg0=1;\n') xml_file.write('\t\t\t\t\tg0=1;\n')
@ -304,7 +320,6 @@ class dvdauthor_converter(devedeng.executor.executor):
xml_file.write("\n") xml_file.write("\n")
# Now, create the titleset for each video # Now, create the titleset for each video
total_t = len(file_movies) total_t = len(file_movies)
@ -319,7 +334,8 @@ class dvdauthor_converter(devedeng.executor.executor):
if element.is_mpeg_ps: if element.is_mpeg_ps:
# if it's already an MPEG-2 compliant file, we use the original values # if it's already an MPEG-2 compliant file, we use the original
# values
if element.original_fps == 25: if element.original_fps == 25:
pal_ntsc = "pal" pal_ntsc = "pal"
ispal = True ispal = True
@ -354,7 +370,8 @@ class dvdauthor_converter(devedeng.executor.executor):
if not onlyone: if not onlyone:
xml_file.write("\t\t<menus>\n") xml_file.write("\t\t<menus>\n")
xml_file.write('\t\t\t<video format="'+pal_ntsc+'" aspect="'+faspect+'"') xml_file.write('\t\t\t<video format="' +
pal_ntsc + '" aspect="' + faspect + '"')
if fwide: if fwide:
xml_file.write(' widescreen="nopanscan"') xml_file.write(' widescreen="nopanscan"')
xml_file.write('> </video>\n') xml_file.write('> </video>\n')
@ -365,15 +382,18 @@ class dvdauthor_converter(devedeng.executor.executor):
xml_file.write('\t\t\t\t\t\tjump vmgm menu entry title;\n') xml_file.write('\t\t\t\t\t\tjump vmgm menu entry title;\n')
xml_file.write('\t\t\t\t\t}\n') xml_file.write('\t\t\t\t\t}\n')
xml_file.write('\t\t\t\t\tg0=100;\n') xml_file.write('\t\t\t\t\tg0=100;\n')
xml_file.write('\t\t\t\t\tg1='+str(int(titles/elements_per_menu))+';\n') xml_file.write('\t\t\t\t\tg1=' +
str(int(titles / elements_per_menu)) + ';\n')
xml_file.write('\t\t\t\t\tjump title 1;\n') xml_file.write('\t\t\t\t\tjump title 1;\n')
xml_file.write('\t\t\t\t</pre>\n') xml_file.write('\t\t\t\t</pre>\n')
# fake video to ensure compatibility # fake video to ensure compatibility
xml_file.write('\t\t\t\t<vob file="') xml_file.write('\t\t\t\t<vob file="')
if ispal: if ispal:
xml_file.write(self.expand_xml(str(os.path.join(self.config.other_path,"base_pal")))) xml_file.write(self.expand_xml(
str(os.path.join(self.config.other_path, "base_pal"))))
else: else:
xml_file.write(self.expand_xml(str(os.path.join(self.config.other_path,"base_ntsc")))) xml_file.write(self.expand_xml(
str(os.path.join(self.config.other_path, "base_ntsc"))))
if fwide: if fwide:
xml_file.write("_wide") xml_file.write("_wide")
xml_file.write('.mpg"></vob>\n') xml_file.write('.mpg"></vob>\n')
@ -381,7 +401,8 @@ class dvdauthor_converter(devedeng.executor.executor):
xml_file.write("\t\t</menus>\n") xml_file.write("\t\t</menus>\n")
xml_file.write("\t\t<titles>\n") xml_file.write("\t\t<titles>\n")
xml_file.write('\t\t\t<video format="'+pal_ntsc+'" aspect="'+faspect+'"') xml_file.write('\t\t\t<video format="' +
pal_ntsc + '" aspect="' + faspect + '"')
if fwide: if fwide:
xml_file.write(' widescreen="nopanscan"') xml_file.write(' widescreen="nopanscan"')
xml_file.write('> </video>\n') xml_file.write('> </video>\n')
@ -396,33 +417,40 @@ class dvdauthor_converter(devedeng.executor.executor):
# xml_file.write('\t\t\t\t\tsubtitle=64;\n') # xml_file.write('\t\t\t\t\tsubtitle=64;\n')
# xml_file.write('\t\t\t\t</pre>\n') # xml_file.write('\t\t\t\t</pre>\n')
xml_file.write('\t\t\t\t<vob file="'+self.expand_xml(element.converted_filename)+'" ') xml_file.write('\t\t\t\t<vob file="' +
self.expand_xml(element.converted_filename) + '" ')
xml_file.write('chapters="0') xml_file.write('chapters="0')
if (element.original_length > 5): if (element.original_length > 5):
if (element.divide_in_chapters): # add chapters if (element.divide_in_chapters): # add chapters
manual_chapter_list = []; manual_chapter_list = []
if (element.chapter_list_entry): if (element.chapter_list_entry):
manual_chapter_list = element.chapter_list_entry.split(",") manual_chapter_list = element.chapter_list_entry.split(
",")
toadd = element.chapter_size toadd = element.chapter_size
seconds = toadd * 60 seconds = toadd * 60
while seconds < (element.original_length - 4): while seconds < (element.original_length - 4):
# Check manual_chapter_list for manual entries before set next chapter # Check manual_chapter_list for manual entries before
# set next chapter
for idx, m_chapter in enumerate(manual_chapter_list): for idx, m_chapter in enumerate(manual_chapter_list):
m_chapter = m_chapter.split(":") m_chapter = m_chapter.split(":")
m_chapter = int(m_chapter[0])*60+int(m_chapter[1]) # Change from mm:ss to seconds # Change from mm:ss to seconds
m_chapter = int(
m_chapter[0]) * 60 + int(m_chapter[1])
if (m_chapter < seconds): if (m_chapter < seconds):
seconds = m_chapter seconds = m_chapter
del manual_chapter_list[idx] del manual_chapter_list[idx]
thetime = self.return_time(seconds, False) thetime = self.return_time(seconds, False)
xml_file.write("," + thetime) xml_file.write("," + thetime)
seconds += (toadd * 60) seconds += (toadd * 60)
xml_file.write(',' + self.return_time((element.original_length -2 ),False)) xml_file.write(
',' + self.return_time((element.original_length - 2), False))
xml_file.write('" />\n') xml_file.write('" />\n')
if not onlyone: if not onlyone:
xml_file.write('\t\t\t\t<post>\n') xml_file.write('\t\t\t\t<post>\n')
files += 1 files += 1
xml_file.write('\t\t\t\t\tg1='+str(int(titles/elements_per_menu))+';\n') xml_file.write('\t\t\t\t\tg1=' +
str(int(titles / elements_per_menu)) + ';\n')
# play all # play all
xml_file.write('\t\t\t\t\tif (g3 eq 1) {\n') # if play all: xml_file.write('\t\t\t\t\tif (g3 eq 1) {\n') # if play all:
@ -458,7 +486,8 @@ class dvdauthor_converter(devedeng.executor.executor):
xml_file.write(';\n') xml_file.write(';\n')
xml_file.write('\t\t\t\t\t}\n') xml_file.write('\t\t\t\t\t}\n')
xml_file.write('\t\t\t\t\tcall vmgm menu entry title;\n') #preform action # preform action
xml_file.write('\t\t\t\t\tcall vmgm menu entry title;\n')
xml_file.write('\t\t\t\t</post>\n') xml_file.write('\t\t\t\t</post>\n')
xml_file.write("\t\t\t</pgc>\n") xml_file.write("\t\t\t</pgc>\n")
xml_file.write("\t\t</titles>\n") xml_file.write("\t\t</titles>\n")
@ -472,9 +501,7 @@ class dvdauthor_converter(devedeng.executor.executor):
return xml_file_path return xml_file_path
def return_time(self, seconds, empty): def return_time(self, seconds, empty):
""" cuts a time in seconds into seconds, minutes and hours """ """ cuts a time in seconds into seconds, minutes and hours """
seconds2 = int(seconds) seconds2 = int(seconds)

2
src/devedeng/end_job.py
View file

@ -19,6 +19,7 @@ from gi.repository import Gtk,Gdk
import os import os
import devedeng.configuration_data import devedeng.configuration_data
class end_window: class end_window:
def __init__(self): def __init__(self):
@ -66,7 +67,6 @@ class end_window:
else: else:
return False return False
def on_copy_clicked(self, b): def on_copy_clicked(self, b):
clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD) clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)

2
src/devedeng/error.py
View file

@ -19,6 +19,7 @@ from gi.repository import Gtk,Gdk
import os import os
import devedeng.configuration_data import devedeng.configuration_data
class error_window: class error_window:
def __init__(self): def __init__(self):
@ -38,7 +39,6 @@ class error_window:
werror_window.run() werror_window.run()
werror_window.destroy() werror_window.destroy()
def on_copy_clicked(self, b): def on_copy_clicked(self, b):
clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD) clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)

44
src/devedeng/executor.py
View file

@ -23,6 +23,7 @@ import os
import signal import signal
import devedeng.configuration_data import devedeng.configuration_data
class executor(GObject.GObject): class executor(GObject.GObject):
""" This class encapsulates everything needed for launching processes """ """ This class encapsulates everything needed for launching processes """
@ -51,7 +52,6 @@ class executor(GObject.GObject):
self.pulse_text = None self.pulse_text = None
self.handle = None self.handle = None
def add_dependency(self, dep): def add_dependency(self, dep):
self.add_dependency2(dep) self.add_dependency2(dep)
@ -59,7 +59,6 @@ class executor(GObject.GObject):
for child in dep.childs: for child in dep.childs:
self.add_dependency2(child) self.add_dependency2(child)
def add_dependency2(self, dep): def add_dependency2(self, dep):
if (self.dependencies is None): if (self.dependencies is None):
@ -68,11 +67,11 @@ class executor(GObject.GObject):
if (self.dependencies.count(dep) == 0): if (self.dependencies.count(dep) == 0):
self.dependencies.append(dep) self.dependencies.append(dep)
# the childs have the same dependencies than the parent process because, from outside, it is viewed as a single process # the childs have the same dependencies than the parent process
# because, from outside, it is viewed as a single process
for child in self.childs: for child in self.childs:
child.add_dependency(dep) child.add_dependency(dep)
def remove_dependency(self, process): def remove_dependency(self, process):
# dependencies are removed only in the parent because the running class have all the processes, parents and childs, and calls # dependencies are removed only in the parent because the running class have all the processes, parents and childs, and calls
# this method on all of them # this method on all of them
@ -86,10 +85,10 @@ class executor(GObject.GObject):
else: else:
self.dependencies = None self.dependencies = None
def add_child_process(self, child): def add_child_process(self, child):
# the childs have the same dependencies than the parent process because, from outside, it is viewed as a single process # the childs have the same dependencies than the parent process
# because, from outside, it is viewed as a single process
if self.dependencies is not None: if self.dependencies is not None:
for dep in self.dependencies: for dep in self.dependencies:
child.add_dependency(dep) child.add_dependency(dep)
@ -97,7 +96,6 @@ class executor(GObject.GObject):
if (self.childs.count(child) == 0): if (self.childs.count(child) == 0):
self.childs.append(child) self.childs.append(child)
def run(self, progress_bar): def run(self, progress_bar):
self.progress_bar = progress_bar self.progress_bar = progress_bar
@ -113,7 +111,6 @@ class executor(GObject.GObject):
if self.use_pulse_mode != self.pulse_mode: if self.use_pulse_mode != self.pulse_mode:
self.set_pulse_mode(self.use_pulse_mode) self.set_pulse_mode(self.use_pulse_mode)
def remove_ansi(self, line): def remove_ansi(self, line):
output = "" output = ""
@ -140,7 +137,6 @@ class executor(GObject.GObject):
break break
return output return output
def launch_process(self, command, redirect_output=True): def launch_process(self, command, redirect_output=True):
if command is not None: if command is not None:
@ -155,12 +151,15 @@ class executor(GObject.GObject):
try: try:
if (self.stdin_file is not None): if (self.stdin_file is not None):
self.handle = subprocess.Popen(command,stdin = subprocess.PIPE, stdout = subprocess.PIPE, stderr = subprocess.PIPE) self.handle = subprocess.Popen(
command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
self.channel_stdin = GLib.IOChannel(self.handle.stdin.fileno()) self.channel_stdin = GLib.IOChannel(self.handle.stdin.fileno())
self.channel_stdin.add_watch(GLib.IO_OUT | GLib.IO_HUP, self.read_stdin_from_file) self.channel_stdin.add_watch(
GLib.IO_OUT | GLib.IO_HUP, self.read_stdin_from_file)
self.file_in = open(self.stdin_file, "rb") self.file_in = open(self.stdin_file, "rb")
else: else:
self.handle = subprocess.Popen(command,stdout = subprocess.PIPE, stderr = subprocess.PIPE) self.handle = subprocess.Popen(
command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
except Exception as error_launch: except Exception as error_launch:
self.handle = None self.handle = None
self.stderr_data += str(error_launch) self.stderr_data += str(error_launch)
@ -173,11 +172,14 @@ class executor(GObject.GObject):
self.channel_stdout = GLib.IOChannel(self.handle.stdout.fileno()) self.channel_stdout = GLib.IOChannel(self.handle.stdout.fileno())
self.channel_stderr = GLib.IOChannel(self.handle.stderr.fileno()) self.channel_stderr = GLib.IOChannel(self.handle.stderr.fileno())
if (self.stdout_file is not None): if (self.stdout_file is not None):
self.channel_stdout.add_watch(GLib.IO_IN | GLib.IO_HUP,self.read_stdout_to_file) self.channel_stdout.add_watch(
GLib.IO_IN | GLib.IO_HUP, self.read_stdout_to_file)
self.file_out = open(self.stdout_file, "wb") self.file_out = open(self.stdout_file, "wb")
else: else:
self.channel_stdout.add_watch(GLib.IO_IN | GLib.IO_HUP,self.read_stdout) self.channel_stdout.add_watch(
self.channel_stderr.add_watch(GLib.IO_IN | GLib.IO_HUP,self.read_stderr) GLib.IO_IN | GLib.IO_HUP, self.read_stdout)
self.channel_stderr.add_watch(
GLib.IO_IN | GLib.IO_HUP, self.read_stderr)
else: else:
(stdout_r, stderr_r) = self.handle.communicate() (stdout_r, stderr_r) = self.handle.communicate()
self.handle = None self.handle = None
@ -192,7 +194,6 @@ class executor(GObject.GObject):
self.config.append_log(stderr_r.decode("latin-1")) self.config.append_log(stderr_r.decode("latin-1"))
return (stdout_r, stderr_r) return (stdout_r, stderr_r)
def set_pulse_mode(self, pulse_mode): def set_pulse_mode(self, pulse_mode):
if pulse_mode == self.pulse_mode: if pulse_mode == self.pulse_mode:
@ -205,7 +206,6 @@ class executor(GObject.GObject):
else: else:
GLib.source_remove(self.timer_pulse) GLib.source_remove(self.timer_pulse)
def run_pulse(self, v=None): def run_pulse(self, v=None):
if self.progress_bar is None: if self.progress_bar is None:
@ -216,7 +216,6 @@ class executor(GObject.GObject):
self.progress_bar[1].pulse() self.progress_bar[1].pulse()
return True return True
def read_stdout_to_file(self, source, condition): def read_stdout_to_file(self, source, condition):
if (condition != GLib.IO_IN): if (condition != GLib.IO_IN):
@ -229,7 +228,6 @@ class executor(GObject.GObject):
self.file_out.write(line_data) self.file_out.write(line_data)
return True return True
def read_stdin_from_file(self, source, condition): def read_stdin_from_file(self, source, condition):
line_data = self.file_in.read1(4096) line_data = self.file_in.read1(4096)
@ -243,7 +241,6 @@ class executor(GObject.GObject):
self.handle.stdin.write(line_data) self.handle.stdin.write(line_data)
return True return True
def read_stdout(self, source, condition): def read_stdout(self, source, condition):
if (condition != GLib.IO_IN): if (condition != GLib.IO_IN):
@ -269,7 +266,6 @@ class executor(GObject.GObject):
self.process_stdout(final_data) self.process_stdout(final_data)
return True return True
def read_stderr(self, source, condition): def read_stderr(self, source, condition):
if (condition != GLib.IO_IN): if (condition != GLib.IO_IN):
@ -295,9 +291,7 @@ class executor(GObject.GObject):
self.process_stderr(final_data) self.process_stderr(final_data)
return True return True
def cancel(self): def cancel(self):
""" Called to kill this process. """ """ Called to kill this process. """
if self.handle is None: if self.handle is None:
@ -306,7 +300,6 @@ class executor(GObject.GObject):
self.killed = True self.killed = True
os.kill(self.handle.pid, signal.SIGKILL) os.kill(self.handle.pid, signal.SIGKILL)
def wait_end(self): def wait_end(self):
if self.handle is not None: if self.handle is not None:
@ -331,7 +324,6 @@ class executor(GObject.GObject):
self.emit("ended", retval) self.emit("ended", retval)
def expand_xml(self, text): def expand_xml(self, text):
text = text.replace('&', '&amp;') text = text.replace('&', '&amp;')
@ -341,7 +333,6 @@ class executor(GObject.GObject):
text = text.replace("'", '&apos;') text = text.replace("'", '&apos;')
return text return text
def get_division(self, data): def get_division(self, data):
pos = data.find("/") pos = data.find("/")
@ -366,7 +357,6 @@ class executor(GObject.GObject):
else: else:
return (float(int((data1 / data2) * 1000.0))) / 1000.0 return (float(int((data1 / data2) * 1000.0))) / 1000.0
def get_time(self, line): def get_time(self, line):
time_string = "" time_string = ""

47
src/devedeng/ffmpeg.py
View file

@ -24,6 +24,7 @@ import devedeng.executor
import devedeng.mux_dvd_menu import devedeng.mux_dvd_menu
import devedeng.project import devedeng.project
class ffmpeg(devedeng.executor.executor): class ffmpeg(devedeng.executor.executor):
supports_analize = False supports_analize = False
@ -38,7 +39,8 @@ class ffmpeg(devedeng.executor.executor):
@staticmethod @staticmethod
def check_is_installed(): def check_is_installed():
try: try:
handle = subprocess.Popen(["ffmpeg","-codecs"], stdout = subprocess.PIPE, stderr = subprocess.PIPE) handle = subprocess.Popen(
["ffmpeg", "-codecs"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdout, stderr) = handle.communicate() (stdout, stderr) = handle.communicate()
if 0 == handle.wait(): if 0 == handle.wait():
mp2 = False mp2 = False
@ -109,9 +111,11 @@ class ffmpeg(devedeng.executor.executor):
if file_project.two_pass_encoding: if file_project.two_pass_encoding:
if pass2: if pass2:
self.text = _("Converting %(X)s (pass 2)") % {"X" : file_project.title_name} self.text = _("Converting %(X)s (pass 2)") % {
"X": file_project.title_name}
else: else:
self.text = _("Converting %(X)s (pass 1)") % {"X" : file_project.title_name} self.text = _("Converting %(X)s (pass 1)") % {
"X": file_project.title_name}
# Prepare the converting process for the second pass # Prepare the converting process for the second pass
tmp = devedeng.ffmpeg.ffmpeg() tmp = devedeng.ffmpeg.ffmpeg()
tmp.convert_file(file_project, output_file, video_length, True) tmp.convert_file(file_project, output_file, video_length, True)
@ -127,7 +131,9 @@ class ffmpeg(devedeng.executor.executor):
second_pass = False second_pass = False
else: else:
# second_pass is TRUE in the second pass of a 2-pass codification, and also when not doing 2-pass codification # second_pass is TRUE in the second pass of a 2-pass codification, and also when not doing 2-pass codification
# It is used to remove unnecessary steps during the first pass, but that are needed on the second pass, or when not using 2-pass codification # It is used to remove unnecessary steps during the first pass, but
# that are needed on the second pass, or when not using 2-pass
# codification
second_pass = True second_pass = True
if (video_length == 0): if (video_length == 0):
@ -141,7 +147,8 @@ class ffmpeg(devedeng.executor.executor):
if (file_project.volume != 100) and second_pass: if (file_project.volume != 100) and second_pass:
self.command_var.append("-vol") self.command_var.append("-vol")
self.command_var.append(str(int((256*file_project.volume)/100))) self.command_var.append(
str(int((256 * file_project.volume) / 100)))
if (file_project.audio_delay != 0.0) and (file_project.copy_sound == False) and (file_project.no_reencode_audio_video == False) and second_pass: if (file_project.audio_delay != 0.0) and (file_project.copy_sound == False) and (file_project.no_reencode_audio_video == False) and second_pass:
self.command_var.append("-itsoffset") self.command_var.append("-itsoffset")
@ -194,23 +201,28 @@ class ffmpeg(devedeng.executor.executor):
if (file_project.width_midle != file_project.original_width) or (file_project.height_midle != file_project.original_height): if (file_project.width_midle != file_project.original_width) or (file_project.height_midle != file_project.original_height):
if (cmd_line != ""): if (cmd_line != ""):
cmd_line += ",fifo," cmd_line += ",fifo,"
x = int((file_project.width_midle - file_project.original_width) /2) x = int((file_project.width_midle -
y = int((file_project.height_midle - file_project.original_height) /2) file_project.original_width) / 2)
y = int((file_project.height_midle -
file_project.original_height) / 2)
if (x > 0) or (y > 0): if (x > 0) or (y > 0):
cmd_line+="pad="+str(file_project.width_midle)+":"+str(file_project.height_midle)+":"+str(x)+":"+str(y)+":0x000000" cmd_line += "pad=" + str(file_project.width_midle) + ":" + str(
file_project.height_midle) + ":" + str(x) + ":" + str(y) + ":0x000000"
else: else:
cmd_line+="crop="+str(file_project.width_midle)+":"+str(file_project.height_midle)+":"+str(x)+":"+str(y) cmd_line += "crop=" + str(file_project.width_midle) + ":" + str(
file_project.height_midle) + ":" + str(x) + ":" + str(y)
if (file_project.width_final != file_project.width_midle) or (file_project.height_final != file_project.height_midle): if (file_project.width_final != file_project.width_midle) or (file_project.height_final != file_project.height_midle):
if (cmd_line != ""): if (cmd_line != ""):
cmd_line += ",fifo," cmd_line += ",fifo,"
cmd_line+="scale="+str(file_project.width_final)+":"+str(file_project.height_final) cmd_line += "scale=" + \
str(file_project.width_final) + ":" + \
str(file_project.height_final)
if cmd_line != "": if cmd_line != "":
self.command_var.append("-vf") self.command_var.append("-vf")
self.command_var.append(cmd_line) self.command_var.append(cmd_line)
self.command_var.append("-y") self.command_var.append("-y")
vcd = False vcd = False
@ -272,7 +284,8 @@ class ffmpeg(devedeng.executor.executor):
self.command_var.append("yuv420p") self.command_var.append("yuv420p")
self.command_var.append("-maxrate:v") self.command_var.append("-maxrate:v")
if maxrate > (devedeng.project.devede_project.dvd_max_bps_base[0] * 1000): if maxrate > (devedeng.project.devede_project.dvd_max_bps_base[0] * 1000):
maxrate = devedeng.project.devede_project.dvd_max_bps_base[0] * 1000 maxrate = devedeng.project.devede_project.dvd_max_bps_base[
0] * 1000
self.command_var.append(str(maxrate)) self.command_var.append(str(maxrate))
self.command_var.append("-minrate:v") self.command_var.append("-minrate:v")
if minrate < (devedeng.project.devede_project.dvd_min_bps * 1000): if minrate < (devedeng.project.devede_project.dvd_min_bps * 1000):
@ -367,7 +380,8 @@ class ffmpeg(devedeng.executor.executor):
self.command_var.append("yuv420p") self.command_var.append("yuv420p")
self.command_var.append("-maxrate:v") self.command_var.append("-maxrate:v")
if maxrate > (devedeng.project.devede_project.svcd_max_bps_base[0] * 1000): if maxrate > (devedeng.project.devede_project.svcd_max_bps_base[0] * 1000):
maxrate = devedeng.project.devede_project.svcd_max_bps_base[0] * 1000 maxrate = devedeng.project.devede_project.svcd_max_bps_base[
0] * 1000
self.command_var.append(str(maxrate)) self.command_var.append(str(maxrate))
self.command_var.append("-minrate:v") self.command_var.append("-minrate:v")
if minrate < (devedeng.project.devede_project.svcd_min_bps * 1000): if minrate < (devedeng.project.devede_project.svcd_min_bps * 1000):
@ -440,7 +454,8 @@ class ffmpeg(devedeng.executor.executor):
if (file_project.no_reencode_audio_video == False) and (vcd == False) and second_pass: if (file_project.no_reencode_audio_video == False) and (vcd == False) and second_pass:
self.command_var.append("-s") self.command_var.append("-s")
self.command_var.append(str(file_project.width_final)+"x"+str(file_project.height_final)) self.command_var.append(
str(file_project.width_final) + "x" + str(file_project.height_final))
if second_pass: if second_pass:
self.command_var.append("-trellis") self.command_var.append("-trellis")
@ -471,7 +486,6 @@ class ffmpeg(devedeng.executor.executor):
self.command_var.append(output_file) self.command_var.append(output_file)
def create_menu_mpeg(self, n_page, background_music, sound_length, pal, video_rate, audio_rate, output_path, use_mp2): def create_menu_mpeg(self, n_page, background_music, sound_length, pal, video_rate, audio_rate, output_path, use_mp2):
self.n_page = n_page self.n_page = n_page
@ -487,7 +501,8 @@ class ffmpeg(devedeng.executor.executor):
self.command_var.append("-f") self.command_var.append("-f")
self.command_var.append("image2") self.command_var.append("image2")
self.command_var.append("-i") self.command_var.append("-i")
self.command_var.append(os.path.join(output_path,"menu_"+str(n_page)+"_bg.png")) self.command_var.append(os.path.join(
output_path, "menu_" + str(n_page) + "_bg.png"))
self.command_var.append("-i") self.command_var.append("-i")
self.command_var.append(background_music) self.command_var.append(background_music)

47
src/devedeng/ffprobe.py
View file

@ -23,6 +23,7 @@ import devedeng.executor
import os import os
import json import json
class ffprobe(devedeng.executor.executor): class ffprobe(devedeng.executor.executor):
supports_analize = True supports_analize = True
@ -36,7 +37,8 @@ class ffprobe(devedeng.executor.executor):
@staticmethod @staticmethod
def check_is_installed(): def check_is_installed():
try: try:
handle = subprocess.Popen(["ffprobe","-h"], stdout = subprocess.PIPE, stderr = subprocess.PIPE) handle = subprocess.Popen(
["ffprobe", "-h"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdout, stderr) = handle.communicate() (stdout, stderr) = handle.communicate()
if 0 == handle.wait(): if 0 == handle.wait():
return True return True
@ -62,7 +64,8 @@ class ffprobe(devedeng.executor.executor):
self.original_file_size = os.path.getsize(file_name) self.original_file_size = os.path.getsize(file_name)
command_line = ["ffprobe",file_name,"-of","json","-show_streams", "-loglevel", "quiet"] command_line = ["ffprobe", file_name, "-of",
"json", "-show_streams", "-loglevel", "quiet"]
(stdout, stderr) = self.launch_process(command_line, False) (stdout, stderr) = self.launch_process(command_line, False)
try: try:
@ -72,7 +75,6 @@ class ffprobe(devedeng.executor.executor):
self.config.append_static_log("FFProbe JSON data: " + str(stdout2)) self.config.append_static_log("FFProbe JSON data: " + str(stdout2))
return self.process_json(file_name, stdout2) return self.process_json(file_name, stdout2)
def process_json(self, file_name, stdout2): def process_json(self, file_name, stdout2):
self.audio_list = [] self.audio_list = []
@ -88,7 +90,8 @@ class ffprobe(devedeng.executor.executor):
self.original_fps = 0 self.original_fps = 0
self.original_aspect_ratio = 0 self.original_aspect_ratio = 0
self.config.append_static_log("Getting data for {:s} with ffprobe".format(file_name)) self.config.append_static_log(
"Getting data for {:s} with ffprobe".format(file_name))
try: try:
video_data = json.loads(stdout2) video_data = json.loads(stdout2)
except: except:
@ -112,26 +115,34 @@ class ffprobe(devedeng.executor.executor):
self.original_width = int(float(element["width"])) self.original_width = int(float(element["width"]))
self.original_height = int(float(element["height"])) self.original_height = int(float(element["height"]))
if ("bit_rate" in element): if ("bit_rate" in element):
self.original_videorate = int(float(element["bit_rate"]))/1000 self.original_videorate = int(
self.original_fps = self.get_division(element["avg_frame_rate"]) float(element["bit_rate"])) / 1000
self.original_fps = self.get_division(
element["avg_frame_rate"])
if ("display_aspect_ratio" in element): if ("display_aspect_ratio" in element):
self.original_aspect_ratio = self.get_division(element["display_aspect_ratio"]) self.original_aspect_ratio = self.get_division(
element["display_aspect_ratio"])
elif (element["codec_type"] == "audio"): elif (element["codec_type"] == "audio"):
self.audio_streams += 1 self.audio_streams += 1
self.audio_list.append(element["index"]) self.audio_list.append(element["index"])
if (self.audio_streams == 1): if (self.audio_streams == 1):
if ("bit_rate" in element): if ("bit_rate" in element):
self.original_audiorate = int(float(element["bit_rate"]))/1000 self.original_audiorate = int(
self.original_audiorate_uncompressed = int(float(element["sample_rate"])) float(element["bit_rate"])) / 1000
self.original_audiorate_uncompressed = int(
float(element["sample_rate"]))
self.original_size = str(self.original_width)+"x"+str(self.original_height) self.original_size = str(self.original_width) + \
"x" + str(self.original_height)
if (self.original_aspect_ratio is None) or (self.original_aspect_ratio <= 1.0): if (self.original_aspect_ratio is None) or (self.original_aspect_ratio <= 1.0):
if (self.original_height != 0): if (self.original_height != 0):
self.original_aspect_ratio = (float(self.original_width))/(float(self.original_height)) self.original_aspect_ratio = (
float(self.original_width)) / (float(self.original_height))
if (self.original_aspect_ratio is not None): if (self.original_aspect_ratio is not None):
self.original_aspect_ratio = (float(int(self.original_aspect_ratio*1000.0)))/1000.0 self.original_aspect_ratio = (
float(int(self.original_aspect_ratio * 1000.0))) / 1000.0
if (len(self.video_list) == 0): if (len(self.video_list) == 0):
return True # the file is not a video file; maybe an audio-only file or another thing return True # the file is not a video file; maybe an audio-only file or another thing
@ -140,15 +151,19 @@ class ffprobe(devedeng.executor.executor):
command_line = ["ffprobe", file_name] command_line = ["ffprobe", file_name]
(stdout, stderr) = self.launch_process(command_line, False) (stdout, stderr) = self.launch_process(command_line, False)
try: try:
stdout2 = stdout.decode("utf-8") + "\n" + stderr.decode("utf-8") stdout2 = stdout.decode("utf-8") + \
"\n" + stderr.decode("utf-8")
except: except:
stdout2 = stdout.decode("latin1") + "\n" + stderr.decode("latin1") stdout2 = stdout.decode("latin1") + \
self.config.append_static_log("Using ffprobe human readable format: "+str(stdout2)) "\n" + stderr.decode("latin1")
self.config.append_static_log(
"Using ffprobe human readable format: " + str(stdout2))
for line in stdout2.split("\n"): for line in stdout2.split("\n"):
line = line.strip() line = line.strip()
if line.startswith("Duration: "): if line.startswith("Duration: "):
self.original_length = self.get_time(line[10:]) self.original_length = self.get_time(line[10:])
break break
self.config.append_static_log("Estimated length: {:d}; Resolution: {:s}".format(self.original_length,self.original_size)) self.config.append_static_log("Estimated length: {:d}; Resolution: {:s}".format(
self.original_length, self.original_size))
return False # no error return False # no error

5
src/devedeng/file_copy.py
View file

@ -21,6 +21,7 @@ import os
import devedeng.configuration_data import devedeng.configuration_data
import devedeng.executor import devedeng.executor
class file_copy(devedeng.executor.executor): class file_copy(devedeng.executor.executor):
def __init__(self, input_path, output_path): def __init__(self, input_path, output_path):
@ -28,14 +29,14 @@ class file_copy(devedeng.executor.executor):
devedeng.executor.executor.__init__(self) devedeng.executor.executor.__init__(self)
self.config = devedeng.configuration_data.configuration.get_config() self.config = devedeng.configuration_data.configuration.get_config()
self.text = _("Copying file %(X)s") % {"X": os.path.basename(input_path)} self.text = _("Copying file %(X)s") % {
"X": os.path.basename(input_path)}
self.command_var = [] self.command_var = []
self.command_var.append("copy_files_verbose.py") self.command_var.append("copy_files_verbose.py")
self.command_var.append(input_path) self.command_var.append(input_path)
self.command_var.append(output_path) self.command_var.append(output_path)
def process_stdout(self, data): def process_stdout(self, data):
if (data is None) or (len(data) == 0): if (data is None) or (len(data) == 0):

169
src/devedeng/file_movie.py
View file

@ -26,9 +26,11 @@ import devedeng.preview
import devedeng.file_copy import devedeng.file_copy
import devedeng.subtitles_mux import devedeng.subtitles_mux
class file_movie(devedeng.interface_manager.interface_manager): class file_movie(devedeng.interface_manager.interface_manager):
__gsignals__ = {'title_changed': (GObject.SIGNAL_RUN_FIRST, None,(str,)), 'in_menu_changed': (GObject.SIGNAL_RUN_FIRST, None,(bool,))} __gsignals__ = {'title_changed': (GObject.SIGNAL_RUN_FIRST, None, (str,)), 'in_menu_changed': (
GObject.SIGNAL_RUN_FIRST, None, (bool,))}
def __init__(self, file_name, list_files=None): def __init__(self, file_name, list_files=None):
@ -45,7 +47,8 @@ class file_movie(devedeng.interface_manager.interface_manager):
if list_files is None: if list_files is None:
self.add_text("file_name", file_name) self.add_text("file_name", file_name)
self.add_text("title_name", os.path.splitext(os.path.basename(file_name))[0]) self.add_text("title_name", os.path.splitext(
os.path.basename(file_name))[0])
self.add_label("original_size", None) self.add_label("original_size", None)
self.add_label("original_length", None) self.add_label("original_length", None)
self.add_label("original_videorate", None) self.add_label("original_videorate", None)
@ -56,7 +59,7 @@ class file_movie(devedeng.interface_manager.interface_manager):
else: else:
self.original_aspect_ratio = 1.777 # dummy value self.original_aspect_ratio = 1.777 # dummy value
self.add_text("chapter_list_entry", None); self.add_text("chapter_list_entry", None)
self.add_dualtoggle("format_pal", "format_ntsc", self.config.PAL) self.add_dualtoggle("format_pal", "format_ntsc", self.config.PAL)
self.add_toggle("video_rate_automatic", True) self.add_toggle("video_rate_automatic", True)
@ -75,13 +78,20 @@ class file_movie(devedeng.interface_manager.interface_manager):
else: else:
self.add_toggle("gop12", True) self.add_toggle("gop12", True)
self.add_group("final_size_pal", ["size_auto", "size_1920x1080", "size_1280x720", "size_720x576", "size_704x576", "size_480x576","size_352x576", "size_352x288"], "size_auto") self.add_group("final_size_pal", ["size_auto", "size_1920x1080", "size_1280x720", "size_720x576",
self.add_group("final_size_ntsc", ["size_auto_ntsc", "size_1920x1080_ntsc", "size_1280x720_ntsc", "size_720x480_ntsc", "size_704x480_ntsc", "size_480x480_ntsc","size_352x480_ntsc", "size_352x240_ntsc"], "size_auto_ntsc") "size_704x576", "size_480x576", "size_352x576", "size_352x288"], "size_auto")
self.add_group("aspect_ratio", ["aspect_auto", "aspect_classic", "aspect_wide"], "aspect_auto") self.add_group("final_size_ntsc", ["size_auto_ntsc", "size_1920x1080_ntsc", "size_1280x720_ntsc", "size_720x480_ntsc",
self.add_group("scaling", ["add_black_bars", "scale_picture" ,"cut_picture"], "add_black_bars") "size_704x480_ntsc", "size_480x480_ntsc", "size_352x480_ntsc", "size_352x240_ntsc"], "size_auto_ntsc")
self.add_group("rotation",["rotation_0","rotation_90","rotation_180","rotation_270"], "rotation_0") self.add_group("aspect_ratio", [
self.add_group("deinterlace", ["deinterlace_none", "deinterlace_ffmpeg", "deinterlace_yadif"], "deinterlace_none") "aspect_auto", "aspect_classic", "aspect_wide"], "aspect_auto")
self.add_group("actions", ["action_stop","action_play_first","action_play_previous","action_play_again","action_play_next","action_play_last"], "action_stop") self.add_group(
"scaling", ["add_black_bars", "scale_picture", "cut_picture"], "add_black_bars")
self.add_group("rotation", [
"rotation_0", "rotation_90", "rotation_180", "rotation_270"], "rotation_0")
self.add_group("deinterlace", [
"deinterlace_none", "deinterlace_ffmpeg", "deinterlace_yadif"], "deinterlace_none")
self.add_group("actions", ["action_stop", "action_play_first", "action_play_previous",
"action_play_again", "action_play_next", "action_play_last"], "action_stop")
self.add_integer_adjustment("volume", 100) self.add_integer_adjustment("volume", 100)
if (self.disc_type == "dvd"): if (self.disc_type == "dvd"):
@ -97,8 +107,10 @@ class file_movie(devedeng.interface_manager.interface_manager):
self.add_integer_adjustment("chapter_size", 5) self.add_integer_adjustment("chapter_size", 5)
self.add_colorbutton("subt_fill_color", self.config.subt_fill_color) self.add_colorbutton("subt_fill_color", self.config.subt_fill_color)
self.add_colorbutton("subt_outline_color", self.config.subt_outline_color) self.add_colorbutton("subt_outline_color",
self.add_float_adjustment("subt_thickness", self.config.subt_outline_thickness) self.config.subt_outline_color)
self.add_float_adjustment(
"subt_thickness", self.config.subt_outline_thickness)
if list_files is None: if list_files is None:
self.add_list("subtitles_list") self.add_list("subtitles_list")
@ -109,15 +121,20 @@ class file_movie(devedeng.interface_manager.interface_manager):
self.add_show_hide("format_pal", ["size_pal"], ["size_ntsc"]) self.add_show_hide("format_pal", ["size_pal"], ["size_ntsc"])
self.add_enable_disable("divide_in_chapters", ["chapter_size_spinbutton", "chapter_list_entry"], []) self.add_enable_disable("divide_in_chapters", [
self.add_enable_disable("video_rate_automatic", [], ["video_spinbutton"]) "chapter_size_spinbutton", "chapter_list_entry"], [])
self.add_enable_disable("audio_rate_automatic", [], ["audio_spinbutton"]) self.add_enable_disable("video_rate_automatic",
[], ["video_spinbutton"])
self.add_enable_disable("audio_rate_automatic",
[], ["audio_spinbutton"])
self.add_enable_disable("sound5_1", ["copy_sound"], []) self.add_enable_disable("sound5_1", ["copy_sound"], [])
if (self.disc_type == "dvd"): if (self.disc_type == "dvd"):
self.add_enable_disable("aspect_wide", [], ["size_704x576", "size_480x576","size_352x576", "size_352x288","size_704x480_ntsc", "size_480x480_ntsc","size_352x480_ntsc", "size_352x240_ntsc"]) self.add_enable_disable("aspect_wide", [], ["size_704x576", "size_480x576", "size_352x576", "size_352x288",
"size_704x480_ntsc", "size_480x480_ntsc", "size_352x480_ntsc", "size_352x240_ntsc"])
self.add_enable_disable("copy_sound", [], ["audio_delay_spinbutton","audio_rate_automatic","audio_spinbutton","spinbutton_volume","scale_volume","reset_volume"]) self.add_enable_disable("copy_sound", [], ["audio_delay_spinbutton", "audio_rate_automatic",
"audio_spinbutton", "spinbutton_volume", "scale_volume", "reset_volume"])
common_elements = ["gop12", "video_rate_automatic", "video_spinbutton", "audio_rate_automatic", "audio_spinbutton", "format_pal", "format_ntsc", "spinbutton_volume", "scale_volume", "reset_volume", common_elements = ["gop12", "video_rate_automatic", "video_spinbutton", "audio_rate_automatic", "audio_spinbutton", "format_pal", "format_ntsc", "spinbutton_volume", "scale_volume", "reset_volume",
"size_auto", "size_1920x1080", "size_1280x720", "size_720x576", "size_704x576", "size_480x576", "size_352x576", "size_352x288", "size_auto", "size_1920x1080", "size_1280x720", "size_720x576", "size_704x576", "size_480x576", "size_352x576", "size_352x288",
@ -136,7 +153,8 @@ class file_movie(devedeng.interface_manager.interface_manager):
no_reencode_audio_video_list.append("is_mpeg_ps") no_reencode_audio_video_list.append("is_mpeg_ps")
self.add_enable_disable("is_mpeg_ps", [], is_mpeg_ps_list) self.add_enable_disable("is_mpeg_ps", [], is_mpeg_ps_list)
self.add_enable_disable("no_reencode_audio_video", [], no_reencode_audio_video_list) self.add_enable_disable("no_reencode_audio_video",
[], no_reencode_audio_video_list)
if list_files is None: if list_files is None:
cv = devedeng.converter.converter.get_converter() cv = devedeng.converter.converter.get_converter()
@ -166,7 +184,8 @@ class file_movie(devedeng.interface_manager.interface_manager):
self.original_audiorate = 224 self.original_audiorate = 224
if self.original_videorate <= 0: if self.original_videorate <= 0:
# presume that there are only video and audio streams # presume that there are only video and audio streams
self.original_videorate = ((8 * self.original_file_size) / self.original_length) - (self.original_audiorate * self.audio_streams) self.original_videorate = ((8 * self.original_file_size) / self.original_length) - (
self.original_audiorate * self.audio_streams)
# to avoid division by zero when a clip is very short # to avoid division by zero when a clip is very short
if self.original_length <= 0: if self.original_length <= 0:
self.original_length = 1 self.original_length = 1
@ -182,21 +201,17 @@ class file_movie(devedeng.interface_manager.interface_manager):
self.aspect_ratio_final = None self.aspect_ratio_final = None
self.converted_filename = None self.converted_filename = None
def set_title(self, new_title): def set_title(self, new_title):
self.title_name = new_title self.title_name = new_title
self.emit('title_changed', self.title_name) self.emit('title_changed', self.title_name)
def set_show_in_menu(self, show): def set_show_in_menu(self, show):
self.show_in_menu = show self.show_in_menu = show
self.emit('in_menu_changed', self.show_in_menu) self.emit('in_menu_changed', self.show_in_menu)
def get_duration(self): def get_duration(self):
return self.original_length return self.original_length
def get_estimated_size(self): def get_estimated_size(self):
""" Returns the estimated final file size, in kBytes, based on the final audio and video rate, and the subtitles """ """ Returns the estimated final file size, in kBytes, based on the final audio and video rate, and the subtitles """
@ -208,11 +223,11 @@ class file_movie(devedeng.interface_manager.interface_manager):
else: else:
# let's asume 8kbps for each subtitle # let's asume 8kbps for each subtitle
sub_rate = 8 * len(self.subtitles_list) sub_rate = 8 * len(self.subtitles_list)
estimated_size = ((self.video_rate_final + (self.audio_rate_final * self.audio_streams) + sub_rate) * self.original_length) / 8 estimated_size = ((self.video_rate_final + (self.audio_rate_final *
self.audio_streams) + sub_rate) * self.original_length) / 8
return estimated_size return estimated_size
def get_size_data(self): def get_size_data(self):
estimated_size = self.get_estimated_size() estimated_size = self.get_estimated_size()
@ -226,13 +241,11 @@ class file_movie(devedeng.interface_manager.interface_manager):
return estimated_size, videorate_fixed_size, self.audio_rate_final * self.audio_streams, sub_rate, self.width_final, self.height_final, self.original_length return estimated_size, videorate_fixed_size, self.audio_rate_final * self.audio_streams, sub_rate, self.width_final, self.height_final, self.original_length
def set_auto_video_audio_rate(self, new_video_rate, new_audio_rate): def set_auto_video_audio_rate(self, new_video_rate, new_audio_rate):
self.video_rate_auto = int(new_video_rate) self.video_rate_auto = int(new_video_rate)
self.audio_rate_auto = int(new_audio_rate) self.audio_rate_auto = int(new_audio_rate)
def get_max_resolution(self, rx, ry, aspect): def get_max_resolution(self, rx, ry, aspect):
tmpx = ry * aspect tmpx = ry * aspect
@ -242,7 +255,6 @@ class file_movie(devedeng.interface_manager.interface_manager):
else: else:
return rx, tmpy return rx, tmpy
def set_final_rates(self): def set_final_rates(self):
if (self.disc_type == "divx") or (self.disc_type == "mkv"): if (self.disc_type == "divx") or (self.disc_type == "mkv"):
@ -272,7 +284,6 @@ class file_movie(devedeng.interface_manager.interface_manager):
else: else:
self.audio_rate_final = self.audio_rate self.audio_rate_final = self.audio_rate
def set_final_size_aspect(self): def set_final_size_aspect(self):
if self.is_mpeg_ps: if self.is_mpeg_ps:
@ -286,9 +297,11 @@ class file_movie(devedeng.interface_manager.interface_manager):
if self.format_pal: if self.format_pal:
final_size = self.final_size_pal final_size = self.final_size_pal
else: else:
final_size = self.final_size_ntsc[:-5] # remove the "_ntsc" from the string # remove the "_ntsc" from the string
final_size = self.final_size_ntsc[:-5]
# for divx or matroska, if the size and the aspect ratio is automatic, just don't change them # for divx or matroska, if the size and the aspect ratio is automatic,
# just don't change them
if ((self.disc_type == "divx") or (self.disc_type == "mkv")) and (final_size == "size_auto") and (self.aspect_ratio == "aspect_auto"): if ((self.disc_type == "divx") or (self.disc_type == "mkv")) and (final_size == "size_auto") and (self.aspect_ratio == "aspect_auto"):
self.width_midle = self.original_width self.width_midle = self.original_width
self.width_final = self.original_width self.width_final = self.original_width
@ -351,7 +364,8 @@ class file_movie(devedeng.interface_manager.interface_manager):
else: else:
self.height_final = 480 self.height_final = 480
else: else:
tx, ty = self.get_max_resolution(self.original_width,self.original_height,self.original_aspect_ratio) tx, ty = self.get_max_resolution(
self.original_width, self.original_height, self.original_aspect_ratio)
if (self.format_pal): if (self.format_pal):
th = 576 th = 576
th2 = 288 th2 = 288
@ -371,7 +385,8 @@ class file_movie(devedeng.interface_manager.interface_manager):
self.width_final = 720 self.width_final = 720
self.height_final = th self.height_final = th
else: else:
self.width_final , self.height_final = self.get_max_resolution(self.original_width,self.original_height,self.original_aspect_ratio) self.width_final, self.height_final = self.get_max_resolution(
self.original_width, self.original_height, self.original_aspect_ratio)
else: else:
values = final_size[5:].split("x") values = final_size[5:].split("x")
self.width_final = int(values[0]) self.width_final = int(values[0])
@ -393,25 +408,27 @@ class file_movie(devedeng.interface_manager.interface_manager):
elif self.scaling == "add_black_bars": elif self.scaling == "add_black_bars":
if midle_aspect_ratio > self.aspect_ratio_final: # add horizontal black bars, at top and bottom if midle_aspect_ratio > self.aspect_ratio_final: # add horizontal black bars, at top and bottom
self.width_midle = int(self.original_width) self.width_midle = int(self.original_width)
self.height_midle = int(self.original_height * midle_aspect_ratio / self.aspect_ratio_final) self.height_midle = int(
self.original_height * midle_aspect_ratio / self.aspect_ratio_final)
else: # add vertical black bars, at left and right else: # add vertical black bars, at left and right
self.width_midle = int(self.original_width * self.aspect_ratio_final / midle_aspect_ratio) self.width_midle = int(
self.original_width * self.aspect_ratio_final / midle_aspect_ratio)
self.height_midle = int(self.original_height) self.height_midle = int(self.original_height)
else: # cut picture else: # cut picture
if midle_aspect_ratio > self.aspect_ratio_final: if midle_aspect_ratio > self.aspect_ratio_final:
self.width_midle = int(self.original_width * self.aspect_ratio_final / midle_aspect_ratio) self.width_midle = int(
self.original_width * self.aspect_ratio_final / midle_aspect_ratio)
self.height_midle = int(self.original_height) self.height_midle = int(self.original_height)
else: else:
self.width_midle = int(self.original_width) self.width_midle = int(self.original_width)
self.height_midle = int(self.original_height * midle_aspect_ratio / self.aspect_ratio_final) self.height_midle = int(
self.original_height * midle_aspect_ratio / self.aspect_ratio_final)
def set_type(self, obj=None, disc_type=None): def set_type(self, obj=None, disc_type=None):
if (disc_type is not None): if (disc_type is not None):
self.disc_type = disc_type self.disc_type = disc_type
def delete_file(self): def delete_file(self):
return return
@ -420,7 +437,6 @@ class file_movie(devedeng.interface_manager.interface_manager):
help_file = devedeng.help.help("file.html") help_file = devedeng.help.help("file.html")
def properties(self): def properties(self):
if (self.wfile_properties is not None): if (self.wfile_properties is not None):
@ -430,15 +446,18 @@ class file_movie(devedeng.interface_manager.interface_manager):
self.builder = Gtk.Builder() self.builder = Gtk.Builder()
self.builder.set_translation_domain(self.config.gettext_domain) self.builder.set_translation_domain(self.config.gettext_domain)
self.builder.add_from_file(os.path.join(self.config.glade,"wfile_properties.ui")) self.builder.add_from_file(os.path.join(
self.config.glade, "wfile_properties.ui"))
self.builder.connect_signals(self) self.builder.connect_signals(self)
self.wfile_properties = self.builder.get_object("file_properties") self.wfile_properties = self.builder.get_object("file_properties")
self.wfile_properties.show_all() self.wfile_properties.show_all()
self.wframe_title = self.builder.get_object("frame_title") self.wframe_title = self.builder.get_object("frame_title")
self.wframe_fileinfo = self.builder.get_object("frame_fileinfo") self.wframe_fileinfo = self.builder.get_object("frame_fileinfo")
self.wframe_multiproperties = self.builder.get_object("frame_multiproperties") self.wframe_multiproperties = self.builder.get_object(
self.wtreeview_multiproperties = self.builder.get_object("treeview_multiproperties") "frame_multiproperties")
self.wtreeview_multiproperties = self.builder.get_object(
"treeview_multiproperties")
self.wbutton_preview = self.builder.get_object("button_preview") self.wbutton_preview = self.builder.get_object("button_preview")
self.wshow_in_menu = self.builder.get_object("show_in_menu") self.wshow_in_menu = self.builder.get_object("show_in_menu")
@ -451,7 +470,8 @@ class file_movie(devedeng.interface_manager.interface_manager):
self.wframe_video_rate = self.builder.get_object("frame_video_rate") self.wframe_video_rate = self.builder.get_object("frame_video_rate")
self.wframe_audio_rate = self.builder.get_object("frame_audio_rate") self.wframe_audio_rate = self.builder.get_object("frame_audio_rate")
self.waudio_rate = self.builder.get_object("audio_rate") self.waudio_rate = self.builder.get_object("audio_rate")
self.wframe_division_chapters = self.builder.get_object("frame_division_chapters") self.wframe_division_chapters = self.builder.get_object(
"frame_division_chapters")
if (self.disc_type == "dvd") or (self.disc_type == "divx") or (self.disc_type == "mkv"): if (self.disc_type == "dvd") or (self.disc_type == "divx") or (self.disc_type == "mkv"):
self.waudio_rate.set_upper(448.0) self.waudio_rate.set_upper(448.0)
@ -461,7 +481,8 @@ class file_movie(devedeng.interface_manager.interface_manager):
# elements in page SUBTITLES # elements in page SUBTITLES
self.wsubtitles_list = self.builder.get_object("subtitles_list") self.wsubtitles_list = self.builder.get_object("subtitles_list")
self.wtreview_subtitles = self.builder.get_object("treeview_subtitles") self.wtreview_subtitles = self.builder.get_object("treeview_subtitles")
self.wscrolledwindow_subtitles = self.builder.get_object("scrolledwindow_subtitles") self.wscrolledwindow_subtitles = self.builder.get_object(
"scrolledwindow_subtitles")
self.wadd_subtitles = self.builder.get_object("add_subtitles") self.wadd_subtitles = self.builder.get_object("add_subtitles")
self.wdel_subtitles = self.builder.get_object("del_subtitles") self.wdel_subtitles = self.builder.get_object("del_subtitles")
@ -471,13 +492,17 @@ class file_movie(devedeng.interface_manager.interface_manager):
# elements in page VIDEO OPTIONS # elements in page VIDEO OPTIONS
self.wsize_1920x1080 = self.builder.get_object("size_1920x1080") self.wsize_1920x1080 = self.builder.get_object("size_1920x1080")
self.wsize_1280x720 = self.builder.get_object("size_1280x720") self.wsize_1280x720 = self.builder.get_object("size_1280x720")
self.wsize_1920x1080_ntsc = self.builder.get_object("size_1920x1080_ntsc") self.wsize_1920x1080_ntsc = self.builder.get_object(
self.wsize_1280x720_ntsc = self.builder.get_object("size_1280x720_ntsc") "size_1920x1080_ntsc")
self.wsize_1280x720_ntsc = self.builder.get_object(
"size_1280x720_ntsc")
self.wframe_final_size = self.builder.get_object("frame_final_size") self.wframe_final_size = self.builder.get_object("frame_final_size")
self.wframe_aspect_ratio = self.builder.get_object("frame_aspect_ratio") self.wframe_aspect_ratio = self.builder.get_object(
"frame_aspect_ratio")
self.waspect_classic = self.builder.get_object("aspect_classic") self.waspect_classic = self.builder.get_object("aspect_classic")
self.waspect_wide = self.builder.get_object("aspect_wide") self.waspect_wide = self.builder.get_object("aspect_wide")
self.wadd_black_bars_pic = self.builder.get_object("add_black_bars_pic") self.wadd_black_bars_pic = self.builder.get_object(
"add_black_bars_pic")
self.wscale_picture_pic = self.builder.get_object("scale_picture_pic") self.wscale_picture_pic = self.builder.get_object("scale_picture_pic")
self.wcut_picture_pic = self.builder.get_object("cut_picture_pic") self.wcut_picture_pic = self.builder.get_object("cut_picture_pic")
@ -552,13 +577,11 @@ class file_movie(devedeng.interface_manager.interface_manager):
sel.set_mode(Gtk.SelectionMode.MULTIPLE) sel.set_mode(Gtk.SelectionMode.MULTIPLE)
self.wtreeview_multiproperties.set_rubber_banding(True) self.wtreeview_multiproperties.set_rubber_banding(True)
self.save_ui() self.save_ui()
self.update_ui(self.builder) self.update_ui(self.builder)
self.on_aspect_classic_toggled(None) self.on_aspect_classic_toggled(None)
self.on_treeview_subtitles_cursor_changed(None) self.on_treeview_subtitles_cursor_changed(None)
def on_aspect_classic_toggled(self, b): def on_aspect_classic_toggled(self, b):
status1 = self.waspect_classic.get_active() status1 = self.waspect_classic.get_active()
@ -573,14 +596,19 @@ class file_movie(devedeng.interface_manager.interface_manager):
else: else:
final_aspect = 4.0 / 3.0 final_aspect = 4.0 / 3.0
if (final_aspect < self.original_aspect_ratio): if (final_aspect < self.original_aspect_ratio):
self.wadd_black_bars_pic.set_from_file(os.path.join(self.config.pic_path,"to_classic_blackbars.png")) self.wadd_black_bars_pic.set_from_file(os.path.join(
self.wcut_picture_pic.set_from_file(os.path.join(self.config.pic_path,"to_classic_cut.png")) self.config.pic_path, "to_classic_blackbars.png"))
self.wscale_picture_pic.set_from_file(os.path.join(self.config.pic_path,"to_classic_scale.png")) self.wcut_picture_pic.set_from_file(os.path.join(
self.config.pic_path, "to_classic_cut.png"))
self.wscale_picture_pic.set_from_file(os.path.join(
self.config.pic_path, "to_classic_scale.png"))
else: else:
self.wadd_black_bars_pic.set_from_file(os.path.join(self.config.pic_path,"to_wide_blackbars.png")) self.wadd_black_bars_pic.set_from_file(os.path.join(
self.wcut_picture_pic.set_from_file(os.path.join(self.config.pic_path,"to_wide_cut.png")) self.config.pic_path, "to_wide_blackbars.png"))
self.wscale_picture_pic.set_from_file(os.path.join(self.config.pic_path,"to_wide_scale.png")) self.wcut_picture_pic.set_from_file(
os.path.join(self.config.pic_path, "to_wide_cut.png"))
self.wscale_picture_pic.set_from_file(
os.path.join(self.config.pic_path, "to_wide_scale.png"))
def on_button_accept_clicked(self, b): def on_button_accept_clicked(self, b):
@ -607,7 +635,6 @@ class file_movie(devedeng.interface_manager.interface_manager):
self.wfile_properties = None self.wfile_properties = None
self.builder = None self.builder = None
def on_button_cancel_clicked(self, b): def on_button_cancel_clicked(self, b):
if self.list_files is None: if self.list_files is None:
@ -617,13 +644,12 @@ class file_movie(devedeng.interface_manager.interface_manager):
self.wfile_properties = None self.wfile_properties = None
self.builder = None self.builder = None
def on_add_subtitles_clicked(self, b): def on_add_subtitles_clicked(self, b):
subt = devedeng.ask_subtitles.ask_subtitles() subt = devedeng.ask_subtitles.ask_subtitles()
if (subt.run()): if (subt.run()):
self.wsubtitles_list.append([subt.filename, subt.encoding, subt.language, subt.put_upper]) self.wsubtitles_list.append(
[subt.filename, subt.encoding, subt.language, subt.put_upper])
def get_selected_subtitle(self): def get_selected_subtitle(self):
@ -635,14 +661,12 @@ class file_movie(devedeng.interface_manager.interface_manager):
else: else:
return ((None, None)) return ((None, None))
def on_del_subtitles_clicked(self, b): def on_del_subtitles_clicked(self, b):
model, treeiter = self.get_selected_subtitle() model, treeiter = self.get_selected_subtitle()
if (model is not None): if (model is not None):
model.remove(treeiter) model.remove(treeiter)
def on_treeview_subtitles_cursor_changed(self, b): def on_treeview_subtitles_cursor_changed(self, b):
model, treeiter = self.get_selected_subtitle() model, treeiter = self.get_selected_subtitle()
@ -651,12 +675,12 @@ class file_movie(devedeng.interface_manager.interface_manager):
else: else:
self.wdel_subtitles.set_sensitive(True) self.wdel_subtitles.set_sensitive(True)
def do_conversion(self, output_path, duration=0): def do_conversion(self, output_path, duration=0):
self.converted_filename = output_path self.converted_filename = output_path
if self.is_mpeg_ps: if self.is_mpeg_ps:
converter = devedeng.file_copy.file_copy(self.file_name,output_path) converter = devedeng.file_copy.file_copy(
self.file_name, output_path)
else: else:
self.set_final_size_aspect() self.set_final_size_aspect()
self.set_final_rates() self.set_final_rates()
@ -695,12 +719,10 @@ class file_movie(devedeng.interface_manager.interface_manager):
return converter return converter
def on_button_preview_clicked(self, b): def on_button_preview_clicked(self, b):
self.store_ui(self.builder) self.store_ui(self.builder)
self.do_preview() self.do_preview()
def do_preview(self): def do_preview(self):
wpreview = devedeng.preview.preview_window() wpreview = devedeng.preview.preview_window()
@ -708,19 +730,19 @@ class file_movie(devedeng.interface_manager.interface_manager):
return return
run_window = devedeng.runner.runner() run_window = devedeng.runner.runner()
p = self.do_conversion(os.path.join(self.config.tmp_folder,"movie_preview.mpg"),wpreview.lvalue) p = self.do_conversion(os.path.join(
self.config.tmp_folder, "movie_preview.mpg"), wpreview.lvalue)
run_window.add_process(p) run_window.add_process(p)
run_window.connect("done", self.preview_done) run_window.connect("done", self.preview_done)
run_window.run() run_window.run()
def preview_done(self, o, retval): def preview_done(self, o, retval):
if (retval == 0): if (retval == 0):
cv = devedeng.converter.converter.get_converter() cv = devedeng.converter.converter.get_converter()
disc_player = (cv.get_film_player())() disc_player = (cv.get_film_player())()
disc_player.play_film(os.path.join(self.config.tmp_folder,"movie_preview.mpg")) disc_player.play_film(os.path.join(
self.config.tmp_folder, "movie_preview.mpg"))
def store_file(self): def store_file(self):
@ -730,18 +752,15 @@ class file_movie(devedeng.interface_manager.interface_manager):
return data return data
def restore_file(self, data): def restore_file(self, data):
self.unserialize(data) self.unserialize(data)
def on_select_all_clicked(self, b): def on_select_all_clicked(self, b):
sel = self.wtreeview_multiproperties.get_selection() sel = self.wtreeview_multiproperties.get_selection()
sel.select_all() sel.select_all()
def on_unselect_all_clicked(self, b): def on_unselect_all_clicked(self, b):
sel = self.wtreeview_multiproperties.get_selection() sel = self.wtreeview_multiproperties.get_selection()

5
src/devedeng/genisoimage.py
View file

@ -22,6 +22,7 @@ import devedeng.configuration_data
import subprocess import subprocess
import devedeng.executor import devedeng.executor
class genisoimage(devedeng.executor.executor): class genisoimage(devedeng.executor.executor):
supports_analize = False supports_analize = False
@ -35,7 +36,8 @@ class genisoimage(devedeng.executor.executor):
@staticmethod @staticmethod
def check_is_installed(): def check_is_installed():
try: try:
handle = subprocess.Popen(["genisoimage","--help"], stdout = subprocess.PIPE, stderr = subprocess.PIPE) handle = subprocess.Popen(
["genisoimage", "--help"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdout, stderr) = handle.communicate() (stdout, stderr) = handle.communicate()
if 0 == handle.wait(): if 0 == handle.wait():
return True return True
@ -66,7 +68,6 @@ class genisoimage(devedeng.executor.executor):
self.command_var.append(filesystem_path) self.command_var.append(filesystem_path)
self.text = _("Creating ISO image") self.text = _("Creating ISO image")
def process_stdout(self, data): def process_stdout(self, data):
return return

7
src/devedeng/help.py
View file

@ -4,14 +4,17 @@ from gi.repository import Gtk,Gdk
import devedeng.configuration_data import devedeng.configuration_data
import os import os
class help: class help:
def __init__(self, help_page): def __init__(self, help_page):
self.config = devedeng.configuration_data.configuration.get_config() self.config = devedeng.configuration_data.configuration.get_config()
file="file://"+os.path.join(self.config.help_path,"html",help_page) file = "file://" + \
os.path.join(self.config.help_path, "html", help_page)
retval = Gtk.show_uri(None, file, Gdk.CURRENT_TIME) retval = Gtk.show_uri(None, file, Gdk.CURRENT_TIME)
if retval == False: if retval == False:
msg=devede_dialogs.show_error(gladefile,_("Can't open the help files.")) msg = devede_dialogs.show_error(
gladefile, _("Can't open the help files."))

55
src/devedeng/interface_manager.py
View file

@ -17,6 +17,7 @@
from gi.repository import GObject, Gdk from gi.repository import GObject, Gdk
class interface_manager(GObject.GObject): class interface_manager(GObject.GObject):
""" This class allows to automatically generate variables for a GLADE interface, """ This class allows to automatically generate variables for a GLADE interface,
set the widgets in the interface to their values, and copy the current values set the widgets in the interface to their values, and copy the current values
@ -75,7 +76,8 @@ class interface_manager(GObject.GObject):
The default value can be a text or None """ The default value can be a text or None """
if (default_value is not None): if (default_value is not None):
exec('self.'+text_name+' = "'+str(default_value).replace('\"','\\"')+'"') exec('self.' + text_name + ' = "' +
str(default_value).replace('\"', '\\"') + '"')
else: else:
exec('self.' + text_name + ' = None') exec('self.' + text_name + ' = None')
self.interface_text.append((text_name, callback)) self.interface_text.append((text_name, callback))
@ -160,7 +162,8 @@ class interface_manager(GObject.GObject):
elements that will be enabled when the element is inactive, and elements that will be enabled when the element is inactive, and
disabled when the element is active """ disabled when the element is active """
self.interface_enable_disable.append([element_name, to_enable, to_disable]) self.interface_enable_disable.append(
[element_name, to_enable, to_disable])
def update_ui(self, builder): def update_ui(self, builder):
""" Sets the value of the widgets in base of the internal variables """ """ Sets the value of the widgets in base of the internal variables """
@ -248,7 +251,8 @@ class interface_manager(GObject.GObject):
for element in self.interface_colorbuttons: for element in self.interface_colorbuttons:
value = eval('self.' + element[0]) value = eval('self.' + element[0])
obj = builder.get_object(element[0]) obj = builder.get_object(element[0])
objcolor = Gdk.Color(int(value[0]*65535.0),int(value[1]*65535.0),int(value[2]*65535.0)) objcolor = Gdk.Color(
int(value[0] * 65535.0), int(value[1] * 65535.0), int(value[2] * 65535.0))
obj.set_color(objcolor) obj.set_color(objcolor)
obj.set_alpha(int(value[3] * 65535.0)) obj.set_alpha(int(value[3] * 65535.0))
callback = element[1] callback = element[1]
@ -316,7 +320,6 @@ class interface_manager(GObject.GObject):
obj.connect('toggled', self.toggled_element2) obj.connect('toggled', self.toggled_element2)
self.toggled_element2(obj) self.toggled_element2(obj)
def toggled_element(self, element): def toggled_element(self, element):
""" Wenever an element with 'hide' or 'show' needs is toggled, this callback is called """ """ Wenever an element with 'hide' or 'show' needs is toggled, this callback is called """
@ -337,7 +340,8 @@ class interface_manager(GObject.GObject):
# And now, hide all items that must be hiden # And now, hide all items that must be hiden
# This is done this way because this allows to have an item being hiden by # This is done this way because this allows to have an item being hiden by
# one widget, and being shown by another: in that case, it will be hiden always # one widget, and being shown by another: in that case, it will be
# hiden always
for key in self.interface_show_hide_obj: for key in self.interface_show_hide_obj:
to_show = self.interface_show_hide_obj[key][0] to_show = self.interface_show_hide_obj[key][0]
to_hide = self.interface_show_hide_obj[key][1] to_hide = self.interface_show_hide_obj[key][1]
@ -352,7 +356,6 @@ class interface_manager(GObject.GObject):
if active: if active:
item.hide() item.hide()
def toggled_element2(self, element): def toggled_element2(self, element):
""" Wenever an element with 'enable' or 'disable' needs is toggled, this callback is called """ """ Wenever an element with 'enable' or 'disable' needs is toggled, this callback is called """
@ -371,7 +374,8 @@ class interface_manager(GObject.GObject):
# And now, disable all items that must be disabled # And now, disable all items that must be disabled
# This is done this way because this allows to have an item being disabled by # This is done this way because this allows to have an item being disabled by
# one widget, and being enabled by another: in that case, it will be disabled always # one widget, and being enabled by another: in that case, it will be
# disabled always
for key in self.interface_enable_disable_obj: for key in self.interface_enable_disable_obj:
to_enable = self.interface_enable_disable_obj[key][0] to_enable = self.interface_enable_disable_obj[key][0]
to_disable = self.interface_enable_disable_obj[key][1] to_disable = self.interface_enable_disable_obj[key][1]
@ -384,7 +388,6 @@ class interface_manager(GObject.GObject):
for item in to_disable: for item in to_disable:
item.set_sensitive(False) item.set_sensitive(False)
def store_ui(self, builder): def store_ui(self, builder):
""" Takes the values of the widgets and stores them in the internal variables """ """ Takes the values of the widgets and stores them in the internal variables """
@ -427,7 +430,8 @@ class interface_manager(GObject.GObject):
obj = builder.get_object(element[0]) obj = builder.get_object(element[0])
objcolor = obj.get_color() objcolor = obj.get_color()
alpha = obj.get_alpha() alpha = obj.get_alpha()
exec('self.'+element[0]+' = ((float(objcolor.red))/65535.0, (float(objcolor.green))/65535.0, (float(objcolor.blue))/65535.0, (float(alpha))/65535.0)') exec(
'self.' + element[0] + ' = ((float(objcolor.red))/65535.0, (float(objcolor.green))/65535.0, (float(objcolor.blue))/65535.0, (float(alpha))/65535.0)')
for element in self.interface_fontbuttons: for element in self.interface_fontbuttons:
obj = builder.get_object(element[0]) obj = builder.get_object(element[0])
@ -451,7 +455,6 @@ class interface_manager(GObject.GObject):
obj = builder.get_object(element[0]) obj = builder.get_object(element[0])
exec('self.' + element[0] + ' = element[1][obj.get_active()]') exec('self.' + element[0] + ' = element[1][obj.get_active()]')
def save_ui(self): def save_ui(self):
""" Makes a copy of all the UI variables """ """ Makes a copy of all the UI variables """
@ -504,7 +507,6 @@ class interface_manager(GObject.GObject):
for element in self.interface_comboboxes: for element in self.interface_comboboxes:
exec('self.' + element[0] + ' = self.' + element[0] + '_backup') exec('self.' + element[0] + ' = self.' + element[0] + '_backup')
def serialize(self): def serialize(self):
""" Returns a dictionary with both the variables of the interface and its values, """ Returns a dictionary with both the variables of the interface and its values,
which can be restored with unserialize which can be restored with unserialize
@ -535,7 +537,6 @@ class interface_manager(GObject.GObject):
output[element[0]] = eval('self.' + element[0]) output[element[0]] = eval('self.' + element[0])
return output return output
def unserialize(self, data_list): def unserialize(self, data_list):
""" Takes a dictionary with the variables of the interface and its values, """ Takes a dictionary with the variables of the interface and its values,
and restores them into their variables and restores them into their variables
@ -546,31 +547,41 @@ class interface_manager(GObject.GObject):
exec('self.' + element + ' = data_list["' + element + '"]') exec('self.' + element + ' = data_list["' + element + '"]')
for element in self.interface_toggles: for element in self.interface_toggles:
if element[0] in data_list: if element[0] in data_list:
exec('self.'+element[0]+' = data_list["'+element[0]+'"]') exec('self.' + element[0] +
' = data_list["' + element[0] + '"]')
for element in self.interface_dualtoggles: for element in self.interface_dualtoggles:
if element[0] in data_list: if element[0] in data_list:
exec('self.'+element[0]+' = data_list["'+element[0]+'"]') exec('self.' + element[0] +
' = data_list["' + element[0] + '"]')
for element in self.interface_text: for element in self.interface_text:
if element[0] in data_list: if element[0] in data_list:
exec('self.'+element[0]+' = data_list["'+element[0]+'"]') exec('self.' + element[0] +
' = data_list["' + element[0] + '"]')
for element in self.interface_integer_adjustments: for element in self.interface_integer_adjustments:
if element[0] in data_list: if element[0] in data_list:
exec('self.'+element[0]+' = data_list["'+element[0]+'"]') exec('self.' + element[0] +
' = data_list["' + element[0] + '"]')
for element in self.interface_float_adjustments: for element in self.interface_float_adjustments:
if element[0] in data_list: if element[0] in data_list:
exec('self.'+element[0]+' = data_list["'+element[0]+'"]') exec('self.' + element[0] +
' = data_list["' + element[0] + '"]')
for element in self.interface_colorbuttons: for element in self.interface_colorbuttons:
if element[0] in data_list: if element[0] in data_list:
exec('self.'+element[0]+' = data_list["'+element[0]+'"]') exec('self.' + element[0] +
' = data_list["' + element[0] + '"]')
for element in self.interface_fontbuttons: for element in self.interface_fontbuttons:
if element[0] in data_list: if element[0] in data_list:
exec('self.'+element[0]+' = data_list["'+element[0]+'"]') exec('self.' + element[0] +
' = data_list["' + element[0] + '"]')
for element in self.interface_filebuttons: for element in self.interface_filebuttons:
if element[0] in data_list: if element[0] in data_list:
exec('self.'+element[0]+' = data_list["'+element[0]+'"]') exec('self.' + element[0] +
' = data_list["' + element[0] + '"]')
for element in self.interface_lists: for element in self.interface_lists:
if element[0] in data_list: if element[0] in data_list:
exec('self.'+element[0]+' = data_list["'+element[0]+'"]') exec('self.' + element[0] +
' = data_list["' + element[0] + '"]')
for element in self.interface_comboboxes: for element in self.interface_comboboxes:
if element[0] in data_list: if element[0] in data_list:
exec('self.'+element[0]+' = data_list["'+element[0]+'"]') exec('self.' + element[0] +
' = data_list["' + element[0] + '"]')

4
src/devedeng/k3b.py
View file

@ -19,6 +19,7 @@ import subprocess
import devedeng.configuration_data import devedeng.configuration_data
import devedeng.executor import devedeng.executor
class k3b(devedeng.executor.executor): class k3b(devedeng.executor.executor):
supports_analize = False supports_analize = False
@ -32,7 +33,8 @@ class k3b(devedeng.executor.executor):
@staticmethod @staticmethod
def check_is_installed(): def check_is_installed():
try: try:
handle = subprocess.Popen(["k3b","--help"], stdout = subprocess.PIPE, stderr = subprocess.PIPE) handle = subprocess.Popen(
["k3b", "--help"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdout, stderr) = handle.communicate() (stdout, stderr) = handle.communicate()
if 0 == handle.wait(): if 0 == handle.wait():
return True return True

1
src/devedeng/message.py
View file

@ -19,6 +19,7 @@ from gi.repository import Gtk
import os import os
import devedeng.configuration_data import devedeng.configuration_data
class message_window: class message_window:
def __init__(self, text, title, list_data=None): def __init__(self, text, title, list_data=None):

5
src/devedeng/mkisofs.py
View file

@ -22,6 +22,7 @@ import devedeng.configuration_data
import subprocess import subprocess
import devedeng.executor import devedeng.executor
class mkisofs(devedeng.executor.executor): class mkisofs(devedeng.executor.executor):
supports_analize = False supports_analize = False
@ -35,7 +36,8 @@ class mkisofs(devedeng.executor.executor):
@staticmethod @staticmethod
def check_is_installed(): def check_is_installed():
try: try:
handle = subprocess.Popen(["mkisofs","--help"], stdout = subprocess.PIPE, stderr = subprocess.PIPE) handle = subprocess.Popen(
["mkisofs", "--help"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdout, stderr) = handle.communicate() (stdout, stderr) = handle.communicate()
if 0 == handle.wait(): if 0 == handle.wait():
return True return True
@ -66,7 +68,6 @@ class mkisofs(devedeng.executor.executor):
self.command_var.append(filesystem_path) self.command_var.append(filesystem_path)
self.text = _("Creating ISO image") self.text = _("Creating ISO image")
def process_stdout(self, data): def process_stdout(self, data):
return return

4
src/devedeng/mplayer.py
View file

@ -22,6 +22,7 @@ import devedeng.configuration_data
import devedeng.executor import devedeng.executor
import os import os
class mplayer(devedeng.executor.executor): class mplayer(devedeng.executor.executor):
supports_analize = False supports_analize = False
@ -35,7 +36,8 @@ class mplayer(devedeng.executor.executor):
@staticmethod @staticmethod
def check_is_installed(): def check_is_installed():
try: try:
handle = subprocess.Popen(["mplayer","-v"], stdout = subprocess.PIPE, stderr = subprocess.PIPE) handle = subprocess.Popen(
["mplayer", "-v"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdout, stderr) = handle.communicate() (stdout, stderr) = handle.communicate()
if 0 == handle.wait(): if 0 == handle.wait():
return True return True

4
src/devedeng/mpv.py
View file

@ -21,6 +21,7 @@ import subprocess
import devedeng.configuration_data import devedeng.configuration_data
import devedeng.executor import devedeng.executor
class mpv(devedeng.executor.executor): class mpv(devedeng.executor.executor):
supports_analize = False supports_analize = False
@ -34,7 +35,8 @@ class mpv(devedeng.executor.executor):
@staticmethod @staticmethod
def check_is_installed(): def check_is_installed():
try: try:
handle = subprocess.Popen(["mpv","-v"], stdout = subprocess.PIPE, stderr = subprocess.PIPE) handle = subprocess.Popen(
["mpv", "-v"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdout, stderr) = handle.communicate() (stdout, stderr) = handle.communicate()
if 0 == handle.wait(): if 0 == handle.wait():
return True return True

4
src/devedeng/mux_dvd_menu.py
View file

@ -21,6 +21,7 @@ import os
import devedeng.configuration_data import devedeng.configuration_data
import devedeng.executor import devedeng.executor
class mux_dvd_menu(devedeng.executor.executor): class mux_dvd_menu(devedeng.executor.executor):
def __init__(self): def __init__(self):
@ -37,7 +38,8 @@ class mux_dvd_menu(devedeng.executor.executor):
self.command_var = [] self.command_var = []
self.command_var.append("spumux") self.command_var.append("spumux")
self.command_var.append(os.path.join(output_path,"menu_"+str(n_page)+".xml")) self.command_var.append(os.path.join(
output_path, "menu_" + str(n_page) + ".xml"))
self.stdin_file = movie_path self.stdin_file = movie_path
self.stdout_file = final_path self.stdout_file = final_path

8
src/devedeng/opensave.py
View file

@ -19,6 +19,7 @@ from gi.repository import Gtk
import os import os
import devedeng.configuration_data import devedeng.configuration_data
class opensave_window: class opensave_window:
def __init__(self, save): def __init__(self, save):
@ -26,16 +27,17 @@ class opensave_window:
self.config = devedeng.configuration_data.configuration.get_config() self.config = devedeng.configuration_data.configuration.get_config()
self.save = save self.save = save
def run(self, current_file=None): def run(self, current_file=None):
builder = Gtk.Builder() builder = Gtk.Builder()
builder.set_translation_domain(self.config.gettext_domain) builder.set_translation_domain(self.config.gettext_domain)
if self.save: if self.save:
builder.add_from_file(os.path.join(self.config.glade,"wsave_project.ui")) builder.add_from_file(os.path.join(
self.config.glade, "wsave_project.ui"))
else: else:
builder.add_from_file(os.path.join(self.config.glade,"wopen_project.ui")) builder.add_from_file(os.path.join(
self.config.glade, "wopen_project.ui"))
builder.connect_signals(self) builder.connect_signals(self)
w_window = builder.get_object("data_project") w_window = builder.get_object("data_project")
if current_file is not None: if current_file is not None:

1
src/devedeng/preview.py
View file

@ -19,6 +19,7 @@ from gi.repository import Gtk
import os import os
import devedeng.configuration_data import devedeng.configuration_data
class preview_window: class preview_window:
def __init__(self): def __init__(self):

88
src/devedeng/project.py
View file

@ -40,6 +40,7 @@ import devedeng.about
import devedeng.opensave import devedeng.opensave
import devedeng.help import devedeng.help
class devede_project: class devede_project:
dvd_max_bps_base = {0: 9000} dvd_max_bps_base = {0: 9000}
@ -54,7 +55,8 @@ class devede_project:
divx_min_bps = 300 divx_min_bps = 300
divx_max_total = -1 divx_max_total = -1
mkv_max_bps_base = {0: 192, 240: 2000, 480: 14000, 720: 50000, 1080: 240000} mkv_max_bps_base = {0: 192, 240: 2000,
480: 14000, 720: 50000, 1080: 240000}
mkv_min_bps = 192 mkv_min_bps = 192
mkv_max_total = -1 mkv_max_total = -1
@ -94,7 +96,6 @@ class devede_project:
self.wcreate_menu = builder.get_object("create_menu") self.wcreate_menu = builder.get_object("create_menu")
self.wmenu_options = builder.get_object("menu_options") self.wmenu_options = builder.get_object("menu_options")
self.wadd_file = builder.get_object("add_file") self.wadd_file = builder.get_object("add_file")
self.wdelete_file = builder.get_object("delete_file") self.wdelete_file = builder.get_object("delete_file")
self.wup_file = builder.get_object("up_file") self.wup_file = builder.get_object("up_file")
@ -120,12 +121,12 @@ class devede_project:
if (self.disc_type is not None): if (self.disc_type is not None):
self.set_type(None, self.disc_type) self.set_type(None, self.disc_type)
self.wmain_window.drag_dest_set(Gtk.DestDefaults.ALL,[],Gdk.DragAction.COPY) self.wmain_window.drag_dest_set(
Gtk.DestDefaults.ALL, [], Gdk.DragAction.COPY)
targets = Gtk.TargetList.new([]) targets = Gtk.TargetList.new([])
targets.add(Gdk.Atom.intern("text/uri-list", False), 0, 0) targets.add(Gdk.Atom.intern("text/uri-list", False), 0, 0)
self.wmain_window.drag_dest_set_target_list(targets) self.wmain_window.drag_dest_set_target_list(targets)
def set_type(self, obj=None, disc_type=None): def set_type(self, obj=None, disc_type=None):
""" this method sets the disk type to the specified one and adapts the interface """ this method sets the disk type to the specified one and adapts the interface
in the main window to it. Also leaves everything ready to start creating a in the main window to it. Also leaves everything ready to start creating a
@ -151,9 +152,7 @@ class devede_project:
self.wframe_menu.hide() self.wframe_menu.hide()
self.wcreate_menu.set_active(False) self.wcreate_menu.set_active(False)
def get_current_file(self): def get_current_file(self):
""" returns the currently selected file """ """ returns the currently selected file """
selection = self.wfiles.get_selection() selection = self.wfiles.get_selection()
@ -171,7 +170,6 @@ class devede_project:
else: else:
return ((None, -1, None, None)) return ((None, -1, None, None))
def get_all_files(self): def get_all_files(self):
retval = [] retval = []
@ -180,7 +178,6 @@ class devede_project:
retval.append(row.model[row.iter][0]) retval.append(row.model[row.iter][0])
return retval return retval
def set_interface_status(self, b): def set_interface_status(self, b):
self.wadd_file.set_sensitive(True) self.wadd_file.set_sensitive(True)
@ -211,19 +208,18 @@ class devede_project:
if (position == (nfiles - 1)): if (position == (nfiles - 1)):
self.wdown_file.set_sensitive(False) self.wdown_file.set_sensitive(False)
def on_cellrenderertext3_edited(self, widget, path, text): def on_cellrenderertext3_edited(self, widget, path, text):
self.wliststore_files[path][0].set_title(text) self.wliststore_files[path][0].set_title(text)
def on_cellrenderertext4_toggled(self, widget, path): def on_cellrenderertext4_toggled(self, widget, path):
self.wliststore_files[path][0].set_show_in_menu(False if widget.get_active() else True) self.wliststore_files[path][0].set_show_in_menu(
False if widget.get_active() else True)
def on_use_pal_toggled(self, b): def on_use_pal_toggled(self, b):
self.config.PAL = self.wuse_pal.get_active() self.config.PAL = self.wuse_pal.get_active()
self.set_interface_status(None) self.set_interface_status(None)
def on_wmain_window_delete_event(self, b, e=None): def on_wmain_window_delete_event(self, b, e=None):
ask = devedeng.ask.ask_window() ask = devedeng.ask.ask_window()
@ -239,7 +235,6 @@ class devede_project:
item.model.set_value(item.iter, 1, new_title) item.model.set_value(item.iter, 1, new_title)
self.refresh_disc_usage() self.refresh_disc_usage()
def in_menu_changed(self, obj, new_inmenu): def in_menu_changed(self, obj, new_inmenu):
for item in self.wliststore_files: for item in self.wliststore_files:
element = item.model[item.iter][0] element = item.model[item.iter][0]
@ -247,7 +242,6 @@ class devede_project:
item.model.set_value(item.iter, 4, new_inmenu) item.model.set_value(item.iter, 4, new_inmenu)
self.refresh_disc_usage() self.refresh_disc_usage()
def on_help_clicked(self, b): def on_help_clicked(self, b):
help_file = devedeng.help.help("main.html") help_file = devedeng.help.help("main.html")
@ -256,14 +250,12 @@ class devede_project:
help_file = devedeng.help.help("index.html") help_file = devedeng.help.help("index.html")
def on_add_file_clicked(self, b): def on_add_file_clicked(self, b):
ask_files = devedeng.add_files.add_files() ask_files = devedeng.add_files.add_files()
if (ask_files.run()): if (ask_files.run()):
self.add_several_files(ask_files.files) self.add_several_files(ask_files.files)
def duration_to_string(self, duration): def duration_to_string(self, duration):
seconds = math.floor(duration % 60) seconds = math.floor(duration % 60)
@ -277,7 +269,6 @@ class devede_project:
output = str(hours) + "h " + output output = str(hours) + "h " + output
return output return output
def add_several_files(self, file_list): def add_several_files(self, file_list):
error_list = [] error_list = []
for efile in file_list: for efile in file_list:
@ -289,13 +280,14 @@ class devede_project:
else: else:
new_file.connect('title_changed', self.title_changed) new_file.connect('title_changed', self.title_changed)
new_file.connect('in_menu_changed', self.in_menu_changed) new_file.connect('in_menu_changed', self.in_menu_changed)
self.wliststore_files.append([new_file, new_file.title_name,True,self.duration_to_string(new_file.get_duration()),new_file.show_in_menu]) self.wliststore_files.append([new_file, new_file.title_name, True, self.duration_to_string(
new_file.get_duration()), new_file.show_in_menu])
if (len(error_list) != 0): if (len(error_list) != 0):
devedeng.message.message_window(_("The following files could not be added:"),_("Error while adding files"),error_list) devedeng.message.message_window(_("The following files could not be added:"), _(
"Error while adding files"), error_list)
self.set_interface_status(None) self.set_interface_status(None)
self.refresh_disc_usage() self.refresh_disc_usage()
def on_delete_file_clicked(self, b): def on_delete_file_clicked(self, b):
(element, position, model, treeiter) = self.get_current_file() (element, position, model, treeiter) = self.get_current_file()
@ -309,7 +301,6 @@ class devede_project:
self.set_interface_status(None) self.set_interface_status(None)
self.refresh_disc_usage() self.refresh_disc_usage()
def on_up_file_clicked(self, b): def on_up_file_clicked(self, b):
(element, position, model, treeiter) = self.get_current_file() (element, position, model, treeiter) = self.get_current_file()
@ -320,7 +311,6 @@ class devede_project:
self.wfiles.get_model().swap(last_element.iter, treeiter) self.wfiles.get_model().swap(last_element.iter, treeiter)
self.set_interface_status(None) self.set_interface_status(None)
def on_down_file_clicked(self, b): def on_down_file_clicked(self, b):
(element, position, model, treeiter) = self.get_current_file() (element, position, model, treeiter) = self.get_current_file()
@ -331,19 +321,16 @@ class devede_project:
self.wfiles.get_model().swap(last_element.iter, treeiter) self.wfiles.get_model().swap(last_element.iter, treeiter)
self.set_interface_status(None) self.set_interface_status(None)
def on_properties_file_clicked(self, b): def on_properties_file_clicked(self, b):
(element, position, model, treeiter) = self.get_current_file() (element, position, model, treeiter) = self.get_current_file()
if (element is None): if (element is None):
return return
element.properties() element.properties()
def on_create_menu_toggled(self, b): def on_create_menu_toggled(self, b):
self.set_interface_status(None) self.set_interface_status(None)
self.refresh_disc_usage() self.refresh_disc_usage()
def on_adjust_disc_usage_clicked(self, b): def on_adjust_disc_usage_clicked(self, b):
total_resolution = 0 total_resolution = 0
@ -356,7 +343,8 @@ class devede_project:
else: else:
fixed_size += ((audio_rate + sub_rate) * time_length) fixed_size += ((audio_rate + sub_rate) * time_length)
# 76800 = 320x240, which is the smallest resolution # 76800 = 320x240, which is the smallest resolution
surface = ((float(width) * float(height)) / 76800.0) * float(time_length) surface = ((float(width) * float(height)) /
76800.0) * float(time_length)
to_adjust.append((f, surface, time_length, audio_rate, height)) to_adjust.append((f, surface, time_length, audio_rate, height))
total_resolution += surface total_resolution += surface
@ -385,7 +373,8 @@ class devede_project:
max_total = devede_project.def_max_total max_total = devede_project.def_max_total
if (total_resolution != 0): if (total_resolution != 0):
remaining_disc_size = ((8000.0 * self.get_dvd_size()[0]) - fixed_size) # in kbits remaining_disc_size = (
(8000.0 * self.get_dvd_size()[0]) - fixed_size) # in kbits
for l in to_adjust: for l in to_adjust:
f = l[0] f = l[0]
surface = l[1] surface = l[1]
@ -400,7 +389,8 @@ class devede_project:
resy = bitrates resy = bitrates
max_bps = max_bps_base[bitrates] max_bps = max_bps_base[bitrates]
video_rate = (remaining_disc_size * surface) / ( length * total_resolution) video_rate = (remaining_disc_size * surface) / \
(length * total_resolution)
if max_total != -1: if max_total != -1:
max2 = max_total - audio_rate max2 = max_total - audio_rate
if (max2 > max_bps): if (max2 > max_bps):
@ -415,7 +405,6 @@ class devede_project:
self.refresh_disc_usage() self.refresh_disc_usage()
def refresh_disc_usage(self): def refresh_disc_usage(self):
used = 0.0 used = 0.0
@ -438,17 +427,15 @@ class devede_project:
self.wdisc_fill_level.set_fraction(used / disc_size) self.wdisc_fill_level.set_fraction(used / disc_size)
addv = 0 addv = 0
self.wdisc_fill_level.set_text(str(addv+int((used / disc_size)*100))+"%") self.wdisc_fill_level.set_text(
str(addv + int((used / disc_size) * 100)) + "%")
self.wdisc_fill_level.set_show_text(True) self.wdisc_fill_level.set_show_text(True)
def on_menu_options_clicked(self, b): def on_menu_options_clicked(self, b):
self.menu.show_configuration(self.get_all_files()) self.menu.show_configuration(self.get_all_files())
def get_dvd_size(self): def get_dvd_size(self):
""" Returns the size for the currently selected disk type, and the minimum and maximum """ Returns the size for the currently selected disk type, and the minimum and maximum
videorate for the current video disk """ videorate for the current video disk """
@ -490,12 +477,10 @@ class devede_project:
return size, minvrate, maxvrate return size, minvrate, maxvrate
def on_disc_size_changed(self, c): def on_disc_size_changed(self, c):
self.refresh_disc_usage() self.refresh_disc_usage()
def on_create_disc_clicked(self, b): def on_create_disc_clicked(self, b):
if self.disc_type == "dvd": if self.disc_type == "dvd":
@ -506,7 +491,8 @@ class devede_project:
file_movies = self.get_all_files() file_movies = self.get_all_files()
t = len(file_movies) t = len(file_movies)
if (max_files != -1) and (t > max_files): if (max_files != -1) and (t > max_files):
devedeng.message.message_window(_("The limit for this format is %(l)d files, but your project has %(h)d.") % {"l": max_files, "h" : t}, _("Too many files in the project")) devedeng.message.message_window(_("The limit for this format is %(l)d files, but your project has %(h)d.") % {
"l": max_files, "h": t}, _("Too many files in the project"))
return return
data = devedeng.create_disk_window.create_disk_window() data = devedeng.create_disk_window.create_disk_window()
@ -546,7 +532,8 @@ class devede_project:
final_dependencies = [] final_dependencies = []
if (self.disc_type == "dvd") and (self.wcreate_menu.get_active()): if (self.disc_type == "dvd") and (self.wcreate_menu.get_active()):
processes,menu_entries = self.menu.create_dvd_menus(file_movies, data.path) processes, menu_entries = self.menu.create_dvd_menus(
file_movies, data.path)
for p in processes: for p in processes:
run_window.add_process(p) run_window.add_process(p)
final_dependencies.append(p) final_dependencies.append(p)
@ -566,7 +553,8 @@ class devede_project:
else: else:
extension = "mpg" extension = "mpg"
for movie in file_movies: for movie in file_movies:
p = movie.do_conversion(os.path.join(movie_folder,"movie_{:d}.{:s}".format(counter,extension))) p = movie.do_conversion(os.path.join(
movie_folder, "movie_{:d}.{:s}".format(counter, extension)))
run_window.add_process(p) run_window.add_process(p)
final_dependencies.append(p) final_dependencies.append(p)
counter += 1 counter += 1
@ -577,7 +565,8 @@ class devede_project:
else: else:
start_with_menu = False start_with_menu = False
dvdauthor = devedeng.dvdauthor_converter.dvdauthor_converter() dvdauthor = devedeng.dvdauthor_converter.dvdauthor_converter()
dvdauthor.create_dvd_project(data.path, data.name, file_movies, menu_entries, start_with_menu, self.menu.play_all_c) dvdauthor.create_dvd_project(
data.path, data.name, file_movies, menu_entries, start_with_menu, self.menu.play_all_c)
# dvdauthor must wait until all the files have been converted # dvdauthor must wait until all the files have been converted
for element in final_dependencies: for element in final_dependencies:
dvdauthor.add_dependency(element) dvdauthor.add_dependency(element)
@ -604,7 +593,6 @@ class devede_project:
self.time_start = time.time() self.time_start = time.time()
run_window.run() run_window.run()
def disc_done(self, object, value): def disc_done(self, object, value):
if self.shutdown: if self.shutdown:
@ -629,12 +617,10 @@ class devede_project:
self.wmain_window.show() self.wmain_window.show()
def disc_done2(self, object, value): def disc_done2(self, object, value):
self.wmain_window.show() self.wmain_window.show()
def on_preview_file_clicked(self, b): def on_preview_file_clicked(self, b):
(element, position, model, treeiter) = self.get_current_file() (element, position, model, treeiter) = self.get_current_file()
@ -642,17 +628,14 @@ class devede_project:
return return
element.do_preview() element.do_preview()
def on_settings_activate(self, b): def on_settings_activate(self, b):
w = devedeng.settings.settings_window() w = devedeng.settings.settings_window()
def on_about_activate(self, b): def on_about_activate(self, b):
w = devedeng.about.about_window() w = devedeng.about.about_window()
def on_new_activate(self, b): def on_new_activate(self, b):
w = devedeng.ask.ask_window() w = devedeng.ask.ask_window()
@ -662,22 +645,18 @@ class devede_project:
self.wmain_window.hide() self.wmain_window.hide()
devedeng.choose_disc_type.choose_disc_type() devedeng.choose_disc_type.choose_disc_type()
def on_wmain_window_drag_motion(self, wid, context, x, y, time): def on_wmain_window_drag_motion(self, wid, context, x, y, time):
Gdk.drag_status(context, Gdk.DragAction.COPY, time) Gdk.drag_status(context, Gdk.DragAction.COPY, time)
return True return True
def on_wmain_window_drag_drop(self, wid, context, x, y, time): def on_wmain_window_drag_drop(self, wid, context, x, y, time):
# Used with windows drag and drop # Used with windows drag and drop
return True return True
def on_wmain_window_drag_data_received(self, widget, drag_context, x, y, data, info, time): def on_wmain_window_drag_data_received(self, widget, drag_context, x, y, data, info, time):
uris = data.get_uris() uris = data.get_uris()
self.add_several_files(uris) self.add_several_files(uris)
Gtk.drag_finish (drag_context, True, Gdk.DragAction.COPY, time); Gtk.drag_finish(drag_context, True, Gdk.DragAction.COPY, time)
def on_save_activate(self, b): def on_save_activate(self, b):
if self.project_file is not None: if self.project_file is not None:
@ -685,7 +664,6 @@ class devede_project:
else: else:
self.on_save_as_activate(None) self.on_save_as_activate(None)
def on_save_as_activate(self, b): def on_save_as_activate(self, b):
while True: while True:
@ -703,14 +681,12 @@ class devede_project:
self.save_current_project() self.save_current_project()
return return
def on_load_activate(self, b): def on_load_activate(self, b):
w = devedeng.opensave.opensave_window(False) w = devedeng.opensave.opensave_window(False)
retval = w.run() retval = w.run()
if retval is not None: if retval is not None:
self.load_project(retval) self.load_project(retval)
def save_current_project(self): def save_current_project(self):
project = {} project = {}
@ -729,7 +705,6 @@ class devede_project:
with open(self.project_file, 'wb') as f: with open(self.project_file, 'wb') as f:
pickle.dump(project, f, 3) pickle.dump(project, f, 3)
def load_project(self, project_file): def load_project(self, project_file):
self.wliststore_files.clear() self.wliststore_files.clear()
@ -755,13 +730,14 @@ class devede_project:
else: else:
new_file.restore_file(efile) new_file.restore_file(efile)
new_file.connect('title_changed', self.title_changed) new_file.connect('title_changed', self.title_changed)
self.wliststore_files.append([new_file, new_file.title_name,True,self.duration_to_string(new_file.get_duration()),new_file.show_in_menu]) self.wliststore_files.append([new_file, new_file.title_name, True, self.duration_to_string(
new_file.get_duration()), new_file.show_in_menu])
if (len(error_list) != 0): if (len(error_list) != 0):
devedeng.message.message_window(_("The following files in the project could not be added again:"),_("Error while adding files"),error_list) devedeng.message.message_window(_("The following files in the project could not be added again:"), _(
"Error while adding files"), error_list)
self.set_interface_status(None) self.set_interface_status(None)
self.refresh_disc_usage() self.refresh_disc_usage()
def on_multiproperties_activate(self, b): def on_multiproperties_activate(self, b):
e = devedeng.file_movie.file_movie(None, self.get_all_files()) e = devedeng.file_movie.file_movie(None, self.get_all_files())

22
src/devedeng/runner.py
View file

@ -21,6 +21,7 @@ import devedeng.configuration_data
import devedeng.error import devedeng.error
import devedeng.ask import devedeng.ask
class runner(GObject.GObject): class runner(GObject.GObject):
__gsignals__ = {'done': (GObject.SIGNAL_RUN_FIRST, None, (int,))} __gsignals__ = {'done': (GObject.SIGNAL_RUN_FIRST, None, (int,))}
@ -47,7 +48,8 @@ class runner(GObject.GObject):
self.builder = Gtk.Builder() self.builder = Gtk.Builder()
self.builder.set_translation_domain(self.config.gettext_domain) self.builder.set_translation_domain(self.config.gettext_domain)
self.builder.add_from_file(os.path.join(self.config.glade,"wprogress.ui")) self.builder.add_from_file(os.path.join(
self.config.glade, "wprogress.ui"))
self.builder.connect_signals(self) self.builder.connect_signals(self)
self.wprogress = self.builder.get_object("progress") self.wprogress = self.builder.get_object("progress")
if show_window: if show_window:
@ -73,7 +75,6 @@ class runner(GObject.GObject):
self.total_processes = 0 self.total_processes = 0
self.error = False self.error = False
def add_process(self, process): def add_process(self, process):
if (self.proc_list.count(process) == 0): if (self.proc_list.count(process) == 0):
@ -84,11 +85,11 @@ class runner(GObject.GObject):
self.total_processes = len(self.proc_list) self.total_processes = len(self.proc_list)
def on_cancel_clicked(self, b): def on_cancel_clicked(self, b):
ask_w = devedeng.ask.ask_window() ask_w = devedeng.ask.ask_window()
retval = ask_w.run(_("Cancel the current job?"),_("Cancel the current job?")) retval = ask_w.run(_("Cancel the current job?"),
_("Cancel the current job?"))
if retval: if retval:
self.error = True self.error = True
for element in self.proc_list: for element in self.proc_list:
@ -117,9 +118,10 @@ class runner(GObject.GObject):
else: else:
self.progress_bars = [] self.progress_bars = []
break break
self.wtotal.set_text(str(self.total_processes - len(self.proc_list))+"/"+str(self.total_processes)) self.wtotal.set_text(
self.wtotal.set_fraction((float(self.total_processes - len(self.proc_list)))/(float(self.total_processes))) str(self.total_processes - len(self.proc_list)) + "/" + str(self.total_processes))
self.wtotal.set_fraction(
(float(self.total_processes - len(self.proc_list))) / (float(self.total_processes)))
def process_ended(self, process, retval): def process_ended(self, process, retval):
@ -135,7 +137,8 @@ class runner(GObject.GObject):
self.emit("done", 1) # there was an error self.emit("done", 1) # there was an error
return return
# move the progress bar used by this process to the list of available progress bars # move the progress bar used by this process to the list of available
# progress bars
tmp = [] tmp = []
for e in self.used_progress_bars: for e in self.used_progress_bars:
if (process.progress_bar == e): if (process.progress_bar == e):
@ -145,7 +148,8 @@ class runner(GObject.GObject):
tmp.append(e) tmp.append(e)
self.used_progress_bars = tmp self.used_progress_bars = tmp
# remove this process from the list of processes, and remove it from the dependencies in other processes # remove this process from the list of processes, and remove it from
# the dependencies in other processes
tmp = [] tmp = []
for e in self.proc_list: for e in self.proc_list:
if (e != process): if (e != process):

16
src/devedeng/settings.py
View file

@ -22,6 +22,7 @@ import devedeng.interface_manager
import gettext import gettext
import devedeng.converter import devedeng.converter
class settings_window(devedeng.interface_manager.interface_manager): class settings_window(devedeng.interface_manager.interface_manager):
def __init__(self): def __init__(self):
@ -46,13 +47,15 @@ class settings_window(devedeng.interface_manager.interface_manager):
counter = 1 counter = 1
for c in range(self.config.cores - 1, -self.config.cores, -1): for c in range(self.config.cores - 1, -self.config.cores, -1):
if c > 0: if c > 0:
translated_string = gettext.ngettext("Use %(X)d core","Use %(X)d cores",c) % {"X":c} translated_string = gettext.ngettext(
"Use %(X)d core", "Use %(X)d cores", c) % {"X": c}
value = c value = c
if c == cores: if c == cores:
default_value = translated_string default_value = translated_string
counter += 1 counter += 1
elif c < 0: elif c < 0:
translated_string = gettext.ngettext("Use all except %(X)d core","Use all except %(X)d cores", -c) % {"X": -c} translated_string = gettext.ngettext(
"Use all except %(X)d core", "Use all except %(X)d cores", -c) % {"X": -c}
value = c value = c
if c == cores: if c == cores:
default_value = translated_string default_value = translated_string
@ -68,11 +71,13 @@ class settings_window(devedeng.interface_manager.interface_manager):
self.add_filebutton("tempo_path", self.config.tmp_folder) self.add_filebutton("tempo_path", self.config.tmp_folder)
c = devedeng.converter.converter.get_converter() c = devedeng.converter.converter.get_converter()
(analizers, players, menuers, converters, burners, mkiso) = c.get_available_programs() (analizers, players, menuers, converters,
burners, mkiso) = c.get_available_programs()
self.add_combobox("analizer", analizers, self.config.film_analizer) self.add_combobox("analizer", analizers, self.config.film_analizer)
self.add_combobox("player", players, self.config.film_player) self.add_combobox("player", players, self.config.film_player)
self.add_combobox("converter", converters,self.config.film_converter,self.set_data_converter) self.add_combobox("converter", converters,
self.config.film_converter, self.set_data_converter)
self.add_combobox("menuer", menuers, self.config.menu_converter) self.add_combobox("menuer", menuers, self.config.menu_converter)
self.add_combobox("mkiso", mkiso, self.config.mkiso) self.add_combobox("mkiso", mkiso, self.config.mkiso)
self.add_combobox("burner", burners, self.config.burner) self.add_combobox("burner", burners, self.config.burner)
@ -80,7 +85,8 @@ class settings_window(devedeng.interface_manager.interface_manager):
self.builder = Gtk.Builder() self.builder = Gtk.Builder()
self.builder.set_translation_domain(self.config.gettext_domain) self.builder.set_translation_domain(self.config.gettext_domain)
self.builder.add_from_file(os.path.join(self.config.glade,"wsettings.ui")) self.builder.add_from_file(os.path.join(
self.config.glade, "wsettings.ui"))
self.builder.connect_signals(self) self.builder.connect_signals(self)
wsettings_window = self.builder.get_object("settings") wsettings_window = self.builder.get_object("settings")
self.wconverter = self.builder.get_object("converter") self.wconverter = self.builder.get_object("converter")

1
src/devedeng/shutdown.py
View file

@ -17,6 +17,7 @@
from gi.repository import Gio, GLib from gi.repository import Gio, GLib
class shutdown: class shutdown:
def __init__(self): def __init__(self):

15
src/devedeng/subtitles_mux.py
View file

@ -23,6 +23,7 @@ import subprocess
import devedeng.configuration_data import devedeng.configuration_data
import devedeng.executor import devedeng.executor
class subtitles_mux(devedeng.executor.executor): class subtitles_mux(devedeng.executor.executor):
def __init__(self): def __init__(self):
@ -40,7 +41,8 @@ class subtitles_mux(devedeng.executor.executor):
self.subt_path = file_path self.subt_path = file_path
self.duration = duration self.duration = duration
self.text = _("Adding %(L)s subtitles to %(X)s") % {"X": os.path.basename(file_path), "L": subt_lang} self.text = _("Adding %(L)s subtitles to %(X)s") % {
"X": os.path.basename(file_path), "L": subt_lang}
out_xml = open(file_path + "_s" + str(stream_id) + ".xml", "w") out_xml = open(file_path + "_s" + str(stream_id) + ".xml", "w")
out_xml.write('<subpictures format="') out_xml.write('<subpictures format="')
@ -59,10 +61,13 @@ class subtitles_mux(devedeng.executor.executor):
if subt_upper: if subt_upper:
out_xml.write('" bottom-margin="50') out_xml.write('" bottom-margin="50')
print("Punto clave") print("Punto clave")
out_xml.write('" fill-color="#%02X%02X%02X"' % tuple([int(fill_color[i] * 255) for i in range(len(fill_color))])) out_xml.write('" fill-color="#%02X%02X%02X"' %
out_xml.write(' outline-color="#%02X%02X%02X"' % tuple([int(outline_color[i] * 255) for i in range(len(outline_color))])) tuple([int(fill_color[i] * 255) for i in range(len(fill_color))]))
out_xml.write(' outline-color="#%02X%02X%02X"' %
tuple([int(outline_color[i] * 255) for i in range(len(outline_color))]))
out_xml.write(' outline-thickness="%d"' % outline_thick) out_xml.write(' outline-thickness="%d"' % outline_thick)
out_xml.write(' font="arial" horizontal-alignment="center" vertical-alignment="bottom" aspect="') out_xml.write(
' font="arial" horizontal-alignment="center" vertical-alignment="bottom" aspect="')
out_xml.write(str(aspect)) out_xml.write(str(aspect))
out_xml.write('" force="') out_xml.write('" force="')
if force_subtitles: if force_subtitles:
@ -87,7 +92,6 @@ class subtitles_mux(devedeng.executor.executor):
self.stdin_file = file_path + ".tmp" self.stdin_file = file_path + ".tmp"
self.stdout_file = file_path self.stdout_file = file_path
def pre_function(self): def pre_function(self):
final_path = self.subt_path + ".tmp" final_path = self.subt_path + ".tmp"
@ -95,7 +99,6 @@ class subtitles_mux(devedeng.executor.executor):
os.remove(final_path) os.remove(final_path)
os.rename(self.subt_path, final_path) os.rename(self.subt_path, final_path)
def process_stderr(self, data): def process_stderr(self, data):
if (data is None) or (len(data) == 0): if (data is None) or (len(data) == 0):

5
src/devedeng/title.py
View file

@ -18,6 +18,7 @@
from gi.repository import Gtk, GObject from gi.repository import Gtk, GObject
import os import os
class title(GObject.GObject): class title(GObject.GObject):
counter = 0 counter = 0
@ -48,7 +49,8 @@ class title(GObject.GObject):
builder = Gtk.Builder() builder = Gtk.Builder()
builder.set_translation_domain(self.config.gettext_domain) builder.set_translation_domain(self.config.gettext_domain)
builder.add_from_file(os.path.join(self.config.glade,"wtitle_properties.ui")) builder.add_from_file(os.path.join(
self.config.glade, "wtitle_properties.ui"))
builder.connect_signals(self) builder.connect_signals(self)
# Interface widgets # Interface widgets
@ -82,7 +84,6 @@ class title(GObject.GObject):
wtitle_properties.destroy() wtitle_properties.destroy()
def delete_title(self): def delete_title(self):
print("Deleted title " + self.title_name) print("Deleted title " + self.title_name)

2
src/devedeng/vcdimager_converter.py
View file

@ -21,6 +21,7 @@ import os
import devedeng.configuration_data import devedeng.configuration_data
import devedeng.executor import devedeng.executor
class vcdimager_converter(devedeng.executor.executor): class vcdimager_converter(devedeng.executor.executor):
def __init__(self): def __init__(self):
@ -45,7 +46,6 @@ class vcdimager_converter(devedeng.executor.executor):
self.command_var.append(element.converted_filename) self.command_var.append(element.converted_filename)
self.text = _("Creating CD image") self.text = _("Creating CD image")
def process_stdout(self, data): def process_stdout(self, data):
print("Stdout: " + str(data)) print("Stdout: " + str(data))
return return

4
src/devedeng/vlc.py
View file

@ -19,6 +19,7 @@ import subprocess
import devedeng.configuration_data import devedeng.configuration_data
import devedeng.executor import devedeng.executor
class vlc(devedeng.executor.executor): class vlc(devedeng.executor.executor):
supports_analize = False supports_analize = False
@ -32,7 +33,8 @@ class vlc(devedeng.executor.executor):
@staticmethod @staticmethod
def check_is_installed(): def check_is_installed():
try: try:
handle = subprocess.Popen(["vlc","-h"], stdout = subprocess.PIPE, stderr = subprocess.PIPE) handle = subprocess.Popen(
["vlc", "-h"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdout, stderr) = handle.communicate() (stdout, stderr) = handle.communicate()
if 0 == handle.wait(): if 0 == handle.wait():
return True return True

29
src/unitests/test_avconv.py
View file

@ -2,6 +2,7 @@ import unittest
import devedeng.avbase import devedeng.avbase
import devedeng.avprobe import devedeng.avprobe
class TestAVConv(unittest.TestCase): class TestAVConv(unittest.TestCase):
def test_ubuntu_14_04(self): def test_ubuntu_14_04(self):
@ -19,9 +20,10 @@ libswscale 2. 1. 1 / 2. 1. 1""".split("\n")
text.append(9) text.append(9)
c.check_version_txt(text) c.check_version_txt(text)
self.assertEqual(c.major_version, 9, "Detecting major version for Ubuntu 14.04's AVConv version") self.assertEqual(
self.assertEqual(c.minor_version, 18, "Detecting minor version for Ubuntu 14.04's AVConv version") c.major_version, 9, "Detecting major version for Ubuntu 14.04's AVConv version")
self.assertEqual(
c.minor_version, 18, "Detecting minor version for Ubuntu 14.04's AVConv version")
def test_ubuntu_14_10(self): def test_ubuntu_14_10(self):
c = devedeng.avbase.avbase() c = devedeng.avbase.avbase()
@ -38,9 +40,10 @@ libswscale 3. 0. 0 / 3. 0. 0""".split("\n")
text.append(9) text.append(9)
c.check_version_txt(text) c.check_version_txt(text)
self.assertEqual(c.major_version, 11, "Detecting major version for Ubuntu 14.10's AVConv version") self.assertEqual(
self.assertEqual(c.minor_version, 0, "Detecting minor version for Ubuntu 14.10's AVConv version") c.major_version, 11, "Detecting major version for Ubuntu 14.10's AVConv version")
self.assertEqual(
c.minor_version, 0, "Detecting minor version for Ubuntu 14.10's AVConv version")
def test_ubuntu_15_04(self): def test_ubuntu_15_04(self):
c = devedeng.avbase.avbase() c = devedeng.avbase.avbase()
@ -57,13 +60,13 @@ libswscale 3. 0. 0 / 3. 0. 0""".split("\n")
text.append(9) text.append(9)
c.check_version_txt(text) c.check_version_txt(text)
self.assertEqual(c.major_version, 11, "Detecting major version for Ubuntu 15.04's AVConv version") self.assertEqual(
self.assertEqual(c.minor_version, 2, "Detecting minor version for Ubuntu 15.04's AVConv version") c.major_version, 11, "Detecting major version for Ubuntu 15.04's AVConv version")
self.assertEqual(
c.minor_version, 2, "Detecting minor version for Ubuntu 15.04's AVConv version")
def test_mkv1(self): def test_mkv1(self):
c = devedeng.avprobe.avprobe() c = devedeng.avprobe.avprobe()
json_test = """{ json_test = """{
"streams": [ "streams": [
@ -165,9 +168,11 @@ libswscale 3. 0. 0 / 3. 0. 0""".split("\n")
}""" }"""
retval = c.process_json(json_test, "filename.mkv") retval = c.process_json(json_test, "filename.mkv")
self.assertFalse(retval) self.assertFalse(retval)
self.assertEqual(c.audio_streams, 1, "Checking number of audio streams") self.assertEqual(c.audio_streams, 1,
"Checking number of audio streams")
self.assertEqual(c.audio_list[0], 0, "Checking audio stream 1") self.assertEqual(c.audio_list[0], 0, "Checking audio stream 1")
self.assertEqual(c.video_streams, 1, "Checking number of video streams") self.assertEqual(c.video_streams, 1,
"Checking number of video streams")
self.assertEqual(c.video_list[0], 1, "Checking video stream 1") self.assertEqual(c.video_list[0], 1, "Checking video stream 1")
if __name__ == '__main__': if __name__ == '__main__':