from __future__ import annotations from typing import List, Optional from struct import pack, unpack from enum import Enum import os class Flag(Enum): IS_SUBTRACK = 1 << 0 # file is not single-track, might have metainfo in external file IS_READONLY = 1 << 1 # check this flag to block tag writing (e.g. in iso.wv) HAS_EMBEDDED_CUESHEET = 1 << 2 TAG_ID3V1 = 1 << 8 TAG_ID3V22 = 1 << 9 TAG_ID3V23 = 1 << 10 TAG_ID3V24 = 1 << 11 TAG_APEV2 = 1 << 12 TAG_VORBISCOMMENTS = 1 << 13 TAG_CUESHEET = 1 << 14 TAG_ICY = 1 << 15 TAG_ITUNES = 1 << 16 TAG_MASK = 0x000fff00 class Track: uri = Optional[str] decoder = Optional[str] num = Optional[int] startsample = Optional[int] endsample = Optional[int] duration = Optional[float] filetype = Optional[str] replaygain_albumgain = Optional[int] replaygain_albumpeak = Optional[int] replaygain_trackgain = Optional[int] replaygain_trackpeak = Optional[int] flags: int meta: dict def __init__(self): self.uri = '' self.decoder = '' self.num = 0 self.startsample = 0 self.endsample = 0 self.duration = 0 self.filetype = '' self.replaygain_albumgain = 0 self.replaygain_albumpeak = 0 self.replaygain_trackgain = 0 self.replaygain_trackpeak = 0 self.flags = 0 self.meta = {} def get_uri(self) -> str: return self.meta[':URI'] if ':URI' in self.meta else self.uri def set_uri(self, uri) -> None: self.uri = uri self.meta[':URI'] = uri def get_startsample(self) -> int: return self.meta[':STARTSAMPLE'] if ':STARTSAMPLE' in self.meta else self.startsample def set_startsample(self, value) -> None: self.startsample = value self.meta[':STARTSAMPLE'] = value def get_endsample(self) -> int: return self.meta[':ENDSAMPLE'] if ':ENDSAMPLE' in self.meta else self.endsample def set_endsample(self, value) -> None: self.endsample = value self.meta[':ENDSAMPLE'] = value def get_writable_meta(self) -> dict: meta = {} for key, value in self.meta.items(): if key[0] != '_' and key[0] != '!': meta[key] = value return meta def pack(self) -> bytes: buf = bytearray() uri_b = self.get_uri().encode() buf.extend(pack('H', len(uri_b))) buf.extend(uri_b) if self.decoder: decoder_b = self.decoder.encode() buf.append(len(decoder_b)) buf.extend(decoder_b) else: buf.append(0) buf.extend(pack('h', self.num)) buf.extend(pack('i', self.get_startsample())) buf.extend(pack('i', self.get_endsample())) buf.extend(pack('f', self.duration)) ft_b = self.filetype.encode() buf.append(len(ft_b)) if len(self.filetype): buf.extend(ft_b) buf.extend(pack('f', self.replaygain_albumgain)) buf.extend(pack('f', self.replaygain_albumpeak)) buf.extend(pack('f', self.replaygain_trackgain)) buf.extend(pack('f', self.replaygain_trackpeak)) buf.extend(pack('I', self.flags)) meta = self.get_writable_meta() buf.extend(pack('h', len(meta))) for key, value in meta.items(): value = str(value).encode() key = key.encode() key_len, value_len = len(key), len(value) buf.extend(pack('H', key_len)) if key_len: buf.extend(key) buf.extend(pack('H', value_len)) if value_len: buf.extend(value) return bytes(buf) class Playlist: MINOR_VERSION = 2 MAJOR_VERSION = 1 major_version: Optional[int] minor_version: Optional[int] tracks = List[Track] meta: dict def __init__(self, file: str): self.file = file self.major_version = None self.minor_version = None self.tracks = [] self.meta = {} self.read() def add_track(self, track: Track) -> None: self.tracks.append(track) def pack(self) -> bytes: pass def read(self) -> None: with open(self.file, 'rb') as f: magic = f.read(4) if magic != b'DBPL': raise ValueError('invalid magic value') # uint8_t self.major_version, self.minor_version = unpack('BB', f.read(2)) if self.major_version != 1: raise ValueError('invalid major version %d' % self.major_version) if self.minor_version < 1: raise ValueError('invalid minor version %d' % self.minor_version) # uint32_t tracks_count = unpack('I', f.read(4))[0] for i in range(tracks_count): track = Track() if self.minor_version <= 2: # uint16_t uri_len = unpack('H', f.read(2))[0] track.uri = f.read(uri_len).decode() # uint8_t decoder_len = unpack('B', f.read(1))[0] if decoder_len >= 20: raise ValueError('invalid decoder length %d' % decoder_len) if decoder_len: track.decoder = f.read(decoder_len).decode() # int16_t track.num = unpack('h', f.read(2))[0] # int32_t ss, es = unpack('ii', f.read(8)) track.set_startsample(ss) track.set_endsample(es) # float track.duration = unpack('f', f.read(4))[0] if self.minor_version <= 2: # legacy filetype support, they say # uint8_t filetype_len = unpack('B', f.read(1))[0] if filetype_len: track.filetype = f.read(filetype_len).decode() # floats ag, ap, tg, tp = unpack('ffff', f.read(16)) if ag != 0: track.replaygain_albumgain = ag if ap != 0 and ap != 1: track.replaygain_albumpeak = ap if tg != 0: track.replaygain_trackgain = tg if tp != 0 and tp != 1: track.replaygain_trackpeak = tp if self.minor_version >= 2: # uint32_t track.flags = unpack('I', f.read(4))[0] elif track.startsample > 0 or track.endsample > 0 or track.num > 0: track.flags |= Flag.IS_SUBTRACK # int16_t meta_count = unpack('h', f.read(2))[0] for j in range(meta_count): # uint16_t value_len = unpack('H', f.read(2))[0] if value_len >= 20000: raise ValueError('invalid key length') key = f.read(value_len).decode() value_len = unpack('H', f.read(2))[0] if value_len >= 20000: f.seek(value_len, os.SEEK_CUR) else: value = f.read(value_len) if key[0] == ':': if key == ':STARTSAMPLE': track.set_startsample(int(value)) elif key == ':ENDSAMPLE': track.set_endsample(int(value)) else: track.meta[key] = value.decode() else: track.meta[key] = value.decode() self.add_track(track) assert tracks_count == len(self.tracks) # playlist metadata # int16_t meta_count = unpack('H', f.read(2))[0] for i in range(meta_count): # int16_t key_len = unpack('h', f.read(2))[0] if key_len < 0 or key_len >= 20000: raise ValueError('invalid length') key = f.read(key_len).decode() # int16_t value_len = unpack('h', f.read(2))[0] if value_len < 0 or value_len >= 20000: f.seek(value_len, os.SEEK_CUR) else: value = f.read(value_len) self.meta[key] = value.decode() def save(self, file: str = None) -> None: if file is None: file = self.file with open(file, 'wb') as f: f.write(b'DBPL') f.write(pack('BB', Playlist.MAJOR_VERSION, Playlist.MINOR_VERSION)) f.write(pack('I', len(self.tracks))) for track in self.tracks: f.write(track.pack()) f.write(pack('h', len(self.meta))) for key, value in self.meta.items(): value = str(value) key_len, value_len = len(key), len(value) f.write(pack('H', key_len)) if key_len: f.write(key.encode()) f.write(pack('H', value_len)) if value_len: f.write(value.encode())