Merge branch 'master' of git.opendreambox.org:/git/enigma2

[enigma2.git] / lib / python / Plugins / Extensions / DVDBurn / Process.py

diff --git a/lib/python/Plugins/Extensions/DVDBurn/Process.py b/lib/python/Plugins/Extensions/DVDBurn/Process.py
index 74f23f1512fdb24cc5f78f9c23a4e8acbb2a5c7b..750e9d9b3ea63643bb5e8aa7409777fb5a8fc49b 100644 (file)
--- a/lib/python/Plugins/Extensions/DVDBurn/Process.py
+++ b/lib/python/Plugins/Extensions/DVDBurn/Process.py
@@ -1,4 +1,5 @@
-from Components.Task import Task, Job, job_manager, DiskspacePrecondition, Condition, ToolExistsPrecondition
+from Components.Task import Task, Job, DiskspacePrecondition, Condition, ToolExistsPrecondition
+from Components.Harddisk import harddiskmanager

 from Screens.MessageBox import MessageBox
 
 class png2yuvTask(Task):
 from Screens.MessageBox import MessageBox
 
 class png2yuvTask(Task):


@@ -7,11 +8,11 @@ class png2yuvTask(Task):
                self.setTool("/usr/bin/png2yuv")
                self.args += ["-n1", "-Ip", "-f25", "-j", inputfile]
                self.dumpFile = outputfile
                self.setTool("/usr/bin/png2yuv")
                self.args += ["-n1", "-Ip", "-f25", "-j", inputfile]
                self.dumpFile = outputfile

-               self.weighting = 10
+               self.weighting = 15

 
 

-       def run(self, callback, task_progress_changed):
-               Task.run(self, callback, task_progress_changed)
-               self.container.stdoutAvail.get().remove(self.processStdout)
+       def run(self, callback):
+               Task.run(self, callback)
+               self.container.stdoutAvail.remove(self.processStdout)

                self.container.dumpToFile(self.dumpFile)
 
        def processStderr(self, data):
                self.container.dumpToFile(self.dumpFile)
 
        def processStderr(self, data):


@@ -23,10 +24,10 @@ class mpeg2encTask(Task):
                self.setTool("/usr/bin/mpeg2enc")
                self.args += ["-f8", "-np", "-a2", "-o", outputfile]
                self.inputFile = inputfile
                self.setTool("/usr/bin/mpeg2enc")
                self.args += ["-f8", "-np", "-a2", "-o", outputfile]
                self.inputFile = inputfile

-               self.weighting = 10
+               self.weighting = 25

                
                

-       def run(self, callback, task_progress_changed):
-               Task.run(self, callback, task_progress_changed)
+       def run(self, callback):
+               Task.run(self, callback)

                self.container.readFromFile(self.inputFile)
 
        def processOutputLine(self, line):
                self.container.readFromFile(self.inputFile)
 
        def processOutputLine(self, line):


@@ -39,11 +40,11 @@ class spumuxTask(Task):
                self.args += [xmlfile]
                self.inputFile = inputfile
                self.dumpFile = outputfile
                self.args += [xmlfile]
                self.inputFile = inputfile
                self.dumpFile = outputfile

-               self.weighting = 10
+               self.weighting = 15

 
 

-       def run(self, callback, task_progress_changed):
-               Task.run(self, callback, task_progress_changed)
-               self.container.stdoutAvail.get().remove(self.processStdout)
+       def run(self, callback):
+               Task.run(self, callback)
+               self.container.stdoutAvail.remove(self.processStdout)

                self.container.dumpToFile(self.dumpFile)
                self.container.readFromFile(self.inputFile)
 
                self.container.dumpToFile(self.dumpFile)
                self.container.readFromFile(self.inputFile)
 


@@ -76,7 +77,7 @@ class CopyMeta(Task):
                        if file.startswith(filename+"."):
                                self.args += [path+'/'+file]
                self.args += [self.job.workspace]
                        if file.startswith(filename+"."):
                                self.args += [path+'/'+file]
                self.args += [self.job.workspace]

-               self.weighting = 10
+               self.weighting = 15

 
 class DemuxTask(Task):
        def __init__(self, job, inputfile):
 
 class DemuxTask(Task):
        def __init__(self, job, inputfile):


@@ -84,23 +85,34 @@ class DemuxTask(Task):
                title = job.project.titles[job.i]
                self.global_preconditions.append(DiskspacePrecondition(title.estimatedDiskspace))
                self.setTool("/usr/bin/projectx")
                title = job.project.titles[job.i]
                self.global_preconditions.append(DiskspacePrecondition(title.estimatedDiskspace))
                self.setTool("/usr/bin/projectx")

-               self.generated_files = [ ]
+               self.args += [inputfile, "-demux", "-out", self.job.workspace ]

                self.end = 300
                self.prog_state = 0
                self.weighting = 1000
                self.cutfile = self.job.workspace + "/cut_%d.Xcl" % (job.i+1)
                self.cutlist = title.cutlist
                self.end = 300
                self.prog_state = 0
                self.weighting = 1000
                self.cutfile = self.job.workspace + "/cut_%d.Xcl" % (job.i+1)
                self.cutlist = title.cutlist

-               self.args += [inputfile, "-demux", "-out", self.job.workspace ]
+               self.currentPID = None
+               self.relevantAudioPIDs = [ ]
+               self.getRelevantAudioPIDs(title)
+               self.generated_files = [ ]
+               self.mplex_streamfiles = [ ]

                if len(self.cutlist) > 1:
                        self.args += [ "-cut", self.cutfile ]
 
        def prepare(self):
                self.writeCutfile()
 
                if len(self.cutlist) > 1:
                        self.args += [ "-cut", self.cutfile ]
 
        def prepare(self):
                self.writeCutfile()
 

+       def getRelevantAudioPIDs(self, title):
+               for audiotrack in title.properties.audiotracks:
+                       if audiotrack.active.getValue():
+                               self.relevantAudioPIDs.append(audiotrack.pid.getValue())
+

        def processOutputLine(self, line):
                line = line[:-1]
                MSG_NEW_FILE = "---> new File: "
                MSG_PROGRESS = "[PROGRESS] "
        def processOutputLine(self, line):
                line = line[:-1]
                MSG_NEW_FILE = "---> new File: "
                MSG_PROGRESS = "[PROGRESS] "

+               MSG_NEW_MP2 = "--> MPEG Audio (0x"
+               MSG_NEW_AC3 = "--> AC-3/DTS Audio on PID "

 
                if line.startswith(MSG_NEW_FILE):
                        file = line[len(MSG_NEW_FILE):]
 
                if line.startswith(MSG_NEW_FILE):
                        file = line[len(MSG_NEW_FILE):]


@@ -110,10 +122,14 @@ class DemuxTask(Task):
                elif line.startswith(MSG_PROGRESS):
                        progress = line[len(MSG_PROGRESS):]
                        self.haveProgress(progress)
                elif line.startswith(MSG_PROGRESS):
                        progress = line[len(MSG_PROGRESS):]
                        self.haveProgress(progress)

+               elif line.startswith(MSG_NEW_MP2) or line.startswith(MSG_NEW_AC3):
+                       self.currentPID = str(int(line.rstrip()[-6:].rsplit('0x',1)[-1],16))

 
        def haveNewFile(self, file):
 
        def haveNewFile(self, file):

-               print "PRODUCED FILE [%s]" % file
+               print "[DemuxTask] produced file:", file, self.currentPID

                self.generated_files.append(file)
                self.generated_files.append(file)

+               if self.currentPID in self.relevantAudioPIDs or file.endswith("m2v"):
+                       self.mplex_streamfiles.append(file)

 
        def haveProgress(self, progress):
                #print "PROGRESS [%s]" % progress
 
        def haveProgress(self, progress):
                #print "PROGRESS [%s]" % progress


@@ -130,7 +146,6 @@ class DemuxTask(Task):
                                if p > self.progress:
                                        self.progress = p
                        except ValueError:
                                if p > self.progress:
                                        self.progress = p
                        except ValueError:

-                               print "val error"

                                pass
 
        def writeCutfile(self):
                                pass
 
        def writeCutfile(self):


@@ -150,8 +165,8 @@ class DemuxTask(Task):
        def cleanup(self, failed):
                if failed:
                        import os
        def cleanup(self, failed):
                if failed:
                        import os

-                       for f in self.generated_files:
-                               os.remove(f)
+                       for file in self.generated_files:
+                               os.remove(file)

 
 class MplexTaskPostcondition(Condition):
        def check(self, task):
 
 class MplexTaskPostcondition(Condition):
        def check(self, task):


@@ -167,9 +182,9 @@ class MplexTaskPostcondition(Condition):
 
 class MplexTask(Task):
        ERROR_UNDERRUN, ERROR_UNKNOWN = range(2)
 
 class MplexTask(Task):
        ERROR_UNDERRUN, ERROR_UNKNOWN = range(2)

-       def __init__(self, job, outputfile, inputfiles=None, demux_task=None):
+       def __init__(self, job, outputfile, inputfiles=None, demux_task=None, weighting = 500):

                Task.__init__(self, job, "Mux ES into PS")
                Task.__init__(self, job, "Mux ES into PS")

-               self.weighting = 500
+               self.weighting = weighting

                self.demux_task = demux_task
                self.postconditions.append(MplexTaskPostcondition())
                self.setTool("/usr/bin/mplex")
                self.demux_task = demux_task
                self.postconditions.append(MplexTaskPostcondition())
                self.setTool("/usr/bin/mplex")


@@ -184,9 +199,9 @@ class MplexTask(Task):
                # we don't want the ReturncodePostcondition in this case because for right now we're just gonna ignore the fact that mplex fails with a buffer underrun error on some streams (this always at the very end)
 
        def prepare(self):
                # we don't want the ReturncodePostcondition in this case because for right now we're just gonna ignore the fact that mplex fails with a buffer underrun error on some streams (this always at the very end)
 
        def prepare(self):

-               self.error = None                       
+               self.error = None

                if self.demux_task:
                if self.demux_task:

-                       self.args += self.demux_task.generated_files
+                       self.args += self.demux_task.mplex_streamfiles

 
        def processOutputLine(self, line):
                print "[MplexTask] ", line[:-1]
 
        def processOutputLine(self, line):
                print "[MplexTask] ", line[:-1]


@@ -201,6 +216,7 @@ class RemoveESFiles(Task):
                Task.__init__(self, job, "Remove temp. files")
                self.demux_task = demux_task
                self.setTool("/bin/rm")
                Task.__init__(self, job, "Remove temp. files")
                self.demux_task = demux_task
                self.setTool("/bin/rm")

+               self.weighting = 10

 
        def prepare(self):
                self.args += ["-f"]
 
        def prepare(self):
                self.args += ["-f"]


@@ -208,11 +224,9 @@ class RemoveESFiles(Task):
                self.args += [self.demux_task.cutfile]
 
 class DVDAuthorTask(Task):
                self.args += [self.demux_task.cutfile]
 
 class DVDAuthorTask(Task):

-       def __init__(self, job, diskspaceNeeded):
+       def __init__(self, job):

                Task.__init__(self, job, "Authoring DVD")
                Task.__init__(self, job, "Authoring DVD")

-
-               self.global_preconditions.append(DiskspacePrecondition(diskspaceNeeded))
-               self.weighting = 300
+               self.weighting = 20

                self.setTool("/usr/bin/dvdauthor")
                self.CWD = self.job.workspace
                self.args += ["-x", self.job.workspace+"/dvdauthor.xml"]
                self.setTool("/usr/bin/dvdauthor")
                self.CWD = self.job.workspace
                self.args += ["-x", self.job.workspace+"/dvdauthor.xml"]


@@ -222,6 +236,14 @@ class DVDAuthorTask(Task):
                print "[DVDAuthorTask] ", line[:-1]
                if not self.menupreview and line.startswith("STAT: Processing"):
                        self.callback(self, [], stay_resident=True)
                print "[DVDAuthorTask] ", line[:-1]
                if not self.menupreview and line.startswith("STAT: Processing"):
                        self.callback(self, [], stay_resident=True)

+               elif line.startswith("STAT: VOBU"):
+                       try:
+                               progress = int(line.split("MB")[0].split(" ")[-1])
+                               if progress:
+                                       self.job.mplextask.progress = progress
+                                       print "[DVDAuthorTask] update mplextask progress:", self.job.mplextask.progress, "of", self.job.mplextask.end
+                       except:
+                               print "couldn't set mux progress"

 
 class DVDAuthorFinalTask(Task):
        def __init__(self, job):
 
 class DVDAuthorFinalTask(Task):
        def __init__(self, job):


@@ -233,7 +255,7 @@ class WaitForResidentTasks(Task):
        def __init__(self, job):
                Task.__init__(self, job, "waiting for dvdauthor to finalize")
                
        def __init__(self, job):
                Task.__init__(self, job, "waiting for dvdauthor to finalize")
                

-       def run(self, callback, task_progress_changed):
+       def run(self, callback):

                print "waiting for %d resident task(s) %s to finish..." % (len(self.job.resident_tasks),str(self.job.resident_tasks))
                if self.job.resident_tasks == 0:
                        callback(self, [])
                print "waiting for %d resident task(s) %s to finish..." % (len(self.job.resident_tasks),str(self.job.resident_tasks))
                if self.job.resident_tasks == 0:
                        callback(self, [])


@@ -241,7 +263,11 @@ class WaitForResidentTasks(Task):
 class BurnTaskPostcondition(Condition):
        RECOVERABLE = True
        def check(self, task):
 class BurnTaskPostcondition(Condition):
        RECOVERABLE = True
        def check(self, task):

-               return task.error is None
+               if task.returncode == 0:
+                       return True
+               elif task.error is None or task.error is task.ERROR_MINUSRWBUG:
+                       return True
+               return False

 
        def getErrorMessage(self, task):
                return {
 
        def getErrorMessage(self, task):
                return {


@@ -251,31 +277,21 @@ class BurnTaskPostcondition(Condition):
                        task.ERROR_WRITE_FAILED: _("Write failed!"),
                        task.ERROR_DVDROM: _("No (supported) DVDROM found!"),
                        task.ERROR_ISOFS: _("Medium is not empty!"),
                        task.ERROR_WRITE_FAILED: _("Write failed!"),
                        task.ERROR_DVDROM: _("No (supported) DVDROM found!"),
                        task.ERROR_ISOFS: _("Medium is not empty!"),

+                       task.ERROR_FILETOOLARGE: _("TS file is too large for ISO9660 level 1!"),
+                       task.ERROR_ISOTOOLARGE: _("ISO file is too large for this filesystem!"),

                        task.ERROR_UNKNOWN: _("An unknown error occured!")
                }[task.error]
 
 class BurnTask(Task):
                        task.ERROR_UNKNOWN: _("An unknown error occured!")
                }[task.error]
 
 class BurnTask(Task):

-       ERROR_NOTWRITEABLE, ERROR_LOAD, ERROR_SIZE, ERROR_WRITE_FAILED, ERROR_DVDROM, ERROR_ISOFS, ERROR_UNKNOWN = range(7)
-       def __init__(self, job, extra_args=[]):
-               Task.__init__(self, job, _("Burn to DVD..."))
-
+       ERROR_NOTWRITEABLE, ERROR_LOAD, ERROR_SIZE, ERROR_WRITE_FAILED, ERROR_DVDROM, ERROR_ISOFS, ERROR_FILETOOLARGE, ERROR_ISOTOOLARGE, ERROR_MINUSRWBUG, ERROR_UNKNOWN = range(10)
+       def __init__(self, job, extra_args=[], tool="/bin/growisofs"):
+               Task.__init__(self, job, job.name)

                self.weighting = 500
                self.end = 120 # 100 for writing, 10 for buffer flush, 10 for closing disc
                self.postconditions.append(BurnTaskPostcondition())
                self.weighting = 500
                self.end = 120 # 100 for writing, 10 for buffer flush, 10 for closing disc
                self.postconditions.append(BurnTaskPostcondition())

-               self.setTool("/bin/growisofs")
-               volName = self.getASCIIname(job.project.settings.name.getValue())
-               self.args += [ "-dvd-compat", "-Z", "/dev/cdroms/cdrom0", "-V", volName, "-publisher", "Dreambox", "-use-the-force-luke=dummy" ]
+               self.setTool(tool)

                self.args += extra_args
                self.args += extra_args

-
-       def getASCIIname(self, name):
-               ASCIIname = ""
-               for char in name.decode("utf-8").encode("ascii","replace"):
-                       if ord(char) <= 0x20 or ( ord(char) >= 0x3a and ord(char) <= 0x40 ):
-                               ASCIIname += '_'
-                       else:
-                               ASCIIname += char
-               return ASCIIname
-               
+       

        def prepare(self):
                self.error = None
 
        def prepare(self):
                self.error = None
 


@@ -294,15 +310,20 @@ class BurnTask(Task):
                                self.error = self.ERROR_NOTWRITEABLE
                        if line.find("ASC=24h") != -1:
                                self.error = self.ERROR_LOAD
                                self.error = self.ERROR_NOTWRITEABLE
                        if line.find("ASC=24h") != -1:
                                self.error = self.ERROR_LOAD

+                       if line.find("SK=5h/ASC=A8h/ACQ=04h") != -1:
+                               self.error = self.ERROR_MINUSRWBUG

                        else:
                                self.error = self.ERROR_UNKNOWN
                                print "BurnTask: unknown error %s" % line
                elif line.startswith(":-("):
                        if line.find("No space left on device") != -1:
                                self.error = self.ERROR_SIZE
                        else:
                                self.error = self.ERROR_UNKNOWN
                                print "BurnTask: unknown error %s" % line
                elif line.startswith(":-("):
                        if line.find("No space left on device") != -1:
                                self.error = self.ERROR_SIZE

+                       elif self.error == self.ERROR_MINUSRWBUG:
+                               print "*sigh* this is a known bug. we're simply gonna assume everything is fine."
+                               self.postconditions = []

                        elif line.find("write failed") != -1:
                                self.error = self.ERROR_WRITE_FAILED
                        elif line.find("write failed") != -1:
                                self.error = self.ERROR_WRITE_FAILED

-                       elif line.find("unable to open64(\"/dev/cdroms/cdrom0\",O_RDONLY): No such file or directory") != -1: # fixme
+                       elif line.find("unable to open64(") != -1 and line.find(",O_RDONLY): No such file or directory") != -1:

                                self.error = self.ERROR_DVDROM
                        elif line.find("media is not recognized as recordable DVD") != -1:
                                self.error = self.ERROR_NOTWRITEABLE
                                self.error = self.ERROR_DVDROM
                        elif line.find("media is not recognized as recordable DVD") != -1:
                                self.error = self.ERROR_NOTWRITEABLE


@@ -315,26 +336,67 @@ class BurnTask(Task):
                        else:
                                self.error = self.ERROR_UNKNOWN
                                print "BurnTask: unknown error %s" % line
                        else:
                                self.error = self.ERROR_UNKNOWN
                                print "BurnTask: unknown error %s" % line

+               elif line.find("-allow-limited-size was not specified. There is no way do represent this file size. Aborting.") != -1:
+                       self.error = self.ERROR_FILETOOLARGE
+               elif line.startswith("genisoimage: File too large."):
+                       self.error = self.ERROR_ISOTOOLARGE
+       
+       def setTool(self, tool):
+               self.cmd = tool
+               self.args = [tool]
+               self.global_preconditions.append(ToolExistsPrecondition())

 
 class RemoveDVDFolder(Task):
        def __init__(self, job):
                Task.__init__(self, job, "Remove temp. files")
                self.setTool("/bin/rm")
                self.args += ["-rf", self.job.workspace]
 
 class RemoveDVDFolder(Task):
        def __init__(self, job):
                Task.__init__(self, job, "Remove temp. files")
                self.setTool("/bin/rm")
                self.args += ["-rf", self.job.workspace]

+               self.weighting = 10

 
 

-class PreviewTask(Task):
+class CheckDiskspaceTask(Task):

        def __init__(self, job):
        def __init__(self, job):

+               Task.__init__(self, job, "Checking free space")
+               totalsize = 0 # require an extra safety 50 MB
+               maxsize = 0
+               for title in job.project.titles:
+                       titlesize = title.estimatedDiskspace
+                       if titlesize > maxsize: maxsize = titlesize
+                       totalsize += titlesize
+               diskSpaceNeeded = totalsize + maxsize
+               job.estimateddvdsize = totalsize / 1024 / 1024
+               totalsize += 50*1024*1024 # require an extra safety 50 MB
+               self.global_preconditions.append(DiskspacePrecondition(diskSpaceNeeded))
+               self.weighting = 5
+
+       def abort(self):
+               self.finish(aborted = True)
+
+       def run(self, callback):
+               failed_preconditions = self.checkPreconditions(True) + self.checkPreconditions(False)
+               if len(failed_preconditions):
+                       callback(self, failed_preconditions)
+                       return
+               self.callback = callback
+               Task.processFinished(self, 0)
+
+class PreviewTask(Task):
+       def __init__(self, job, path):

                Task.__init__(self, job, "Preview")
                self.postconditions.append(PreviewTaskPostcondition())
                self.job = job
                Task.__init__(self, job, "Preview")
                self.postconditions.append(PreviewTaskPostcondition())
                self.job = job

+               self.path = path
+               self.weighting = 10

 
 

-       def run(self, callback, task_progress_changed):
+       def run(self, callback):

                self.callback = callback
                self.callback = callback

-               self.task_progress_changed = task_progress_changed

                if self.job.menupreview:
                        self.previewProject()
                else:
                if self.job.menupreview:
                        self.previewProject()
                else:

-                       self.job.project.session.openWithCallback(self.previewCB, MessageBox, _("Do you want to preview this DVD before burning?"), timeout = 60, default = False)
+                       from Tools import Notifications
+                       Notifications.AddNotificationWithCallback(self.previewCB, MessageBox, _("Do you want to preview this DVD before burning?"), timeout = 60, default = False)
+
+       def abort(self):
+               self.finish(aborted = True)

        
        def previewCB(self, answer):
                if answer == True:
        
        def previewCB(self, answer):
                if answer == True:


@@ -346,17 +408,18 @@ class PreviewTask(Task):
                if self.job.menupreview:
                        self.closedCB(True)
                else:
                if self.job.menupreview:
                        self.closedCB(True)
                else:

-                       self.job.project.session.openWithCallback(self.closedCB, MessageBox, _("Do you want to burn this collection to DVD medium?") )
+                       from Tools import Notifications
+                       Notifications.AddNotificationWithCallback(self.closedCB, MessageBox, _("Do you want to burn this collection to DVD medium?") )

 
        def closedCB(self, answer):
                if answer == True:
                        Task.processFinished(self, 0)
                else:
                        Task.processFinished(self, 1)
 
        def closedCB(self, answer):
                if answer == True:
                        Task.processFinished(self, 0)
                else:
                        Task.processFinished(self, 1)

-               
+

        def previewProject(self):
                from Plugins.Extensions.DVDPlayer.plugin import DVDPlayer
        def previewProject(self):
                from Plugins.Extensions.DVDPlayer.plugin import DVDPlayer

-               self.job.project.session.openWithCallback(self.playerClosed, DVDPlayer, dvd_filelist= [ self.job.project.workspace + "/dvd/VIDEO_TS/" ])
+               self.job.project.session.openWithCallback(self.playerClosed, DVDPlayer, dvd_filelist= [ self.path ])

 
 class PreviewTaskPostcondition(Condition):
        def check(self, task):
 
 class PreviewTaskPostcondition(Condition):
        def check(self, task):


@@ -365,27 +428,6 @@ class PreviewTaskPostcondition(Condition):
        def getErrorMessage(self, task):
                return "Cancel"
 
        def getErrorMessage(self, task):
                return "Cancel"
 

-def formatTitle(template, title, track):
-       template = template.replace("$i", str(track))
-       template = template.replace("$t", title.name)
-       template = template.replace("$d", title.descr)
-       template = template.replace("$c", str(len(title.chaptermarks)+1))
-       template = template.replace("$A", str(title.audiotracks))
-       template = template.replace("$f", title.inputfile)
-       template = template.replace("$C", title.channel)
-       l = title.length
-       lengthstring = "%d:%02d:%02d" % (l/3600, l%3600/60, l%60)
-       template = template.replace("$l", lengthstring)
-       if title.timeCreate:
-               template = template.replace("$Y", str(title.timeCreate[0]))
-               template = template.replace("$M", str(title.timeCreate[1]))
-               template = template.replace("$D", str(title.timeCreate[2]))
-               timestring = "%d:%02d" % (title.timeCreate[3], title.timeCreate[4])
-               template = template.replace("$T", timestring)
-       else:
-               template = template.replace("$Y", "").replace("$M", "").replace("$D", "").replace("$T", "")
-       return template.decode("utf-8")
-

 class ImagingPostcondition(Condition):
        def check(self, task):
                return task.returncode == 0
 class ImagingPostcondition(Condition):
        def check(self, task):
                return task.returncode == 0


@@ -401,9 +443,8 @@ class ImagePrepareTask(Task):
                self.job = job
                self.Menus = job.Menus
                
                self.job = job
                self.Menus = job.Menus
                

-       def run(self, callback, task_progress_changed):                 
+       def run(self, callback):

                self.callback = callback
                self.callback = callback

-               self.task_progress_changed = task_progress_changed

                # we are doing it this weird way so that the TaskView Screen actually pops up before the spinner comes
                from enigma import eTimer
                self.delayTimer = eTimer()
                # we are doing it this weird way so that the TaskView Screen actually pops up before the spinner comes
                from enigma import eTimer
                self.delayTimer = eTimer()


@@ -413,7 +454,7 @@ class ImagePrepareTask(Task):
        def conduct(self):
                try:
                        from ImageFont import truetype
        def conduct(self):
                try:
                        from ImageFont import truetype

-                       from Image import open as Image_open            
+                       from Image import open as Image_open

                        s = self.job.project.settings
                        self.Menus.im_bg_orig = Image_open(s.menubg.getValue())
                        if self.Menus.im_bg_orig.size != (self.Menus.imgwidth, self.Menus.imgheight):
                        s = self.job.project.settings
                        self.Menus.im_bg_orig = Image_open(s.menubg.getValue())
                        if self.Menus.im_bg_orig.size != (self.Menus.imgwidth, self.Menus.imgheight):


@@ -429,7 +470,7 @@ class MenuImageTask(Task):
        def __init__(self, job, menu_count, spuxmlfilename, menubgpngfilename, highlightpngfilename):
                Task.__init__(self, job, "Create Menu %d Image" % menu_count)
                self.postconditions.append(ImagingPostcondition())
        def __init__(self, job, menu_count, spuxmlfilename, menubgpngfilename, highlightpngfilename):
                Task.__init__(self, job, "Create Menu %d Image" % menu_count)
                self.postconditions.append(ImagingPostcondition())

-               self.weighting = 20 
+               self.weighting = 10

                self.job = job
                self.Menus = job.Menus
                self.menu_count = menu_count
                self.job = job
                self.Menus = job.Menus
                self.menu_count = menu_count


@@ -437,9 +478,8 @@ class MenuImageTask(Task):
                self.menubgpngfilename = menubgpngfilename
                self.highlightpngfilename = highlightpngfilename
 
                self.menubgpngfilename = menubgpngfilename
                self.highlightpngfilename = highlightpngfilename
 

-       def run(self, callback, task_progress_changed):
+       def run(self, callback):

                self.callback = callback
                self.callback = callback

-               self.task_progress_changed = task_progress_changed

                try:
                        import ImageDraw, Image, os
                        s = self.job.project.settings
                try:
                        import ImageDraw, Image, os
                        s = self.job.project.settings


@@ -474,14 +514,13 @@ class MenuImageTask(Task):
                                menu_end_title = nr_titles+1
                        menu_i = 0
                        for title_no in range( menu_start_title , menu_end_title ):
                                menu_end_title = nr_titles+1
                        menu_i = 0
                        for title_no in range( menu_start_title , menu_end_title ):

-                               i = title_no-1
-                               top = s_top + ( menu_i * rowheight )

                                menu_i += 1
                                menu_i += 1

-                               title = self.job.project.titles[i]
-                               titleText = formatTitle(s.titleformat.getValue(), title, title_no)
+                               title = self.job.project.titles[title_no-1]
+                               top = s_top + ( menu_i * rowheight )
+                               titleText = title.formatDVDmenuText(s.titleformat.getValue(), title_no).decode("utf-8")

                                draw_bg.text((s_left,top), titleText, fill=self.Menus.color_button, font=fonts[1])
                                draw_high.text((s_left,top), titleText, fill=1, font=self.Menus.fonts[1])
                                draw_bg.text((s_left,top), titleText, fill=self.Menus.color_button, font=fonts[1])
                                draw_high.text((s_left,top), titleText, fill=1, font=self.Menus.fonts[1])

-                               subtitleText = formatTitle(s.subtitleformat.getValue(), title, title_no)
+                               subtitleText = title.formatDVDmenuText(s.subtitleformat.getValue(), title_no).decode("utf-8")

                                draw_bg.text((s_left,top+36), subtitleText, fill=self.Menus.color_button, font=fonts[2])
                                bottom = top+rowheight
                                if bottom > self.Menus.imgheight:
                                draw_bg.text((s_left,top+36), subtitleText, fill=self.Menus.color_button, font=fonts[2])
                                bottom = top+rowheight
                                if bottom > self.Menus.imgheight:


@@ -559,11 +598,11 @@ class Menus:
                        mpeg2encTask(job, job.workspace+"/dvdmenubg"+num+".yuv", menubgm2vfilename)
                        menubgmpgfilename = job.workspace+"/dvdmenubg"+num+".mpg"
                        menuaudiofilename = s.menuaudio.getValue()
                        mpeg2encTask(job, job.workspace+"/dvdmenubg"+num+".yuv", menubgm2vfilename)
                        menubgmpgfilename = job.workspace+"/dvdmenubg"+num+".mpg"
                        menuaudiofilename = s.menuaudio.getValue()

-                       MplexTask(job, outputfile=menubgmpgfilename, inputfiles = [menubgm2vfilename, menuaudiofilename])
+                       MplexTask(job, outputfile=menubgmpgfilename, inputfiles = [menubgm2vfilename, menuaudiofilename], weighting = 20)

                        menuoutputfilename = job.workspace+"/dvdmenu"+num+".mpg"
                        spumuxTask(job, spuxmlfilename, menubgmpgfilename, menuoutputfilename)
                
                        menuoutputfilename = job.workspace+"/dvdmenu"+num+".mpg"
                        spumuxTask(job, spuxmlfilename, menubgmpgfilename, menuoutputfilename)
                

-def CreateAuthoringXML(job):
+def CreateAuthoringXML_singleset(job):

        nr_titles = len(job.project.titles)
        mode = job.project.settings.authormode.getValue()
        authorxml = []
        nr_titles = len(job.project.titles)
        mode = job.project.settings.authormode.getValue()
        authorxml = []


@@ -605,9 +644,7 @@ def CreateAuthoringXML(job):
                authorxml.append('   </menus>\n')
        authorxml.append('   <titles>\n')
        for i in range( nr_titles ):
                authorxml.append('   </menus>\n')
        authorxml.append('   <titles>\n')
        for i in range( nr_titles ):

-               #for audiotrack in job.project.titles[i].audiotracks:
-                       #authorxml.append('    <audio lang="'+audiotrack[0][:2]+'" format="'+audiotrack[1]+'" />\n')
-               chapters = ','.join(["%d:%02d:%02d.%03d" % (p / (90000 * 3600), p % (90000 * 3600) / (90000 * 60), p % (90000 * 60) / 90000, (p % 90000) / 90) for p in job.project.titles[i].chaptermarks])
+               chapters = ','.join(job.project.titles[i].getChapterMarks())

                title_no = i+1
                title_filename = job.workspace + "/dvd_title_%d.mpg" % (title_no)
                if job.menupreview:
                title_no = i+1
                title_filename = job.workspace + "/dvd_title_%d.mpg" % (title_no)
                if job.menupreview:


@@ -633,9 +670,96 @@ def CreateAuthoringXML(job):
                f.write(x)
        f.close()
 
                f.write(x)
        f.close()
 

+def CreateAuthoringXML_multiset(job):
+       nr_titles = len(job.project.titles)
+       mode = job.project.settings.authormode.getValue()
+       authorxml = []
+       authorxml.append('<?xml version="1.0" encoding="utf-8"?>\n')
+       authorxml.append(' <dvdauthor dest="' + (job.workspace+"/dvd") + '" jumppad="yes">\n')
+       authorxml.append('  <vmgm>\n')
+       authorxml.append('   <menus>\n')
+       authorxml.append('    <video aspect="4:3"/>\n')
+       if mode.startswith("menu"):
+               for menu_count in range(1 , job.nr_menus+1):
+                       authorxml.append('    <pgc>\n')
+                       menu_start_title = (menu_count-1)*job.titles_per_menu + 1
+                       menu_end_title = (menu_count)*job.titles_per_menu + 1
+                       if menu_end_title > nr_titles:
+                               menu_end_title = nr_titles+1
+                       for i in range( menu_start_title , menu_end_title ):
+                               authorxml.append('     <button name="button' + (str(i).zfill(2)) + '"> jump titleset ' + str(i) +' title 1; </button>\n')
+                       if menu_count > 1:
+                               authorxml.append('     <button name="button_prev"> jump menu ' + str(menu_count-1) + '; </button>\n')
+                       if menu_count < job.nr_menus:
+                               authorxml.append('     <button name="button_next"> jump menu ' + str(menu_count+1) + '; </button>\n')
+                       menuoutputfilename = job.workspace+"/dvdmenu"+str(menu_count)+".mpg"
+                       authorxml.append('     <vob file="' + menuoutputfilename + '" pause="inf"/>\n')
+                       authorxml.append('    </pgc>\n')
+       else:
+               authorxml.append('    <pgc>\n')
+               authorxml.append('     <vob file="' + job.project.settings.vmgm.getValue() + '" />\n' )
+               authorxml.append('     <post> jump titleset 1 title 1; </post>\n')
+               authorxml.append('    </pgc>\n')
+       authorxml.append('   </menus>\n')
+       authorxml.append('  </vmgm>\n')
+
+       for i in range( nr_titles ):
+               title = job.project.titles[i]
+               authorxml.append('  <titleset>\n')
+               authorxml.append('   <titles>\n')
+               for audiotrack in title.properties.audiotracks:
+                       active = audiotrack.active.getValue()
+                       if active:
+                               format = audiotrack.format.getValue()
+                               language = audiotrack.language.getValue()
+                               audio_tag = '    <audio format="%s"' % format
+                               if language != "nolang":
+                                       audio_tag += ' lang="%s"' % language
+                               audio_tag += ' />\n'
+                               authorxml.append(audio_tag)
+               aspect = title.properties.aspect.getValue()
+               video_tag = '    <video aspect="'+aspect+'"'
+               if title.properties.widescreen.getValue() == "4:3":
+                       video_tag += ' widescreen="'+title.properties.widescreen.getValue()+'"'
+               video_tag += ' />\n'
+               authorxml.append(video_tag)
+               chapters = ','.join(title.getChapterMarks())
+               title_no = i+1
+               title_filename = job.workspace + "/dvd_title_%d.mpg" % (title_no)
+               if job.menupreview:
+                       LinkTS(job, job.project.settings.vmgm.getValue(), title_filename)
+               else:
+                       MakeFifoNode(job, title_no)
+               if mode.endswith("linked") and title_no < nr_titles:
+                       post_tag = "jump titleset %d title 1;" % ( title_no+1 )
+               elif mode.startswith("menu"):
+                       post_tag = "call vmgm menu 1;"
+               else:   post_tag = ""
+
+               authorxml.append('    <pgc>\n')
+               authorxml.append('     <vob file="' + title_filename + '" chapters="' + chapters + '" />\n')
+               authorxml.append('     <post> ' + post_tag + ' </post>\n')
+               authorxml.append('    </pgc>\n')
+               authorxml.append('   </titles>\n')
+               authorxml.append('  </titleset>\n')
+       authorxml.append(' </dvdauthor>\n')
+       f = open(job.workspace+"/dvdauthor.xml", "w")
+       for x in authorxml:
+               f.write(x)
+       f.close()
+
+def getISOfilename(isopath, volName):
+       from Tools.Directories import fileExists
+       i = 0
+       filename = isopath+'/'+volName+".iso"
+       while fileExists(filename):
+               i = i+1
+               filename = isopath+'/'+volName + str(i).zfill(3) + ".iso"
+       return filename
+

 class DVDJob(Job):
        def __init__(self, project, menupreview=False):
 class DVDJob(Job):
        def __init__(self, project, menupreview=False):

-               Job.__init__(self, _("Burn DVD"))
+               Job.__init__(self, "DVDBurn Job")

                self.project = project
                from time import strftime
                from Tools.Directories import SCOPE_HDD, resolveFilename, createDir
                self.project = project
                from time import strftime
                from Tools.Directories import SCOPE_HDD, resolveFilename, createDir


@@ -647,36 +771,45 @@ class DVDJob(Job):
                self.conduct()
 
        def conduct(self):
                self.conduct()
 
        def conduct(self):

+               CheckDiskspaceTask(self)

                if self.project.settings.authormode.getValue().startswith("menu") or self.menupreview:
                        Menus(self)
                if self.project.settings.authormode.getValue().startswith("menu") or self.menupreview:
                        Menus(self)

-               CreateAuthoringXML(self)
-
-               totalsize = 50*1024*1024 # require an extra safety 50 MB
-               maxsize = 0
-               for title in self.project.titles:
-                       titlesize = title.estimatedDiskspace
-                       if titlesize > maxsize: maxsize = titlesize
-                       totalsize += titlesize
-               diskSpaceNeeded = totalsize + maxsize
+               if self.project.settings.titlesetmode.getValue() == "multi":
+                       CreateAuthoringXML_multiset(self)
+               else:
+                       CreateAuthoringXML_singleset(self)

 
 

-               DVDAuthorTask(self, diskSpaceNeeded)
+               DVDAuthorTask(self)

                
                nr_titles = len(self.project.titles)
                
                nr_titles = len(self.project.titles)

-               
+

                if self.menupreview:
                if self.menupreview:

-                       PreviewTask(self)
+                       PreviewTask(self, self.workspace + "/dvd/VIDEO_TS/")

                else:
                        for self.i in range(nr_titles):
                else:
                        for self.i in range(nr_titles):

-                               title = self.project.titles[self.i]
+                               self.title = self.project.titles[self.i]

                                link_name =  self.workspace + "/source_title_%d.ts" % (self.i+1)
                                title_filename = self.workspace + "/dvd_title_%d.mpg" % (self.i+1)
                                link_name =  self.workspace + "/source_title_%d.ts" % (self.i+1)
                                title_filename = self.workspace + "/dvd_title_%d.mpg" % (self.i+1)

-                               LinkTS(self, title.inputfile, link_name)
+                               LinkTS(self, self.title.inputfile, link_name)

                                demux = DemuxTask(self, link_name)
                                demux = DemuxTask(self, link_name)

-                               MplexTask(self, outputfile=title_filename, demux_task=demux)
+                               self.mplextask = MplexTask(self, outputfile=title_filename, demux_task=demux)
+                               self.mplextask.end = self.estimateddvdsize

                                RemoveESFiles(self, demux)
                        WaitForResidentTasks(self)
                                RemoveESFiles(self, demux)
                        WaitForResidentTasks(self)

-                       PreviewTask(self)
-                       BurnTask(self, ["-dvd-video", self.workspace + "/dvd"])
+                       PreviewTask(self, self.workspace + "/dvd/VIDEO_TS/")
+                       output = self.project.settings.output.getValue()
+                       volName = self.project.settings.name.getValue()
+                       if output == "dvd":
+                               self.name = _("Burn DVD")
+                               tool = "/bin/growisofs"
+                               burnargs = [ "-Z", "/dev/" + harddiskmanager.getCD(), "-dvd-compat" ]
+                       elif output == "iso":
+                               self.name = _("Create DVD-ISO")
+                               tool = "/usr/bin/mkisofs"
+                               isopathfile = getISOfilename(self.project.settings.isopath.getValue(), volName)
+                               burnargs = [ "-o", isopathfile ]
+                       burnargs += [ "-dvd-video", "-publisher", "Dreambox", "-V", volName, self.workspace + "/dvd" ]
+                       BurnTask(self, burnargs, tool)

                RemoveDVDFolder(self)
 
 class DVDdataJob(Job):
                RemoveDVDFolder(self)
 
 class DVDdataJob(Job):


@@ -692,31 +825,49 @@ class DVDdataJob(Job):
                self.conduct()
 
        def conduct(self):
                self.conduct()
 
        def conduct(self):

-               diskSpaceNeeded = 50*1024*1024 # require an extra safety 50 MB
-               for title in self.project.titles:
-                       diskSpaceNeeded += title.filesize
+               if self.project.settings.output.getValue() == "iso":
+                       CheckDiskspaceTask(self)

                nr_titles = len(self.project.titles)
                nr_titles = len(self.project.titles)

-

                for self.i in range(nr_titles):
                        title = self.project.titles[self.i]
                        filename = title.inputfile.rstrip("/").rsplit("/",1)[1]
                        link_name =  self.workspace + filename
                        LinkTS(self, title.inputfile, link_name)
                        CopyMeta(self, title.inputfile)
                for self.i in range(nr_titles):
                        title = self.project.titles[self.i]
                        filename = title.inputfile.rstrip("/").rsplit("/",1)[1]
                        link_name =  self.workspace + filename
                        LinkTS(self, title.inputfile, link_name)
                        CopyMeta(self, title.inputfile)

-               BurnTask(self, ["-follow-links", self.workspace])
-               RemoveDVDFolder(self)

 
 

-def Burn(session, project):
-       j = DVDJob(project)
-       job_manager.AddJob(j)
-       return j
-
-def PreviewMenu(session, project):
-       j = DVDJob(project, menupreview=True)
-       job_manager.AddJob(j)
-       return j
+               output = self.project.settings.output.getValue()
+               volName = self.project.settings.name.getValue()
+               tool = "/bin/growisofs"
+               if output == "dvd":
+                       self.name = _("Burn DVD")
+                       burnargs = [ "-Z", "/dev/" + harddiskmanager.getCD(), "-dvd-compat" ]
+               elif output == "iso":
+                       tool = "/usr/bin/mkisofs"
+                       self.name = _("Create DVD-ISO")
+                       isopathfile = getISOfilename(self.project.settings.isopath.getValue(), volName)
+                       burnargs = [ "-o", isopathfile ]
+               if self.project.settings.dataformat.getValue() == "iso9660_1":
+                       burnargs += ["-iso-level", "1" ]
+               elif self.project.settings.dataformat.getValue() == "iso9660_4":
+                       burnargs += ["-iso-level", "4", "-allow-limited-size" ]
+               elif self.project.settings.dataformat.getValue() == "udf":
+                       burnargs += ["-udf", "-allow-limited-size" ]
+               burnargs += [ "-publisher", "Dreambox", "-V", volName, "-follow-links", self.workspace ]
+               BurnTask(self, burnargs, tool)
+               RemoveDVDFolder(self)

 
 

-def BurnDataTS(session, project):
-       j = DVDdataJob(project)
-       job_manager.AddJob(j)
-       return j
+class DVDisoJob(Job):
+       def __init__(self, project, imagepath):
+               Job.__init__(self, _("Burn DVD"))
+               self.project = project
+               self.menupreview = False
+               if imagepath.endswith(".iso"):
+                       PreviewTask(self, imagepath)
+                       burnargs = [ "-Z", "/dev/" + harddiskmanager.getCD() + '='+imagepath, "-dvd-compat" ]
+               else:
+                       PreviewTask(self, imagepath + "/VIDEO_TS/")
+                       volName = self.project.settings.name.getValue()
+                       burnargs = [ "-Z", "/dev/" + harddiskmanager.getCD(), "-dvd-compat" ]
+                       burnargs += [ "-dvd-video", "-publisher", "Dreambox", "-V", volName, imagepath ]
+               tool = "/bin/growisofs"
+               BurnTask(self, burnargs, tool)