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:
pass
def get_data_files():
data_files = [
(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/codepages.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', 'man', 'man1'), ['data/devede.1.gz'])
]
for lang_name in [f for f in os.listdir('locale')]:
mofile = os.path.join('locale', lang_name,'LC_MESSAGES','devedeng.mo')
# translations must be always in /usr/share because Gtk.builder only search there. If someone knows how to fix this...
target = os.path.join('/usr','share', 'locale', lang_name, 'LC_MESSAGES') # share/locale/fr/LC_MESSAGES/
mofile = os.path.join('locale', lang_name,
'LC_MESSAGES', 'devedeng.mo')
# 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]))
return data_files
@ -39,8 +45,10 @@ def compile_translations():
pofile = os.path.join('po', pofile)
lang = os.path.basename(pofile)[:-3] # len('.po') == 3
modir = os.path.join('locale', lang, 'LC_MESSAGES') # e.g. locale/fr/LC_MESSAGES/
mofile = os.path.join(modir, 'devedeng.mo') # e.g. locale/fr/LC_MESSAGES/devedeng.mo
# e.g. locale/fr/LC_MESSAGES/
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
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
# 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 devedeng.configuration_data
class about_window:
def __init__(self):

1
src/devedeng/add_files.py
View file

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

1
src/devedeng/ask.py
View file

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

11
src/devedeng/ask_subtitles.py
View file

@ -20,6 +20,7 @@ import os
import devedeng.configuration_data
import devedeng.add_files
class ask_subtitles:
def __init__(self):
@ -31,7 +32,8 @@ class ask_subtitles:
builder = Gtk.Builder()
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)
wask_window = builder.get_object("ask_subtitles")
self.wfilename = builder.get_object("subtitle_file")
@ -42,7 +44,8 @@ class ask_subtitles:
wlanguage = builder.get_object("language_l")
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
enc_selection = 0
@ -97,7 +100,8 @@ class ask_subtitles:
self.on_subtitle_file_set(None)
retval = wask_window.run()
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_language = wlanguage.get_active_id()
self.encoding = wencoding.get_active_id()
@ -110,7 +114,6 @@ class ask_subtitles:
else:
return False
def on_subtitle_file_set(self, b):
f = self.wfilename.get_filename()

7
src/devedeng/avbase.py
View file

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

54
src/devedeng/avconv.py
View file

@ -23,6 +23,7 @@ import devedeng.configuration_data
import devedeng.avbase
import devedeng.mux_dvd_menu
class avconv(devedeng.avbase.avbase):
supports_analize = False
@ -34,11 +35,11 @@ class avconv(devedeng.avbase.avbase):
display_name = "AVCONV"
disc_types = []
@staticmethod
def check_is_installed():
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()
if 0 == handle.wait():
mp2 = False
@ -100,21 +101,21 @@ class avconv(devedeng.avbase.avbase):
except:
return False
def __init__(self):
devedeng.executor.executor.__init__(self)
self.config = devedeng.configuration_data.configuration.get_config()
self.check_version(["avconv", "-version"])
def convert_file(self, file_project, output_file, video_length, pass2=False):
if file_project.two_pass_encoding:
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:
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
tmp = devedeng.avconv.avconv()
tmp.convert_file(file_project, output_file, video_length, True)
@ -130,7 +131,9 @@ class avconv(devedeng.avbase.avbase):
second_pass = False
else:
# 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
if (video_length == 0):
@ -144,7 +147,8 @@ class avconv(devedeng.avbase.avbase):
if (file_project.volume != 100) and second_pass:
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:
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 (cmd_line != ""):
cmd_line += ",fifo,"
x = int((file_project.width_midle - file_project.original_width) /2)
y = int((file_project.height_midle - file_project.original_height) /2)
x = int((file_project.width_midle -
file_project.original_width) / 2)
y = int((file_project.height_midle -
file_project.original_height) / 2)
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:
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 (cmd_line != ""):
cmd_line += ",fifo,"
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:
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 != "":
self.command_var.append("-vf")
self.command_var.append(cmd_line)
self.command_var.append("-y")
vcd = False
@ -278,7 +289,8 @@ class avconv(devedeng.avbase.avbase):
self.command_var.append("yuv420p")
self.command_var.append("-maxrate:v")
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("-minrate:v")
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("-maxrate:v")
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("-minrate:v")
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:
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:
self.command_var.append("-trellis")
@ -477,7 +491,6 @@ class avconv(devedeng.avbase.avbase):
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):
self.n_page = n_page
@ -493,7 +506,8 @@ class avconv(devedeng.avbase.avbase):
self.command_var.append("-f")
self.command_var.append("image2")
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(background_music)

47
src/devedeng/avprobe.py
View file

@ -23,6 +23,7 @@ import devedeng.executor
import os
import json
class avprobe(devedeng.avbase.avbase):
supports_analize = True
@ -36,7 +37,8 @@ class avprobe(devedeng.avbase.avbase):
@staticmethod
def check_is_installed():
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()
if 0 == handle.wait():
return True
@ -62,7 +64,8 @@ class avprobe(devedeng.avbase.avbase):
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)
@ -73,7 +76,6 @@ class avprobe(devedeng.avbase.avbase):
self.config.append_static_log("AVProbe JSON data: " + str(stdout2))
return self.process_json(stdout2, file_name)
def process_json(self, stdout2, file_name):
self.audio_list = []
@ -89,7 +91,8 @@ class avprobe(devedeng.avbase.avbase):
self.original_fps = 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:
video_data = json.loads(stdout2)
except:
@ -113,26 +116,34 @@ class avprobe(devedeng.avbase.avbase):
self.original_width = int(float(element["width"]))
self.original_height = int(float(element["height"]))
if ("bit_rate" in element):
self.original_videorate = int(float(element["bit_rate"]))/1000
self.original_fps = self.get_division(element["avg_frame_rate"])
self.original_videorate = int(
float(element["bit_rate"])) / 1000
self.original_fps = self.get_division(
element["avg_frame_rate"])
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"):
self.audio_streams += 1
self.audio_list.append(element["index"])
if (self.audio_streams == 1):
if ("bit_rate" in element):
self.original_audiorate = int(float(element["bit_rate"]))/1000
self.original_audiorate_uncompressed = int(float(element["sample_rate"]))
self.original_audiorate = int(
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_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):
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):
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]
(stdout, stderr) = self.launch_process(command_line, False)
try:
stdout2 = stdout.decode("utf-8") + "\n" + stderr.decode("utf-8")
stdout2 = stdout.decode("utf-8") + \
"\n" + stderr.decode("utf-8")
except:
stdout2 = stdout.decode("latin1") + "\n" + stderr.decode("latin1")
self.config.append_static_log("Using avprobe human readable format: "+str(stdout2))
stdout2 = stdout.decode("latin1") + \
"\n" + stderr.decode("latin1")
self.config.append_static_log(
"Using avprobe human readable format: " + str(stdout2))
for line in stdout2.split("\n"):
line = line.strip()
if line.startswith("Duration: "):
self.original_length = self.get_time(line[10:])
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

4
src/devedeng/brasero.py
View file

@ -19,6 +19,7 @@ import subprocess
import devedeng.configuration_data
import devedeng.executor
class brasero(devedeng.executor.executor):
supports_analize = False
@ -32,7 +33,8 @@ class brasero(devedeng.executor.executor):
@staticmethod
def check_is_installed():
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()
if 0 == handle.wait():
return True

74
src/devedeng/choose_disc_type.py
View file

@ -21,6 +21,7 @@ import subprocess
import devedeng.configuration_data
class choose_disc_type(GObject.GObject):
def __init__(self):
@ -30,7 +31,8 @@ class choose_disc_type(GObject.GObject):
builder = Gtk.Builder()
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)
self.wask_window = builder.get_object("wselect_disk")
@ -93,7 +95,8 @@ class choose_disc_type(GObject.GObject):
def check_program(self, command_line):
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()
retval = handle.wait()
return True
@ -151,18 +154,24 @@ class choose_disc_type(GObject.GObject):
text = ""
for e in analizers:
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:
text += _("\t%(program_name)s (installed)\n") % {"program_name": e.display_name}
text1 = _("Movie identifiers (install at least one of these):\n\n%(program_list)s\n") % {"program_list" : text}
text += _("\t%(program_name)s (installed)\n") % {
"program_name": e.display_name}
text1 = _("Movie identifiers (install at least one of these):\n\n%(program_list)s\n") % {
"program_list": text}
text = ""
for e in players:
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:
text += _("\t%(program_name)s (installed)\n") % {"program_name": e.display_name}
text2 = _("Movie players (install at least one of these):\n\n%(program_list)s\n") % {"program_list" : text}
text += _("\t%(program_name)s (installed)\n") % {
"program_name": e.display_name}
text2 = _("Movie players (install at least one of these):\n\n%(program_list)s\n") % {
"program_list": text}
text = ""
for e in converters:
@ -172,49 +181,64 @@ class choose_disc_type(GObject.GObject):
sup += ", "
sup += s
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:
text += _("\t%(program_name)s (installed)\n") % {"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 += _("\t%(program_name)s (installed)\n") % {
"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 = ""
for e in burners:
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:
text += _("\t%(program_name)s (installed)\n") % {"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 += _("\t%(program_name)s (installed)\n") % {
"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 = ""
for e in mkiso:
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:
text += _("\t%(program_name)s (installed)\n") % {"program_name": e.display_name}
text5 = _("ISO creators (install at least one of these):\n\n%(program_list)s\n") % {"program_list" : text}
text += _("\t%(program_name)s (installed)\n") % {
"program_name": e.display_name}
text5 = _("ISO creators (install at least one of these):\n\n%(program_list)s\n") % {
"program_list": text}
text = ""
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:
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:
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:
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:
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:
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
textbuf.insert_at_cursor(final_text, len(final_text))
window.run()
window.destroy()
def on_wselect_disk_destroy_event(self, w, b):
Gtk.main_quit()

53
src/devedeng/configuration_data.py
View file

@ -21,6 +21,7 @@ from gi.repository import GObject
import os
import pkg_resources
class configuration(GObject.GObject):
current_configuration = None
@ -70,7 +71,8 @@ class configuration(GObject.GObject):
return True
else:
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.glade = "/usr/local/share/devedeng"
self.font_path = "/usr/local/share/devedeng"
@ -159,10 +161,12 @@ class configuration(GObject.GObject):
continue
if linea[:20] == "subtitle_fill_color:":
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:":
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:":
self.subt_outline_thickness = float(linea[27:].strip())
config_data.close()
@ -171,7 +175,6 @@ class configuration(GObject.GObject):
return False
def set_disc_type(self, disc_type):
self.disc_type = disc_type
@ -179,7 +182,6 @@ class configuration(GObject.GObject):
self.clear_log()
self.emit('disc_type', disc_type)
def save_config(self):
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("multicore:" + str(self.multicore) + "\n")
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):
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):
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):
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):
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):
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):
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:
config_data.write("burner:" + str(self.burner) + "\n")
if self.mkiso is not None:
config_data.write("mkiso:" + str(self.mkiso) + "\n")
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):
config_data.write("sub_language:"+str(self.sub_language)+"\n")
config_data.write("subtitle_font_size:"+str(self.subtitles_font_size)+"\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_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.write("sub_language:" +
str(self.sub_language) + "\n")
config_data.write("subtitle_font_size:" +
str(self.subtitles_font_size) + "\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_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()
except:
pass
def append_log(self, data, cr=True):
self.log += data
if (cr):
self.log += "\n"
def append_static_log(self, data, cr=True):
self.static_log += data

11
src/devedeng/converter.py
View file

@ -28,6 +28,7 @@ import devedeng.mkisofs
import devedeng.genisoimage
import devedeng.mpv
class converter:
current_converter = None
@ -38,7 +39,6 @@ class converter:
converter.current_converter = converter()
return converter.current_converter
def __init__(self):
self.config = devedeng.configuration_data.configuration.get_config()
@ -92,7 +92,6 @@ class converter:
if (self.default_burner is None):
self.default_burner = element
def get_supported_programs(self):
analizers = []
@ -118,7 +117,6 @@ class converter:
return (analizers, players, menuers, converters, burners, mkiso)
def get_available_programs(self):
players = []
@ -143,7 +141,6 @@ class converter:
return (analizers, players, menuers, converters, burners, mkiso)
def get_needed_programs(self):
""" 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
@ -221,13 +218,15 @@ class converter:
def get_disc_converter(self):
""" 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):
# and that converter supports the current disc type
if self.converters[self.config.film_converter].disc_types.count(self.config.disc_type) != 0:
# return that 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:
if self.converters[converter].disc_types.count(self.config.disc_type) != 0:
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 devedeng.configuration_data
class create_disk_window:
def __init__(self):

174
src/devedeng/dvd_menu.py
View file

@ -23,6 +23,7 @@ import devedeng.interface_manager
import devedeng.message
import devedeng.mux_dvd_menu
class dvd_menu(devedeng.interface_manager.interface_manager):
def __init__(self):
@ -33,20 +34,26 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
devedeng.interface_manager.interface_manager.__init__(self)
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.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("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("selected_color", (0,1,1,1), self.update_preview)
self.add_colorbutton("background_color", (0,0,0,0.75), self.update_preview)
self.add_colorbutton(
"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_group("position_horizontal", ["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_group("position_horizontal", [
"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_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("entry_font", "Sans 28", self.update_preview)
self.add_filebutton("background_picture", self.default_background, self.update_preview)
self.add_filebutton("background_music", self.default_sound, self.update_music)
self.add_filebutton("background_picture",
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_size = 0
@ -77,47 +86,46 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
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
def update_music(self, b=None):
self.store_ui(self.builder)
cv = devedeng.converter.converter.get_converter()
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):
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)
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)
else:
self.sound_length = length
def update_preview(self, b=None):
self.store_ui(self.builder)
self.sf = None # force to repaint the menu
self.wdrawing_area.queue_draw()
def on_default_background_clicked(self, b):
self.background_picture = self.default_background
self.update_ui(self.builder)
self.update_preview()
def on_no_sound_clicked(self, b):
self.background_music = self.default_sound
self.sound_length = 30
self.update_ui(self.builder)
def show_configuration(self, file_list):
self.builder = Gtk.Builder()
@ -130,7 +138,8 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.builder.connect_signals(self)
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.wpreview_menu = self.builder.get_object("preview_menu")
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.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")
file_filter_pictures = Gtk.FileFilter()
@ -171,19 +181,16 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.update_ui(self.builder)
self.save_ui()
def on_accept_clicked(self, b):
self.store_ui(self.builder)
self.wmenu.destroy()
def on_cancel_clicked(self, b):
self.restore_ui()
self.wmenu.destroy()
def get_font_params(self, font_name):
font_elements = font_name.split(" ")
@ -216,7 +223,6 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
return fontname, fontstyle, fontslant, fontsize
def paint_arrow(self, xl, xr, y, arrow_type, left):
if arrow_type == "menu_entry":
@ -224,7 +230,8 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
elif arrow_type == "menu_entry_selected":
fgcolor = self.selected_color
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:
return
@ -250,7 +257,6 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.cr.set_font_options(fo)
self.cr.set_antialias(cairo.ANTIALIAS_DEFAULT)
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 """
@ -273,7 +279,8 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
hard_borders = True
font = self.entry_font
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
hard_borders = True
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)
if (bgcolor is not None):
self.cr.move_to(x+extents[0]+2,y-(extents[3]/2.0)-extents[1]+2)
self.cr.set_source_rgba(bgcolor[0],bgcolor[1],bgcolor[2],bgcolor[3])
self.cr.move_to(x + extents[0] + 2, y -
(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.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_antialias(cairo.ANTIALIAS_DEFAULT)
def refresh_static_data(self):
""" This method sets data that can't be changed from the dvd settings window.
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.wcurrent_page = None
def paint_menu(self, paint_background, paint_selected, paint_activated, page_number):
coordinates = []
@ -345,7 +352,8 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
if self.cached_menu_font != self.entry_font:
# 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.set_font_size(fontsize)
extents = self.cr.font_extents()
@ -353,19 +361,22 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.cached_menu_font = self.entry_font
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_y = float(extra_pixbuf.get_height())
self.cr.save()
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.paint()
self.cr.restore()
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:
# self.cr.set_source_rgb(1.0,1.0,1.0)
# 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
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
entries_per_page = int((self.y - top_margin_p - bottom_margin_p) / entry_height)
entry_height = self.cached_menu_size + \
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):
entries_per_page -= 1
n_entries = len(self.title_list)
@ -393,7 +406,8 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
page_number -= 1
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
xr = 720.0 - right_margin_p
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"])
if paint_background:
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:
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:
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
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
if paint_background:
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:
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:
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
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)
return coordinates
def paint_base(self, xl, xr, y, type_b):
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 += 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.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.curve_to(xl - radius, y + height, xl - radius, y, xl, y)
self.cr.fill()
def on_next_page_clicked(self, b):
self.current_shown_page += 1
@ -488,7 +508,6 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.current_shown_page -= 1
self.update_preview()
def on_previous_page_clicked(self, b):
self.current_shown_page -= 1
@ -496,23 +515,20 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
self.current_shown_page = 0
self.update_preview()
def on_drawingarea_preview_draw(self, widget, cr):
""" Callback to repaint the menu preview window when it
sends the EXPOSE event """
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):
self.current_shown_page = self.pages
cr.set_source_surface(self.sf)
cr.paint()
def create_menu_stream(self, path, n_page, coordinates):
""" Creates the menu XML file """
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
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"')
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"'))
# transparent="000000"')
xml_file.write(
'<subpictures>\n\t<stream>\n\t\t<spu force="yes" start="00:00:00.00"')
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')
n_elements = 0
has_next = False
@ -560,12 +581,16 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
if (element[4] == "left"):
entry_data["left"] = "boton" + str(n_page) + "x" + str(counter)
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:
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('" x0="'+str(xl)+'" y0="'+str(yt)+'" x1="'+str(xr)+'" y1="'+str(yb)+'"')
xml_file.write('\t\t\t<button name="boton' +
str(n_page) + "x" + str(counter))
xml_file.write('" x0="' + str(xl) + '" y0="' + str(yt) +
'" x1="' + str(xr) + '" y1="' + str(yb) + '"')
if counter > 0:
xml_file.write(' up="boton' + str(n_page) + "x")
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('"')
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):
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')
counter += 1
@ -590,7 +617,6 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
return entry_data
def create_dvd_menus(self, file_list, base_path):
self.file_list = file_list
@ -609,19 +635,25 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
while n_page < self.pages:
self.sf = None
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.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.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.paint_menu(False, False, True, n_page)
self.sf.write_to_png(os.path.join(menu_folder,"menu_"+str(n_page)+"_active_bg.png"))
entry_data = self.create_menu_stream(menu_folder, n_page, coordinates)
self.sf.write_to_png(os.path.join(
menu_folder, "menu_" + str(n_page) + "_active_bg.png"))
entry_data = self.create_menu_stream(
menu_folder, n_page, coordinates)
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
menu_entries.append(entry_data)
# add this process without dependencies
@ -630,12 +662,10 @@ class dvd_menu(devedeng.interface_manager.interface_manager):
return processes, menu_entries
def store_menu(self):
return self.serialize()
def restore_menu(self, data):
self.unserialize(data)

115
src/devedeng/dvdauthor_converter.py
View file

@ -21,6 +21,7 @@ import os
import devedeng.configuration_data
import devedeng.executor
class dvdauthor_converter(devedeng.executor.executor):
def __init__(self):
@ -28,7 +29,6 @@ class dvdauthor_converter(devedeng.executor.executor):
devedeng.executor.executor.__init__(self)
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):
movie_path = os.path.join(path, "dvd_tree")
@ -37,7 +37,8 @@ class dvdauthor_converter(devedeng.executor.executor):
except:
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.append("dvdauthor")
@ -48,17 +49,14 @@ class dvdauthor_converter(devedeng.executor.executor):
self.use_pulse_mode = True
self.text = _("Creating DVD structure")
def process_stdout(self, data):
return
def process_stderr(self, data):
if (data is not None) and (data[0] != ""):
self.progress_bar[1].set_text(data[0])
return
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")
@ -100,7 +98,8 @@ class dvdauthor_converter(devedeng.executor.executor):
# 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\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</fpc>\n')
# 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
# contained in G1
@ -138,7 +136,8 @@ class dvdauthor_converter(devedeng.executor.executor):
counter = 1
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\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')
counter += 1
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}\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="')
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:
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('\t\t\t</pgc>\n')
@ -161,8 +163,8 @@ class dvdauthor_converter(devedeng.executor.executor):
xml_file.write("\n")
# the first titleset contains all the menus. G1 allows us to jump to the desired menu
# the first titleset contains all the menus. G1 allows us to jump
# to the desired menu
xml_file.write('\t<titleset>\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
xml_file.write('\t\t\t<pgc>\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
if first_entry: # here we add some code to jump to each menu
for menu2 in range(nmenues - 1):
xml_file.write('\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\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')
# 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\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')
first_entry = False
@ -213,7 +219,8 @@ class dvdauthor_converter(devedeng.executor.executor):
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+'">\n')
xml_file.write(
'\t\t\t\t<button name="' + nbutton + '">\n')
# If PlayAll option is set, the first button on each page
# will be the PlayAll button
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\tjump vmgm menu;\n')
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')
title_counter += 1
button_counter += 1
xml_file.write('\t\t\t\t</button>\n')
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('; g2=1024; jump menu ')
xml_file.write(str(menu_number))
xml_file.write('; </button>\n')
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('; g2=1024; jump menu ')
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\tg2=s8;\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</pgc>\n')
menu_number += 1
@ -258,15 +269,18 @@ class dvdauthor_converter(devedeng.executor.executor):
# 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\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</pre>\n')
xml_file.write('\t\t\t\t<vob file="')
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:
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('\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\t<vob file="')
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:
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('\t\t\t\t<post>\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")
# Now, create the titleset for each video
total_t = len(file_movies)
@ -319,7 +334,8 @@ class dvdauthor_converter(devedeng.executor.executor):
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:
pal_ntsc = "pal"
ispal = True
@ -354,7 +370,8 @@ class dvdauthor_converter(devedeng.executor.executor):
if not onlyone:
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:
xml_file.write(' widescreen="nopanscan"')
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}\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</pre>\n')
# fake video to ensure compatibility
xml_file.write('\t\t\t\t<vob file="')
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:
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:
xml_file.write("_wide")
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<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:
xml_file.write(' widescreen="nopanscan"')
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</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')
if (element.original_length > 5):
if (element.divide_in_chapters): # add chapters
manual_chapter_list = [];
manual_chapter_list = []
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
seconds = toadd * 60
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):
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):
seconds = m_chapter
del manual_chapter_list[idx]
thetime = self.return_time(seconds, False)
xml_file.write("," + thetime)
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')
if not onlyone:
xml_file.write('\t\t\t\t<post>\n')
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
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('\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</pgc>\n")
xml_file.write("\t\t</titles>\n")
@ -472,9 +501,7 @@ class dvdauthor_converter(devedeng.executor.executor):
return xml_file_path
def return_time(self, seconds, empty):
""" cuts a time in seconds into seconds, minutes and hours """
seconds2 = int(seconds)

2
src/devedeng/end_job.py
View file

@ -19,6 +19,7 @@ from gi.repository import Gtk,Gdk
import os
import devedeng.configuration_data
class end_window:
def __init__(self):
@ -66,7 +67,6 @@ class end_window:
else:
return False
def on_copy_clicked(self, b):
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 devedeng.configuration_data
class error_window:
def __init__(self):
@ -38,7 +39,6 @@ class error_window:
werror_window.run()
werror_window.destroy()
def on_copy_clicked(self, b):
clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)

44
src/devedeng/executor.py
View file

@ -23,6 +23,7 @@ import os
import signal
import devedeng.configuration_data
class executor(GObject.GObject):
""" This class encapsulates everything needed for launching processes """
@ -51,7 +52,6 @@ class executor(GObject.GObject):
self.pulse_text = None
self.handle = None
def add_dependency(self, dep):
self.add_dependency2(dep)
@ -59,7 +59,6 @@ class executor(GObject.GObject):
for child in dep.childs:
self.add_dependency2(child)
def add_dependency2(self, dep):
if (self.dependencies is None):
@ -68,11 +67,11 @@ class executor(GObject.GObject):
if (self.dependencies.count(dep) == 0):
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:
child.add_dependency(dep)
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
# this method on all of them
@ -86,10 +85,10 @@ class executor(GObject.GObject):
else:
self.dependencies = None
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:
for dep in self.dependencies:
child.add_dependency(dep)
@ -97,7 +96,6 @@ class executor(GObject.GObject):
if (self.childs.count(child) == 0):
self.childs.append(child)
def run(self, progress_bar):
self.progress_bar = progress_bar
@ -113,7 +111,6 @@ class executor(GObject.GObject):
if self.use_pulse_mode != self.pulse_mode:
self.set_pulse_mode(self.use_pulse_mode)
def remove_ansi(self, line):
output = ""
@ -140,7 +137,6 @@ class executor(GObject.GObject):
break
return output
def launch_process(self, command, redirect_output=True):
if command is not None:
@ -155,12 +151,15 @@ class executor(GObject.GObject):
try:
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.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")
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:
self.handle = None
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_stderr = GLib.IOChannel(self.handle.stderr.fileno())
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")
else:
self.channel_stdout.add_watch(GLib.IO_IN | GLib.IO_HUP,self.read_stdout)
self.channel_stderr.add_watch(GLib.IO_IN | GLib.IO_HUP,self.read_stderr)
self.channel_stdout.add_watch(
GLib.IO_IN | GLib.IO_HUP, self.read_stdout)
self.channel_stderr.add_watch(
GLib.IO_IN | GLib.IO_HUP, self.read_stderr)
else:
(stdout_r, stderr_r) = self.handle.communicate()
self.handle = None
@ -192,7 +194,6 @@ class executor(GObject.GObject):
self.config.append_log(stderr_r.decode("latin-1"))
return (stdout_r, stderr_r)
def set_pulse_mode(self, pulse_mode):
if pulse_mode == self.pulse_mode:
@ -205,7 +206,6 @@ class executor(GObject.GObject):
else:
GLib.source_remove(self.timer_pulse)
def run_pulse(self, v=None):
if self.progress_bar is None:
@ -216,7 +216,6 @@ class executor(GObject.GObject):
self.progress_bar[1].pulse()
return True
def read_stdout_to_file(self, source, condition):
if (condition != GLib.IO_IN):
@ -229,7 +228,6 @@ class executor(GObject.GObject):
self.file_out.write(line_data)
return True
def read_stdin_from_file(self, source, condition):
line_data = self.file_in.read1(4096)
@ -243,7 +241,6 @@ class executor(GObject.GObject):
self.handle.stdin.write(line_data)
return True
def read_stdout(self, source, condition):
if (condition != GLib.IO_IN):
@ -269,7 +266,6 @@ class executor(GObject.GObject):
self.process_stdout(final_data)
return True
def read_stderr(self, source, condition):
if (condition != GLib.IO_IN):
@ -295,9 +291,7 @@ class executor(GObject.GObject):
self.process_stderr(final_data)
return True
def cancel(self):
""" Called to kill this process. """
if self.handle is None:
@ -306,7 +300,6 @@ class executor(GObject.GObject):
self.killed = True
os.kill(self.handle.pid, signal.SIGKILL)
def wait_end(self):
if self.handle is not None:
@ -331,7 +324,6 @@ class executor(GObject.GObject):
self.emit("ended", retval)
def expand_xml(self, text):
text = text.replace('&', '&amp;')
@ -341,7 +333,6 @@ class executor(GObject.GObject):
text = text.replace("'", '&apos;')
return text
def get_division(self, data):
pos = data.find("/")
@ -366,7 +357,6 @@ class executor(GObject.GObject):
else:
return (float(int((data1 / data2) * 1000.0))) / 1000.0
def get_time(self, line):
time_string = ""

47
src/devedeng/ffmpeg.py
View file

@ -24,6 +24,7 @@ import devedeng.executor
import devedeng.mux_dvd_menu
import devedeng.project
class ffmpeg(devedeng.executor.executor):
supports_analize = False
@ -38,7 +39,8 @@ class ffmpeg(devedeng.executor.executor):
@staticmethod
def check_is_installed():
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()
if 0 == handle.wait():
mp2 = False
@ -109,9 +111,11 @@ class ffmpeg(devedeng.executor.executor):
if file_project.two_pass_encoding:
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:
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
tmp = devedeng.ffmpeg.ffmpeg()
tmp.convert_file(file_project, output_file, video_length, True)
@ -127,7 +131,9 @@ class ffmpeg(devedeng.executor.executor):
second_pass = False
else:
# 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
if (video_length == 0):
@ -141,7 +147,8 @@ class ffmpeg(devedeng.executor.executor):
if (file_project.volume != 100) and second_pass:
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:
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 (cmd_line != ""):
cmd_line += ",fifo,"
x = int((file_project.width_midle - file_project.original_width) /2)
y = int((file_project.height_midle - file_project.original_height) /2)
x = int((file_project.width_midle -
file_project.original_width) / 2)
y = int((file_project.height_midle -
file_project.original_height) / 2)
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:
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 (cmd_line != ""):
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 != "":
self.command_var.append("-vf")
self.command_var.append(cmd_line)
self.command_var.append("-y")
vcd = False
@ -272,7 +284,8 @@ class ffmpeg(devedeng.executor.executor):
self.command_var.append("yuv420p")
self.command_var.append("-maxrate:v")
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("-minrate:v")
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("-maxrate:v")
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("-minrate:v")
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:
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:
self.command_var.append("-trellis")
@ -471,7 +486,6 @@ class ffmpeg(devedeng.executor.executor):
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):
self.n_page = n_page
@ -487,7 +501,8 @@ class ffmpeg(devedeng.executor.executor):
self.command_var.append("-f")
self.command_var.append("image2")
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(background_music)

47
src/devedeng/ffprobe.py
View file

@ -23,6 +23,7 @@ import devedeng.executor
import os
import json
class ffprobe(devedeng.executor.executor):
supports_analize = True
@ -36,7 +37,8 @@ class ffprobe(devedeng.executor.executor):
@staticmethod
def check_is_installed():
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()
if 0 == handle.wait():
return True
@ -62,7 +64,8 @@ class ffprobe(devedeng.executor.executor):
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)
try:
@ -72,7 +75,6 @@ class ffprobe(devedeng.executor.executor):
self.config.append_static_log("FFProbe JSON data: " + str(stdout2))
return self.process_json(file_name, stdout2)
def process_json(self, file_name, stdout2):
self.audio_list = []
@ -88,7 +90,8 @@ class ffprobe(devedeng.executor.executor):
self.original_fps = 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:
video_data = json.loads(stdout2)
except:
@ -112,26 +115,34 @@ class ffprobe(devedeng.executor.executor):
self.original_width = int(float(element["width"]))
self.original_height = int(float(element["height"]))
if ("bit_rate" in element):
self.original_videorate = int(float(element["bit_rate"]))/1000
self.original_fps = self.get_division(element["avg_frame_rate"])
self.original_videorate = int(
float(element["bit_rate"])) / 1000
self.original_fps = self.get_division(
element["avg_frame_rate"])
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"):
self.audio_streams += 1
self.audio_list.append(element["index"])
if (self.audio_streams == 1):
if ("bit_rate" in element):
self.original_audiorate = int(float(element["bit_rate"]))/1000
self.original_audiorate_uncompressed = int(float(element["sample_rate"]))
self.original_audiorate = int(
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_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):
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):
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]
(stdout, stderr) = self.launch_process(command_line, False)
try:
stdout2 = stdout.decode("utf-8") + "\n" + stderr.decode("utf-8")
stdout2 = stdout.decode("utf-8") + \
"\n" + stderr.decode("utf-8")
except:
stdout2 = stdout.decode("latin1") + "\n" + stderr.decode("latin1")
self.config.append_static_log("Using ffprobe human readable format: "+str(stdout2))
stdout2 = stdout.decode("latin1") + \
"\n" + stderr.decode("latin1")
self.config.append_static_log(
"Using ffprobe human readable format: " + str(stdout2))
for line in stdout2.split("\n"):
line = line.strip()
if line.startswith("Duration: "):
self.original_length = self.get_time(line[10:])
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

5
src/devedeng/file_copy.py
View file

@ -21,6 +21,7 @@ import os
import devedeng.configuration_data
import devedeng.executor
class file_copy(devedeng.executor.executor):
def __init__(self, input_path, output_path):
@ -28,14 +29,14 @@ class file_copy(devedeng.executor.executor):
devedeng.executor.executor.__init__(self)
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.append("copy_files_verbose.py")
self.command_var.append(input_path)
self.command_var.append(output_path)
def process_stdout(self, data):
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.subtitles_mux
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):
@ -45,7 +47,8 @@ class file_movie(devedeng.interface_manager.interface_manager):
if list_files is None:
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_length", None)
self.add_label("original_videorate", None)
@ -56,7 +59,7 @@ class file_movie(devedeng.interface_manager.interface_manager):
else:
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_toggle("video_rate_automatic", True)
@ -75,13 +78,20 @@ class file_movie(devedeng.interface_manager.interface_manager):
else:
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_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")
self.add_group("aspect_ratio", ["aspect_auto", "aspect_classic", "aspect_wide"], "aspect_auto")
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_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_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")
self.add_group("aspect_ratio", [
"aspect_auto", "aspect_classic", "aspect_wide"], "aspect_auto")
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)
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_colorbutton("subt_fill_color", self.config.subt_fill_color)
self.add_colorbutton("subt_outline_color", self.config.subt_outline_color)
self.add_float_adjustment("subt_thickness", self.config.subt_outline_thickness)
self.add_colorbutton("subt_outline_color",
self.config.subt_outline_color)
self.add_float_adjustment(
"subt_thickness", self.config.subt_outline_thickness)
if list_files is None:
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_enable_disable("divide_in_chapters", ["chapter_size_spinbutton", "chapter_list_entry"], [])
self.add_enable_disable("video_rate_automatic", [], ["video_spinbutton"])
self.add_enable_disable("audio_rate_automatic", [], ["audio_spinbutton"])
self.add_enable_disable("divide_in_chapters", [
"chapter_size_spinbutton", "chapter_list_entry"], [])
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"], [])
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",
"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")
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:
cv = devedeng.converter.converter.get_converter()
@ -166,7 +184,8 @@ class file_movie(devedeng.interface_manager.interface_manager):
self.original_audiorate = 224
if self.original_videorate <= 0:
# 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
if self.original_length <= 0:
self.original_length = 1
@ -182,21 +201,17 @@ class file_movie(devedeng.interface_manager.interface_manager):
self.aspect_ratio_final = None
self.converted_filename = None
def set_title(self, new_title):
self.title_name = new_title
self.emit('title_changed', self.title_name)
def set_show_in_menu(self, show):
self.show_in_menu = show
self.emit('in_menu_changed', self.show_in_menu)
def get_duration(self):
return self.original_length
def get_estimated_size(self):
""" 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:
# let's asume 8kbps for each subtitle
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
def get_size_data(self):
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
def set_auto_video_audio_rate(self, new_video_rate, new_audio_rate):
self.video_rate_auto = int(new_video_rate)
self.audio_rate_auto = int(new_audio_rate)
def get_max_resolution(self, rx, ry, aspect):
tmpx = ry * aspect
@ -242,7 +255,6 @@ class file_movie(devedeng.interface_manager.interface_manager):
else:
return rx, tmpy
def set_final_rates(self):
if (self.disc_type == "divx") or (self.disc_type == "mkv"):
@ -272,7 +284,6 @@ class file_movie(devedeng.interface_manager.interface_manager):
else:
self.audio_rate_final = self.audio_rate
def set_final_size_aspect(self):
if self.is_mpeg_ps:
@ -286,9 +297,11 @@ class file_movie(devedeng.interface_manager.interface_manager):
if self.format_pal:
final_size = self.final_size_pal
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"):
self.width_midle = self.original_width
self.width_final = self.original_width
@ -351,7 +364,8 @@ class file_movie(devedeng.interface_manager.interface_manager):
else:
self.height_final = 480
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):
th = 576
th2 = 288
@ -371,7 +385,8 @@ class file_movie(devedeng.interface_manager.interface_manager):
self.width_final = 720
self.height_final = th
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:
values = final_size[5:].split("x")
self.width_final = int(values[0])
@ -393,25 +408,27 @@ class file_movie(devedeng.interface_manager.interface_manager):
elif self.scaling == "add_black_bars":
if midle_aspect_ratio > self.aspect_ratio_final: # add horizontal black bars, at top and bottom
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
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)
else: # cut picture
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)
else:
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):
if (disc_type is not None):
self.disc_type = disc_type
def delete_file(self):
return
@ -420,7 +437,6 @@ class file_movie(devedeng.interface_manager.interface_manager):
help_file = devedeng.help.help("file.html")
def properties(self):
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.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.wfile_properties = self.builder.get_object("file_properties")
self.wfile_properties.show_all()
self.wframe_title = self.builder.get_object("frame_title")
self.wframe_fileinfo = self.builder.get_object("frame_fileinfo")
self.wframe_multiproperties = self.builder.get_object("frame_multiproperties")
self.wtreeview_multiproperties = self.builder.get_object("treeview_multiproperties")
self.wframe_multiproperties = self.builder.get_object(
"frame_multiproperties")
self.wtreeview_multiproperties = self.builder.get_object(
"treeview_multiproperties")
self.wbutton_preview = self.builder.get_object("button_preview")
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_audio_rate = self.builder.get_object("frame_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"):
self.waudio_rate.set_upper(448.0)
@ -461,7 +481,8 @@ class file_movie(devedeng.interface_manager.interface_manager):
# elements in page SUBTITLES
self.wsubtitles_list = self.builder.get_object("subtitles_list")
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.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
self.wsize_1920x1080 = self.builder.get_object("size_1920x1080")
self.wsize_1280x720 = self.builder.get_object("size_1280x720")
self.wsize_1920x1080_ntsc = self.builder.get_object("size_1920x1080_ntsc")
self.wsize_1280x720_ntsc = self.builder.get_object("size_1280x720_ntsc")
self.wsize_1920x1080_ntsc = self.builder.get_object(
"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_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_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.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)
self.wtreeview_multiproperties.set_rubber_banding(True)
self.save_ui()
self.update_ui(self.builder)
self.on_aspect_classic_toggled(None)
self.on_treeview_subtitles_cursor_changed(None)
def on_aspect_classic_toggled(self, b):
status1 = self.waspect_classic.get_active()
@ -573,14 +596,19 @@ class file_movie(devedeng.interface_manager.interface_manager):
else:
final_aspect = 4.0 / 3.0
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.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"))
self.wadd_black_bars_pic.set_from_file(os.path.join(
self.config.pic_path, "to_classic_blackbars.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:
self.wadd_black_bars_pic.set_from_file(os.path.join(self.config.pic_path,"to_wide_blackbars.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"))
self.wadd_black_bars_pic.set_from_file(os.path.join(
self.config.pic_path, "to_wide_blackbars.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):
@ -607,7 +635,6 @@ class file_movie(devedeng.interface_manager.interface_manager):
self.wfile_properties = None
self.builder = None
def on_button_cancel_clicked(self, b):
if self.list_files is None:
@ -617,13 +644,12 @@ class file_movie(devedeng.interface_manager.interface_manager):
self.wfile_properties = None
self.builder = None
def on_add_subtitles_clicked(self, b):
subt = devedeng.ask_subtitles.ask_subtitles()
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):
@ -635,14 +661,12 @@ class file_movie(devedeng.interface_manager.interface_manager):
else:
return ((None, None))
def on_del_subtitles_clicked(self, b):
model, treeiter = self.get_selected_subtitle()
if (model is not None):
model.remove(treeiter)
def on_treeview_subtitles_cursor_changed(self, b):
model, treeiter = self.get_selected_subtitle()
@ -651,12 +675,12 @@ class file_movie(devedeng.interface_manager.interface_manager):
else:
self.wdel_subtitles.set_sensitive(True)
def do_conversion(self, output_path, duration=0):
self.converted_filename = output_path
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:
self.set_final_size_aspect()
self.set_final_rates()
@ -695,12 +719,10 @@ class file_movie(devedeng.interface_manager.interface_manager):
return converter
def on_button_preview_clicked(self, b):
self.store_ui(self.builder)
self.do_preview()
def do_preview(self):
wpreview = devedeng.preview.preview_window()
@ -708,19 +730,19 @@ class file_movie(devedeng.interface_manager.interface_manager):
return
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.connect("done", self.preview_done)
run_window.run()
def preview_done(self, o, retval):
if (retval == 0):
cv = devedeng.converter.converter.get_converter()
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):
@ -730,18 +752,15 @@ class file_movie(devedeng.interface_manager.interface_manager):
return data
def restore_file(self, data):
self.unserialize(data)
def on_select_all_clicked(self, b):
sel = self.wtreeview_multiproperties.get_selection()
sel.select_all()
def on_unselect_all_clicked(self, b):
sel = self.wtreeview_multiproperties.get_selection()

5
src/devedeng/genisoimage.py
View file

@ -22,6 +22,7 @@ import devedeng.configuration_data
import subprocess
import devedeng.executor
class genisoimage(devedeng.executor.executor):
supports_analize = False
@ -35,7 +36,8 @@ class genisoimage(devedeng.executor.executor):
@staticmethod
def check_is_installed():
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()
if 0 == handle.wait():
return True
@ -66,7 +68,6 @@ class genisoimage(devedeng.executor.executor):
self.command_var.append(filesystem_path)
self.text = _("Creating ISO image")
def process_stdout(self, data):
return

7
src/devedeng/help.py
View file

@ -4,14 +4,17 @@ from gi.repository import Gtk,Gdk
import devedeng.configuration_data
import os
class help:
def __init__(self, help_page):
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)
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
class interface_manager(GObject.GObject):
""" 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
@ -75,7 +76,8 @@ class interface_manager(GObject.GObject):
The default value can be a text or None """
if (default_value is not None):
exec('self.'+text_name+' = "'+str(default_value).replace('\"','\\"')+'"')
exec('self.' + text_name + ' = "' +
str(default_value).replace('\"', '\\"') + '"')
else:
exec('self.' + text_name + ' = None')
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
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):
""" 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:
value = eval('self.' + 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_alpha(int(value[3] * 65535.0))
callback = element[1]
@ -316,7 +320,6 @@ class interface_manager(GObject.GObject):
obj.connect('toggled', self.toggled_element2)
self.toggled_element2(obj)
def toggled_element(self, element):
""" 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
# 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:
to_show = self.interface_show_hide_obj[key][0]
to_hide = self.interface_show_hide_obj[key][1]
@ -352,7 +356,6 @@ class interface_manager(GObject.GObject):
if active:
item.hide()
def toggled_element2(self, element):
""" 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
# 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:
to_enable = self.interface_enable_disable_obj[key][0]
to_disable = self.interface_enable_disable_obj[key][1]
@ -384,7 +388,6 @@ class interface_manager(GObject.GObject):
for item in to_disable:
item.set_sensitive(False)
def store_ui(self, builder):
""" 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])
objcolor = obj.get_color()
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:
obj = builder.get_object(element[0])
@ -451,7 +455,6 @@ class interface_manager(GObject.GObject):
obj = builder.get_object(element[0])
exec('self.' + element[0] + ' = element[1][obj.get_active()]')
def save_ui(self):
""" Makes a copy of all the UI variables """
@ -504,7 +507,6 @@ class interface_manager(GObject.GObject):
for element in self.interface_comboboxes:
exec('self.' + element[0] + ' = self.' + element[0] + '_backup')
def serialize(self):
""" Returns a dictionary with both the variables of the interface and its values,
which can be restored with unserialize
@ -535,7 +537,6 @@ class interface_manager(GObject.GObject):
output[element[0]] = eval('self.' + element[0])
return output
def unserialize(self, data_list):
""" Takes a dictionary with the variables of the interface and its values,
and restores them into their variables
@ -546,31 +547,41 @@ class interface_manager(GObject.GObject):
exec('self.' + element + ' = data_list["' + element + '"]')
for element in self.interface_toggles:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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.executor
class k3b(devedeng.executor.executor):
supports_analize = False
@ -32,7 +33,8 @@ class k3b(devedeng.executor.executor):
@staticmethod
def check_is_installed():
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()
if 0 == handle.wait():
return True

1
src/devedeng/message.py
View file

@ -19,6 +19,7 @@ from gi.repository import Gtk
import os
import devedeng.configuration_data
class message_window:
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 devedeng.executor
class mkisofs(devedeng.executor.executor):
supports_analize = False
@ -35,7 +36,8 @@ class mkisofs(devedeng.executor.executor):
@staticmethod
def check_is_installed():
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()
if 0 == handle.wait():
return True
@ -66,7 +68,6 @@ class mkisofs(devedeng.executor.executor):
self.command_var.append(filesystem_path)
self.text = _("Creating ISO image")
def process_stdout(self, data):
return

4
src/devedeng/mplayer.py
View file

@ -22,6 +22,7 @@ import devedeng.configuration_data
import devedeng.executor
import os
class mplayer(devedeng.executor.executor):
supports_analize = False
@ -35,7 +36,8 @@ class mplayer(devedeng.executor.executor):
@staticmethod
def check_is_installed():
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()
if 0 == handle.wait():
return True

4
src/devedeng/mpv.py
View file

@ -21,6 +21,7 @@ import subprocess
import devedeng.configuration_data
import devedeng.executor
class mpv(devedeng.executor.executor):
supports_analize = False
@ -34,7 +35,8 @@ class mpv(devedeng.executor.executor):
@staticmethod
def check_is_installed():
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()
if 0 == handle.wait():
return True

4
src/devedeng/mux_dvd_menu.py
View file

@ -21,6 +21,7 @@ import os
import devedeng.configuration_data
import devedeng.executor
class mux_dvd_menu(devedeng.executor.executor):
def __init__(self):
@ -37,7 +38,8 @@ class mux_dvd_menu(devedeng.executor.executor):
self.command_var = []
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.stdout_file = final_path

8
src/devedeng/opensave.py
View file

@ -19,6 +19,7 @@ from gi.repository import Gtk
import os
import devedeng.configuration_data
class opensave_window:
def __init__(self, save):
@ -26,16 +27,17 @@ class opensave_window:
self.config = devedeng.configuration_data.configuration.get_config()
self.save = save
def run(self, current_file=None):
builder = Gtk.Builder()
builder.set_translation_domain(self.config.gettext_domain)
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:
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)
w_window = builder.get_object("data_project")
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 devedeng.configuration_data
class preview_window:
def __init__(self):

88
src/devedeng/project.py
View file

@ -40,6 +40,7 @@ import devedeng.about
import devedeng.opensave
import devedeng.help
class devede_project:
dvd_max_bps_base = {0: 9000}
@ -54,7 +55,8 @@ class devede_project:
divx_min_bps = 300
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_max_total = -1
@ -94,7 +96,6 @@ class devede_project:
self.wcreate_menu = builder.get_object("create_menu")
self.wmenu_options = builder.get_object("menu_options")
self.wadd_file = builder.get_object("add_file")
self.wdelete_file = builder.get_object("delete_file")
self.wup_file = builder.get_object("up_file")
@ -120,12 +121,12 @@ class devede_project:
if (self.disc_type is not None):
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.add(Gdk.Atom.intern("text/uri-list", False), 0, 0)
self.wmain_window.drag_dest_set_target_list(targets)
def set_type(self, obj=None, disc_type=None):
""" 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
@ -151,9 +152,7 @@ class devede_project:
self.wframe_menu.hide()
self.wcreate_menu.set_active(False)
def get_current_file(self):
""" returns the currently selected file """
selection = self.wfiles.get_selection()
@ -171,7 +170,6 @@ class devede_project:
else:
return ((None, -1, None, None))
def get_all_files(self):
retval = []
@ -180,7 +178,6 @@ class devede_project:
retval.append(row.model[row.iter][0])
return retval
def set_interface_status(self, b):
self.wadd_file.set_sensitive(True)
@ -211,19 +208,18 @@ class devede_project:
if (position == (nfiles - 1)):
self.wdown_file.set_sensitive(False)
def on_cellrenderertext3_edited(self, widget, path, text):
self.wliststore_files[path][0].set_title(text)
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):
self.config.PAL = self.wuse_pal.get_active()
self.set_interface_status(None)
def on_wmain_window_delete_event(self, b, e=None):
ask = devedeng.ask.ask_window()
@ -239,7 +235,6 @@ class devede_project:
item.model.set_value(item.iter, 1, new_title)
self.refresh_disc_usage()
def in_menu_changed(self, obj, new_inmenu):
for item in self.wliststore_files:
element = item.model[item.iter][0]
@ -247,7 +242,6 @@ class devede_project:
item.model.set_value(item.iter, 4, new_inmenu)
self.refresh_disc_usage()
def on_help_clicked(self, b):
help_file = devedeng.help.help("main.html")
@ -256,14 +250,12 @@ class devede_project:
help_file = devedeng.help.help("index.html")
def on_add_file_clicked(self, b):
ask_files = devedeng.add_files.add_files()
if (ask_files.run()):
self.add_several_files(ask_files.files)
def duration_to_string(self, duration):
seconds = math.floor(duration % 60)
@ -277,7 +269,6 @@ class devede_project:
output = str(hours) + "h " + output
return output
def add_several_files(self, file_list):
error_list = []
for efile in file_list:
@ -289,13 +280,14 @@ class devede_project:
else:
new_file.connect('title_changed', self.title_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):
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.refresh_disc_usage()
def on_delete_file_clicked(self, b):
(element, position, model, treeiter) = self.get_current_file()
@ -309,7 +301,6 @@ class devede_project:
self.set_interface_status(None)
self.refresh_disc_usage()
def on_up_file_clicked(self, b):
(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.set_interface_status(None)
def on_down_file_clicked(self, b):
(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.set_interface_status(None)
def on_properties_file_clicked(self, b):
(element, position, model, treeiter) = self.get_current_file()
if (element is None):
return
element.properties()
def on_create_menu_toggled(self, b):
self.set_interface_status(None)
self.refresh_disc_usage()
def on_adjust_disc_usage_clicked(self, b):
total_resolution = 0
@ -356,7 +343,8 @@ class devede_project:
else:
fixed_size += ((audio_rate + sub_rate) * time_length)
# 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))
total_resolution += surface
@ -385,7 +373,8 @@ class devede_project:
max_total = devede_project.def_max_total
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:
f = l[0]
surface = l[1]
@ -400,7 +389,8 @@ class devede_project:
resy = 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:
max2 = max_total - audio_rate
if (max2 > max_bps):
@ -415,7 +405,6 @@ class devede_project:
self.refresh_disc_usage()
def refresh_disc_usage(self):
used = 0.0
@ -438,17 +427,15 @@ class devede_project:
self.wdisc_fill_level.set_fraction(used / disc_size)
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)
def on_menu_options_clicked(self, b):
self.menu.show_configuration(self.get_all_files())
def get_dvd_size(self):
""" Returns the size for the currently selected disk type, and the minimum and maximum
videorate for the current video disk """
@ -490,12 +477,10 @@ class devede_project:
return size, minvrate, maxvrate
def on_disc_size_changed(self, c):
self.refresh_disc_usage()
def on_create_disc_clicked(self, b):
if self.disc_type == "dvd":
@ -506,7 +491,8 @@ class devede_project:
file_movies = self.get_all_files()
t = len(file_movies)
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
data = devedeng.create_disk_window.create_disk_window()
@ -546,7 +532,8 @@ class devede_project:
final_dependencies = []
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:
run_window.add_process(p)
final_dependencies.append(p)
@ -566,7 +553,8 @@ class devede_project:
else:
extension = "mpg"
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)
final_dependencies.append(p)
counter += 1
@ -577,7 +565,8 @@ class devede_project:
else:
start_with_menu = False
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
for element in final_dependencies:
dvdauthor.add_dependency(element)
@ -604,7 +593,6 @@ class devede_project:
self.time_start = time.time()
run_window.run()
def disc_done(self, object, value):
if self.shutdown:
@ -629,12 +617,10 @@ class devede_project:
self.wmain_window.show()
def disc_done2(self, object, value):
self.wmain_window.show()
def on_preview_file_clicked(self, b):
(element, position, model, treeiter) = self.get_current_file()
@ -642,17 +628,14 @@ class devede_project:
return
element.do_preview()
def on_settings_activate(self, b):
w = devedeng.settings.settings_window()
def on_about_activate(self, b):
w = devedeng.about.about_window()
def on_new_activate(self, b):
w = devedeng.ask.ask_window()
@ -662,22 +645,18 @@ class devede_project:
self.wmain_window.hide()
devedeng.choose_disc_type.choose_disc_type()
def on_wmain_window_drag_motion(self, wid, context, x, y, time):
Gdk.drag_status(context, Gdk.DragAction.COPY, time)
return True
def on_wmain_window_drag_drop(self, wid, context, x, y, time):
# Used with windows drag and drop
return True
def on_wmain_window_drag_data_received(self, widget, drag_context, x, y, data, info, time):
uris = data.get_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):
if self.project_file is not None:
@ -685,7 +664,6 @@ class devede_project:
else:
self.on_save_as_activate(None)
def on_save_as_activate(self, b):
while True:
@ -703,14 +681,12 @@ class devede_project:
self.save_current_project()
return
def on_load_activate(self, b):
w = devedeng.opensave.opensave_window(False)
retval = w.run()
if retval is not None:
self.load_project(retval)
def save_current_project(self):
project = {}
@ -729,7 +705,6 @@ class devede_project:
with open(self.project_file, 'wb') as f:
pickle.dump(project, f, 3)
def load_project(self, project_file):
self.wliststore_files.clear()
@ -755,13 +730,14 @@ class devede_project:
else:
new_file.restore_file(efile)
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):
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.refresh_disc_usage()
def on_multiproperties_activate(self, b):
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.ask
class runner(GObject.GObject):
__gsignals__ = {'done': (GObject.SIGNAL_RUN_FIRST, None, (int,))}
@ -47,7 +48,8 @@ class runner(GObject.GObject):
self.builder = Gtk.Builder()
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.wprogress = self.builder.get_object("progress")
if show_window:
@ -73,7 +75,6 @@ class runner(GObject.GObject):
self.total_processes = 0
self.error = False
def add_process(self, process):
if (self.proc_list.count(process) == 0):
@ -84,11 +85,11 @@ class runner(GObject.GObject):
self.total_processes = len(self.proc_list)
def on_cancel_clicked(self, b):
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:
self.error = True
for element in self.proc_list:
@ -117,9 +118,10 @@ class runner(GObject.GObject):
else:
self.progress_bars = []
break
self.wtotal.set_text(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)))
self.wtotal.set_text(
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):
@ -135,7 +137,8 @@ class runner(GObject.GObject):
self.emit("done", 1) # there was an error
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 = []
for e in self.used_progress_bars:
if (process.progress_bar == e):
@ -145,7 +148,8 @@ class runner(GObject.GObject):
tmp.append(e)
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 = []
for e in self.proc_list:
if (e != process):

16
src/devedeng/settings.py
View file

@ -22,6 +22,7 @@ import devedeng.interface_manager
import gettext
import devedeng.converter
class settings_window(devedeng.interface_manager.interface_manager):
def __init__(self):
@ -46,13 +47,15 @@ class settings_window(devedeng.interface_manager.interface_manager):
counter = 1
for c in range(self.config.cores - 1, -self.config.cores, -1):
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
if c == cores:
default_value = translated_string
counter += 1
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
if c == cores:
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)
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("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("mkiso", mkiso, self.config.mkiso)
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.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)
wsettings_window = self.builder.get_object("settings")
self.wconverter = self.builder.get_object("converter")

1
src/devedeng/shutdown.py
View file

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

15
src/devedeng/subtitles_mux.py
View file

@ -23,6 +23,7 @@ import subprocess
import devedeng.configuration_data
import devedeng.executor
class subtitles_mux(devedeng.executor.executor):
def __init__(self):
@ -40,7 +41,8 @@ class subtitles_mux(devedeng.executor.executor):
self.subt_path = file_path
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.write('<subpictures format="')
@ -59,10 +61,13 @@ class subtitles_mux(devedeng.executor.executor):
if subt_upper:
out_xml.write('" bottom-margin="50')
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(' outline-color="#%02X%02X%02X"' % tuple([int(outline_color[i] * 255) for i in range(len(outline_color))]))
out_xml.write('" fill-color="#%02X%02X%02X"' %
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(' 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('" force="')
if force_subtitles:
@ -87,7 +92,6 @@ class subtitles_mux(devedeng.executor.executor):
self.stdin_file = file_path + ".tmp"
self.stdout_file = file_path
def pre_function(self):
final_path = self.subt_path + ".tmp"
@ -95,7 +99,6 @@ class subtitles_mux(devedeng.executor.executor):
os.remove(final_path)
os.rename(self.subt_path, final_path)
def process_stderr(self, data):
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
import os
class title(GObject.GObject):
counter = 0
@ -48,7 +49,8 @@ class title(GObject.GObject):
builder = Gtk.Builder()
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)
# Interface widgets
@ -82,7 +84,6 @@ class title(GObject.GObject):
wtitle_properties.destroy()
def delete_title(self):
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.executor
class vcdimager_converter(devedeng.executor.executor):
def __init__(self):
@ -45,7 +46,6 @@ class vcdimager_converter(devedeng.executor.executor):
self.command_var.append(element.converted_filename)
self.text = _("Creating CD image")
def process_stdout(self, data):
print("Stdout: " + str(data))
return

4
src/devedeng/vlc.py
View file

@ -19,6 +19,7 @@ import subprocess
import devedeng.configuration_data
import devedeng.executor
class vlc(devedeng.executor.executor):
supports_analize = False
@ -32,7 +33,8 @@ class vlc(devedeng.executor.executor):
@staticmethod
def check_is_installed():
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()
if 0 == handle.wait():
return True

29
src/unitests/test_avconv.py
View file

@ -2,6 +2,7 @@ import unittest
import devedeng.avbase
import devedeng.avprobe
class TestAVConv(unittest.TestCase):
def test_ubuntu_14_04(self):
@ -19,9 +20,10 @@ libswscale 2. 1. 1 / 2. 1. 1""".split("\n")
text.append(9)
c.check_version_txt(text)
self.assertEqual(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")
self.assertEqual(
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):
c = devedeng.avbase.avbase()
@ -38,9 +40,10 @@ libswscale 3. 0. 0 / 3. 0. 0""".split("\n")
text.append(9)
c.check_version_txt(text)
self.assertEqual(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")
self.assertEqual(
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):
c = devedeng.avbase.avbase()
@ -57,13 +60,13 @@ libswscale 3. 0. 0 / 3. 0. 0""".split("\n")
text.append(9)
c.check_version_txt(text)
self.assertEqual(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")
self.assertEqual(
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):
c = devedeng.avprobe.avprobe()
json_test = """{
"streams": [
@ -165,9 +168,11 @@ libswscale 3. 0. 0 / 3. 0. 0""".split("\n")
}"""
retval = c.process_json(json_test, "filename.mkv")
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.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")
if __name__ == '__main__':