X-Git-Url: https://git.distorted.org.uk/~mdw/epls/blobdiff_plain/04a05f7fae649e7f3f355daade12bacbb51f0ac0..HEAD:/mkm3u diff --git a/mkm3u b/mkm3u index 5ef5832..6fc83e4 100755 --- a/mkm3u +++ b/mkm3u @@ -2,8 +2,12 @@ ### -*- mode: python; coding: utf-8 -*- from contextlib import contextmanager +import errno as E +import optparse as OP import os as OS import re as RX +import sqlite3 as SQL +import subprocess as SP import sys as SYS class ExpectedError (Exception): pass @@ -23,10 +27,27 @@ def filter(value, func = None, dflt = None): def check(cond, msg): if not cond: raise ExpectedError(msg) +def lookup(dict, key, msg): + try: return dict[key] + except KeyError: raise ExpectedError(msg) + +def forget(dict, key): + try: del dict[key] + except KeyError: pass + def getint(s): if not s.isdigit(): raise ExpectedError("bad integer `%s'" % s) return int(s) +def getbool(s): + if s == "t": return True + elif s == "nil": return False + else: raise ExpectedError("bad boolean `%s'" % s) + +def quote(s): + if s is None: return "-" + else: return '"' + s.replace("\\", "\\\\").replace('"', '\\"') + '"' + class Words (object): def __init__(me, s): me._s = s @@ -50,11 +71,17 @@ class Words (object): if begin < 0: return None else: return s[begin:].rstrip() +def program_output(*args, **kw): + try: return SP.check_output(*args, **kw) + except SP.CalledProcessError as e: + raise ExpectedError("program `%s' failed with code %d" % + (e.cmd, e.returncode)) + URL_SAFE_P = 256*[False] for ch in \ b"ABCDEFGHIJKLMNOPQRSTUVWXYZ" \ b"abcdefghijklmnopqrstuvwxyz" \ - b"0123456789" b"!$%-.,/": + b"0123456789" b"!$%_-.,/": URL_SAFE_P[ch] = True def urlencode(s): return "".join((URL_SAFE_P[ch] and chr(ch) or "%%%02x" % ch @@ -76,161 +103,369 @@ class FileLocation (BaseLocation): LOC = DummyLocation() +ROOT = "/mnt/dvd/archive/" +DB = None + +def init_db(fn): + global DB + DB = SQL.connect(fn) + DB.cursor().execute("PRAGMA journal_mode = WAL") + +def setup_db(fn): + try: OS.unlink(fn) + except OSError as e: + if e.errno == E.ENOENT: pass + else: raise + init_db(fn) + DB.cursor().execute(""" + CREATE TABLE duration + (path TEXT NOT NULL, + title INTEGER NOT NULL, + start_chapter INTEGER NOT NULL, + end_chapter INTEGER NOT NULL, + inode INTEGER NOT NULL, + device INTEGER NOT NULL, + size INTEGER NOT NULL, + mtime REAL NOT NULL, + duration REAL NOT NULL, + PRIMARY KEY (path, title, start_chapter, end_chapter)); + """) + class Source (object): + PREFIX = "" TITLEP = CHAPTERP = False - def __init__(me, fn): + + def __init__(me, fn, prefix = None): me.fn = fn - def url(me, title = None, chapter = None): - if title is None: + me.neps = None + me.used_titles = set() + me.used_chapters = set() + me.nuses = 0 + me._pfx = prefix + + def _prefix(me): + if me._pfx is not None: return me._pfx + else: return me.PREFIX + + def _duration(me, title, start_chapter, end_chapter): + return -1 + + def url_and_duration(me, title = -1, start_chapter = -1, end_chapter = -1): + if title == -1: if me.TITLEP: raise ExpectedError("missing title number") - if chapter is not None: + if start_chapter != -1 or end_chapter != -1: raise ExpectedError("can't specify chapter without title") suffix = "" elif not me.TITLEP: raise ExpectedError("can't specify title with `%s'" % me.fn) - elif chapter is None: + elif start_chapter == -1: + if end_chapter != -1: + raise ExpectedError("can't specify end chapter without start chapter") suffix = "#%d" % title elif not me.CHAPTERP: raise ExpectedError("can't specify chapter with `%s'" % me.fn) + elif end_chapter == -1: + suffix = "#%d:%d" % (title, start_chapter) + else: + suffix = "#%d:%d-%d:%d" % (title, start_chapter, title, end_chapter - 1) + + duration = None + if DB is None: + duration = me._duration(title, start_chapter, end_chapter) + else: + st = OS.stat(OS.path.join(ROOT, me.fn)) + duration = None + c = DB.cursor() + c.execute(""" + SELECT device, inode, size, mtime, duration FROM duration + WHERE path = ? AND title = ? AND + start_chapter = ? AND end_chapter = ? + """, [me.fn, title, start_chapter, end_chapter]) + row = c.fetchone() + foundp = False + if row is None: + duration = me._duration(title, start_chapter, end_chapter) + c.execute(""" + INSERT OR REPLACE INTO duration + (path, title, start_chapter, end_chapter, + device, inode, size, mtime, duration) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) + """, [me.fn, title, start_chapter, end_chapter, + st.st_dev, st.st_ino, st.st_size, st.st_mtime, + duration]) + else: + dev, ino, sz, mt, d = row + if (dev, ino, sz, mt) == \ + (st.st_dev, st.st_ino, st.st_size, st.st_mtime): + duration = d + else: + duration = me._duration(title, start_chapter, end_chapter) + c.execute(""" + UPDATE duration + SET device = ?, inode = ?, size = ?, mtime = ?, duration = ? + WHERE path = ? AND title = ? AND + start_chapter = ? AND end_chapter = ? + """, [st.st_dev, st.st_dev, st.st_size, st.st_mtime, duration, + me.fn, title, start_chapter, end_chapter]) + DB.commit() + + if end_chapter != -1: + keys = [(title, ch) for ch in range(start_chapter, end_chapter)] + set = me.used_chapters + else: + keys, set = [title], me.used_titles + for k in keys: + if k in set: + if title == -1: + raise ExpectedError("`%s' already used" % me.fn) + elif end_chapter == -1: + raise ExpectedError("`%s' title %d already used" % (me.fn, title)) + else: + raise ExpectedError("`%s' title %d chapter %d already used" % + (me.fn, title, k[1])) + if end_chapter == -1: + me.used_titles.add(title) else: - suffix = "#%d:%d-%d:%d" % (title, chapter, title, chapter) - return me.PREFIX + ROOT + urlencode(me.fn) + suffix + for ch in range(start_chapter, end_chapter): + me.used_chapters.add((title, ch)) + return me._prefix() + ROOT + urlencode(me.fn) + suffix, duration -class VideoDisc (Source): +class DVDFile (Source): PREFIX = "dvd://" TITLEP = CHAPTERP = True -class VideoEpisodes (VideoDisc): - def __init__(me, fn, season, eps, *args, **kw): - super().__init__(fn, *args, **kw) - me.season = season - me.eps = eps + def __init__(me, fn, menuhack = False, *args, **kw): + pfx = None + if menuhack: pfx = "dvdsimple://" + super().__init__(fn, prefix = pfx, *args, **kw) + me.neps = 0 -class VideoSeason (object): + def _duration(me, title, start_chapter, end_chapter): + path = OS.path.join(ROOT, me.fn) + ntitle = int(program_output(["dvd-info", path, "titles"])) + if not 1 <= title <= ntitle: + raise ExpectedError("bad title %d for `%s': must be in 1 .. %d" % + (title, me.fn, ntitle)) + if start_chapter == -1: + durq = "duration:%d" % title + else: + nch = int(program_output(["dvd-info", path, "chapters:%d" % title])) + if end_chapter == -1: end_chapter = nch + else: end_chapter -= 1 + if not 1 <= start_chapter <= end_chapter <= nch: + raise ExpectedError("bad chapter range %d .. %d for `%s' title %d: " + "must be in 1 .. %d" % + (start_chapter, end_chapter, me.fn, title, nch)) + durq = "duration:%d.%d-%d" % (title, start_chapter, end_chapter) + duration = int(program_output(["dvd-info", path, durq])) + return duration + +class DVDSeason (object): def __init__(me, i, title): me.i = i me.title = title me.episodes = {} - def add_disc(me, fn, eps): - d = VideoEpisodes(fn, me, eps) - for i in eps: - if i in me.episodes: - raise ExpectedError("season %d episode %d already taken" % (me.i, i)) - me.episodes[i] = d - return d - -def some_group(m, *gg): - for g in gg: - s = m.group(g) + def set_episode_disc(me, i, disc): + if i in me.episodes: + raise ExpectedError("season %d episode %d already taken" % (me.i, i)) + me.episodes[i] = disc; disc.neps += 1 + +def match_group(m, *groups, dflt = None, mustp = False): + for g in groups: + try: s = m.group(g) + except IndexError: continue if s is not None: return s - return None + if mustp: raise ValueError("no match found") + else: return dflt -class VideoDir (object): +class DVDDir (object): - _R_ISO_PRE = RX.compile(r""" - ^ - (?: S (?P \d+) (?: \. \ (?P .*)—)? (?: D (?P \d+))? | - (?P \d+)) - \. \ # - (?P .*) - \. iso $ - """, RX.X) + _R_ISO_PRE = list(map(lambda pats: + list(map(lambda pat: + RX.compile("^" + pat + r"\.iso$", RX.X), + pats)), + [[r""" S (?P \d+) \. \ (?P .*) — (?: D (?P \d+) \. \ )? + (?P .*) """, + r""" S (?P \d+) (?: D (?P \d+))? \. \ (?P .*) """, + r""" S (?P \d+) \. \ (?P E \d+ .*) """, + r""" S (?P \d+) E (?P \d+) \. \ .* """], + [r""" (?P \d+) [A-Z]? \. \ (?P .*) — (?P .*) """], + [r""" (?P \d+) \. \ (?P [ES] \d+ .*) """], + [r""" (?P \d+ ) \. \ .* """]])) - _R_ISO_EP = RX.compile(r""" - ^ E (?P \d+) (?: – (?P \d+))? $ + _R_ISO_EP = RX.compile(r""" ^ + (?: S (?P \d+) \ )? + E (?P \d+) (?: – (?P \d+))? $ """, RX.X) - def __init__(me, dir): + def __init__(me, dir, hacks): + me.dir = dir fns = OS.listdir(OS.path.join(ROOT, dir)) fns.sort() - season, last_j = None, 0 + season = None seasons = {} + styles = me._R_ISO_PRE for fn in fns: path = OS.path.join(dir, fn) if not fn.endswith(".iso"): continue - m = me._R_ISO_PRE.match(fn) - if not m: continue - - i = filter(m.group("si"), int, 1) - stitle = m.group("st") - if season is None or i != season.i: - check(season is None or i == season.i + 1, - "season %d /= %d" % (i, season is None and -1 or season.i + 1)) - check(i not in seasons, "season %d already seen" % i) - seasons[i] = season = VideoSeason(i, stitle) - last_j = 0 + #print(";; `%s'" % path, file = SYS.stderr) + for sty in styles: + for r in sty: + m = r.match(fn) + if m: styles = [sty]; break + else: + continue + break else: - check(stitle == season.title, - "season title `%s' /= `%s'" % (stitle, season.title)) - j = filter(some_group(m, "sdi", "di"), int) - if j is not None: - check(j == last_j + 1, - "season %d disc %d /= %d" % (season.i, j, last_j + 1)) - - eps = set() - bad = False - for eprange in m.group("eps").split(", "): + #print(";;\tignored (regex mismatch)", file = SYS.stderr) + continue + + si = filter(match_group(m, "si"), int) + stitle = match_group(m, "stitle") + + check(si is not None or stitle is None, + "explicit season title without number in `%s'" % fn) + if si is not None: + if season is None or si != season.i: + check(season is None or si == season.i + 1, + "season %d /= %d" % + (si, season is None and -1 or season.i + 1)) + check(si not in seasons, "season %d already seen" % si) + seasons[si] = season = DVDSeason(si, stitle) + else: + check(stitle == season.title, + "season title `%s' /= `%s'" % (stitle, season.title)) + + ts = season + any, bad = False, False + ei = match_group(m, "ei") + if ei is not None: eplist = ["E" + ei] + else: eplist = match_group(m, "epex", mustp = True).split(", ") + + di = filter(match_group(m, "di"), int) + discid = "" + if si is not None: discid += "S%02d" % si + if di is not None: discid += "D%02d" % di + elif ei is not None: discid += "E%02d" % int(ei) + menuhack = False + for h in hacks.get(discid, []): + if h == "menu": menuhack = True + else: raise ExpectedError("unknown hack `%s'" % h) + disc = DVDFile(path, menuhack) + + for eprange in eplist: mm = me._R_ISO_EP.match(eprange) - if mm is None: bad = True; continue + if mm is None: + #print(";;\t`%s'?" % eprange, file = SYS.stderr) + bad = True; continue + if not any: any = True + i = filter(mm.group("si"), int) + if i is not None: + try: ts = seasons[i] + except KeyError: ts = seasons[i] = DVDSeason(i, None) + if ts is None: + ts = season = seasons[1] = DVDSeason(1, None) start = filter(mm.group("ei"), int) end = filter(mm.group("ej"), int, start) - for k in range(start, end + 1): eps.add(k) - if bad and eps: + for k in range(start, end + 1): + ts.set_episode_disc(k, disc) + #print(";;\tepisode %d.%d" % (ts.i, k), file = SYS.stderr) + if not any: + #print(";;\tignored", file = SYS.stderr) + pass + elif bad: raise ExpectedError("bad ep list in `%s'", fn) - season.add_disc(path, eps) - last_j = j me.seasons = seasons -class AudioDisc (Source): - #PREFIX = "file://" - TITLEP = CHAPTERP = False - -class AudioEpisode (Source): - #PREFIX = "file://" - TITLEP = CHAPTERP = False - def __init__(me, fn, i, *args, **kw): - super().__init__(fn, *args, **kw) - me.i = i +class SingleFileDir (object): -class AudioDir (object): - - _R_FLAC = RX.compile(r""" - ^ - E (\d+) - (?: \. \ (.*))? - \. flac $ - """, RX.X) + _CHECK_COMPLETE = True def __init__(me, dir): + me.dir = dir fns = OS.listdir(OS.path.join(ROOT, dir)) fns.sort() episodes = {} last_i = 0 + rx = RX.compile(r""" + E (\d+) + (?: \. \ (.*))? + %s $ + """ % RX.escape(me._EXT), RX.X) + for fn in fns: path = OS.path.join(dir, fn) - if not fn.endswith(".flac"): continue - m = me._R_FLAC.match(fn) + if not fn.endswith(me._EXT): continue + m = rx.match(fn) if not m: continue i = filter(m.group(1), int) etitle = m.group(2) - check(i == last_i + 1, "episode %d /= %d" % (i, last_i + 1)) - episodes[i] = AudioEpisode(path, i) + if me._CHECK_COMPLETE: + check(i == last_i + 1, "episode %d /= %d" % (i, last_i + 1)) + episodes[i] = me._mkepisode(path, i) last_i = i me.episodes = episodes +class AudioFile (Source): + PREFIX = "file://" + TITLEP = CHAPTERP = False + + def _duration(me, title, start_chapter, end_chaptwr): + out = program_output(["metaflac", + "--show-total-samples", "--show-sample-rate", + OS.path.join(ROOT, me.fn)]) + nsamples, hz = map(float, out.split()) + return int(nsamples/hz) + +class AudioEpisode (AudioFile): + def __init__(me, fn, i, *args, **kw): + super().__init__(fn, *args, **kw) + me.i = i + +class AudioDir (SingleFileDir): + _EXT = ".flac" + + def _mkepisode(me, path, i): + return AudioEpisode(path, i) + +class VideoFile (Source): + PREFIX = "file://" + TITLEP = CHAPTERP = False + + def _duration(me, title, start_chapter, end_chaptwr): + out = program_output(["mediainfo", "--output=General;%Duration%", + OS.path.join(ROOT, me.fn)]) + return int(out)//1000 + +class VideoEpisode (VideoFile): + def __init__(me, fn, i, *args, **kw): + super().__init__(fn, *args, **kw) + me.i = i + +class VideoDir (SingleFileDir): + _EXT = ".mp4" + _CHECK_COMPLETE = False + + def _mkepisode(me, path, i): + return VideoEpisode(path, i) + class Chapter (object): def __init__(me, episode, title, i): me.title, me.i = title, i - me.url = episode.source.url(episode.tno, i) + me.url, me.duration = \ + episode.source.url_and_duration(episode.tno, i, i + 1) class Episode (object): - def __init__(me, season, i, neps, title, src, tno = None): + def __init__(me, season, i, neps, title, src, series_title_p = True, + tno = -1, startch = -1, endch = -1): me.season = season me.i, me.neps, me.title = i, neps, title me.chapters = [] me.source, me.tno = src, tno - me.url = src.url(tno) + me.series_title_p = series_title_p + me.tno, me.start_chapter, me.end_chapter = tno, startch, endch + me.url, me.duration = src.url_and_duration(tno, startch, endch) def add_chapter(me, title, j): ch = Chapter(me, title, j) me.chapters.append(ch) @@ -238,207 +473,567 @@ class Episode (object): def label(me): return me.season._eplabel(me.i, me.neps, me.title) -class Season (object): - def __init__(me, playlist, title, i, implicitp = False): - me.playlist = playlist - me.title, me.i = title, i - me.implicitp = implicitp +class BaseSeason (object): + def __init__(me, series, implicitp = False): + me.series = series me.episodes = [] - def add_episode(me, j, neps, title, src, tno): - ep = Episode(me, j, neps, title, src, tno) + me.implicitp = implicitp + me.ep_i, episodes = 1, [] + def add_episode(me, j, neps, title, src, series_title_p, + tno, startch, endch): + ep = Episode(me, j, neps, title, src, series_title_p, + tno, startch, endch) me.episodes.append(ep) + src.nuses += neps; me.ep_i += neps return ep + def _epnames(me, i, neps): + playlist = me.series.playlist + if neps == 1: return playlist.epname, ["%d" % i] + elif neps == 2: return playlist.epnames, ["%d" % i, "%d" % (i + 1)] + else: return playlist.epnames, ["%d–%d" % (i, i + neps - 1)] + +class Season (BaseSeason): + def __init__(me, series, title, i, *args, **kw): + super().__init__(series, *args, **kw) + me.title, me.i = title, i def _eplabel(me, i, neps, title): - if neps == 1: epname = me.playlist.epname; epn = "%d" % i - elif neps == 2: epname = me.playlist.epnames; epn = "%d, %d" % (i, i + 1) - else: epname = me.playlist.epnames; epn = "%d–%d" % (i, i + neps - 1) + epname, epn = me._epnames(i, neps) if title is None: - if me.implicitp: return "%s %s" % (epname, epn) - elif me.title is None: return "%s %d.%s" % (epname, me.i, epn) - else: return "%s—%s %s" % (me.title, epname, epn) + if me.implicitp: + label = "%s %s" % (epname, ", ".join(epn)) + elif me.title is None: + label = "%s %s" % \ + (epname, ", ".join("%d.%s" % (me.i, e) for e in epn)) + else: + label = "%s: %s %s" % (me.title, epname, ", ".join(epn)) + else: + if me.implicitp: + label = "%s. %s" % (", ".join(epn), title) + elif me.title is None: + label = "%s. %s" % \ + (", ".join("%d.%s" % (me.i, e) for e in epn), title) + else: + label = "%s: %s. %s" % (me.title, ", ".join(epn), title) + return label + +class MovieSeason (BaseSeason): + def __init__(me, series, title, *args, **kw): + super().__init__(series, *args, **kw) + me.title = title + me.i = None + def add_episode(me, j, neps, title, src, series_title_p, + tno, startch, endch): + if me.title is None and title is None: + raise ExpectedError("movie or movie season must have a title") + return super().add_episode(j, neps, title, src, series_title_p, + tno, startch, endch) + def _eplabel(me, i, neps, title): + if me.title is None: + label = title + elif title is None: + epname, epn = me._epnames(i, neps) + label = "%s: %s %s" % (me.title, epname, ", ".join(epn)) else: - if me.implicitp: return "%s. %s" % (epn, title) - elif me.title is None: return "%d.%s. %s" % (me.i, epn, title) - else: return "%s—%s. %s" % (me.title, epn, title) + label = "%s: %s" % (me.title, title) + return label -class MovieSeason (object): - def __init__(me, playlist): +class Series (object): + def __init__(me, playlist, name, title = None, + full_title = None, wantedp = True): me.playlist = playlist - me.i = -1 - me.implicitp = False - me.episodes = [] - def add_episode(me, j, neps, title, src, tno): - if title is None: raise ExpectedError("movie must have a title") - ep = Episode(me, j, neps, title, src, tno) - me.episodes.append(ep) - return ep - def _eplabel(me, i, epn, title): - return title + me.name, me.title, me.full_title = name, title, full_title + me.cur_season = None + me.wantedp = wantedp + def _add_season(me, season): + me.cur_season = season + def add_season(me, title, i, implicitp = False): + me._add_season(Season(me, title, i, implicitp)) + def add_movies(me, title = None): + me._add_season(MovieSeason(me, title)) + def ensure_season(me): + if me.cur_season is None: me.add_season(None, 1, implicitp = True) + return me.cur_season + def end_season(me): + me.cur_season = None class Playlist (object): def __init__(me): me.seasons = [] + me.episodes = [] me.epname, me.epnames = "Episode", "Episodes" + me.nseries = 0 + me.single_series_p = False + me.series_title = None + me.series_sep = "" - def add_season(me, title, i, implicitp = False): - season = Season(me, title, i, implicitp) - me.seasons.append(season) - return season + def add_episode(me, episode): + me.episodes.append(episode) - def add_movies(me): - season = MovieSeason(me) - me.seasons.append(season) - return season + def done_season(me): + if me.episodes: + me.seasons.append(me.episodes) + me.episodes = [] def write(me, f): f.write("#EXTM3U\n") for season in me.seasons: f.write("\n") - for i, ep in enumerate(season.episodes, 1): + for ep in season: + label = ep.label() + if me.nseries > 1 and ep.series_title_p and \ + ep.season.series.title is not None: + if ep.season.i is None: sep = ":" + else: sep = me.series_sep + label = ep.season.series.title + sep + " " + label if not ep.chapters: - f.write("#EXTINF:0,,%s\n%s\n" % (ep.label(), ep.url)) + f.write("#EXTINF:%d,,%s\n%s\n" % (ep.duration, label, ep.url)) else: for ch in ep.chapters: - f.write("#EXTINF:0,,%s: %s\n%s\n" % - (ep.label(), ch.title, ch.url)) - -UNSET = ["UNSET"] - -def parse_list(fn): - playlist = Playlist() - season, episode, chapter, ep_i = None, None, None, 1 - vds = {} - ads = iso = None - with location(FileLocation(fn, 0)) as floc: - with open(fn, "r") as f: - for line in f: - floc.stepline() - sline = line.lstrip() - if sline == "" or sline.startswith(";"): continue - - if line.startswith("!"): - ww = Words(line[1:]) - cmd = ww.nextword() - check(cmd is not None, "missing command") - - if cmd == "season": - v = ww.nextword(); - check(v is not None, "missing season number") - if v == "-": - check(v.rest() is None, "trailing junk") - season = playlist.add_movies() - else: - i = getint(v) - title = ww.rest() - season = playlist.add_season(title, i, implicitp = False) - episode = chapter = None - ep_i = 1 - - elif cmd == "movie": - check(ww.rest() is None, "trailing junk") - season = playlist.add_movies() - episode = chapter = None - ep_i = 1 - - elif cmd == "epname": - name = ww.rest() - check(name is not None, "missing episode name") - try: sep = name.index(":") - except ValueError: names = name + "s" - else: name, names = name[:sep], name[sep + 1:] - playlist.epname, playlist.epnames = name, names - - elif cmd == "epno": - i = ww.rest() - check(i is not None, "missing episode number") - ep_i = getint(i) - - elif cmd == "iso": - fn = ww.rest(); check(fn is not None, "missing filename") - if fn == "-": iso = None - else: - check(OS.path.exists(OS.path.join(ROOT, fn)), - "iso file `%s' not found" % fn) - iso = VideoDisc(fn) - - elif cmd == "vdir": - name = ww.nextword(); check(name is not None, "missing name") - fn = ww.rest(); check(fn is not None, "missing directory") - if fn == "-": - try: del vds[name] - except KeyError: pass - else: - vds[name] = VideoDir(fn) - - elif cmd == "adir": - fn = ww.rest(); check(fn is not None, "missing directory") - if fn == "-": ads = None - else: ads = AudioDir(fn) - - elif cmd == "end": - break - - else: - raise ExpectedError("unknown command `%s'" % cmd) + f.write("#EXTINF:%d,,%s: %s\n%s\n" % + (ch.duration, label, ch.title, ch.url)) + def dump(me, f): + if opts.list_name is not None: f.write("LIST %s\n" % opts.list_name) + if me.series_title is not None and \ + me.nseries > 1 and not me.single_series_p: + raise ExpectedError("can't force series name for multi-series list") + series = set() + if me.single_series_p: + f.write("SERIES - %s\n" % quote(me.series_title)) + for season in me.seasons: + for ep in season: + label = ep.label() + title = ep.season.series.full_title + if me.single_series_p: + stag = "-" + if title is not None: label = title + me.series_sep + " " + label else: + if title is None: title = me.series_title + stag = ep.season.series.name + if stag is None: stag = "-" + if stag not in series: + f.write("SERIES %s %s\n" % (stag, quote(title))) + series.add(stag) + f.write("ENTRY %s %s %s %d %d %d %g\n" % + (stag, quote(label), quote(ep.source.fn), + ep.tno, ep.start_chapter, ep.end_chapter, ep.duration)) - if not line[0].isspace(): - ww = Words(line) - conf = ww.nextword() - - check(conf is not None, "missing config") - i, vdname, neps, fake_epi = UNSET, "-", 1, ep_i - for c in conf.split(","): - if c.isdigit(): i = int(c) - elif c == "-": i = None - else: - eq = c.find("="); check(eq >= 0, "bad assignment `%s'" % c) - k, v = c[:eq], c[eq + 1:] - if k == "vd": vdname = v - elif k == "n": neps = getint(v) - elif k == "ep": fake_epi = getint(v) - else: raise ExpectedError("unknown setting `%s'" % k) - - title = ww.rest() - check(i is not UNSET, "no title number") - if season is None: - season = playlist.add_season(None, 1, implicitp = True) - - if i is None: - check(ads, "no title, but no audio directory") - check(season.implicitp, "audio source, but explicit season") - src = ads.episodes[ep_i] - - elif iso: - src = iso - - else: - check(vdname in vds, "title, but no iso or video directory") - src = vds[vdname].seasons[season.i].episodes[ep_i] - - episode = season.add_episode(fake_epi, neps, title, src, i) - chapter = None - ep_i += neps - - else: - ww = Words(line) - title = ww.rest() - check(episode is not None, "no current episode") - check(episode.source.CHAPTERP, - "episode source doesn't allow chapters") - if chapter is None: j = 1 - else: j += 1 - chapter = episode.add_chapter(title, j) - - return playlist + def write_deps(me, f, out): + deps = set() + for season in me.seasons: + for ep in season: deps.add(ep.source.fn) + f.write("### -*-makefile-*-\n") + f.write("%s: $(call check-deps, %s," % (out, out)) + for dep in sorted(deps): + f.write(" \\\n\t'%s'" % + OS.path.join(ROOT, dep) + .replace(",", "$(comma)") + .replace("'", "'\\''")) + f.write(")\n") -ROOT = "/mnt/dvd/archive/" +DEFAULT_EXPVAR = 0.05 +R_DURMULT = RX.compile(r""" ^ + (\d+ (?: \. \d+)?) x +$ """, RX.X) +R_DUR = RX.compile(r""" ^ + (?: (?: (\d+) :)? (\d+) :)? (\d+) + (?: / (\d+ (?: \. \d+)?) \%)? +$ """, RX.X) +def parse_duration(s, base = None, basevar = DEFAULT_EXPVAR): + if base is not None: + m = R_DURMULT.match(s) + if m is not None: return base*float(m.group(1)), basevar + m = R_DUR.match(s) + if not m: raise ExpectedError("invalid duration spec `%s'" % s) + hr, min, sec = map(lambda g: filter(m.group(g), int, 0), [1, 2, 3]) + var = filter(m.group(4), lambda x: float(x)/100.0) + if var is None: var = DEFAULT_EXPVAR + return 3600*hr + 60*min + sec, var +def format_duration(d): + if d >= 3600: return "%d:%02d:%02d" % (d//3600, (d//60)%60, d%60) + elif d >= 60: return "%d:%02d" % (d//60, d%60) + else: return "%d s" % d + +MODE_UNSET = 0 +MODE_SINGLE = 1 +MODE_MULTI = 2 + +class EpisodeListParser (object): + + def __init__(me, series_wanted = None, chapters_wanted_p = False): + me._pl = Playlist() + me._cur_episode = me._cur_chapter = None + me._series = {}; me._vdirs = {}; me._sfdirs = {}; me._isos = {} + me._series_wanted = series_wanted + me._chaptersp = chapters_wanted_p + me._explen, me._expvar = None, DEFAULT_EXPVAR + me._hacks = {} + if series_wanted is None: me._mode = MODE_UNSET + else: me._mode = MODE_MULTI + + def _bad_keyval(me, cmd, k, v): + raise ExpectedError("invalid `!%s' option `%s'" % + (cmd, v if k is None else k)) + + def _keyvals(me, opts): + if opts is not None: + for kv in opts.split(","): + try: sep = kv.index("=") + except ValueError: yield None, kv + else: yield kv[:sep], kv[sep + 1:] + + def _set_mode(me, mode): + if me._mode == MODE_UNSET: + me._mode = mode + elif me._mode != mode: + raise ExpectedError("inconsistent single-/multi-series usage") + + def _get_series(me, name): + if name is None: + me._set_mode(MODE_SINGLE) + try: series = me._series[None] + except KeyError: + series = me._series[None] = Series(me._pl, None) + me._pl.nseries += 1 + else: + me._set_mode(MODE_MULTI) + series = lookup(me._series, name, "unknown series `%s'" % name) + return series + + def _opts_series(me, cmd, opts): + name = None + for k, v in me._keyvals(opts): + if k is None: name = v + else: me._bad_keyval(cmd, k, v) + return me._get_series(name) + + def _auto_epsrc(me, series): + dir = lookup(me._vdirs, series.name, "no active video directory") + season = series.ensure_season() + check(season.i is not None, "must use explicit iso for movie seasons") + vseason = lookup(dir.seasons, season.i, + "season %d not found in video dir `%s'" % + (season.i, dir.dir)) + src = lookup(vseason.episodes, season.ep_i, + "episode %d.%d not found in video dir `%s'" % + (season.i, season.ep_i, dir.dir)) + return src + + def _process_cmd(me, ww): + + cmd = ww.nextword(); check(cmd is not None, "missing command") + try: sep = cmd.index(":") + except ValueError: opts = None + else: cmd, opts = cmd[:sep], cmd[sep + 1:] + + if cmd == "title": + for k, v in me._keyvals(opts): me._bad_keyval("title", k, v) + title = ww.rest(); check(title is not None, "missing title") + check(me._pl.series_title is None, "already set a title") + me._pl.series_title = title + + elif cmd == "single": + for k, v in me._keyvals(opts): me._bad_keyval("single", k, v) + check(ww.rest() is None, "trailing junk") + check(not me._pl.single_series_p, "single-series already set") + me._pl.single_series_p = True + + elif cmd == "series": + name = None + for k, v in me._keyvals(opts): + if k is None: name = v + else: me._bad_keyval(cmd, k, v) + check(name is not None, "missing series name") + check(name not in me._series, "series `%s' already defined" % name) + title = ww.rest() + if title is None: + full = None + else: + try: sep = title.index("::") + except ValueError: full = title + else: + full = title[sep + 2:].strip() + if sep == 0: title = None + else: title = title[:sep].strip() + me._set_mode(MODE_MULTI) + me._series[name] = series = Series(me._pl, name, title, full, + me._series_wanted is None or + name in me._series_wanted) + if series.wantedp: me._pl.nseries += 1 + + elif cmd == "season": + series = me._opts_series(cmd, opts) + w = ww.nextword(); check(w is not None, "missing season number") + if w == "-": + if not series.wantedp: return + series.add_movies(ww.rest()) + else: + title = ww.rest(); i = getint(w) + if not series.wantedp: return + series.add_season(ww.rest(), getint(w), implicitp = False) + me._cur_episode = me._cur_chapter = None + me._pl.done_season() + + elif cmd == "explen": + w = ww.rest(); check(w is not None, "missing duration spec") + if w == "-": + me._explen, me._expvar = None, DEFAULT_EXPVAR + else: + d, v = parse_duration(w) + me._explen = d + if v is not None: me._expvar = v + elif cmd == "epname": + for k, v in me._keyvals(opts): me._bad_keyval("epname", k, v) + name = ww.rest(); check(name is not None, "missing episode name") + try: sep = name.index("::") + except ValueError: names = name + "s" + else: name, names = name[:sep], name[sep + 2:] + me._pl.epname, me._pl.epnames = name, names + + elif cmd == "epno": + series = me._opts_series(cmd, opts) + w = ww.rest(); check(w is not None, "missing episode number") + epi = getint(w) + if not series.wantedp: return + series.ensure_season().ep_i = epi + + elif cmd == "hacks": + series = me._opts_series(cmd, opts) + discid = ww.nextword(); check(discid is not None, "missing disc id") + hh = me._hacks.setdefault(series.name, {}).setdefault(discid, []) + while True: + h = ww.nextword() + if h is None: break + hh.append(h) + + elif cmd == "dvd" or cmd == "dvdsimple": + series = me._opts_series(cmd, opts) + fn = ww.rest(); check(fn is not None, "missing filename") + menuhack = cmd == "dvdsimple" + if not series.wantedp: return + if fn == "-": forget(me._isos, series.name) + else: + check(OS.path.exists(OS.path.join(ROOT, fn)), + "dvd iso file `%s' not found" % fn) + me._isos[series.name] = DVDFile(fn, menuhack) + + elif cmd == "dvddir": + series = me._opts_series(cmd, opts) + dir = ww.rest(); check(dir is not None, "missing directory") + if not series.wantedp: return + if dir == "-": forget(me._vdirs, series.name) + else: + me._vdirs[series.name] = \ + DVDDir(dir, me._hacks.get(series.name, {})) + + elif cmd == "vdir": + series = me._opts_series(cmd, opts) + dir = ww.rest(); check(dir is not None, "missing directory") + if not series.wantedp: return + if dir == "-": forget(me._sfdirs, series.name) + else: me._sfdirs[series.name] = VideoDir(dir) + + elif cmd == "adir": + series = me._opts_series(cmd, opts) + dir = ww.rest(); check(dir is not None, "missing directory") + if not series.wantedp: return + if dir == "-": forget(me._sfdirs, series.name) + else: me._sfdirs[series.name] = AudioDir(dir) + + elif cmd == "displaced": + series = me._opts_series(cmd, opts) + w = ww.rest(); check(w is not None, "missing count"); n = getint(w) + src = me._auto_epsrc(series) + src.nuses += n + + elif cmd == "sep": + sep = ww.rest(); check(sep is not None, "missing separator") + me._pl.series_sep = sep + + else: + raise ExpectedError("unknown command `%s'" % cmd) + + def _process_episode(me, ww): + + opts = ww.nextword(); check(opts is not None, "missing title/options") + ti = -1; sname = None; neps = 1; epi = None; loch = hich = -1 + explen, expvar, explicitlen = me._explen, me._expvar, False + series_title_p = True + for k, v in me._keyvals(opts): + if k is None: + if v.isdigit(): ti = int(v) + elif v == "-": ti = -1 + else: sname = v + elif k == "s": sname = v + elif k == "n": neps = getint(v) + elif k == "ep": epi = getint(v) + elif k == "st": series_title_p = getbool(v) + elif k == "l": + if v == "-": me._explen, me._expvar = None, DEFAULT_EXPVAR + else: + explen, expvar = parse_duration(v, explen, expvar) + explicitlen = True + elif k == "ch": + try: sep = v.index("-") + except ValueError: loch, hich = getint(v), -1 + else: loch, hich = getint(v[:sep]), getint(v[sep + 1:]) + 1 + else: raise ExpectedError("unknown episode option `%s'" % k) + check(ti is not None, "missing title number") + series = me._get_series(sname) + me._cur_chapter = None + + title = ww.rest() + if not series.wantedp: return + season = series.ensure_season() + if epi is None: epi = season.ep_i + + if ti == -1: + check(season.implicitp or season.i is None, + "audio source, but explicit non-movie season") + dir = lookup(me._sfdirs, series.name, + "no title, and no single-file directory") + src = lookup(dir.episodes, season.ep_i, + "episode %d not found in single-file dir `%s'" % + (epi, dir.dir)) + + else: + try: src = me._isos[series.name] + except KeyError: src = me._auto_epsrc(series) + + episode = season.add_episode(epi, neps, title, src, + series_title_p, ti, loch, hich) + + if episode.duration != -1 and explen is not None: + if not explicitlen: explen *= neps + if not explen*(1 - expvar) <= episode.duration <= explen*(1 + expvar): + if season.i is None: epid = "episode %d" % epi + else: epid = "episode %d.%d" % (season.i, epi) + raise ExpectedError \ + ("%s duration %s %g%% > %g%% from expected %s" % + (epid, format_duration(episode.duration), + abs(100*(episode.duration - explen)/explen), 100*expvar, + format_duration(explen))) + me._pl.add_episode(episode) + me._cur_episode = episode + + def _process_chapter(me, ww): + check(me._cur_episode is not None, "no current episode") + check(me._cur_episode.source.CHAPTERP, + "episode source doesn't allow chapters") + if me._chaptersp: + if me._cur_chapter is None: i = 1 + else: i = me._cur_chapter.i + 1 + me._cur_chapter = me._cur_episode.add_chapter(ww.rest(), i) + + def parse_file(me, fn): + with location(FileLocation(fn, 0)) as floc: + with open(fn, "r") as f: + for line in f: + floc.stepline() + sline = line.lstrip() + if sline == "" or sline.startswith(";"): continue + + if line.startswith("!"): me._process_cmd(Words(line[1:])) + elif not line[0].isspace(): me._process_episode(Words(line)) + else: me._process_chapter(Words(line)) + me._pl.done_season() + + def done(me): + discs = set() + for name, vdir in me._vdirs.items(): + if not me._series[name].wantedp: continue + for s in vdir.seasons.values(): + for d in s.episodes.values(): + discs.add(d) + for sfdir in me._sfdirs.values(): + for d in sfdir.episodes.values(): + discs.add(d) + for d in sorted(discs, key = lambda d: d.fn): + if d.neps is not None and d.neps != d.nuses: + raise ExpectedError("disc `%s' has %d episodes, used %d times" % + (d.fn, d.neps, d.nuses)) + return me._pl + +op = OP.OptionParser \ + (usage = "%prog [-Dc] [-L NAME] [-M DEPS] [-d CACHE] [-o OUT] [-s SERIES] EPLS\n" + "%prog -i -d CACHE", + description = "Generate M3U playlists from an episode list.") +op.add_option("-D", "--dump", + dest = "dump", action = "store_true", default = False, + help = "Dump playlist in machine-readable form") +op.add_option("-L", "--list-name", metavar = "NAME", + dest = "list_name", type = "str", default = None, + help = "Set the playlist name") +op.add_option("-M", "--make-deps", metavar = "DEPS", + dest = "deps", type = "str", default = None, + help = "Write a `make' fragment for dependencies") +op.add_option("-c", "--chapters", + dest = "chaptersp", action = "store_true", default = False, + help = "Output individual chapter names") +op.add_option("-i", "--init-db", + dest = "initdbp", action = "store_true", default = False, + help = "Initialize the database") +op.add_option("-d", "--database", metavar = "CACHE", + dest = "database", type = "str", default = None, + help = "Set filename for cache database") +op.add_option("-o", "--output", metavar = "OUT", + dest = "output", type = "str", default = None, + help = "Write output playlist to OUT") +op.add_option("-O", "--fake-output", metavar = "OUT", + dest = "fakeout", type = "str", default = None, + help = "Pretend output goes to OUT for purposes of `-M'") +op.add_option("-s", "--series", metavar = "SERIES", + dest = "series", type = "str", default = None, + help = "Output only the listed SERIES (comma-separated)") try: - for f in SYS.argv[1:]: - parse_list(f).write(SYS.stdout) + opts, argv = op.parse_args() + + if opts.initdbp: + if opts.chaptersp or opts.series is not None or \ + opts.output is not None or opts.deps is not None or \ + opts.fakeout is not None or \ + opts.database is None or len(argv): + op.print_usage(file = SYS.stderr); SYS.exit(2) + setup_db(opts.database) + + else: + if len(argv) != 1: op.print_usage(file = SYS.stderr); SYS.exit(2) + if opts.database is not None: init_db(opts.database) + if opts.series is None: + series_wanted = None + else: + series_wanted = set() + for name in opts.series.split(","): series_wanted.add(name) + if opts.deps is not None: + if (opts.output is None or opts.output == "-") and opts.fakeout is None: + raise ExpectedError("can't write dep fragment without output file") + if opts.fakeout is None: opts.fakeout = opts.output + else: + if opts.fakeout is not None: + raise ExpectedError("fake output set but no dep fragment") + + ep = EpisodeListParser(series_wanted, opts.chaptersp) + ep.parse_file(argv[0]) + pl = ep.done() + + if opts.list_name is None: + opts.list_name, _ = OS.path.splitext(OS.path.basename(argv[0])) + + if opts.dump: outfn = pl.dump + else: outfn = pl.write + if opts.output is None or opts.output == "-": + outfn(SYS.stdout) + else: + with open(opts.output, "w") as f: outfn(f) + + if opts.deps: + if opts.deps == "-": + pl.write_deps(SYS.stdout, opts.fakeout) + else: + with open(opts.deps, "w") as f: pl.write_deps(f, opts.fakeout) + except (ExpectedError, IOError, OSError) as e: LOC.report(e) SYS.exit(2)