Changeset 1797 for CodeSnippets/VideoTools/eac3to.py

Timestamp:

11/14/08 17:48:21 (16 months ago)

Author:

JensDiemer

Message:

CodeSnippets/VideoTools?: many updates for eac3to.py

Files:

• CodeSnippets/VideoTools/eac3to.py (modified) (10 diffs)

CodeSnippets/VideoTools/eac3to.py

@@ -5 +5 @@
 """
 
-import os, sys, time, datetime, subprocess, logging
+import os, sys, glob, time, datetime, subprocess, logging
+from pprint import pprint
+
+import Tkinter as tk
 
 import win32api
 
 from shared.config import VideoToolsConfig
-from shared.tools import askopenfilename2, askdirectory2
+from shared.tk_tools import askopenfilename2, askdirectory2, TkListbox
+from shared.tools import make_slug, human_filesize
 
 DEBUG = False
@@ -16 +20 @@
 
 
-class StreamInfo(object):
-    def __init__(self, filename, txt_filter, parameter=[]):
-        self.filename = filename
-        self.txt_filter = txt_filter
-        self.parameter = parameter
+VIDEO_EXT = ".mkv" # ToDo: Should go into the config
+
+STREAMINFOS = [
+    {
+        "txt_filter": ("Chapters",),
+        "ext": ".txt",
+    },
+    {
+        "txt_filter": ("h264", "VC-1", "MPEG2",),
+        "ext": VIDEO_EXT
+    },
+    {
+        "txt_filter": ("DTS Hi-Res",),
+        "ext": ".dtshr",
+    },
+    {
+        "txt_filter": ("DTS",),
+        "ext": ".dts",
+    },
+    {
+        "txt_filter": ("Subtitle",),
+        "ext": ".sup",
+    },
+]
+
+
+
+class Drive(dict):
+    def __init__(self, driveletter, cfg):
+        self["letter"] = driveletter
+        self.cfg = cfg
+
+        self["vol_info"] = None
+        self["lable"] = None
+
+        self["stream_dir"] = os.path.join(driveletter, cfg["stream_dir"])
+
+    def set_vol_info(self, vol_info):
+        self["vol_info"] = vol_info
+        self["lable"] = vol_info[0]
+        
+    def debug(self):
+        print "_"*79
+        print "Drive debug:"
+        pprint(self)
+        print "-"*79
 
     def __str__(self):
-        return "<StreamInfo %s (%s)>" % (
-            self.filename, self.parameter
+        return "<Drive '%s'>" % self["letter"]
+#    def __repr__(self):
+#        return self.__str__()
+
+
+
+
+
+
+
+
+class VideoFile(dict):
+    def __init__(self, name, drive, abs_path, stat, cfg):
+        self["name"] = name # Filename
+
+        self["fn"], self.ext = os.path.splitext(self["name"])
+
+        self["drive"] = drive # class "Drive"
+        self["abs_path"] = abs_path # File path + filename
+        self["stat"] = stat # os.stat
+        
+        self.cfg = cfg
+
+        self["out_path"] = os.path.join(cfg["out_dir"], drive["lable"])
+
+        self["name_prefix"] = self["name"].replace(".", "_")
+
+        self["eac3to_txt_path"] = os.path.join(
+            self["out_path"],
+            "%s_eac3to.txt" % self["name_prefix"]
         )
-    def __repr__(self):
-        return self.__str__()
-
-
-VIDEO_EXT = "mkv" # ToDo: Should go into the config
-
-STREAMINFOS = [
-    StreamInfo(
-        filename = "chapters.txt",
-        txt_filter = ("Chapters",),
-    ),
-    StreamInfo(
-        filename = "h264."+VIDEO_EXT,
-        txt_filter = ("h264",),
-    ),
-    StreamInfo(
-        filename = "VC1."+VIDEO_EXT,
-        txt_filter = ("VC-1",),
-    ),
-    StreamInfo(
-        filename = "MPEG2."+VIDEO_EXT,
-        txt_filter = ("MPEG2",),
-    ),
-    StreamInfo(
-        filename = "ger 384KBits.ac3",
-        txt_filter = ("German",),
-        parameter = ["-384", "-down6", "-quality=4"],
-    ),
-]
-
-
-
-class Drive(object):
-    def __init__(self, driveletter, cfg):
-        self.letter = driveletter
-        self.cfg = cfg
-
-        self.vol_info = None
-        self.lable = None
-
-        self.stream_dir = os.path.join(driveletter, cfg["stream_dir"])
-
-    def set_vol_info(self, vol_info):
-        self.vol_info = vol_info
-        self.lable = vol_info[0]
-
-    def __str__(self):
-        return "<Drive '%s'>" % self.letter
-    def __repr__(self):
-        return self.__str__()
-
-
-class Files(list):
-    def print_info(self):
-        for file in self:
-            print file.abs_path,
-            size = file.stat.st_size/1024.0/1024.0/1024.0
-            print "%.1f GB" % size
-            print "output path....:", file.output_path
-            print "log file path..:", file.log_file_path
-            print
-
-
-
-
-
-
-
-
-
-
-class VideoFile(object):
-    def __init__(self, name, drive, abs_path, stat, cfg):
-        self.name = name # Filename
-
-        self.fn, self.ext = os.path.splitext(self.name)
-
-        self.drive = drive # class "Drive"
-        self.abs_path = abs_path # File path + filename
-        self.stat = stat # os.stat
-        
-        self.cfg = cfg
-
-        self.output_path = os.path.join(cfg["out_dir"], drive.lable)
-
-        log_fn = "%s.log" % self.name.replace(".", "_")
-        self.log_file_path = os.path.join(self.output_path, log_fn)
-
-        self.streams = None # set in self.parse_streaminfo()
+
+        self["log_file_path"] = os.path.join(
+            self["out_path"],
+            "%s.log" % self["name_prefix"]
+        )
+        self.log_file = file(self["log_file_path"], "a")
+        self.log("Start logging")
+
+        self["streams"] = None # set in self.parse_streaminfo()
 
     def create_outdir(self):
-        if not os.path.isdir(self.output_path):
-            os.makedirs(self.output_path)
+        if not os.path.isdir(self["out_path"]):
+            os.makedirs(self["out_path"])
 
     #-------------------------------------------------------------------------
-
-    def open_log(self):
-        """
-        Open the log file
-        """
-        self.log_file = file(self.log_file_path, "a")
-        self.log("Start logging")
 
     def log(self, txt):
@@ -140 +126 @@
     #-------------------------------------------------------------------------
 
-    def get_command(self):
-        cmds = [self.cfg["eac3to"], self.abs_path]
-        for no, stream in self.streams:
-            #~ print stream
-            out_name = "%s_%s" % (self.fn, stream.filename)
-            out_fn = os.path.join(self.output_path, out_name)
-            cmds.append("%s: %s" % (no, out_fn))
-
-            if stream.parameter:
-                cmds += stream.parameter
-
-        return " ".join(cmds)
-
-    def parse_line(self, no, info):
-        def in_list(txt, l):
-            for item in l:
-                if item in txt:
-                    return True
-            return False
-
-        for stream_info in STREAMINFOS:
-            if in_list(info, stream_info.txt_filter):
-                self.streams.append([no, stream_info])
+    def get_command(self, stream_selection):
+        cmd = [self.cfg["eac3to"], self["abs_path"]]
+        
+        value_dict = {}
+        for k,v in self["streams"].iteritems():
+#            print k,v
+            if v not in value_dict:
+                value_dict[v] = []
+        
+            value_dict[v].append(k)
+        
+#        pprint(value_dict)
+
+        def get_file_ext(stream_txt):
+            def in_list(txt, l):
+                for item in l:
+                    if item in txt:
+                        return True
+                return False
+            
+            for stream_info in STREAMINFOS:
+                if in_list(stream_txt, stream_info["txt_filter"]):
+                    return stream_info["ext"]
+                
+            raise RuntimeError(
+                "No STREAMINFOS entry matched for '%s'" % stream_txt
+            )
+        
+        selected_streams = {}
+        for stream_txt in stream_selection:
+            try:
+                ids = value_dict[stream_txt]
+            except KeyError:
+                print "Stream '%s' doesn't exist. Skip file." % stream_txt
                 return
+            
+            file_ext = get_file_ext(stream_txt)
+            
+            for id in ids:
+                filename = "%s - %i - %s%s" % (
+                    self["name_prefix"],
+                    id,
+                    make_slug(stream_txt),
+                    file_ext,
+                )
+                out_filepath = os.path.join(self["out_path"], filename)
+                
+                cmd.append("%i:" % id)
+                cmd.append(out_filepath)
+                        
+        return cmd
 
 
     def parse_streaminfo(self, txt):
-        self.streams = []
+        self["streams"] = {}
         lines = txt.splitlines()
         lines = lines[1:]
         for line in lines:
-            #~ print ">", line
+            if DEBUG:
+                print ">", line
             no, info = line.split(":",1)
-            no = int(no)
+            
+            try:
+                no = int(no)
+            except ValueError:
+                continue
+            
             info = info.strip()
-            if info.startswith("Subtitle"):
-                # Skip all subtitle streams
-                continue
-
-            self.parse_line(no, info)
-
+            
+            self["streams"][no] = info
+ 
 
     def get_stream_info(self):
-        cmd = [self.cfg["eac3to"], self.abs_path]
-        print "run '%s'..." % " ".join(cmd)
-        process, output = subprocess2(cmd)
-        return process, output
+        """
+        Run eac3to and cache the output data.
+        """
+        if os.path.isfile(self["eac3to_txt_path"]):
+            print "Use existing eac3to output from cache file '%s'..." % (
+                self["eac3to_txt_path"]
+            )
+            f = file(self["eac3to_txt_path"], "r")
+            output = f.read()
+            f.close()
+        else:
+            # run eac3to and save the output data into self["eac3to_txt_path"]
+            cmd = [self.cfg["eac3to"], self["abs_path"]]
+            print "run '%s'..." % " ".join(cmd)
+            process, output = subprocess2(cmd)
+            
+            f = file(self["eac3to_txt_path"], "w")
+            f.write(output)
+            f.close()
+            
+        return output
 
     #-------------------------------------------------------------------------
+    
+    def debug(self):
+        print "_"*79
+        print "VideoFile debug:"
+        pprint(self)
+        print "-"*79
 
     def __str__(self):
-        return "<File '%s'>" % self.abs_path
-    def __repr__(self):
-        return self.__str__()
-
-
-
+        return "<File '%s'>" % self["abs_path"]
+
+
+#------------------------------------------------------------------------------
 
 
@@ -217 +254 @@
             continue
 
-        if os.path.isdir(drive.stream_dir):
+        if os.path.isdir(drive["stream_dir"]):
             drive.set_vol_info(vol_info)
             result.append(drive)
@@ -225 +262 @@
 
 
+def choose_drive(cfg):
+    """
+    Choose a stream dir manuely.
+    """
+    path = askopenfilename2(
+        title = "Choose the stream dir:",
+        initialdir = cfg["last sourcedir"],
+        filetypes = [('M2TS File','*.m2ts')],
+    )
+    
+    vol_info = path.replace("\\", "_").replace(":","_") # Fallback
+    for part in reversed(path.split(os.sep)[:-1]):
+        # Use the last part of the path as a vol_info
+        if part.upper() not in ("BDMV", "STREAM"):
+            vol_info = part
+            break
+    
+    drive = Drive(os.path.splitdrive(path)[0], cfg)
+    drive["stream_dir"] = os.path.split(path)[0]
+    drive.set_vol_info((vol_info,))
+    
+    drive.debug()
+    
+    drives = [drive,]
+    
+    cfg["last sourcedir"] = path
+    
+    return drives
+
+
+#------------------------------------------------------------------------------
+
 
 def get_stream_files(drives, skip_size):
-    files = Files()
+    files = []
     for drive in drives:
         print drive,
-        path = drive.stream_dir
+        path = drive["stream_dir"]
         print path
         if not os.path.isdir(path):
@@ -236 +305 @@
             continue
         
-        for fn in sorted(os.listdir(path)):
-            abs_path = os.path.join(path, fn)
+        glob_path = os.path.join(path, cfg["glob"])
+        print "Looking in", glob_path
+        file_list = glob.glob(glob_path)
+        print "Files found:", file_list
+        for abs_path in sorted(file_list):
+            filename = os.path.basename(abs_path)
+            
             stat = os.stat(abs_path)
-            size = stat.st_size
-            if size<cfg["skip_size"]:
-                # Skip small files
-                continue
-
-            f = VideoFile(fn, drive, abs_path, stat, cfg)
+
+#            print (filename, drive, abs_path, stat, cfg)
+            f = VideoFile(filename, drive, abs_path, stat, cfg)
             files.append(f)
 
@@ -263 +334 @@
 
 
+def select_videofiles(videofiles):
+    """
+    Select witch founded files should be recordnized.
+    """
+    activated = []
+    item_list = []
+    for index, videofile in enumerate(videofiles):
+        filesize = videofile["stat"].st_size
+        
+        line = "%s - %s" % (videofile["abs_path"], human_filesize(filesize))
+        item_list.append(line)
+        
+        if filesize>cfg["skip_size"]:
+            activated.append(index)
+    
+#    size = stat.st_size
+#    if size<cfg["skip_size"]:
+#        # Skip small files
+#        continue  
+    
+    lb = TkListbox(
+        title = "Please select",
+        lable = "Please select files witch should be converted:",
+        items = item_list,
+        activated = activated
+    )
+    print "selected items:"
+    pprint(lb.selection) # list of selected items.
+    
+    curselection = lb.curselection # tuple containing index of selected items
+    print "curselection:", curselection      
+        
+    new_list = [
+        item
+        for index, item in enumerate(videofiles)
+        if index in curselection
+    ]
+
+    return new_list
+
+
+
+
 
 def subprocess2(cmd):
+    print "_"*80
+    print "subprocess2():"
+    pprint(cmd)
+    print " -"*40
     process = subprocess.Popen(
         cmd,
@@ -294 +412 @@
     return process, output
 
-
+    
+def select_streams(videofiles):
+    """
+    select witch streams should be convert.
+    """
+    print "*"*79
+    streams_txt = []
+    for videofile in videofiles:
+#        videofile.debug()
+        for stream_txt in videofile["streams"].values():
+            if not stream_txt in streams_txt:
+                streams_txt.append(stream_txt)
+#    
+#    lb = TkListbox(
+#        title = "Please select",
+#        lable = "Please select streams:",
+#        items = streams_txt
+#    )
+#    print lb.selection
+    
+    selection = TkListbox(
+        title = "Please select",
+        lable = "Please select streams:",
+        items = streams_txt
+    ).selection
+    
+    return selection
+
+def convert_streams(videofile, stream_selection):
+    print "convert_streams():", videofile, stream_selection
+    videofile.debug()
+    
+    
 
 
@@ -304 +454 @@
         print "DEBUG!!!"
         drive = Drive("d:", cfg)
-        drive.stream_dir = r"d:\TEST\BDMV\STREAM"
+        drive["stream_dir"] = r"d:\TEST\BDMV\STREAM"
         drive.set_vol_info(("TEST_LABLE",))
         drives = [drive,]
@@ -313 +463 @@
 
     if not drives:
-        print "No drives with stream files found -> abort, ok."
-        sys.exit()
-
-    files = get_stream_files(drives, cfg)
-    files.print_info()
-    
-    if not files:
+        print "No drives with stream files found -> choose manuel"
+        drives = choose_drive(cfg)
+
+    # Get from all path all m2ts files
+    videofiles = get_stream_files(drives, cfg)
+
+    # Select via Tk the files witch realy convert
+    videofiles = select_videofiles(videofiles)
+    
+    if not videofiles:
         print "No stream files found -> abort, ok."
         sys.exit()
 
-    if not continue_loop():
-        print "Abort, ok."
-        sys.exit()
-
-    for videofile in files:
+#    if not continue_loop():
+#        print "Abort, ok."
+#        sys.exit()
+
+    for videofile in videofiles:
         print videofile
 
         videofile.create_outdir()
-        videofile.open_log()
-
-        #~ file.parse_streaminfo(txt)
-        process, output = videofile.get_stream_info()
+
+        output = videofile.get_stream_info()
         print "-"*80
         videofile.log("eac2to analyse output: %s" % output.lstrip("- "))
         videofile.parse_streaminfo(output)
 
-        cmd = videofile.get_command()
+        if videofile["streams"]:
+            print "Streams found:", videofile["streams"]
+        else:
+            print "ERROR: No streams found!"
+            continue
+        
+
+
+    stream_selection = select_streams(videofiles)
+    print "selected streams:", stream_selection
+
+    for videofile in videofiles:
+        print videofile
+        cmd = videofile.get_command(stream_selection)
+
         videofile.log("run: %s" % cmd)
-        print cmd
         if DEBUG:
             print "DEBUG, skip real run..."
         else:
             process, output = subprocess2(cmd)
-        videofile.log("eac2to output: %s" % output.lstrip("- "))
+            videofile.log("eac2to output: %s" % output.lstrip("- "))
 
         videofile.close_log()
-        
-        break
+        print "-"*79
 
     print " -- END -- "