class ZoneElement(ebml.serialization.Object): ebmlID = b"\x41\x02" __ebmlchildren__ = ( EBMLProperty("srcStart", SrcStart), EBMLProperty("options", (ebml.serialization.State, ebml.serialization.StateDict), optional=True), ) @classmethod def _createConstructorElement(cls, constructor, environ, refs): return None def _getConstructor(self, environ): return environ.get("zoneclass") @classmethod def _createArgsElement(cls, args, environ, refs): return SrcStart(*args) def _constructArgs(self, environ, refs): return (self.srcStart,) def _saveState(self, state, environ, refs): if isinstance(state, dict): self.options = ebml.serialization.StateDict.fromObj( state, environ, refs) else: self.options = ebml.serialization.State.fromObj( state, environ, refs) def _restoreState(self, obj, environ, refs): if self.options: obj.__setstate__(self.options.toObj(environ, refs))
class ChapterTranslate(EBMLMasterElement): ebmlID = b"\x69\x24" __ebmlchildren__ = ( EBMLProperty("chapterTranslateEditionUID", ChapterTranslateEditionUID, True), EBMLProperty("chapterTranslateCodec", ChapterTranslateCodec), EBMLProperty("chapterTranslateID", ChapterTranslateID) )
class EditionEntry(EBMLMasterElement): ebmlID = b"\x45\xb9" __ebmlchildren__ = ( EBMLProperty("editionUID", EditionUID, True), EBMLProperty("editionFlagHidden", EditionFlagHidden), EBMLProperty("editionFlagDefault", EditionFlagDefault), EBMLProperty("editionFlagOrdered", EditionFlagOrdered, True), EBMLProperty("chapterAtoms", ChapterAtoms) ) @property def append(self): return self.chapterAtoms.append @property def insert(self): return self.chapterAtoms.insert @property def remove(self): return self.chapterAtoms.remove @property def extend(self): return self.chapterAtoms.extend @property def __iter__(self): return self.chapterAtoms.__iter__ @property def __getitem__(self): return self.chapterAtoms.__getitem__
class InputFile(ebml.serialization.Object): ebmlID = b"\x31\xbc\xac" module = containers __ebmlchildren__ = ( EBMLProperty("objID", ebml.serialization.ObjID, optional=True), EBMLProperty("constructor", ebml.serialization.Constructor), EBMLProperty("inputPath", InputPath), EBMLProperty("tracks", InputTracks, optional=True), EBMLProperty("state", ebml.serialization.StateDict, optional=True), ) @classmethod def _createArgsElement(cls, args, environ, refs): (inputPath, ) = args return cls.inputPath.cls.fromObj(inputPath, environ, refs) def _saveItems(self, items, environ, refs): self.tracks = self.__class__.tracks.cls.fromObj(items, environ, refs) def _constructArgs(self, environ, refs): return (self._inputPath.toObj(environ, refs), ) def _restoreItems(self, obj, environ, refs): if self.tracks: if hasattr(obj, "trackclass"): environ["trackclass"] = obj.trackclass obj.tracks.clear() obj.extend(self.tracks.toObj(environ, refs))
class ChapterProcess(EBMLMasterElement): ebmlID = b"\x69\x44" __ebmlchildren__ = ( EBMLProperty("chapProcessCodecID", ChapProcessCodecID), EBMLProperty("chapProcessPrivate", ChapProcessPrivate), EBMLProperty("chapProcessCommands", ChapProcessCommands, optional=True) )
class Audio(EBMLMasterElement): ebmlID = b"\xe1" __ebmlchildren__ = ( EBMLProperty("samplingFrequency", SamplingFrequency), EBMLProperty("outputSamplingFrequency", OutputSamplingFrequency, True), EBMLProperty("channels", Channels), EBMLProperty("bitDepth", BitDepth, True), )
class ChapterDisplay(EBMLMasterElement): ebmlID = b"\x80" __ebmlchildren__ = ( EBMLProperty("chapString", ChapString), EBMLProperty("chapLanguages", ChapLanguages), EBMLProperty("chapLanguagesIETF", ChapLanguagesIETF, True), EBMLProperty("chapCountries", ChapCountries, True) )
class Projection(EBMLMasterElement): ebmlID = b"\x76\x70" __ebmlchildren__ = (EBMLProperty("projectionType", ProjectionType), EBMLProperty("projectionPrivate", ProjectionPrivate, True), EBMLProperty("projectionPoseYaw", ProjectionPoseYaw), EBMLProperty("projectionPosePitch", ProjectionPosePitch), EBMLProperty("projectionPoseRoll", ProjectionPoseRoll))
class ContentEncoding(EBMLMasterElement): ebmlID = b"\x62\x40" __ebmlchildren__ = ( EBMLProperty("contentEncodingOrder", ContentEncodingOrder, True), EBMLProperty("contentEncodingScope", ContentEncodingScope, True), EBMLProperty("contentEncodingType", ContentEncodingType, True), EBMLProperty("contentCompression", ContentCompression, optional=True), EBMLProperty("contentEncryption", ContentEncryption, optional=True), )
class TrackTranslate(EBMLMasterElement): ebmlID = b"\x66\x24" __ebmlchildren__ = ( EBMLProperty("trackTranslateEditionUIDs", TrackTranslateEditionUIDs, optional=True), EBMLProperty("trackTranslateCodec", TrackTranslateCodec), EBMLProperty("trackTranslateTrackID", TrackTranslateTrackID), )
class ConcatenateElement(ebml.serialization.Object): ebmlID = b"\x2a\xcf\xc0" constructor = Concatenate _typeMap = {object: FilterElement} _typesByID = {FilterElement.ebmlID: FilterElement} __ebmlchildren__ = ( EBMLProperty("objID", ebml.serialization.ObjID, optional=True), EBMLProperty("options", (ebml.serialization.State, ebml.serialization.StateDict), optional=True), EBMLProperty("name", FilterName, optional=True), EBMLProperty("segments", Refs, optional=True), ) @classmethod def _createElement(cls, constructor, args, environ, refs): return cls() def _constructArgs(self, environ, refs): return () def _restoreState(self, obj, environ, refs): if self.options: state = self.options.toObj(environ, refs) else: state = {} if self.name: state.update(name=self.name) obj.__setstate__(state) def _restoreItems(self, obj, environ, refs): if self.segments: obj.clear() segments = [refs[ref] for ref in self.segments] obj.extend(segments) def _saveState(self, state, environ, refs): if isinstance(state, dict): if "name" in state: self.name = state.pop("name") self.options = ebml.serialization.StateDict.fromObj( state, environ, refs) else: self.options = ebml.serialization.State.fromObj( state, environ, refs) def _saveItems(self, items, environ, refs): self.segments = Refs(items=[]) for segment in items: segment = ebml.serialization.Ref(refs[id(segment)]) self.segments.append(segment)
class CuePoint(EBMLMasterElement): ebmlID = b"\xbb" __ebmlchildren__ = ( EBMLProperty("cueTime", CueTime), EBMLProperty("cueTrackPositionsList", CueTrackPositionsList), ) __ebmladdproperties__ = ( EBMLProperty("data", bytes, optional=True), )
class MasteringMetadata(EBMLMasterElement): ebmlID = b"\x55\xd0" __ebmlchildren__ = ( EBMLProperty("primaryRChromaticityX", PrimaryRChromaticityX, True), EBMLProperty("primaryRChromaticityY", PrimaryRChromaticityY, True), EBMLProperty("primaryGChromaticityX", PrimaryGChromaticityX, True), EBMLProperty("primaryGChromaticityY", PrimaryGChromaticityY, True), EBMLProperty("primaryBChromaticityX", PrimaryBChromaticityX, True), EBMLProperty("primaryBChromaticityY", PrimaryBChromaticityY, True), EBMLProperty("whitePointChromaticityX", WhitePointChromaticityX, True), EBMLProperty("whitePointChromaticityY", WhitePointChromaticityY, True), EBMLProperty("luminanceMax", LuminanceMax, True), EBMLProperty("luminanceMin", LuminanceMin, True), )
class SeekHead(EBMLMasterElement): ebmlID = b"\x11\x4d\x9b\x74" __ebmlchildren__ = (EBMLProperty("seeks", Seeks), ) def __getitem__(self, cls): for seek in self.seeks: if seek.seekID == cls.ebmlID: return seek.seekPosition raise KeyError(f"{formatBytes(cls.ebmlID)}") def __setitem__(self, cls, value): for seek in self.seeks: if seek.seekID == cls.ebmlID: seek.seekPosition = value break else: self.seeks.append(Seek(seekID=cls.ebmlID, seekPosition=value)) def __delitem__(self, cls): for seek in self.seeks: if seek.seekID == cls.ebmlID: self.seeks.remove(seek) return raise KeyError(f"{formatBytes(cls.ebmlID)}") def __contains__(self, cls): for seek in self.seeks: if seek.seekID == cls.ebmlID: return True return False
class Chapters(EBMLMasterElement): ebmlID = b"\x10\x43\xa7\x70" __ebmlchildren__ = (EBMLProperty("editionEntries", EditionEntries),) @property def append(self): return self.editionEntries.append @property def __len__(self): return self.editionEntries.__len__ @property def insert(self): return self.editionEntries.insert @property def remove(self): return self.editionEntries.remove @property def extend(self): return self.editionEntries.extend @property def __iter__(self): return self.editionEntries.__iter__ @property def __getitem__(self): return self.editionEntries.__getitem__
class Tuple(BaseObj): ebmlID = b"\xf6" __ebmlchildren__ = (EBMLProperty("objID", ObjID, optional=True), EBMLProperty("items", Items, optional=True)) @classmethod def _fromObj(cls, obj, environ, refs): return cls( items=[cls._wrapChild(child, environ, refs) for child in obj]) def _createObj(self, environ, refs): if self.items: return tuple( item.toObj(environ, refs) if hasattr(item, "toObj") else item. data for item in self.items) return ()
class UID(EBMLData): data = EBMLProperty("data", bytes) #__ebmlproperties__ = (data,) @data.sethook def data(self, value): if isinstance(value, int): value = value.to_bytes(16, "big") return value
class EBMLHead(EBMLMasterElement): ebmlID = b"\x1a\x45\xdf\xa3" __ebmlchildren__ = (EBMLProperty("ebmlVersion", EBMLVersion), EBMLProperty("ebmlReadVersion", EBMLReadVersion), EBMLProperty("ebmlMaxIDLength", EBMLMaxIDLength), EBMLProperty("ebmlMaxSizeLength", EBMLMaxSizeLength), EBMLProperty("docType", DocType), EBMLProperty("docTypeVersion", DocTypeVersion), EBMLProperty("docTypeReadVersion", DocTypeReadVersion))
class ContentCompAlgo(EBMLInteger): ebmlID = b"\x42\x54" data = EBMLProperty("data", int) __ebmlproperties__ = (data, ) @data.sethook def data(self, value): if isinstance(value, int) and value not in (0, 1, 2, 3): raise ValueError("Invalid value for ContentCompAlgo.") return value
class InputTrack(ebml.serialization.Object): ebmlID = b"\x5b\xda" module = containers __ebmlchildren__ = ( EBMLProperty("objID", ebml.serialization.ObjID, optional=True), EBMLProperty("state", (ebml.serialization.State, ebml.serialization.StateDict), optional=True), ) @classmethod def _createConstructorElement(cls, constructor, environ, refs): return None def _getConstructor(self, environ): return environ.get("trackclass") def _createArgsElement(self, environ, refs): return () def _constructArgs(self, environ, refs): return ()
class Dict(BaseObj): ebmlID = b"\x8d" __ebmlchildren__ = (EBMLProperty("objID", ObjID, optional=True), EBMLProperty("items", Pairs, optional=True)) def _createObj(self, environ, refs): return {} def _restoreDict(self, obj, environ, refs): if self.items: for item in self.items: key, val = item.toObj(environ, refs) obj[key] = val @classmethod def _fromObj(cls, obj, environ, refs): ref = cls._createRef(refs) refs[id(obj)] = ref return cls(items=[ cls._wrapChild(child, environ, refs) for child in obj.items() ], objID=ref)
class Bool(EBMLData): ebmlID = b"\xf2" __ebmlproperties__ = (EBMLProperty("data", bool), ) def _size(self): return 1 def _toBytes(self): return b"\x01" if self.data else b"\x00" @classmethod def _fromBytes(cls, data, parent=None): return cls(True) if len(data) and data[0] else cls(False)
class Shape(EBMLData): ebmlID = b"\x95" __ebmlproperties__ = (EBMLProperty("data", tuple), ) @classmethod def _fromBytes(cls, data, parent=None): return cls(tuple(fromVint(b) for b in parseVints(data)), parent=parent) def _toBytes(self): return b"".join(toVint(k) for k in self.data) def _size(self): return sum(len(toVint(k)) for k in self.data)
class CueTrackPositions(EBMLMasterElement): ebmlID = b"\xb7" __ebmlchildren__ = ( EBMLProperty("cueTrack", CueTrack), EBMLProperty("cueClusterPosition", CueClusterPosition), EBMLProperty("cueRelativePosition", CueRelativePosition, True), EBMLProperty("cueDuration", CueDuration, True), EBMLProperty("cueBlockNumber", CueBlockNumber, True), EBMLProperty("cueCodecState", CueCodecState, True), EBMLProperty("cueReferences", CueReferences, optional=True), )
class Encoder(ebml.serialization.Object): ebmlID = b"\x42\x85" module = encoders __ebmlchildren__ = ( EBMLProperty("constructor", ebml.serialization.Constructor), EBMLProperty("name", EncoderName, optional=True), EBMLProperty("options", (ebml.serialization.State, ebml.serialization.StateDict), optional=True), ) def _constructArgs(self, environ, refs): if self.name: return (self.name, ) return () @classmethod def _createArgsElement(cls, args, environ, refs): if len(args) == 1: (name, ) = args return dict(name=name) return () def _saveState(self, state, environ, refs): if isinstance(state, dict): self.options = ebml.serialization.StateDict.fromObj( state, environ, refs) else: self.options = ebml.serialization.State.fromObj( state, environ, refs) def _restoreState(self, obj, environ, refs): if self.options: obj.__setstate__(self.options.toObj(environ, refs))
class OutputFile(ebml.serialization.Object): ebmlID = b"\x33\xe6\xfe" module = containers __ebmlchildren__ = ( EBMLProperty("constructor", ebml.serialization.Constructor), EBMLProperty("objID", ebml.serialization.ObjID, optional=True), EBMLProperty("outputPath", OutputPath), EBMLProperty("tracks", OutputTracks, optional=True), EBMLProperty("options", (ebml.serialization.State, ebml.serialization.StateDict), optional=True), ) @classmethod def _createArgsElement(cls, args, environ, refs): (path, ) = args return dict(outputPath=cls.outputPath.cls.fromObj(path, environ, refs)) def _saveState(self, state, environ, refs): self.tracks = self.__class__.tracks.cls.fromObj( state.pop("tracks"), environ, refs) self.options = ebml.serialization.StateDict.fromObj( state, environ, refs) def _constructArgs(self, environ, refs): return (self._outputPath.toObj(environ, refs), ) def _restoreState(self, obj, environ, refs): state = {} environ["trackclass"] = obj.trackclass state["tracks"] = self.tracks.toObj(environ, refs) if self.options: state.update(self.options.toObj(environ, refs)) obj.__setstate__(state)
class ContentEncryption(EBMLMasterElement): ebmlID = b"\x50\x35" __ebmlchildren__ = ( EBMLProperty("contentEncAlgo", ContentEncAlgo, True), EBMLProperty("contentEncKeyID", ContentEncKeyID, True), EBMLProperty("contentEncAESSettings", ContentEncAESSettings, optional=True), EBMLProperty("contentSignature", ContentSignature, True), EBMLProperty("contentSigKeyID", ContentSigKeyID, True), EBMLProperty("contentSigAlgo", ContentSigAlgo, True), EBMLProperty("contentSigHashAlgo", ContentSigHashAlgo, True), )
class Targets(EBMLMasterElement): ebmlID = b"\x63\xc0" __ebmlchildren__ = ( EBMLProperty("targetTypeValue", TargetTypeValue, True), EBMLProperty("targetType", TargetType, True), EBMLProperty("tagTrackUIDs", TagTrackUIDs, optional=True), EBMLProperty("tagEditionUIDs", TagEditionUIDs, optional=True), EBMLProperty("tagChapterUIDs", TagChapterUIDs, optional=True), EBMLProperty("tagAttachmentUIDs", TagAttachmentUIDs, optional=True), )
class SimpleTag(EBMLMasterElement): ebmlID = b"\x67\xc8" __ebmlchildren__ = ( EBMLProperty("tagName", TagName), EBMLProperty("tagLanguage", TagLanguage, True), EBMLProperty("tagLanguageIETF", TagLanguageIETF, True), EBMLProperty("tagDefault", TagDefault, True), EBMLProperty("tagString", TagString, True), EBMLProperty("tagBinary", TagBinary, True), )
class EBMLNDArray(EBMLData): data = EBMLProperty("data", numpy.ndarray) __ebmlproperties__ = (data, ) @classmethod def _fromBytes(cls, data, ebmlID=None, parent=None): dtype = None shape = None arraydata = None for (offset, childEbmlID, k, data) in parseElements(data): if childEbmlID == EBMLArrayData.ebmlID: arraydata = data elif childEbmlID == Shape.ebmlID: shape = Shape._fromBytes(data) elif childEbmlID == DType.ebmlID: dtype = DType._fromBytes(data) if ebmlID is not None: return cls(numpy.frombuffer( arraydata, dtype=dtype.toNumpy()).reshape(shape.data), ebmlID=ebmlID, parent=parent) return cls(numpy.frombuffer(arraydata, dtype=dtype.toNumpy()).reshape(shape.data), parent=parent) @property def dtype(self): return DType.fromNumpy(self.data.dtype, parent=self) @property def shape(self): return Shape(self.data.shape, parent=self) def _toBytes(self): return self.dtype.toBytes() + self.shape.toBytes() + EBMLArrayData( bytes(self.data)).toBytes() def _size(self): datasize = self.data.size * self.data.itemsize return self.dtype.size() + self.shape.size() + len( EBMLArrayData.ebmlID) + len(toVint(datasize)) + datasize