fix crash on aborting during CheckDiskspaceTask
[enigma2.git] / lib / python / Plugins / Extensions / DVDBurn / Process.py
index 7a03b7ebd68cdf8c9f54d8ba442f199282f1d6c9..6d9a44918c1ecb9d95dbe4a255488df60fdd757d 100644 (file)
@@ -10,8 +10,8 @@ class png2yuvTask(Task):
                self.dumpFile = outputfile
                self.weighting = 15
 
-       def run(self, callback, task_progress_changed):
-               Task.run(self, callback, task_progress_changed)
+       def run(self, callback):
+               Task.run(self, callback)
                self.container.stdoutAvail.remove(self.processStdout)
                self.container.dumpToFile(self.dumpFile)
 
@@ -26,8 +26,8 @@ class mpeg2encTask(Task):
                self.inputFile = inputfile
                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):
@@ -42,8 +42,8 @@ class spumuxTask(Task):
                self.dumpFile = outputfile
                self.weighting = 15
 
-       def run(self, callback, task_progress_changed):
-               Task.run(self, callback, task_progress_changed)
+       def run(self, callback):
+               Task.run(self, callback)
                self.container.stdoutAvail.remove(self.processStdout)
                self.container.dumpToFile(self.dumpFile)
                self.container.readFromFile(self.inputFile)
@@ -85,23 +85,34 @@ class DemuxTask(Task):
                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.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()
 
+       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] "
+               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):]
@@ -111,10 +122,14 @@ class DemuxTask(Task):
                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):
-               print "PRODUCED FILE [%s]" % file
+               print "[DemuxTask] produced file:", file, self.currentPID
                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
@@ -131,7 +146,6 @@ class DemuxTask(Task):
                                if p > self.progress:
                                        self.progress = p
                        except ValueError:
-                               print "val error"
                                pass
 
        def writeCutfile(self):
@@ -151,8 +165,8 @@ class DemuxTask(Task):
        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):
@@ -185,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):
-               self.error = None                       
+               self.error = None
                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]
@@ -212,7 +226,7 @@ class RemoveESFiles(Task):
 class DVDAuthorTask(Task):
        def __init__(self, job):
                Task.__init__(self, job, "Authoring DVD")
-               self.weighting = 300
+               self.weighting = 20
                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)
+               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):
@@ -233,7 +255,7 @@ class WaitForResidentTasks(Task):
        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, [])
@@ -241,7 +263,11 @@ class WaitForResidentTasks(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 {
@@ -257,7 +283,7 @@ class BurnTaskPostcondition(Condition):
                }[task.error]
 
 class BurnTask(Task):
-       ERROR_NOTWRITEABLE, ERROR_LOAD, ERROR_SIZE, ERROR_WRITE_FAILED, ERROR_DVDROM, ERROR_ISOFS, ERROR_FILETOOLARGE, ERROR_ISOTOOLARGE, ERROR_UNKNOWN = range(9)
+       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
@@ -284,12 +310,17 @@ class BurnTask(Task):
                                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
+                       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("unable to open64(") != -1 and line.find(",O_RDONLY): No such file or directory") != -1:
@@ -309,6 +340,11 @@ class BurnTask(Task):
                        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):
@@ -320,23 +356,27 @@ class RemoveDVDFolder(Task):
 class CheckDiskspaceTask(Task):
        def __init__(self, job):
                Task.__init__(self, job, "Checking free space")
-               totalsize = 50*1024*1024 # require an extra safety 50 MB
+               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 run(self, callback, task_progress_changed):
+       def abort(self):
+               self.finish(aborted = True)
+
+       def run(self, callback):
+               self.callback = callback
                failed_preconditions = self.checkPreconditions(True) + self.checkPreconditions(False)
                if len(failed_preconditions):
                        callback(self, failed_preconditions)
                        return
-               self.callback = callback
-               self.task_progress_changed = task_progress_changed
                Task.processFinished(self, 0)
 
 class PreviewTask(Task):
@@ -347,9 +387,8 @@ class PreviewTask(Task):
                self.path = path
                self.weighting = 10
 
-       def run(self, callback, task_progress_changed):
+       def run(self, callback):
                self.callback = callback
-               self.task_progress_changed = task_progress_changed
                if self.job.menupreview:
                        self.previewProject()
                else:
@@ -389,27 +428,6 @@ class PreviewTaskPostcondition(Condition):
        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
@@ -425,9 +443,8 @@ class ImagePrepareTask(Task):
                self.job = job
                self.Menus = job.Menus
                
-       def run(self, callback, task_progress_changed):                 
+       def run(self, 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()
@@ -437,14 +454,14 @@ class ImagePrepareTask(Task):
        def conduct(self):
                try:
                        from ImageFont import truetype
-                       from Image import open as Image_open            
-                       s = self.job.project.settings
+                       from Image import open as Image_open
+                       s = self.job.project.menutemplate.settings
+                       (width, height) = s.dimensions.getValue()
                        self.Menus.im_bg_orig = Image_open(s.menubg.getValue())
-                       if self.Menus.im_bg_orig.size != (self.Menus.imgwidth, self.Menus.imgheight):
-                               self.Menus.im_bg_orig = self.Menus.im_bg_orig.resize((720, 576))        
-                       self.Menus.fontsizes = s.font_size.getValue()
-                       fontface = s.font_face.getValue()
-                       self.Menus.fonts = [truetype(fontface, self.Menus.fontsizes[0]), truetype(fontface, self.Menus.fontsizes[1]), truetype(fontface, self.Menus.fontsizes[2])]
+                       if self.Menus.im_bg_orig.size != (width, height):
+                               self.Menus.im_bg_orig = self.Menus.im_bg_orig.resize((width, height))
+                       self.Menus.fontsizes = [s.fontsize_headline.getValue(), s.fontsize_title.getValue(), s.fontsize_subtitle.getValue()]
+                       self.Menus.fonts = [(truetype(s.fontface_headline.getValue(), self.Menus.fontsizes[0])), (truetype(s.fontface_title.getValue(), self.Menus.fontsizes[1])),(truetype(s.fontface_subtitle.getValue(), self.Menus.fontsizes[2]))]
                        Task.processFinished(self, 0)
                except:
                        Task.processFinished(self, 1)
@@ -461,102 +478,160 @@ class MenuImageTask(Task):
                self.menubgpngfilename = menubgpngfilename
                self.highlightpngfilename = highlightpngfilename
 
-       def run(self, callback, task_progress_changed):
+       def run(self, callback):
                self.callback = callback
-               self.task_progress_changed = task_progress_changed
-               try:
-                       import ImageDraw, Image, os
-                       s = self.job.project.settings
-                       fonts = self.Menus.fonts
-                       im_bg = self.Menus.im_bg_orig.copy()
-                       im_high = Image.new("P", (self.Menus.imgwidth, self.Menus.imgheight), 0)
-                       im_high.putpalette(self.Menus.spu_palette)
-                       draw_bg = ImageDraw.Draw(im_bg)
-                       draw_high = ImageDraw.Draw(im_high)
-                       if self.menu_count == 1:
-                               headline = s.name.getValue().decode("utf-8")
-                               textsize = draw_bg.textsize(headline, font=fonts[0])
-                               if textsize[0] > self.Menus.imgwidth:
-                                       offset = (0 , 20)
-                               else:
-                                       offset = (((self.Menus.imgwidth-textsize[0]) / 2) , 20)
-                               draw_bg.text(offset, headline, fill=self.Menus.color_headline, font=fonts[0])
-                       spuxml = """<?xml version="1.0" encoding="utf-8"?>
-               <subpictures>
-               <stream>
-               <spu 
-               highlight="%s"
-               transparent="%02x%02x%02x"
-               start="00:00:00.00"
-               force="yes" >""" % (self.highlightpngfilename, self.Menus.spu_palette[0], self.Menus.spu_palette[1], self.Menus.spu_palette[2])
-                       s_top, s_rows, s_left = s.space.getValue()
-                       rowheight = (self.Menus.fontsizes[1]+self.Menus.fontsizes[2]+s_rows)
-                       menu_start_title = (self.menu_count-1)*self.job.titles_per_menu + 1
-                       menu_end_title = (self.menu_count)*self.job.titles_per_menu + 1
-                       nr_titles = len(self.job.project.titles)
-                       if menu_end_title > nr_titles:
-                               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
-                               title = self.job.project.titles[i]
-                               titleText = formatTitle(s.titleformat.getValue(), title, title_no)
-                               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)
-                               draw_bg.text((s_left,top+36), subtitleText, fill=self.Menus.color_button, font=fonts[2])
-                               bottom = top+rowheight
-                               if bottom > self.Menus.imgheight:
-                                       bottom = self.Menus.imgheight
-                               spuxml += """
-               <button name="button%s" x0="%d" x1="%d" y0="%d" y1="%d"/>""" % (str(title_no).zfill(2),s_left,self.Menus.imgwidth,top,bottom )
-                       if self.menu_count < self.job.nr_menus:
-                               next_page_text = ">>>"
-                               textsize = draw_bg.textsize(next_page_text, font=fonts[1])
-                               offset = ( self.Menus.imgwidth-textsize[0]-2*s_left, s_top + ( self.job.titles_per_menu * rowheight ) )
-                               draw_bg.text(offset, next_page_text, fill=self.Menus.color_button, font=fonts[1])
-                               draw_high.text(offset, next_page_text, fill=1, font=fonts[1])
-                               spuxml += """
-               <button name="button_next" x0="%d" x1="%d" y0="%d" y1="%d"/>""" % (offset[0],offset[0]+textsize[0],offset[1],offset[1]+textsize[1])
-                       if self.menu_count > 1:
-                               prev_page_text = "<<<"
-                               textsize = draw_bg.textsize(prev_page_text, font=fonts[1])
-                               offset = ( 2*s_left, s_top + ( self.job.titles_per_menu * rowheight ) )
-                               draw_bg.text(offset, prev_page_text, fill=self.Menus.color_button, font=fonts[1])
-                               draw_high.text(offset, prev_page_text, fill=1, font=fonts[1])
-                               spuxml += """
-               <button name="button_prev" x0="%d" x1="%d" y0="%d" y1="%d"/>""" % (offset[0],offset[0]+textsize[0],offset[1],offset[1]+textsize[1])
-                       del draw_bg
-                       del draw_high
-                       fd=open(self.menubgpngfilename,"w")
-                       im_bg.save(fd,"PNG")
-                       fd.close()
-                       fd=open(self.highlightpngfilename,"w")
-                       im_high.save(fd,"PNG")
-                       fd.close()
+               #try:
+               import ImageDraw, Image, os
+               s = self.job.project.menutemplate.settings
+               s_top = s.margin_top.getValue()
+               s_bottom = s.margin_bottom.getValue()
+               s_left = s.margin_left.getValue()
+               s_right = s.margin_right.getValue()
+               s_rows = s.space_rows.getValue()
+               s_cols = s.space_cols.getValue()
+               nr_cols = s.cols.getValue()
+               nr_rows = s.rows.getValue()
+               thumb_size = s.thumb_size.getValue()
+               if thumb_size[0]:
+                       from Image import open as Image_open
+               (s_width, s_height) = s.dimensions.getValue()
+               fonts = self.Menus.fonts
+               im_bg = self.Menus.im_bg_orig.copy()
+               im_high = Image.new("P", (s_width, s_height), 0)
+               im_high.putpalette(self.Menus.spu_palette)
+               draw_bg = ImageDraw.Draw(im_bg)
+               draw_high = ImageDraw.Draw(im_high)
+               if self.menu_count == 1:
+                       headlineText = self.job.project.settings.name.getValue().decode("utf-8")
+                       headlinePos = self.getPosition(s.offset_headline.getValue(), 0, 0, s_width, s_top, draw_bg.textsize(headlineText, font=fonts[0]))
+                       draw_bg.text(headlinePos, headlineText, fill=self.Menus.color_headline, font=fonts[0])
+               spuxml = """<?xml version="1.0" encoding="utf-8"?>
+       <subpictures>
+       <stream>
+       <spu 
+       highlight="%s"
+       transparent="%02x%02x%02x"
+       start="00:00:00.00"
+       force="yes" >""" % (self.highlightpngfilename, self.Menus.spu_palette[0], self.Menus.spu_palette[1], self.Menus.spu_palette[2])
+               #rowheight = (self.Menus.fontsizes[1]+self.Menus.fontsizes[2]+thumb_size[1]+s_rows)
+               menu_start_title = (self.menu_count-1)*self.job.titles_per_menu + 1
+               menu_end_title = (self.menu_count)*self.job.titles_per_menu + 1
+               nr_titles = len(self.job.project.titles)
+               if menu_end_title > nr_titles:
+                       menu_end_title = nr_titles+1
+               col = 1
+               row = 1
+               for title_no in range( menu_start_title , menu_end_title ):
+                       title = self.job.project.titles[title_no-1]
+                       col_width  = ( s_width  - s_left - s_right  ) / nr_cols
+                       row_height = ( s_height - s_top  - s_bottom ) / nr_rows
+                       left =   s_left + ( (col-1) * col_width ) + s_cols/2
+                       right =    left + col_width - s_cols
+                       top =     s_top + ( (row-1) * row_height) + s_rows/2
+                       bottom =    top + row_height - s_rows
+                       width = right - left
+                       height = bottom - top
+
+                       if bottom > s_height:
+                               bottom = s_height
+                       #draw_bg.rectangle((left, top, right, bottom), outline=(255,0,0))
+                       im_cell_bg = Image.new("RGBA", (width, height),(0,0,0,0))
+                       draw_cell_bg = ImageDraw.Draw(im_cell_bg)
+                       im_cell_high = Image.new("P", (width, height), 0)
+                       im_cell_high.putpalette(self.Menus.spu_palette)
+                       draw_cell_high = ImageDraw.Draw(im_cell_high)
+
+                       if thumb_size[0]:
+                               thumbPos = self.getPosition(s.offset_thumb.getValue(), 0, 0, width, height, thumb_size)
+                               box = (thumbPos[0], thumbPos[1], thumbPos[0]+thumb_size[0], thumbPos[1]+thumb_size[1])
+                               try:
+                                       thumbIm = Image_open(title.inputfile.rsplit('.',1)[0] + ".png")
+                                       im_cell_bg.paste(thumbIm,thumbPos)
+                               except:
+                                       draw_cell_bg.rectangle(box, fill=(64,127,127,127))
+                               border = s.thumb_border.getValue()
+                               if border:
+                                       draw_cell_high.rectangle(box, fill=1)
+                                       draw_cell_high.rectangle((box[0]+border, box[1]+border, box[2]-border, box[3]-border), fill=0)
+
+                       titleText = title.formatDVDmenuText(s.titleformat.getValue(), title_no).decode("utf-8")
+                       titlePos = self.getPosition(s.offset_title.getValue(), 0, 0, width, height, draw_bg.textsize(titleText, font=fonts[1]))
+
+                       draw_cell_bg.text(titlePos, titleText, fill=self.Menus.color_button, font=fonts[1])
+                       draw_cell_high.text(titlePos, titleText, fill=1, font=self.Menus.fonts[1])
+                       
+                       subtitleText = title.formatDVDmenuText(s.subtitleformat.getValue(), title_no).decode("utf-8")
+                       subtitlePos = self.getPosition(s.offset_subtitle.getValue(), 0, 0, width, height, draw_cell_bg.textsize(subtitleText, font=fonts[2]))
+                       draw_cell_bg.text(subtitlePos, subtitleText, fill=self.Menus.color_button, font=fonts[2])
+
+                       del draw_cell_bg
+                       del draw_cell_high
+                       im_bg.paste(im_cell_bg,(left, top, right, bottom), mask=im_cell_bg)
+                       im_high.paste(im_cell_high,(left, top, right, bottom))
+
                        spuxml += """
-               </spu>
-               </stream>
-               </subpictures>"""
-       
-                       f = open(self.spuxmlfilename, "w")
-                       f.write(spuxml)
-                       f.close()
-                       Task.processFinished(self, 0)
-               except:
-                       Task.processFinished(self, 1)
+       <button name="button%s" x0="%d" x1="%d" y0="%d" y1="%d"/>""" % (str(title_no).zfill(2),left,right,top,bottom )
+                       if col < nr_cols:
+                               col += 1
+                       else:
+                               col = 1
+                               row += 1
+
+               top = s_height - s_bottom - s_rows/2
+               if self.menu_count < self.job.nr_menus:
+                       next_page_text = s.next_page_text.getValue().decode("utf-8")
+                       textsize = draw_bg.textsize(next_page_text, font=fonts[1])
+                       pos = ( s_width-textsize[0]-s_right, top )
+                       draw_bg.text(pos, next_page_text, fill=self.Menus.color_button, font=fonts[1])
+                       draw_high.text(pos, next_page_text, fill=1, font=fonts[1])
+                       spuxml += """
+       <button name="button_next" x0="%d" x1="%d" y0="%d" y1="%d"/>""" % (pos[0],pos[0]+textsize[0],pos[1],pos[1]+textsize[1])
+               if self.menu_count > 1:
+                       prev_page_text = s.prev_page_text.getValue().decode("utf-8")
+                       textsize = draw_bg.textsize(prev_page_text, font=fonts[1])
+                       pos = ( (s_left+s_cols/2), top )
+                       draw_bg.text(pos, prev_page_text, fill=self.Menus.color_button, font=fonts[1])
+                       draw_high.text(pos, prev_page_text, fill=1, font=fonts[1])
+                       spuxml += """
+       <button name="button_prev" x0="%d" x1="%d" y0="%d" y1="%d"/>""" % (pos[0],pos[0]+textsize[0],pos[1],pos[1]+textsize[1])
+               del draw_bg
+               del draw_high
+               fd=open(self.menubgpngfilename,"w")
+               im_bg.save(fd,"PNG")
+               fd.close()
+               fd=open(self.highlightpngfilename,"w")
+               im_high.save(fd,"PNG")
+               fd.close()
+               spuxml += """
+       </spu>
+       </stream>
+       </subpictures>"""
+
+               f = open(self.spuxmlfilename, "w")
+               f.write(spuxml)
+               f.close()
+               Task.processFinished(self, 0)
+               #except:
+                       #Task.processFinished(self, 1)
+                       
+       def getPosition(self, offset, left, top, right, bottom, size):
+               pos = [left, top]
+               if offset[0] != -1:
+                       pos[0] += offset[0]
+               else:
+                       pos[0] += ( (right-left) - size[0] ) / 2
+               if offset[1] != -1:
+                       pos[1] += offset[1]
+               else:
+                       pos[1] += ( (bottom-top) - size[1] ) / 2
+               return tuple(pos)
 
 class Menus:
        def __init__(self, job):
                self.job = job
                job.Menus = self
-               
-               s = self.job.project.settings
 
-               self.imgwidth = 720
-               self.imgheight = 576
+               s = self.job.project.menutemplate.settings
 
                self.color_headline = tuple(s.color_headline.getValue())
                self.color_button = tuple(s.color_button.getValue())
@@ -565,10 +640,9 @@ class Menus:
 
                ImagePrepareTask(job)
                nr_titles = len(job.project.titles)
-               if nr_titles < 6:
-                       job.titles_per_menu = 5
-               else:
-                       job.titles_per_menu = 4
+               
+               job.titles_per_menu = s.cols.getValue()*s.rows.getValue()
+
                job.nr_menus = ((nr_titles+job.titles_per_menu-1)/job.titles_per_menu)
 
                #a new menu_count every 4 titles (1,2,3,4->1 ; 5,6,7,8->2 etc.)
@@ -587,7 +661,7 @@ class Menus:
                        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 = []
@@ -629,9 +703,7 @@ def CreateAuthoringXML(job):
                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:
@@ -657,6 +729,84 @@ def CreateAuthoringXML(job):
                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
@@ -683,7 +833,10 @@ class DVDJob(Job):
                CheckDiskspaceTask(self)
                if self.project.settings.authormode.getValue().startswith("menu") or self.menupreview:
                        Menus(self)
-               CreateAuthoringXML(self)
+               if self.project.settings.titlesetmode.getValue() == "multi":
+                       CreateAuthoringXML_multiset(self)
+               else:
+                       CreateAuthoringXML_singleset(self)
 
                DVDAuthorTask(self)
                
@@ -693,12 +846,13 @@ class DVDJob(Job):
                        PreviewTask(self, self.workspace + "/dvd/VIDEO_TS/")
                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)
-                               LinkTS(self, title.inputfile, link_name)
+                               LinkTS(self, self.title.inputfile, 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)
                        PreviewTask(self, self.workspace + "/dvd/VIDEO_TS/")