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
