using System.Collections.Generic;
using System.CodeDom.Compiler;
using System.Linq;
using System.Reflection;
using NEbml.Core;
//--------------------------------------------------------------------------------------------------------
//
// This C# code class was auto-generated at 06/14/2025 08:18:24.
// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
//
// Based on "https://github.com/ietf-wg-cellar/matroska-specification/blob/master/ebml_matroska.xml".
//
//--------------------------------------------------------------------------------------------------------
namespace Matroska;
///
/// Contains the EBML elements specified by the Matroska project (https://matroska.org/technical/specs/index.html)
///
[GeneratedCode("MatroskaSpecification.tt", "1.0.0.0")]
internal static class MatroskaSpecification
{
#region Helpers
private static readonly Dictionary _elementDescriptorsByVInt = new Dictionary();
private static readonly Dictionary _elementDescriptorsByIdentifier = new Dictionary();
///
/// Gets a dictionary of all Matroska elements.
///
public static IReadOnlyDictionary ElementDescriptors => _elementDescriptorsByVInt;
///
/// Gets a dictionary of all Matroska elements.
///
public static IReadOnlyDictionary ElementDescriptorsByIdentifier => _elementDescriptorsByIdentifier;
static MatroskaSpecification()
{
var fields = typeof(MatroskaSpecification).GetFields(BindingFlags.Public | BindingFlags.Static);
foreach (FieldInfo field in fields.Where(ft => ft.FieldType == typeof(ElementDescriptor)))
{
var value = (ElementDescriptor)field.GetValue(null)!;
_elementDescriptorsByVInt.Add(value.Identifier, value);
}
foreach (FieldInfo field in fields.Where(ft => ft.FieldType == typeof(ulong)))
{
var identifier = (ulong)field.GetValue(null)!;
_elementDescriptorsByIdentifier.Add(identifier, _elementDescriptorsByVInt[VInt.FromEncoded(identifier)]);
}
}
#endregion
#region Definitions
/// Used to void damaged data, to avoid unexpected behaviors when using damaged data. The content is discarded. Also used to reserve space in a sub-element for later use.
public const ulong Void = 0xEC;
public static readonly ElementDescriptor VoidDescriptor = new ElementDescriptor(Void, nameof(Void), ElementType.Binary);
/// The CRC is computed on all the data of the Master element it's in. The CRC element should be the first in it's parent master for easier reading. All level 1 elements should include a CRC-32. The CRC in use is the IEEE CRC32 Little Endian.
public const ulong CRC32 = 0xBF;
public static readonly ElementDescriptor CRC32Descriptor = new ElementDescriptor(CRC32, nameof(CRC32), ElementType.Binary);
/// [Required] Set the EBML characteristics of the data to follow. Each EBML document has to start with this.
public const ulong EBML = 0x1A45DFA3;
public static readonly ElementDescriptor EBMLDescriptor = new ElementDescriptor(EBML, nameof(EBML), ElementType.MasterElement);
/// [Required] A string that describes the type of document that follows this EBML header, for example 'matroska' or 'webm'.
public const ulong DocType = 0x4282;
public static readonly ElementDescriptor DocTypeDescriptor = new ElementDescriptor(DocType, nameof(DocType), ElementType.AsciiString);
/// A DocTypeExtension adds extra Elements to the main DocType+DocTypeVersion tuple it's attached to. An EBML Reader **MAY** know these extra Elements and how to use them. A DocTypeExtension **MAY** be used to iterate between experimental Elements before they are integrated into a regular DocTypeVersion. Reading one DocTypeExtension version of a DocType+DocTypeVersion tuple doesn't imply one should be able to read upper versions of this DocTypeExtension.
public const ulong DocTypeExtension = 0x4281;
public static readonly ElementDescriptor DocTypeExtensionDescriptor = new ElementDescriptor(DocTypeExtension, nameof(DocTypeExtension), ElementType.MasterElement);
/// [Required] The name of the DocTypeExtension to differentiate it from other DocTypeExtensions of the same DocType+DocTypeVersion tuple. A DocTypeExtensionName value **MUST** be unique within the EBML Header.
public const ulong DocTypeExtensionName = 0x4283;
public static readonly ElementDescriptor DocTypeExtensionNameDescriptor = new ElementDescriptor(DocTypeExtensionName, nameof(DocTypeExtensionName), ElementType.AsciiString);
/// [Required] The version of the DocTypeExtension. Different DocTypeExtensionVersion values of the same DocType + DocTypeVersion + DocTypeExtensionName tuple **MAY** contain completely different sets of extra Elements. An EBML Reader **MAY** support multiple versions of the same tuple, only one version of the tuple, or not support the tuple at all.
public const ulong DocTypeExtensionVersion = 0x4284;
public static readonly ElementDescriptor DocTypeExtensionVersionDescriptor = new ElementDescriptor(DocTypeExtensionVersion, nameof(DocTypeExtensionVersion), ElementType.UnsignedInteger);
/// [Required] The minimum DocType version an interpreter has to support to read this file.
public const ulong DocTypeReadVersion = 0x4285;
public static readonly ElementDescriptor DocTypeReadVersionDescriptor = new ElementDescriptor(DocTypeReadVersion, nameof(DocTypeReadVersion), ElementType.UnsignedInteger);
/// [Required] The version of DocType interpreter used to create the file.
public const ulong DocTypeVersion = 0x4287;
public static readonly ElementDescriptor DocTypeVersionDescriptor = new ElementDescriptor(DocTypeVersion, nameof(DocTypeVersion), ElementType.UnsignedInteger);
/// [Required] The maximum length of the IDs you'll find in this file (4 or less in Matroska).
public const ulong EBMLMaxIDLength = 0x42F2;
public static readonly ElementDescriptor EBMLMaxIDLengthDescriptor = new ElementDescriptor(EBMLMaxIDLength, nameof(EBMLMaxIDLength), ElementType.UnsignedInteger);
/// [Required] The maximum length of the sizes you'll find in this file (8 or less in Matroska). This does not override the element size indicated at the beginning of an element. Elements that have an indicated size which is larger than what is allowed by EBMLMaxSizeLength shall be considered invalid.
public const ulong EBMLMaxSizeLength = 0x42F3;
public static readonly ElementDescriptor EBMLMaxSizeLengthDescriptor = new ElementDescriptor(EBMLMaxSizeLength, nameof(EBMLMaxSizeLength), ElementType.UnsignedInteger);
/// [Required] The minimum EBML version a parser has to support to read this file.
public const ulong EBMLReadVersion = 0x42F7;
public static readonly ElementDescriptor EBMLReadVersionDescriptor = new ElementDescriptor(EBMLReadVersion, nameof(EBMLReadVersion), ElementType.UnsignedInteger);
/// [Required] The version of EBML parser used to create the file.
public const ulong EBMLVersion = 0x4286;
public static readonly ElementDescriptor EBMLVersionDescriptor = new ElementDescriptor(EBMLVersion, nameof(EBMLVersion), ElementType.UnsignedInteger);
/// [Required] The `Root Element` that contains all other `Top-Level Elements`; see (#data-layout).
public const ulong Segment = 0x18538067;
public static readonly ElementDescriptor SegmentDescriptor = new ElementDescriptor(Segment, nameof(Segment), ElementType.MasterElement);
/// Contains attached files.
public const ulong Attachments = 0x1941A469;
public static readonly ElementDescriptor AttachmentsDescriptor = new ElementDescriptor(Attachments, nameof(Attachments), ElementType.MasterElement);
/// [Required] An attached file.
public const ulong AttachedFile = 0x61A7;
public static readonly ElementDescriptor AttachedFileDescriptor = new ElementDescriptor(AttachedFile, nameof(AttachedFile), ElementType.MasterElement);
/// [Required] The data of the file.
public const ulong FileData = 0x465C;
public static readonly ElementDescriptor FileDataDescriptor = new ElementDescriptor(FileData, nameof(FileData), ElementType.Binary);
/// A human-friendly name for the attached file.
public const ulong FileDescription = 0x467E;
public static readonly ElementDescriptor FileDescriptionDescriptor = new ElementDescriptor(FileDescription, nameof(FileDescription), ElementType.Utf8String);
/// [Required] Media type of the file following the format described in [@!RFC6838].
public const ulong FileMediaType = 0x4660;
public static readonly ElementDescriptor FileMediaTypeDescriptor = new ElementDescriptor(FileMediaType, nameof(FileMediaType), ElementType.AsciiString);
/// [Required] Filename of the attached file.
public const ulong FileName = 0x466E;
public static readonly ElementDescriptor FileNameDescriptor = new ElementDescriptor(FileName, nameof(FileName), ElementType.Utf8String);
/// A binary value that a track/codec can refer to when the attachment is needed.
public const ulong FileReferral = 0x4675;
public static readonly ElementDescriptor FileReferralDescriptor = new ElementDescriptor(FileReferral, nameof(FileReferral), ElementType.Binary);
/// [Required] UID representing the file, as random as possible.
public const ulong FileUID = 0x46AE;
public static readonly ElementDescriptor FileUIDDescriptor = new ElementDescriptor(FileUID, nameof(FileUID), ElementType.UnsignedInteger);
/// The timestamp at which this optimized font attachment goes out of context, expressed in Segment Ticks, which are based on`TimestampScale`. See [@?DivXWorldFonts].
public const ulong FileUsedEndTime = 0x4662;
public static readonly ElementDescriptor FileUsedEndTimeDescriptor = new ElementDescriptor(FileUsedEndTime, nameof(FileUsedEndTime), ElementType.UnsignedInteger);
/// The timestamp at which this optimized font attachment comes into context, expressed in Segment Ticks, which are based on`TimestampScale`. See [@?DivXWorldFonts].
public const ulong FileUsedStartTime = 0x4661;
public static readonly ElementDescriptor FileUsedStartTimeDescriptor = new ElementDescriptor(FileUsedStartTime, nameof(FileUsedStartTime), ElementType.UnsignedInteger);
/// A system to define basic menus and partition data.For more detailed information, see (#chapters).
public const ulong Chapters = 0x1043A770;
public static readonly ElementDescriptor ChaptersDescriptor = new ElementDescriptor(Chapters, nameof(Chapters), ElementType.MasterElement);
/// [Required] Contains all information about a `Segment` edition.
public const ulong EditionEntry = 0x45B9;
public static readonly ElementDescriptor EditionEntryDescriptor = new ElementDescriptor(EditionEntry, nameof(EditionEntry), ElementType.MasterElement);
/// [Required] Contains the atom information to use as the chapter atom (applies to all tracks).
public const ulong ChapterAtom = 0xB6;
public static readonly ElementDescriptor ChapterAtomDescriptor = new ElementDescriptor(ChapterAtom, nameof(ChapterAtom), ElementType.MasterElement);
/// Contains all the commands associated with the Atom.
public const ulong ChapProcess = 0x6944;
public static readonly ElementDescriptor ChapProcessDescriptor = new ElementDescriptor(ChapProcess, nameof(ChapProcess), ElementType.MasterElement);
/// [Required] Contains the type of the codec used for processing.
public const ulong ChapProcessCodecID = 0x6955;
public static readonly ElementDescriptor ChapProcessCodecIDDescriptor = new ElementDescriptor(ChapProcessCodecID, nameof(ChapProcessCodecID), ElementType.UnsignedInteger);
/// Contains all the commands associated with the Atom.
public const ulong ChapProcessCommand = 0x6911;
public static readonly ElementDescriptor ChapProcessCommandDescriptor = new ElementDescriptor(ChapProcessCommand, nameof(ChapProcessCommand), ElementType.MasterElement);
/// [Required] Contains the command information.The data **SHOULD** be interpreted depending on the `ChapProcessCodecID` value. For `ChapProcessCodecID` = 1,the data correspond to the binary DVD cell pre/post commands; see (#menu-features) on DVD menus.
public const ulong ChapProcessData = 0x6933;
public static readonly ElementDescriptor ChapProcessDataDescriptor = new ElementDescriptor(ChapProcessData, nameof(ChapProcessData), ElementType.Binary);
/// [Required] Defines when the process command **SHOULD** be handled.
public const ulong ChapProcessTime = 0x6922;
public static readonly ElementDescriptor ChapProcessTimeDescriptor = new ElementDescriptor(ChapProcessTime, nameof(ChapProcessTime), ElementType.UnsignedInteger);
/// Optional data attached to the `ChapProcessCodecID` information.For `ChapProcessCodecID` = 1, it is the "DVD level" equivalent; see (#menu-features) on DVD menus.
public const ulong ChapProcessPrivate = 0x450D;
public static readonly ElementDescriptor ChapProcessPrivateDescriptor = new ElementDescriptor(ChapProcessPrivate, nameof(ChapProcessPrivate), ElementType.Binary);
/// Contains all possible strings to use for the chapter display.
public const ulong ChapterDisplay = 0x80;
public static readonly ElementDescriptor ChapterDisplayDescriptor = new ElementDescriptor(ChapterDisplay, nameof(ChapterDisplay), ElementType.MasterElement);
/// A country corresponding to the string,in the Matroska countries form; see (#country-codes) on country codes.This element **MUST** be ignored if a `ChapLanguageBCP47` element is used within the same `ChapterDisplay` element.
public const ulong ChapCountry = 0x437E;
public static readonly ElementDescriptor ChapCountryDescriptor = new ElementDescriptor(ChapCountry, nameof(ChapCountry), ElementType.AsciiString);
/// [Required] A language corresponding to the string,in the Matroska languages form; see (#language-codes) on language codes.This element **MUST** be ignored if a `ChapLanguageBCP47` element is used within the same `ChapterDisplay` element.
public const ulong ChapLanguage = 0x437C;
public static readonly ElementDescriptor ChapLanguageDescriptor = new ElementDescriptor(ChapLanguage, nameof(ChapLanguage), ElementType.AsciiString);
/// A language corresponding to the `ChapString`,in the form defined in [@!RFC5646]; see (#language-codes) on language codes.If a `ChapLanguageBCP47` element is used, then any `ChapLanguage` and `ChapCountry` elements used in the same `ChapterDisplay` **MUST** be ignored.
public const ulong ChapLanguageBCP47 = 0x437D;
public static readonly ElementDescriptor ChapLanguageBCP47Descriptor = new ElementDescriptor(ChapLanguageBCP47, nameof(ChapLanguageBCP47), ElementType.AsciiString);
/// [Required] Contains the string to use as the chapter atom.
public const ulong ChapString = 0x85;
public static readonly ElementDescriptor ChapStringDescriptor = new ElementDescriptor(ChapString, nameof(ChapString), ElementType.Utf8String);
/// [Required] Set to 1 if the chapter is enabled. It can be enabled/disabled by a Control Track.When disabled, the movie **SHOULD** skip all the content between the TimeStart and TimeEnd of this chapter; see (#chapter-flags) on `Chapter` flags.
public const ulong ChapterFlagEnabled = 0x4598;
public static readonly ElementDescriptor ChapterFlagEnabledDescriptor = new ElementDescriptor(ChapterFlagEnabled, nameof(ChapterFlagEnabled), ElementType.UnsignedInteger);
/// [Required] Set to 1 if a chapter is hidden.Hidden chapters **SHOULD NOT** be available to the user interface(but still be available to Control Tracks; see (#chapterflaghidden) on `Chapter` flags).
public const ulong ChapterFlagHidden = 0x98;
public static readonly ElementDescriptor ChapterFlagHiddenDescriptor = new ElementDescriptor(ChapterFlagHidden, nameof(ChapterFlagHidden), ElementType.UnsignedInteger);
/// Specifies the physical equivalent of this `ChapterAtom`, e.g., "DVD" (60) or "SIDE" (50);see (#physical-types) for a complete list of values.
public const ulong ChapterPhysicalEquiv = 0x63C3;
public static readonly ElementDescriptor ChapterPhysicalEquivDescriptor = new ElementDescriptor(ChapterPhysicalEquiv, nameof(ChapterPhysicalEquiv), ElementType.UnsignedInteger);
/// The `EditionUID` to play from the `Segment` linked in `ChapterSegmentUUID`.If `ChapterSegmentEditionUID` is undeclared, then no `Edition` of the `Linked Segment` is used; see (#medium-linking) on Medium-Linking `Segments`.
public const ulong ChapterSegmentEditionUID = 0x6EBC;
public static readonly ElementDescriptor ChapterSegmentEditionUIDDescriptor = new ElementDescriptor(ChapterSegmentEditionUID, nameof(ChapterSegmentEditionUID), ElementType.UnsignedInteger);
/// The `SegmentUUID` of another `Segment` to play during this chapter.
public const ulong ChapterSegmentUUID = 0x6E67;
public static readonly ElementDescriptor ChapterSegmentUUIDDescriptor = new ElementDescriptor(ChapterSegmentUUID, nameof(ChapterSegmentUUID), ElementType.Binary);
/// Indicates what type of content the `ChapterAtom` contains and might be skipped.It can be used to automatically skip content based on the type.If a `ChapterAtom` is inside a `ChapterAtom` that has a `ChapterSkipType` set, it**MUST NOT** have a `ChapterSkipType` or have a `ChapterSkipType` with the same value as it's parent `ChapterAtom`.If the `ChapterAtom` doesn't contain a `ChapterTimeEnd`, the value of the `ChapterSkipType` is only valid until the next `ChapterAtom` with a `ChapterSkipType` value or the end of the file.
public const ulong ChapterSkipType = 0x4588;
public static readonly ElementDescriptor ChapterSkipTypeDescriptor = new ElementDescriptor(ChapterSkipType, nameof(ChapterSkipType), ElementType.UnsignedInteger);
/// A unique string ID that identifies the `Chapter`.For example, it is used as the storage for cue identifier values [@?WebVTT].
public const ulong ChapterStringUID = 0x5654;
public static readonly ElementDescriptor ChapterStringUIDDescriptor = new ElementDescriptor(ChapterStringUID, nameof(ChapterStringUID), ElementType.Utf8String);
/// Timestamp of the end of `Chapter` (timestamp excluded), expressed in Matroska Ticks -- i.e., in nanoseconds; see (#timestamp-ticks).The value **MUST** be greater than or equal to the `ChapterTimeStart` of the same `ChapterAtom`.
public const ulong ChapterTimeEnd = 0x92;
public static readonly ElementDescriptor ChapterTimeEndDescriptor = new ElementDescriptor(ChapterTimeEnd, nameof(ChapterTimeEnd), ElementType.UnsignedInteger);
/// [Required] Timestamp of the start of `Chapter`, expressed in Matroska Ticks -- i.e., in nanoseconds; see (#timestamp-ticks).
public const ulong ChapterTimeStart = 0x91;
public static readonly ElementDescriptor ChapterTimeStartDescriptor = new ElementDescriptor(ChapterTimeStart, nameof(ChapterTimeStart), ElementType.UnsignedInteger);
/// List of tracks on which the chapter applies. If this element is not present, all tracks apply.
public const ulong ChapterTrack = 0x8F;
public static readonly ElementDescriptor ChapterTrackDescriptor = new ElementDescriptor(ChapterTrack, nameof(ChapterTrack), ElementType.MasterElement);
/// [Required] UID of the `Track` to apply this chapter to.In the absence of a control track, choosing this chapter will select the listed `Tracks` and deselect unlisted tracks.Absence of this element indicates that the `Chapter` **SHOULD** be applied to any currently used `Tracks`.
public const ulong ChapterTrackUID = 0x89;
public static readonly ElementDescriptor ChapterTrackUIDDescriptor = new ElementDescriptor(ChapterTrackUID, nameof(ChapterTrackUID), ElementType.UnsignedInteger);
/// [Required] A UID that identifies the `Chapter`.
public const ulong ChapterUID = 0x73C4;
public static readonly ElementDescriptor ChapterUIDDescriptor = new ElementDescriptor(ChapterUID, nameof(ChapterUID), ElementType.UnsignedInteger);
/// Contains a possible string to use for the edition display for the given languages.
public const ulong EditionDisplay = 0x4520;
public static readonly ElementDescriptor EditionDisplayDescriptor = new ElementDescriptor(EditionDisplay, nameof(EditionDisplay), ElementType.MasterElement);
/// One language corresponding to the EditionString,in the form defined in [@!RFC5646]; see (#language-codes) on language codes.
public const ulong EditionLanguageIETF = 0x45E4;
public static readonly ElementDescriptor EditionLanguageIETFDescriptor = new ElementDescriptor(EditionLanguageIETF, nameof(EditionLanguageIETF), ElementType.AsciiString);
/// [Required] Contains the string to use as the edition name.
public const ulong EditionString = 0x4521;
public static readonly ElementDescriptor EditionStringDescriptor = new ElementDescriptor(EditionString, nameof(EditionString), ElementType.Utf8String);
/// [Required] Set to 1 if the edition **SHOULD** be used as the default one.
public const ulong EditionFlagDefault = 0x45DB;
public static readonly ElementDescriptor EditionFlagDefaultDescriptor = new ElementDescriptor(EditionFlagDefault, nameof(EditionFlagDefault), ElementType.UnsignedInteger);
/// [Required] Set to 1 if an edition is hidden. Hidden editions **SHOULD NOT** be available to the user interface(but still be available to Control Tracks; see (#chapter-flags) on `Chapter` flags).
public const ulong EditionFlagHidden = 0x45BD;
public static readonly ElementDescriptor EditionFlagHiddenDescriptor = new ElementDescriptor(EditionFlagHidden, nameof(EditionFlagHidden), ElementType.UnsignedInteger);
/// [Required] Set to 1 if the chapters can be defined multiple times and the order to play them is enforced; see (#editionflagordered).
public const ulong EditionFlagOrdered = 0x45DD;
public static readonly ElementDescriptor EditionFlagOrderedDescriptor = new ElementDescriptor(EditionFlagOrdered, nameof(EditionFlagOrdered), ElementType.UnsignedInteger);
/// A UID that identifies the edition. It's useful for tagging an edition.
public const ulong EditionUID = 0x45BC;
public static readonly ElementDescriptor EditionUIDDescriptor = new ElementDescriptor(EditionUID, nameof(EditionUID), ElementType.UnsignedInteger);
/// The `Top-Level Element` containing the (monolithic) `Block` structure.
public const ulong Cluster = 0x1F43B675;
public static readonly ElementDescriptor ClusterDescriptor = new ElementDescriptor(Cluster, nameof(Cluster), ElementType.MasterElement);
/// Basic container of information containing a single `Block` and information specific to that `Block`.
public const ulong BlockGroup = 0xA0;
public static readonly ElementDescriptor BlockGroupDescriptor = new ElementDescriptor(BlockGroup, nameof(BlockGroup), ElementType.MasterElement);
/// [Required] `Block` containing the actual data to be rendered and a timestamp relative to the `Cluster` Timestamp;see (#block-structure) on `Block` Structure.
public const ulong Block = 0xA1;
public static readonly ElementDescriptor BlockDescriptor = new ElementDescriptor(Block, nameof(Block), ElementType.Binary);
/// Contains additional binary data to complete the `Block` element; see [@?I-D.ietf-cellar-codec, section 4.1.5] for more information.An EBML parser that has no knowledge of the `Block` structure could still see and use/skip these data.
public const ulong BlockAdditions = 0x75A1;
public static readonly ElementDescriptor BlockAdditionsDescriptor = new ElementDescriptor(BlockAdditions, nameof(BlockAdditions), ElementType.MasterElement);
/// [Required] Contains the `BlockAdditional` and some parameters.
public const ulong BlockMore = 0xA6;
public static readonly ElementDescriptor BlockMoreDescriptor = new ElementDescriptor(BlockMore, nameof(BlockMore), ElementType.MasterElement);
/// [Required] An ID that identifies how to interpret the `BlockAdditional` data; see [@?I-D.ietf-cellar-codec, section 4.1.5] formore information. A value of 1 indicates that the `BlockAdditional` data isdefined by the codec. Any other value indicates that the `BlockAdditional` datashould be handled according to the `BlockAddIDType` that is located in the`TrackEntry`.
public const ulong BlockAddID = 0xEE;
public static readonly ElementDescriptor BlockAddIDDescriptor = new ElementDescriptor(BlockAddID, nameof(BlockAddID), ElementType.UnsignedInteger);
/// [Required] Interpreted by the codec as it wishes (using the `BlockAddID`).
public const ulong BlockAdditional = 0xA5;
public static readonly ElementDescriptor BlockAdditionalDescriptor = new ElementDescriptor(BlockAdditional, nameof(BlockAdditional), ElementType.Binary);
/// The duration of the `Block`, expressed in Track Ticks; see (#timestamp-ticks).The `BlockDuration` element can be usefulat the end of a `Track` to define the duration of the last frame (asthere is no subsequent `Block` available) or when there is a break in atrack like for subtitle tracks.
public const ulong BlockDuration = 0x9B;
public static readonly ElementDescriptor BlockDurationDescriptor = new ElementDescriptor(BlockDuration, nameof(BlockDuration), ElementType.UnsignedInteger);
/// A `Block` with no data. It must be stored in the stream at the place the real `Block` would be in display order.
public const ulong BlockVirtual = 0xA2;
public static readonly ElementDescriptor BlockVirtualDescriptor = new ElementDescriptor(BlockVirtual, nameof(BlockVirtual), ElementType.Binary);
/// The new codec state to use. Data interpretation is private to the codec.This information **SHOULD** always be referenced by a seek entry.
public const ulong CodecState = 0xA4;
public static readonly ElementDescriptor CodecStateDescriptor = new ElementDescriptor(CodecState, nameof(CodecState), ElementType.Binary);
/// Duration of the silent data added to the `Block`, expressed inMatroska Ticks -- i.e., in nanoseconds; see (#timestamp-ticks)(padding at the end of the `Block` for positive values and at thebeginning of the `Block` for negative values). The duration of`DiscardPadding` is not calculated in the duration of the`TrackEntry` and **SHOULD** be discarded duringplayback.
public const ulong DiscardPadding = 0x75A2;
public static readonly ElementDescriptor DiscardPaddingDescriptor = new ElementDescriptor(DiscardPadding, nameof(DiscardPadding), ElementType.SignedInteger);
/// A timestamp value, relative to the timestamp of the `Block` in this `BlockGroup`, expressed in Track Ticks; see (#timestamp-ticks).This is used to reference other frames necessary to decode this frame.The relative value **SHOULD** correspond to a valid `Block` that this `Block` depends on.Historically, `Matroska Writers` didn't write the actual `Block(s)` that this `Block` depends on, but they did write *some* `Block(s)` in the past.The value "0" **MAY** also be used to signify that this `Block` cannot be decoded on its own, but the necessary reference `Block(s)` is unknown. In this case, other `ReferenceBlock` elements **MUST NOT** be found in the same `BlockGroup`. If the `BlockGroup` doesn't have a `ReferenceBlock` element, then the `Block` it contains can be decoded without using any other `Block` data.
public const ulong ReferenceBlock = 0xFB;
public static readonly ElementDescriptor ReferenceBlockDescriptor = new ElementDescriptor(ReferenceBlock, nameof(ReferenceBlock), ElementType.SignedInteger);
/// Contains information about the last reference frame. See [@?DivXTrickTrack].
public const ulong ReferenceFrame = 0xC8;
public static readonly ElementDescriptor ReferenceFrameDescriptor = new ElementDescriptor(ReferenceFrame, nameof(ReferenceFrame), ElementType.MasterElement);
/// [Required] The relative offset, in bytes, from the previous `BlockGroup` element for this Smooth FF/RW video track to the containing `BlockGroup`element. See [@?DivXTrickTrack].
public const ulong ReferenceOffset = 0xC9;
public static readonly ElementDescriptor ReferenceOffsetDescriptor = new ElementDescriptor(ReferenceOffset, nameof(ReferenceOffset), ElementType.UnsignedInteger);
/// [Required] The timestamp of the `BlockGroup` pointed to by ReferenceOffset, expressed in Track Ticks; see (#timestamp-ticks). See [@?DivXTrickTrack].
public const ulong ReferenceTimestamp = 0xCA;
public static readonly ElementDescriptor ReferenceTimestampDescriptor = new ElementDescriptor(ReferenceTimestamp, nameof(ReferenceTimestamp), ElementType.UnsignedInteger);
/// [Required] This frame is referenced and has the specified cache priority.In the cache, only a frame of the same or higher priority can replace this frame. A value of 0 means the frame is not referenced.
public const ulong ReferencePriority = 0xFA;
public static readonly ElementDescriptor ReferencePriorityDescriptor = new ElementDescriptor(ReferencePriority, nameof(ReferencePriority), ElementType.UnsignedInteger);
/// The `Segment Position` of the data that would otherwise be in position of the virtual block.
public const ulong ReferenceVirtual = 0xFD;
public static readonly ElementDescriptor ReferenceVirtualDescriptor = new ElementDescriptor(ReferenceVirtual, nameof(ReferenceVirtual), ElementType.SignedInteger);
/// Contains slices description.
public const ulong Slices = 0x8E;
public static readonly ElementDescriptor SlicesDescriptor = new ElementDescriptor(Slices, nameof(Slices), ElementType.MasterElement);
/// Contains extra time information about the data contained in the `Block`.Being able to interpret this element is not required for playback.
public const ulong TimeSlice = 0xE8;
public static readonly ElementDescriptor TimeSliceDescriptor = new ElementDescriptor(TimeSlice, nameof(TimeSlice), ElementType.MasterElement);
/// The ID of the `BlockAdditional` element (0 is the main `Block`).
public const ulong BlockAdditionID = 0xCB;
public static readonly ElementDescriptor BlockAdditionIDDescriptor = new ElementDescriptor(BlockAdditionID, nameof(BlockAdditionID), ElementType.UnsignedInteger);
/// The delay to apply to the element, expressed in Track Ticks; see (#timestamp-ticks).
public const ulong Delay = 0xCE;
public static readonly ElementDescriptor DelayDescriptor = new ElementDescriptor(Delay, nameof(Delay), ElementType.UnsignedInteger);
/// The number of the frame to generate from this lace with this delay(allows for the generation of many frames from the same Block/Frame).
public const ulong FrameNumber = 0xCD;
public static readonly ElementDescriptor FrameNumberDescriptor = new ElementDescriptor(FrameNumber, nameof(FrameNumber), ElementType.UnsignedInteger);
/// The reverse number of the frame in the lace (0 is the last frame, 1 is the next to last, etc.).Being able to interpret this element is not required for playback.
public const ulong LaceNumber = 0xCC;
public static readonly ElementDescriptor LaceNumberDescriptor = new ElementDescriptor(LaceNumber, nameof(LaceNumber), ElementType.UnsignedInteger);
/// The duration to apply to the element, expressed in Track Ticks; see (#timestamp-ticks).
public const ulong SliceDuration = 0xCF;
public static readonly ElementDescriptor SliceDurationDescriptor = new ElementDescriptor(SliceDuration, nameof(SliceDuration), ElementType.UnsignedInteger);
/// Similar to `SimpleBlock` (see (#simpleblock-structure)),but the data inside the `Block` are Transformed (encrypted and/or signed).
public const ulong EncryptedBlock = 0xAF;
public static readonly ElementDescriptor EncryptedBlockDescriptor = new ElementDescriptor(EncryptedBlock, nameof(EncryptedBlock), ElementType.Binary);
/// The `Segment Position` of the `Cluster` in the `Segment` (0 in live streams).It might help to resynchronize the offset on damaged streams.
public const ulong Position = 0xA7;
public static readonly ElementDescriptor PositionDescriptor = new ElementDescriptor(Position, nameof(Position), ElementType.UnsignedInteger);
/// Size of the previous `Cluster`, in octets. Can be useful for backward playing.
public const ulong PrevSize = 0xAB;
public static readonly ElementDescriptor PrevSizeDescriptor = new ElementDescriptor(PrevSize, nameof(PrevSize), ElementType.UnsignedInteger);
/// The list of tracks that are not used in that part of the stream.It is useful when using overlay tracks for seeking or deciding what track to use.
public const ulong SilentTracks = 0x5854;
public static readonly ElementDescriptor SilentTracksDescriptor = new ElementDescriptor(SilentTracks, nameof(SilentTracks), ElementType.MasterElement);
/// One of the track numbers that is not used from now on in the stream.It could change later if not specified as silent in a further `Cluster`.
public const ulong SilentTrackNumber = 0x58D7;
public static readonly ElementDescriptor SilentTrackNumberDescriptor = new ElementDescriptor(SilentTrackNumber, nameof(SilentTrackNumber), ElementType.UnsignedInteger);
/// Similar to `Block` (see (#block-structure)) but without all the extra information.Mostly used to reduce overhead when no extra feature is needed; see (#simpleblock-structure) on `SimpleBlock` Structure.
public const ulong SimpleBlock = 0xA3;
public static readonly ElementDescriptor SimpleBlockDescriptor = new ElementDescriptor(SimpleBlock, nameof(SimpleBlock), ElementType.Binary);
/// [Required] Absolute timestamp of the cluster, expressed in Segment Ticks, which are based on `TimestampScale`; see (#timestamp-ticks).
public const ulong Timestamp = 0xE7;
public static readonly ElementDescriptor TimestampDescriptor = new ElementDescriptor(Timestamp, nameof(Timestamp), ElementType.UnsignedInteger);
/// A `Top-Level Element` to speed seeking access. All entries arelocal to the `Segment`.
public const ulong Cues = 0x1C53BB6B;
public static readonly ElementDescriptor CuesDescriptor = new ElementDescriptor(Cues, nameof(Cues), ElementType.MasterElement);
/// [Required] Contains all information relative to a seek point in the `Segment`.
public const ulong CuePoint = 0xBB;
public static readonly ElementDescriptor CuePointDescriptor = new ElementDescriptor(CuePoint, nameof(CuePoint), ElementType.MasterElement);
/// [Required] Absolute timestamp of the seek point, expressed in Segment Ticks, which are based on `TimestampScale`; see (#timestamp-ticks).
public const ulong CueTime = 0xB3;
public static readonly ElementDescriptor CueTimeDescriptor = new ElementDescriptor(CueTime, nameof(CueTime), ElementType.UnsignedInteger);
/// [Required] Contains positions for different tracks corresponding to the timestamp.
public const ulong CueTrackPositions = 0xB7;
public static readonly ElementDescriptor CueTrackPositionsDescriptor = new ElementDescriptor(CueTrackPositions, nameof(CueTrackPositions), ElementType.MasterElement);
/// Number of the `Block` in the specified `Cluster`.
public const ulong CueBlockNumber = 0x5378;
public static readonly ElementDescriptor CueBlockNumberDescriptor = new ElementDescriptor(CueBlockNumber, nameof(CueBlockNumber), ElementType.UnsignedInteger);
/// [Required] The `Segment Position` ((#segment-position)) of the `Cluster` containing the associated `Block`.
public const ulong CueClusterPosition = 0xF1;
public static readonly ElementDescriptor CueClusterPositionDescriptor = new ElementDescriptor(CueClusterPosition, nameof(CueClusterPosition), ElementType.UnsignedInteger);
/// [Required] The `Segment Position` ((#segment-position)) of theCodec State corresponding to this `Cues` element. 0 means that thedata is taken from the initial `TrackEntry`.
public const ulong CueCodecState = 0xEA;
public static readonly ElementDescriptor CueCodecStateDescriptor = new ElementDescriptor(CueCodecState, nameof(CueCodecState), ElementType.UnsignedInteger);
/// The duration of the block, expressed in Segment Ticks, which are based on `TimestampScale`; see (#timestamp-ticks).If missing, the track's `DefaultDuration` does not apply and no duration information is available in terms of the cues.
public const ulong CueDuration = 0xB2;
public static readonly ElementDescriptor CueDurationDescriptor = new ElementDescriptor(CueDuration, nameof(CueDuration), ElementType.UnsignedInteger);
/// The `Clusters` containing the referenced `Blocks`.
public const ulong CueReference = 0xDB;
public static readonly ElementDescriptor CueReferenceDescriptor = new ElementDescriptor(CueReference, nameof(CueReference), ElementType.MasterElement);
/// [Required] The `Segment Position` of the `Cluster` containing the referenced `Block`.
public const ulong CueRefCluster = 0x97;
public static readonly ElementDescriptor CueRefClusterDescriptor = new ElementDescriptor(CueRefCluster, nameof(CueRefCluster), ElementType.UnsignedInteger);
/// The `Segment Position` of the Codec State corresponding to this referenced element.0 means that the data is taken from the initial `TrackEntry`.
public const ulong CueRefCodecState = 0xEB;
public static readonly ElementDescriptor CueRefCodecStateDescriptor = new ElementDescriptor(CueRefCodecState, nameof(CueRefCodecState), ElementType.UnsignedInteger);
/// Number of the referenced `Block` of Track X in the specified `Cluster`.
public const ulong CueRefNumber = 0x535F;
public static readonly ElementDescriptor CueRefNumberDescriptor = new ElementDescriptor(CueRefNumber, nameof(CueRefNumber), ElementType.UnsignedInteger);
/// [Required] Timestamp of the referenced `Block`, expressed in Segment Ticks which is based on `TimestampScale`; see (#timestamp-ticks).
public const ulong CueRefTime = 0x96;
public static readonly ElementDescriptor CueRefTimeDescriptor = new ElementDescriptor(CueRefTime, nameof(CueRefTime), ElementType.UnsignedInteger);
/// The relative position inside the `Cluster` of the referenced `SimpleBlock` or `BlockGroup`with 0 being the first possible position for an element inside that `Cluster`.
public const ulong CueRelativePosition = 0xF0;
public static readonly ElementDescriptor CueRelativePositionDescriptor = new ElementDescriptor(CueRelativePosition, nameof(CueRelativePosition), ElementType.UnsignedInteger);
/// [Required] The track for which a position is given.
public const ulong CueTrack = 0xF7;
public static readonly ElementDescriptor CueTrackDescriptor = new ElementDescriptor(CueTrack, nameof(CueTrack), ElementType.UnsignedInteger);
/// [Required] Contains general information about the `Segment`.
public const ulong Info = 0x1549A966;
public static readonly ElementDescriptor InfoDescriptor = new ElementDescriptor(Info, nameof(Info), ElementType.MasterElement);
/// The mapping between this `Segment` and asegment value in the given Chapter Codec.
public const ulong ChapterTranslate = 0x6924;
public static readonly ElementDescriptor ChapterTranslateDescriptor = new ElementDescriptor(ChapterTranslate, nameof(ChapterTranslate), ElementType.MasterElement);
/// [Required] Applies to the chapter codec of the given chapter edition(s); see (#chapprocesscodecid-element).
public const ulong ChapterTranslateCodec = 0x69BF;
public static readonly ElementDescriptor ChapterTranslateCodecDescriptor = new ElementDescriptor(ChapterTranslateCodec, nameof(ChapterTranslateCodec), ElementType.UnsignedInteger);
/// Specifies a chapter edition UID to which this `ChapterTranslate` applies.
public const ulong ChapterTranslateEditionUID = 0x69FC;
public static readonly ElementDescriptor ChapterTranslateEditionUIDDescriptor = new ElementDescriptor(ChapterTranslateEditionUID, nameof(ChapterTranslateEditionUID), ElementType.UnsignedInteger);
/// [Required] The binary value used to represent this `Segment` in the chapter codec data.The format depends on the `ChapProcessCodecID` used; see (#chapprocesscodecid-element).
public const ulong ChapterTranslateID = 0x69A5;
public static readonly ElementDescriptor ChapterTranslateIDDescriptor = new ElementDescriptor(ChapterTranslateID, nameof(ChapterTranslateID), ElementType.Binary);
/// The date and time that the `Segment` was created by the muxing application or library.
public const ulong DateUTC = 0x4461;
public static readonly ElementDescriptor DateUTCDescriptor = new ElementDescriptor(DateUTC, nameof(DateUTC), ElementType.Date);
/// Duration of the `Segment`, expressed in `Segment` Ticks, which are based on `TimestampScale`; see (#timestamp-ticks).
public const ulong Duration = 0x4489;
public static readonly ElementDescriptor DurationDescriptor = new ElementDescriptor(Duration, nameof(Duration), ElementType.Float);
/// [Required] Muxing application or library (example: "libmatroska-0.4.3").
public const ulong MuxingApp = 0x4D80;
public static readonly ElementDescriptor MuxingAppDescriptor = new ElementDescriptor(MuxingApp, nameof(MuxingApp), ElementType.Utf8String);
/// A filename corresponding to the file of the next `Linked Segment`.
public const ulong NextFilename = 0x3E83BB;
public static readonly ElementDescriptor NextFilenameDescriptor = new ElementDescriptor(NextFilename, nameof(NextFilename), ElementType.Utf8String);
/// An ID that identifies the next `Segment` of a `Linked Segment`.
public const ulong NextUUID = 0x3EB923;
public static readonly ElementDescriptor NextUUIDDescriptor = new ElementDescriptor(NextUUID, nameof(NextUUID), ElementType.Binary);
/// A filename corresponding to the file of the previous `Linked Segment`.
public const ulong PrevFilename = 0x3C83AB;
public static readonly ElementDescriptor PrevFilenameDescriptor = new ElementDescriptor(PrevFilename, nameof(PrevFilename), ElementType.Utf8String);
/// An ID that identifies the previous `Segment` of a `Linked Segment`.
public const ulong PrevUUID = 0x3CB923;
public static readonly ElementDescriptor PrevUUIDDescriptor = new ElementDescriptor(PrevUUID, nameof(PrevUUID), ElementType.Binary);
/// A UID that all `Segments` of a `Linked Segment` **MUST** share (128 bits). It is equivalent to a UUID v4 [@!RFC9562] with all bits randomly (or pseudorandomly) chosen. An actual UUID v4 value, where some bits are not random, **MAY** also be used.
public const ulong SegmentFamily = 0x4444;
public static readonly ElementDescriptor SegmentFamilyDescriptor = new ElementDescriptor(SegmentFamily, nameof(SegmentFamily), ElementType.Binary);
/// A filename corresponding to this `Segment`.
public const ulong SegmentFilename = 0x7384;
public static readonly ElementDescriptor SegmentFilenameDescriptor = new ElementDescriptor(SegmentFilename, nameof(SegmentFilename), ElementType.Utf8String);
/// A randomly generated UID that identifies the `Segment` amongst many others (128 bits). It is equivalent to a Universally Unique Identifier (UUID) v4 [@!RFC9562] with all bits randomly (or pseudorandomly) chosen. An actual UUID v4 value, where some bits are not random, **MAY** also be used.
public const ulong SegmentUUID = 0x73A4;
public static readonly ElementDescriptor SegmentUUIDDescriptor = new ElementDescriptor(SegmentUUID, nameof(SegmentUUID), ElementType.Binary);
/// [Required] Base unit for Segment Ticks and Track Ticks, in nanoseconds. A `TimestampScale` value of 1000000 means scaled timestamps in the `Segment` are expressed in milliseconds; see (#timestamps) on how to interpret timestamps.
public const ulong TimestampScale = 0x2AD7B1;
public static readonly ElementDescriptor TimestampScaleDescriptor = new ElementDescriptor(TimestampScale, nameof(TimestampScale), ElementType.UnsignedInteger);
/// General name of the `Segment`.
public const ulong Title = 0x7BA9;
public static readonly ElementDescriptor TitleDescriptor = new ElementDescriptor(Title, nameof(Title), ElementType.Utf8String);
/// [Required] Writing application (example: "mkvmerge-0.3.3").
public const ulong WritingApp = 0x5741;
public static readonly ElementDescriptor WritingAppDescriptor = new ElementDescriptor(WritingApp, nameof(WritingApp), ElementType.Utf8String);
/// Contains seeking information of `Top-Level Elements`; see (#data-layout).
public const ulong SeekHead = 0x114D9B74;
public static readonly ElementDescriptor SeekHeadDescriptor = new ElementDescriptor(SeekHead, nameof(SeekHead), ElementType.MasterElement);
/// [Required] Contains a single seek entry to an EBML Element.
public const ulong Seek = 0x4DBB;
public static readonly ElementDescriptor SeekDescriptor = new ElementDescriptor(Seek, nameof(Seek), ElementType.MasterElement);
/// [Required] The binary EBML ID of a `Top-Level Element`.
public const ulong SeekID = 0x53AB;
public static readonly ElementDescriptor SeekIDDescriptor = new ElementDescriptor(SeekID, nameof(SeekID), ElementType.Binary);
/// [Required] The `Segment Position` ((#segment-position)) of a `Top-Level Element`.
public const ulong SeekPosition = 0x53AC;
public static readonly ElementDescriptor SeekPositionDescriptor = new ElementDescriptor(SeekPosition, nameof(SeekPosition), ElementType.UnsignedInteger);
/// Element containing metadata describing `Tracks`, `Editions`, `Chapters`, `Attachments`, or the `Segment` as a whole.A list of valid tags can be found in [@?I-D.ietf-cellar-tags].
public const ulong Tags = 0x1254C367;
public static readonly ElementDescriptor TagsDescriptor = new ElementDescriptor(Tags, nameof(Tags), ElementType.MasterElement);
/// [Required] A single metadata descriptor.
public const ulong Tag = 0x7373;
public static readonly ElementDescriptor TagDescriptor = new ElementDescriptor(Tag, nameof(Tag), ElementType.MasterElement);
/// [Required] Contains general information about the target.
public const ulong SimpleTag = 0x67C8;
public static readonly ElementDescriptor SimpleTagDescriptor = new ElementDescriptor(SimpleTag, nameof(SimpleTag), ElementType.MasterElement);
/// The tag value if it is binary. Note that this cannot be used in the same `SimpleTag` as `TagString`.
public const ulong TagBinary = 0x4485;
public static readonly ElementDescriptor TagBinaryDescriptor = new ElementDescriptor(TagBinary, nameof(TagBinary), ElementType.Binary);
/// [Required] A boolean value to indicate if this is the default/original language to use for the given tag.
public const ulong TagDefault = 0x4484;
public static readonly ElementDescriptor TagDefaultDescriptor = new ElementDescriptor(TagDefault, nameof(TagDefault), ElementType.UnsignedInteger);
/// [Required] A variant of the `TagDefault` element with a bogus element ID; see (#tagdefault-element).
public const ulong TagDefaultBogus = 0x44B4;
public static readonly ElementDescriptor TagDefaultBogusDescriptor = new ElementDescriptor(TagDefaultBogus, nameof(TagDefaultBogus), ElementType.UnsignedInteger);
/// [Required] Specifies the language of the specified tag in the Matroska languages form; see (#language-codes) on language codes.This element **MUST** be ignored if the `TagLanguageBCP47` element is used within the same `SimpleTag` element.
public const ulong TagLanguage = 0x447A;
public static readonly ElementDescriptor TagLanguageDescriptor = new ElementDescriptor(TagLanguage, nameof(TagLanguage), ElementType.AsciiString);
/// The language used in the `TagString`,in the form defined in [@!RFC5646]; see (#language-codes) on language codes.If this element is used, then any `TagLanguage` elements used in the same `SimpleTag` **MUST** be ignored.
public const ulong TagLanguageBCP47 = 0x447B;
public static readonly ElementDescriptor TagLanguageBCP47Descriptor = new ElementDescriptor(TagLanguageBCP47, nameof(TagLanguageBCP47), ElementType.AsciiString);
/// [Required] The name of the tag value that is going to be stored.
public const ulong TagName = 0x45A3;
public static readonly ElementDescriptor TagNameDescriptor = new ElementDescriptor(TagName, nameof(TagName), ElementType.Utf8String);
/// The tag value.
public const ulong TagString = 0x4487;
public static readonly ElementDescriptor TagStringDescriptor = new ElementDescriptor(TagString, nameof(TagString), ElementType.Utf8String);
/// [Required] Specifies which other elements the metadata represented by the tag value applies to.If empty or omitted, then the tag value describes everything in the `Segment`.
public const ulong Targets = 0x63C0;
public static readonly ElementDescriptor TargetsDescriptor = new ElementDescriptor(Targets, nameof(Targets), ElementType.MasterElement);
/// A UID that identifies the Attachment(s) that the tags belong to.
public const ulong TagAttachmentUID = 0x63C6;
public static readonly ElementDescriptor TagAttachmentUIDDescriptor = new ElementDescriptor(TagAttachmentUID, nameof(TagAttachmentUID), ElementType.UnsignedInteger);
/// A UID that identifies the `Chapter(s)` that the tags belong to.
public const ulong TagChapterUID = 0x63C4;
public static readonly ElementDescriptor TagChapterUIDDescriptor = new ElementDescriptor(TagChapterUID, nameof(TagChapterUID), ElementType.UnsignedInteger);
/// A UID that identifies the `EditionEntry(s)` that the tags belong to.
public const ulong TagEditionUID = 0x63C9;
public static readonly ElementDescriptor TagEditionUIDDescriptor = new ElementDescriptor(TagEditionUID, nameof(TagEditionUID), ElementType.UnsignedInteger);
/// A UID that identifies the `Track(s)` that the tags belong to.
public const ulong TagTrackUID = 0x63C5;
public static readonly ElementDescriptor TagTrackUIDDescriptor = new ElementDescriptor(TagTrackUID, nameof(TagTrackUID), ElementType.UnsignedInteger);
/// An informational string that can be used to display the logical level of the target, such as "ALBUM", "TRACK", "MOVIE", "CHAPTER", etc.
public const ulong TargetType = 0x63CA;
public static readonly ElementDescriptor TargetTypeDescriptor = new ElementDescriptor(TargetType, nameof(TargetType), ElementType.AsciiString);
/// [Required] A number to indicate the logical level of the target.
public const ulong TargetTypeValue = 0x68CA;
public static readonly ElementDescriptor TargetTypeValueDescriptor = new ElementDescriptor(TargetTypeValue, nameof(TargetTypeValue), ElementType.UnsignedInteger);
/// A `Top-Level Element` of information with many tracks described.
public const ulong Tracks = 0x1654AE6B;
public static readonly ElementDescriptor TracksDescriptor = new ElementDescriptor(Tracks, nameof(Tracks), ElementType.MasterElement);
/// [Required] Describes a track with all elements.
public const ulong TrackEntry = 0xAE;
public static readonly ElementDescriptor TrackEntryDescriptor = new ElementDescriptor(TrackEntry, nameof(TrackEntry), ElementType.MasterElement);
/// The UID of an attachment that is used by this codec.
public const ulong AttachmentLink = 0x7446;
public static readonly ElementDescriptor AttachmentLinkDescriptor = new ElementDescriptor(AttachmentLink, nameof(AttachmentLink), ElementType.UnsignedInteger);
/// Audio settings.
public const ulong Audio = 0xE1;
public static readonly ElementDescriptor AudioDescriptor = new ElementDescriptor(Audio, nameof(Audio), ElementType.MasterElement);
/// Bits per sample, mostly used for PCM.
public const ulong BitDepth = 0x6264;
public static readonly ElementDescriptor BitDepthDescriptor = new ElementDescriptor(BitDepth, nameof(BitDepth), ElementType.UnsignedInteger);
/// Table of horizontal angles for each successive channel.
public const ulong ChannelPositions = 0x7D7B;
public static readonly ElementDescriptor ChannelPositionsDescriptor = new ElementDescriptor(ChannelPositions, nameof(ChannelPositions), ElementType.Binary);
/// [Required] Numbers of channels in the track.
public const ulong Channels = 0x9F;
public static readonly ElementDescriptor ChannelsDescriptor = new ElementDescriptor(Channels, nameof(Channels), ElementType.UnsignedInteger);
/// [Required] Audio emphasis applied on audio samples. The player **MUST** apply the inverse emphasis to get the proper audio samples.
public const ulong Emphasis = 0x52F1;
public static readonly ElementDescriptor EmphasisDescriptor = new ElementDescriptor(Emphasis, nameof(Emphasis), ElementType.UnsignedInteger);
/// Real output sampling frequency in Hz that is used for Spectral Band Replication (SBR) techniques.
public const ulong OutputSamplingFrequency = 0x78B5;
public static readonly ElementDescriptor OutputSamplingFrequencyDescriptor = new ElementDescriptor(OutputSamplingFrequency, nameof(OutputSamplingFrequency), ElementType.Float);
/// [Required] Sampling frequency in Hz.
public const ulong SamplingFrequency = 0xB5;
public static readonly ElementDescriptor SamplingFrequencyDescriptor = new ElementDescriptor(SamplingFrequency, nameof(SamplingFrequency), ElementType.Float);
/// Contains elements that extend the track format by adding content either to each frame,with `BlockAddID` ((#blockaddid-element)), or to the track as a wholewith `BlockAddIDExtraData`.
public const ulong BlockAdditionMapping = 0x41E4;
public static readonly ElementDescriptor BlockAdditionMappingDescriptor = new ElementDescriptor(BlockAdditionMapping, nameof(BlockAdditionMapping), ElementType.MasterElement);
/// Extra binary data that the `BlockAddIDType` can use to interpret the `BlockAdditional` data.The interpretation of the binary data depends on the `BlockAddIDType` value and the corresponding `Block Additional Mapping`.
public const ulong BlockAddIDExtraData = 0x41ED;
public static readonly ElementDescriptor BlockAddIDExtraDataDescriptor = new ElementDescriptor(BlockAddIDExtraData, nameof(BlockAddIDExtraData), ElementType.Binary);
/// A human-friendly name describing the type of `BlockAdditional` data,as defined by the associated `Block Additional Mapping`.
public const ulong BlockAddIDName = 0x41A4;
public static readonly ElementDescriptor BlockAddIDNameDescriptor = new ElementDescriptor(BlockAddIDName, nameof(BlockAddIDName), ElementType.AsciiString);
/// [Required] Stores the registered identifier of the `Block Additional Mapping`to define how the `BlockAdditional` data should be handled.
public const ulong BlockAddIDType = 0x41E7;
public static readonly ElementDescriptor BlockAddIDTypeDescriptor = new ElementDescriptor(BlockAddIDType, nameof(BlockAddIDType), ElementType.UnsignedInteger);
/// If the track format extension needs content beside frames,the value refers to the `BlockAddID` ((#blockaddid-element)) value being described.
public const ulong BlockAddIDValue = 0x41F0;
public static readonly ElementDescriptor BlockAddIDValueDescriptor = new ElementDescriptor(BlockAddIDValue, nameof(BlockAddIDValue), ElementType.UnsignedInteger);
/// [Required] Set to 1 if the codec can decode potentially damaged data.
public const ulong CodecDecodeAll = 0xAA;
public static readonly ElementDescriptor CodecDecodeAllDescriptor = new ElementDescriptor(CodecDecodeAll, nameof(CodecDecodeAll), ElementType.UnsignedInteger);
/// [Required] The built-in delay for the codec, expressed in Matroska Ticks -- i.e., in nanoseconds; see (#timestamp-ticks).It represents the number of codec samples that will be discarded by the decoder during playback.This timestamp value **MUST** be subtracted from each frame timestamp in order to get the timestamp that will be actually played.The value **SHOULD** be small so the muxing of tracks with the same actual timestamp are in the same `Cluster`.
public const ulong CodecDelay = 0x56AA;
public static readonly ElementDescriptor CodecDelayDescriptor = new ElementDescriptor(CodecDelay, nameof(CodecDelay), ElementType.UnsignedInteger);
/// A URL to download information about the codec used.
public const ulong CodecDownloadURL = 0x26B240;
public static readonly ElementDescriptor CodecDownloadURLDescriptor = new ElementDescriptor(CodecDownloadURL, nameof(CodecDownloadURL), ElementType.AsciiString);
/// [Required] An ID corresponding to the codec;see [@?I-D.ietf-cellar-codec] for more info.
public const ulong CodecID = 0x86;
public static readonly ElementDescriptor CodecIDDescriptor = new ElementDescriptor(CodecID, nameof(CodecID), ElementType.AsciiString);
/// A URL to find information about the codec used.
public const ulong CodecInfoURL = 0x3B4040;
public static readonly ElementDescriptor CodecInfoURLDescriptor = new ElementDescriptor(CodecInfoURL, nameof(CodecInfoURL), ElementType.AsciiString);
/// A human-readable string specifying the codec.
public const ulong CodecName = 0x258688;
public static readonly ElementDescriptor CodecNameDescriptor = new ElementDescriptor(CodecName, nameof(CodecName), ElementType.Utf8String);
/// Private data only known to the codec.
public const ulong CodecPrivate = 0x63A2;
public static readonly ElementDescriptor CodecPrivateDescriptor = new ElementDescriptor(CodecPrivate, nameof(CodecPrivate), ElementType.Binary);
/// A string describing the encoding setting used.
public const ulong CodecSettings = 0x3A9697;
public static readonly ElementDescriptor CodecSettingsDescriptor = new ElementDescriptor(CodecSettings, nameof(CodecSettings), ElementType.Utf8String);
/// Settings for several content encoding mechanisms like compression or encryption.
public const ulong ContentEncodings = 0x6D80;
public static readonly ElementDescriptor ContentEncodingsDescriptor = new ElementDescriptor(ContentEncodings, nameof(ContentEncodings), ElementType.MasterElement);
/// [Required] Settings for one content encoding like compression or encryption.
public const ulong ContentEncoding = 0x6240;
public static readonly ElementDescriptor ContentEncodingDescriptor = new ElementDescriptor(ContentEncoding, nameof(ContentEncoding), ElementType.MasterElement);
/// Settings describing the compression used.This element **MUST** be present if the value of `ContentEncodingType` is 0 and absent otherwise.Each block **MUST** be decompressable, even if no previous block is available in order to not prevent seeking.
public const ulong ContentCompression = 0x5034;
public static readonly ElementDescriptor ContentCompressionDescriptor = new ElementDescriptor(ContentCompression, nameof(ContentCompression), ElementType.MasterElement);
/// [Required] The compression algorithm used.
public const ulong ContentCompAlgo = 0x4254;
public static readonly ElementDescriptor ContentCompAlgoDescriptor = new ElementDescriptor(ContentCompAlgo, nameof(ContentCompAlgo), ElementType.UnsignedInteger);
/// Settings that might be needed by the decompressor. For Header Stripping (`ContentCompAlgo`=3),the bytes that were removed from the beginning of each frame of the track.
public const ulong ContentCompSettings = 0x4255;
public static readonly ElementDescriptor ContentCompSettingsDescriptor = new ElementDescriptor(ContentCompSettings, nameof(ContentCompSettings), ElementType.Binary);
/// [Required] Defines the order to apply each `ContentEncoding` of the `ContentEncodings`.The decoder/demuxer **MUST** start with the `ContentEncoding` with the highest `ContentEncodingOrder` and work its way down to the `ContentEncoding` with the lowest `ContentEncodingOrder`.This value **MUST** be unique for each `ContentEncoding` found in the `ContentEncodings` of this `TrackEntry`.
public const ulong ContentEncodingOrder = 0x5031;
public static readonly ElementDescriptor ContentEncodingOrderDescriptor = new ElementDescriptor(ContentEncodingOrder, nameof(ContentEncodingOrder), ElementType.UnsignedInteger);
/// [Required] A bit field that describes which elements have been modified in this way. Values (big-endian) can be OR'ed.
public const ulong ContentEncodingScope = 0x5032;
public static readonly ElementDescriptor ContentEncodingScopeDescriptor = new ElementDescriptor(ContentEncodingScope, nameof(ContentEncodingScope), ElementType.UnsignedInteger);
/// [Required] A value describing the kind of transformation that is applied.
public const ulong ContentEncodingType = 0x5033;
public static readonly ElementDescriptor ContentEncodingTypeDescriptor = new ElementDescriptor(ContentEncodingType, nameof(ContentEncodingType), ElementType.UnsignedInteger);
/// Settings describing the encryption used.This element **MUST** be present if the value of `ContentEncodingType` is 1 (encryption) and **MUST** be ignored otherwise.A `Matroska Player` **MAY** support encryption.
public const ulong ContentEncryption = 0x5035;
public static readonly ElementDescriptor ContentEncryptionDescriptor = new ElementDescriptor(ContentEncryption, nameof(ContentEncryption), ElementType.MasterElement);
/// Settings describing the encryption algorithm used.
public const ulong ContentEncAESSettings = 0x47E7;
public static readonly ElementDescriptor ContentEncAESSettingsDescriptor = new ElementDescriptor(ContentEncAESSettings, nameof(ContentEncAESSettings), ElementType.MasterElement);
/// [Required] The AES cipher mode used in the encryption.
public const ulong AESSettingsCipherMode = 0x47E8;
public static readonly ElementDescriptor AESSettingsCipherModeDescriptor = new ElementDescriptor(AESSettingsCipherMode, nameof(AESSettingsCipherMode), ElementType.UnsignedInteger);
/// [Required] The encryption algorithm used.
public const ulong ContentEncAlgo = 0x47E1;
public static readonly ElementDescriptor ContentEncAlgoDescriptor = new ElementDescriptor(ContentEncAlgo, nameof(ContentEncAlgo), ElementType.UnsignedInteger);
/// For public key algorithms, the ID of the public key that the data was encrypted with.
public const ulong ContentEncKeyID = 0x47E2;
public static readonly ElementDescriptor ContentEncKeyIDDescriptor = new ElementDescriptor(ContentEncKeyID, nameof(ContentEncKeyID), ElementType.Binary);
/// The algorithm used for the signature.
public const ulong ContentSigAlgo = 0x47E5;
public static readonly ElementDescriptor ContentSigAlgoDescriptor = new ElementDescriptor(ContentSigAlgo, nameof(ContentSigAlgo), ElementType.UnsignedInteger);
/// The hash algorithm used for the signature.
public const ulong ContentSigHashAlgo = 0x47E6;
public static readonly ElementDescriptor ContentSigHashAlgoDescriptor = new ElementDescriptor(ContentSigHashAlgo, nameof(ContentSigHashAlgo), ElementType.UnsignedInteger);
/// This is the ID of the private key that the data was signed with.
public const ulong ContentSigKeyID = 0x47E4;
public static readonly ElementDescriptor ContentSigKeyIDDescriptor = new ElementDescriptor(ContentSigKeyID, nameof(ContentSigKeyID), ElementType.Binary);
/// A cryptographic signature of the contents.
public const ulong ContentSignature = 0x47E3;
public static readonly ElementDescriptor ContentSignatureDescriptor = new ElementDescriptor(ContentSignature, nameof(ContentSignature), ElementType.Binary);
/// The period between two successive fields at the output of the decoding process, expressed in Matroska Ticks -- i.e., in nanoseconds; see (#timestamp-ticks).See (#defaultdecodedfieldduration) for more information.
public const ulong DefaultDecodedFieldDuration = 0x234E7A;
public static readonly ElementDescriptor DefaultDecodedFieldDurationDescriptor = new ElementDescriptor(DefaultDecodedFieldDuration, nameof(DefaultDecodedFieldDuration), ElementType.UnsignedInteger);
/// Number of nanoseconds per frame, expressed in Matroska Ticks -- i.e., in nanoseconds; see (#timestamp-ticks)("frame" in the Matroska sense -- one element put into a (Simple)Block).
public const ulong DefaultDuration = 0x23E383;
public static readonly ElementDescriptor DefaultDurationDescriptor = new ElementDescriptor(DefaultDuration, nameof(DefaultDuration), ElementType.UnsignedInteger);
/// Set to 1 if and only if the track contains commentary.
public const ulong FlagCommentary = 0x55AF;
public static readonly ElementDescriptor FlagCommentaryDescriptor = new ElementDescriptor(FlagCommentary, nameof(FlagCommentary), ElementType.UnsignedInteger);
/// [Required] Set to 1 if the track (audio, video, or subtitles) is eligible for automatic selection by the player; see (#default-track-selection) for more details.
public const ulong FlagDefault = 0x88;
public static readonly ElementDescriptor FlagDefaultDescriptor = new ElementDescriptor(FlagDefault, nameof(FlagDefault), ElementType.UnsignedInteger);
/// [Required] Set to 1 if the track is usable. It is possible to turn a track that is not usable into a usable track using chapter codecs or control tracks.
public const ulong FlagEnabled = 0xB9;
public static readonly ElementDescriptor FlagEnabledDescriptor = new ElementDescriptor(FlagEnabled, nameof(FlagEnabled), ElementType.UnsignedInteger);
/// [Required] Applies only to subtitles. Set to 1 if the track is eligible for automatic selection by the player if it matches the user's language preference,even if the user's preferences would not normally enable subtitles with the selected audio track;this can be used for tracks containing only translations of audio in foreign languages or on-screen text.See (#default-track-selection) for more details.
public const ulong FlagForced = 0x55AA;
public static readonly ElementDescriptor FlagForcedDescriptor = new ElementDescriptor(FlagForced, nameof(FlagForced), ElementType.UnsignedInteger);
/// Set to 1 if and only if the track is suitable for users with hearing impairments.
public const ulong FlagHearingImpaired = 0x55AB;
public static readonly ElementDescriptor FlagHearingImpairedDescriptor = new ElementDescriptor(FlagHearingImpaired, nameof(FlagHearingImpaired), ElementType.UnsignedInteger);
/// [Required] Set to 1 if the track **MAY** contain blocks that use lacing.When set to 0, all blocks **MUST** have their lacing flags set to "no lacing"; see (#block-lacing) on 'Block' Lacing.
public const ulong FlagLacing = 0x9C;
public static readonly ElementDescriptor FlagLacingDescriptor = new ElementDescriptor(FlagLacing, nameof(FlagLacing), ElementType.UnsignedInteger);
/// Set to 1 if and only if the track is in the content's original language.
public const ulong FlagOriginal = 0x55AE;
public static readonly ElementDescriptor FlagOriginalDescriptor = new ElementDescriptor(FlagOriginal, nameof(FlagOriginal), ElementType.UnsignedInteger);
/// Set to 1 if and only if the track contains textual descriptions of video content.
public const ulong FlagTextDescriptions = 0x55AD;
public static readonly ElementDescriptor FlagTextDescriptionsDescriptor = new ElementDescriptor(FlagTextDescriptions, nameof(FlagTextDescriptions), ElementType.UnsignedInteger);
/// Set to 1 if and only if the track is suitable for users with visual impairments.
public const ulong FlagVisualImpaired = 0x55AC;
public static readonly ElementDescriptor FlagVisualImpairedDescriptor = new ElementDescriptor(FlagVisualImpaired, nameof(FlagVisualImpaired), ElementType.UnsignedInteger);
/// [Required] The language of the track,in the Matroska languages form; see (#language-codes) on language codes.This element **MUST** be ignored if the `LanguageBCP47` element is used in the same `TrackEntry`.
public const ulong Language = 0x22B59C;
public static readonly ElementDescriptor LanguageDescriptor = new ElementDescriptor(Language, nameof(Language), ElementType.AsciiString);
/// The language of the track,in the form defined in [@!RFC5646]; see (#language-codes) on language codes.If this element is used, then any `Language` elements used in the same `TrackEntry` **MUST** be ignored.
public const ulong LanguageBCP47 = 0x22B59D;
public static readonly ElementDescriptor LanguageBCP47Descriptor = new ElementDescriptor(LanguageBCP47, nameof(LanguageBCP47), ElementType.AsciiString);
/// [Required] The maximum value of `BlockAddID` ((#blockaddid-element)).A value of 0 means there is no `BlockAdditions` ((#blockadditions-element)) for this track.
public const ulong MaxBlockAdditionID = 0x55EE;
public static readonly ElementDescriptor MaxBlockAdditionIDDescriptor = new ElementDescriptor(MaxBlockAdditionID, nameof(MaxBlockAdditionID), ElementType.UnsignedInteger);
/// The maximum cache size necessary to store referenced frames in and the current frame.0 means no cache is needed.
public const ulong MaxCache = 0x6DF8;
public static readonly ElementDescriptor MaxCacheDescriptor = new ElementDescriptor(MaxCache, nameof(MaxCache), ElementType.UnsignedInteger);
/// [Required] The minimum number of frames a player should be able to cache during playback.If set to 0, the reference pseudo-cache system is not used.
public const ulong MinCache = 0x6DE7;
public static readonly ElementDescriptor MinCacheDescriptor = new ElementDescriptor(MinCache, nameof(MinCache), ElementType.UnsignedInteger);
/// A human-readable track name.
public const ulong Name = 0x536E;
public static readonly ElementDescriptor NameDescriptor = new ElementDescriptor(Name, nameof(Name), ElementType.Utf8String);
/// [Required] After a discontinuity, the duration of the datathat the decoder **MUST** decode before the decoded data is valid, expressed in Matroska Ticks -- i.e., in nanoseconds; see (#timestamp-ticks).
public const ulong SeekPreRoll = 0x56BB;
public static readonly ElementDescriptor SeekPreRollDescriptor = new ElementDescriptor(SeekPreRoll, nameof(SeekPreRoll), ElementType.UnsignedInteger);
/// [Required] The track number as used in the `Block` Header.
public const ulong TrackNumber = 0xD7;
public static readonly ElementDescriptor TrackNumberDescriptor = new ElementDescriptor(TrackNumber, nameof(TrackNumber), ElementType.UnsignedInteger);
/// A value to add to the `Block`'s Timestamp, expressed in Matroska Ticks -- i.e., in nanoseconds; see (#timestamp-ticks).This can be used to adjust the playback offset of a track.
public const ulong TrackOffset = 0x537F;
public static readonly ElementDescriptor TrackOffsetDescriptor = new ElementDescriptor(TrackOffset, nameof(TrackOffset), ElementType.SignedInteger);
/// Operation that needs to be applied on tracks to create this virtual track. For more details, see (#track-operation).
public const ulong TrackOperation = 0xE2;
public static readonly ElementDescriptor TrackOperationDescriptor = new ElementDescriptor(TrackOperation, nameof(TrackOperation), ElementType.MasterElement);
/// Contains the list of all video plane tracks that need to be combined to create this 3D track.
public const ulong TrackCombinePlanes = 0xE3;
public static readonly ElementDescriptor TrackCombinePlanesDescriptor = new ElementDescriptor(TrackCombinePlanes, nameof(TrackCombinePlanes), ElementType.MasterElement);
/// [Required] Contains a video plane track that needs to be combined to create this 3D track.
public const ulong TrackPlane = 0xE4;
public static readonly ElementDescriptor TrackPlaneDescriptor = new ElementDescriptor(TrackPlane, nameof(TrackPlane), ElementType.MasterElement);
/// [Required] The kind of plane this track corresponds to.
public const ulong TrackPlaneType = 0xE6;
public static readonly ElementDescriptor TrackPlaneTypeDescriptor = new ElementDescriptor(TrackPlaneType, nameof(TrackPlaneType), ElementType.UnsignedInteger);
/// [Required] The `TrackUID` number of the track representing the plane.
public const ulong TrackPlaneUID = 0xE5;
public static readonly ElementDescriptor TrackPlaneUIDDescriptor = new ElementDescriptor(TrackPlaneUID, nameof(TrackPlaneUID), ElementType.UnsignedInteger);
/// Contains the list of all tracks whose `Blocks` need to be combined to create this virtual track.
public const ulong TrackJoinBlocks = 0xE9;
public static readonly ElementDescriptor TrackJoinBlocksDescriptor = new ElementDescriptor(TrackJoinBlocks, nameof(TrackJoinBlocks), ElementType.MasterElement);
/// [Required] The `TrackUID` number of a track whose blocks are used to create this virtual track.
public const ulong TrackJoinUID = 0xED;
public static readonly ElementDescriptor TrackJoinUIDDescriptor = new ElementDescriptor(TrackJoinUID, nameof(TrackJoinUID), ElementType.UnsignedInteger);
/// Specify that this track is an overlay track for the `Track` specified (in the u-integer).This means that when this track has a gap on `SilentTracks`, the overlay track should be used instead. The order of multiple `TrackOverlay` matters; the first one is the one that should be used.If the first one is not found, it should be the second, etc.
public const ulong TrackOverlay = 0x6FAB;
public static readonly ElementDescriptor TrackOverlayDescriptor = new ElementDescriptor(TrackOverlay, nameof(TrackOverlay), ElementType.UnsignedInteger);
/// [Required] The scale to apply on this track to work at normal speed in relation with other tracks(mostly used to adjust video speed when the audio length differs).
public const ulong TrackTimestampScale = 0x23314F;
public static readonly ElementDescriptor TrackTimestampScaleDescriptor = new ElementDescriptor(TrackTimestampScale, nameof(TrackTimestampScale), ElementType.Float);
/// The mapping between this `TrackEntry` and a track value in the given Chapter Codec.
public const ulong TrackTranslate = 0x6624;
public static readonly ElementDescriptor TrackTranslateDescriptor = new ElementDescriptor(TrackTranslate, nameof(TrackTranslate), ElementType.MasterElement);
/// [Required] Applies to the chapter codec of the given chapter edition(s); see (#chapprocesscodecid-element).
public const ulong TrackTranslateCodec = 0x66BF;
public static readonly ElementDescriptor TrackTranslateCodecDescriptor = new ElementDescriptor(TrackTranslateCodec, nameof(TrackTranslateCodec), ElementType.UnsignedInteger);
/// Specifies a chapter edition UID to which this `TrackTranslate` applies.
public const ulong TrackTranslateEditionUID = 0x66FC;
public static readonly ElementDescriptor TrackTranslateEditionUIDDescriptor = new ElementDescriptor(TrackTranslateEditionUID, nameof(TrackTranslateEditionUID), ElementType.UnsignedInteger);
/// [Required] The binary value used to represent this `TrackEntry` in the chapter codec data.The format depends on the `ChapProcessCodecID` used; see (#chapprocesscodecid-element).
public const ulong TrackTranslateTrackID = 0x66A5;
public static readonly ElementDescriptor TrackTranslateTrackIDDescriptor = new ElementDescriptor(TrackTranslateTrackID, nameof(TrackTranslateTrackID), ElementType.Binary);
/// [Required] The `TrackType` defines the type of each frame found in the `Track`.The value **SHOULD** be stored on 1 octet.
public const ulong TrackType = 0x83;
public static readonly ElementDescriptor TrackTypeDescriptor = new ElementDescriptor(TrackType, nameof(TrackType), ElementType.UnsignedInteger);
/// [Required] A UID that identifies the `Track`.
public const ulong TrackUID = 0x73C5;
public static readonly ElementDescriptor TrackUIDDescriptor = new ElementDescriptor(TrackUID, nameof(TrackUID), ElementType.UnsignedInteger);
/// The `SegmentUUID` of the `Segment` containing the track identified by MasterTrackUID. See [@?DivXTrickTrack].
public const ulong TrickMasterTrackSegmentUID = 0xC4;
public static readonly ElementDescriptor TrickMasterTrackSegmentUIDDescriptor = new ElementDescriptor(TrickMasterTrackSegmentUID, nameof(TrickMasterTrackSegmentUID), ElementType.Binary);
/// The `TrackUID` of the video track in the paired EBML structure that corresponds to this Smooth FF/RW track. See [@?DivXTrickTrack].
public const ulong TrickMasterTrackUID = 0xC7;
public static readonly ElementDescriptor TrickMasterTrackUIDDescriptor = new ElementDescriptor(TrickMasterTrackUID, nameof(TrickMasterTrackUID), ElementType.UnsignedInteger);
/// Set to 1 if this video track is a Smooth FF/RW track. If set to 1, `MasterTrackUID` and `MasterTrackSegUID` should be present, and`BlockGroups` for this track must contain ReferenceFrame structures.Otherwise, TrickTrackUID and TrickTrackSegUID must be present if this track has a corresponding Smooth FF/RW track. See [@?DivXTrickTrack].
public const ulong TrickTrackFlag = 0xC6;
public static readonly ElementDescriptor TrickTrackFlagDescriptor = new ElementDescriptor(TrickTrackFlag, nameof(TrickTrackFlag), ElementType.UnsignedInteger);
/// The `SegmentUUID` of the `Segment` containing the track identified by TrickTrackUID. See [@?DivXTrickTrack].
public const ulong TrickTrackSegmentUID = 0xC1;
public static readonly ElementDescriptor TrickTrackSegmentUIDDescriptor = new ElementDescriptor(TrickTrackSegmentUID, nameof(TrickTrackSegmentUID), ElementType.Binary);
/// The `TrackUID` of the Smooth FF/RW video in the paired EBML structure corresponding to this video track. See [@?DivXTrickTrack].
public const ulong TrickTrackUID = 0xC0;
public static readonly ElementDescriptor TrickTrackUIDDescriptor = new ElementDescriptor(TrickTrackUID, nameof(TrickTrackUID), ElementType.UnsignedInteger);
/// Video settings.
public const ulong Video = 0xE0;
public static readonly ElementDescriptor VideoDescriptor = new ElementDescriptor(Video, nameof(Video), ElementType.MasterElement);
/// [Required] Indicates whether the `BlockAdditional` element with `BlockAddID` of "1"contains Alpha data as defined by the Codec Mapping for the `CodecID`.Undefined values (i.e., values other than 0 or 1) **SHOULD NOT** be used, as thebehavior of known implementations is different.
public const ulong AlphaMode = 0x53C0;
public static readonly ElementDescriptor AlphaModeDescriptor = new ElementDescriptor(AlphaMode, nameof(AlphaMode), ElementType.UnsignedInteger);
/// Specifies the possible modifications to the aspect ratio.
public const ulong AspectRatioType = 0x54B3;
public static readonly ElementDescriptor AspectRatioTypeDescriptor = new ElementDescriptor(AspectRatioType, nameof(AspectRatioType), ElementType.UnsignedInteger);
/// Settings describing the color format.
public const ulong Colour = 0x55B0;
public static readonly ElementDescriptor ColourDescriptor = new ElementDescriptor(Colour, nameof(Colour), ElementType.MasterElement);
/// [Required] Number of decoded bits per channel. A value of 0 indicates that the `BitsPerChannel` is unspecified.
public const ulong BitsPerChannel = 0x55B2;
public static readonly ElementDescriptor BitsPerChannelDescriptor = new ElementDescriptor(BitsPerChannel, nameof(BitsPerChannel), ElementType.UnsignedInteger);
/// The number of pixels to remove in the Cb channel for every pixel not removed horizontally.This is additive with `ChromaSubsamplingHorz`.Example: For video with 4:2:1 chromasubsampling, the `ChromaSubsamplingHorz` **SHOULD** be set to 1, and `CbSubsamplingHorz` **SHOULD** be set to 1.
public const ulong CbSubsamplingHorz = 0x55B5;
public static readonly ElementDescriptor CbSubsamplingHorzDescriptor = new ElementDescriptor(CbSubsamplingHorz, nameof(CbSubsamplingHorz), ElementType.UnsignedInteger);
/// The number of pixels to remove in the Cb channel for every pixel not removed vertically.This is additive with `ChromaSubsamplingVert`.
public const ulong CbSubsamplingVert = 0x55B6;
public static readonly ElementDescriptor CbSubsamplingVertDescriptor = new ElementDescriptor(CbSubsamplingVert, nameof(CbSubsamplingVert), ElementType.UnsignedInteger);
/// [Required] How chroma is subsampled horizontally.
public const ulong ChromaSitingHorz = 0x55B7;
public static readonly ElementDescriptor ChromaSitingHorzDescriptor = new ElementDescriptor(ChromaSitingHorz, nameof(ChromaSitingHorz), ElementType.UnsignedInteger);
/// [Required] How chroma is subsampled vertically.
public const ulong ChromaSitingVert = 0x55B8;
public static readonly ElementDescriptor ChromaSitingVertDescriptor = new ElementDescriptor(ChromaSitingVert, nameof(ChromaSitingVert), ElementType.UnsignedInteger);
/// The number of pixels to remove in the Cr and Cb channels for every pixel not removed horizontally. Example: For video with 4:2:0 chroma subsampling, the `ChromaSubsamplingHorz`**SHOULD** be set to 1.
public const ulong ChromaSubsamplingHorz = 0x55B3;
public static readonly ElementDescriptor ChromaSubsamplingHorzDescriptor = new ElementDescriptor(ChromaSubsamplingHorz, nameof(ChromaSubsamplingHorz), ElementType.UnsignedInteger);
/// The number of pixels to remove in the Cr and Cb channels for every pixel not removed vertically.Example: For video with 4:2:0 chroma subsampling, the `ChromaSubsamplingVert`**SHOULD** be set to 1.
public const ulong ChromaSubsamplingVert = 0x55B4;
public static readonly ElementDescriptor ChromaSubsamplingVertDescriptor = new ElementDescriptor(ChromaSubsamplingVert, nameof(ChromaSubsamplingVert), ElementType.UnsignedInteger);
/// SMPTE 2086 mastering data.
public const ulong MasteringMetadata = 0x55D0;
public static readonly ElementDescriptor MasteringMetadataDescriptor = new ElementDescriptor(MasteringMetadata, nameof(MasteringMetadata), ElementType.MasterElement);
/// Maximum luminance. Represented in candelas per square meter (cd/m^2^).
public const ulong LuminanceMax = 0x55D9;
public static readonly ElementDescriptor LuminanceMaxDescriptor = new ElementDescriptor(LuminanceMax, nameof(LuminanceMax), ElementType.Float);
/// Minimum luminance. Represented in candelas per square meter (cd/m^2^).
public const ulong LuminanceMin = 0x55DA;
public static readonly ElementDescriptor LuminanceMinDescriptor = new ElementDescriptor(LuminanceMin, nameof(LuminanceMin), ElementType.Float);
/// Blue X chromaticity coordinate, as defined by [@!CIE-1931].
public const ulong PrimaryBChromaticityX = 0x55D5;
public static readonly ElementDescriptor PrimaryBChromaticityXDescriptor = new ElementDescriptor(PrimaryBChromaticityX, nameof(PrimaryBChromaticityX), ElementType.Float);
/// Blue Y chromaticity coordinate, as defined by [@!CIE-1931].
public const ulong PrimaryBChromaticityY = 0x55D6;
public static readonly ElementDescriptor PrimaryBChromaticityYDescriptor = new ElementDescriptor(PrimaryBChromaticityY, nameof(PrimaryBChromaticityY), ElementType.Float);
/// Green X chromaticity coordinate, as defined by [@!CIE-1931].
public const ulong PrimaryGChromaticityX = 0x55D3;
public static readonly ElementDescriptor PrimaryGChromaticityXDescriptor = new ElementDescriptor(PrimaryGChromaticityX, nameof(PrimaryGChromaticityX), ElementType.Float);
/// Green Y chromaticity coordinate, as defined by [@!CIE-1931].
public const ulong PrimaryGChromaticityY = 0x55D4;
public static readonly ElementDescriptor PrimaryGChromaticityYDescriptor = new ElementDescriptor(PrimaryGChromaticityY, nameof(PrimaryGChromaticityY), ElementType.Float);
/// Red X chromaticity coordinate, as defined by [@!CIE-1931].
public const ulong PrimaryRChromaticityX = 0x55D1;
public static readonly ElementDescriptor PrimaryRChromaticityXDescriptor = new ElementDescriptor(PrimaryRChromaticityX, nameof(PrimaryRChromaticityX), ElementType.Float);
/// Red Y chromaticity coordinate, as defined by [@!CIE-1931].
public const ulong PrimaryRChromaticityY = 0x55D2;
public static readonly ElementDescriptor PrimaryRChromaticityYDescriptor = new ElementDescriptor(PrimaryRChromaticityY, nameof(PrimaryRChromaticityY), ElementType.Float);
/// White X chromaticity coordinate, as defined by [@!CIE-1931].
public const ulong WhitePointChromaticityX = 0x55D7;
public static readonly ElementDescriptor WhitePointChromaticityXDescriptor = new ElementDescriptor(WhitePointChromaticityX, nameof(WhitePointChromaticityX), ElementType.Float);
/// White Y chromaticity coordinate, as defined by [@!CIE-1931].
public const ulong WhitePointChromaticityY = 0x55D8;
public static readonly ElementDescriptor WhitePointChromaticityYDescriptor = new ElementDescriptor(WhitePointChromaticityY, nameof(WhitePointChromaticityY), ElementType.Float);
/// [Required] The Matrix Coefficients of the video used to derive luma and chroma values from red, green, and blue color primaries.For clarity, the value and meanings for `MatrixCoefficients` are adopted from Table 4 of [@!ITU-H.273].
public const ulong MatrixCoefficients = 0x55B1;
public static readonly ElementDescriptor MatrixCoefficientsDescriptor = new ElementDescriptor(MatrixCoefficients, nameof(MatrixCoefficients), ElementType.UnsignedInteger);
/// Maximum brightness of a single pixel (Maximum Content Light Level)in candelas per square meter (cd/m^2^).
public const ulong MaxCLL = 0x55BC;
public static readonly ElementDescriptor MaxCLLDescriptor = new ElementDescriptor(MaxCLL, nameof(MaxCLL), ElementType.UnsignedInteger);
/// Maximum brightness of a single full frame (Maximum Frame-Average Light Level)in candelas per square meter (cd/m^2^).
public const ulong MaxFALL = 0x55BD;
public static readonly ElementDescriptor MaxFALLDescriptor = new ElementDescriptor(MaxFALL, nameof(MaxFALL), ElementType.UnsignedInteger);
/// [Required] The color primaries of the video. For clarity,the value and meanings for `Primaries` are adopted from Table 2 of [@!ITU-H.273].
public const ulong Primaries = 0x55BB;
public static readonly ElementDescriptor PrimariesDescriptor = new ElementDescriptor(Primaries, nameof(Primaries), ElementType.UnsignedInteger);
/// [Required] Clipping of the color ranges.
public const ulong Range = 0x55B9;
public static readonly ElementDescriptor RangeDescriptor = new ElementDescriptor(Range, nameof(Range), ElementType.UnsignedInteger);
/// [Required] The transfer characteristics of the video. For clarity,the value and meanings for `TransferCharacteristics` are adopted from Table 3 of [@!ITU-H.273].
public const ulong TransferCharacteristics = 0x55BA;
public static readonly ElementDescriptor TransferCharacteristicsDescriptor = new ElementDescriptor(TransferCharacteristics, nameof(TransferCharacteristics), ElementType.UnsignedInteger);
/// Height of the video frames to display. Applies to the video frame after cropping (PixelCrop* Elements).
public const ulong DisplayHeight = 0x54BA;
public static readonly ElementDescriptor DisplayHeightDescriptor = new ElementDescriptor(DisplayHeight, nameof(DisplayHeight), ElementType.UnsignedInteger);
/// [Required] How `DisplayWidth` and `DisplayHeight` are interpreted.
public const ulong DisplayUnit = 0x54B2;
public static readonly ElementDescriptor DisplayUnitDescriptor = new ElementDescriptor(DisplayUnit, nameof(DisplayUnit), ElementType.UnsignedInteger);
/// Width of the video frames to display. Applies to the video frame after cropping (PixelCrop* Elements).
public const ulong DisplayWidth = 0x54B0;
public static readonly ElementDescriptor DisplayWidthDescriptor = new ElementDescriptor(DisplayWidth, nameof(DisplayWidth), ElementType.UnsignedInteger);
/// [Required] Specifies the field ordering of video frames in this track.
public const ulong FieldOrder = 0x9D;
public static readonly ElementDescriptor FieldOrderDescriptor = new ElementDescriptor(FieldOrder, nameof(FieldOrder), ElementType.UnsignedInteger);
/// [Required] Specifies whether the video frames in this track are interlaced.
public const ulong FlagInterlaced = 0x9A;
public static readonly ElementDescriptor FlagInterlacedDescriptor = new ElementDescriptor(FlagInterlaced, nameof(FlagInterlaced), ElementType.UnsignedInteger);
/// Number of frames per second. This value is informational only. It is intended for constant frame rate streams and should not beused for a variable frame rate `TrackEntry`.
public const ulong FrameRate = 0x2383E3;
public static readonly ElementDescriptor FrameRateDescriptor = new ElementDescriptor(FrameRate, nameof(FrameRate), ElementType.Float);
/// Gamma value.
public const ulong GammaValue = 0x2FB523;
public static readonly ElementDescriptor GammaValueDescriptor = new ElementDescriptor(GammaValue, nameof(GammaValue), ElementType.Float);
/// Bogus `StereoMode` value used in old versions of [@?libmatroska].
public const ulong OldStereoMode = 0x53B9;
public static readonly ElementDescriptor OldStereoModeDescriptor = new ElementDescriptor(OldStereoMode, nameof(OldStereoMode), ElementType.UnsignedInteger);
/// [Required] The number of video pixels to remove at the bottom of the image.
public const ulong PixelCropBottom = 0x54AA;
public static readonly ElementDescriptor PixelCropBottomDescriptor = new ElementDescriptor(PixelCropBottom, nameof(PixelCropBottom), ElementType.UnsignedInteger);
/// [Required] The number of video pixels to remove on the left of the image.
public const ulong PixelCropLeft = 0x54CC;
public static readonly ElementDescriptor PixelCropLeftDescriptor = new ElementDescriptor(PixelCropLeft, nameof(PixelCropLeft), ElementType.UnsignedInteger);
/// [Required] The number of video pixels to remove on the right of the image.
public const ulong PixelCropRight = 0x54DD;
public static readonly ElementDescriptor PixelCropRightDescriptor = new ElementDescriptor(PixelCropRight, nameof(PixelCropRight), ElementType.UnsignedInteger);
/// [Required] The number of video pixels to remove at the top of the image.
public const ulong PixelCropTop = 0x54BB;
public static readonly ElementDescriptor PixelCropTopDescriptor = new ElementDescriptor(PixelCropTop, nameof(PixelCropTop), ElementType.UnsignedInteger);
/// [Required] Height of the encoded video frames in pixels.
public const ulong PixelHeight = 0xBA;
public static readonly ElementDescriptor PixelHeightDescriptor = new ElementDescriptor(PixelHeight, nameof(PixelHeight), ElementType.UnsignedInteger);
/// [Required] Width of the encoded video frames in pixels.
public const ulong PixelWidth = 0xB0;
public static readonly ElementDescriptor PixelWidthDescriptor = new ElementDescriptor(PixelWidth, nameof(PixelWidth), ElementType.UnsignedInteger);
/// Describes the video projection details. Used to render spherical or VR videos or to flip videos horizontally or vertically.
public const ulong Projection = 0x7670;
public static readonly ElementDescriptor ProjectionDescriptor = new ElementDescriptor(Projection, nameof(Projection), ElementType.MasterElement);
/// [Required] Specifies a pitch rotation to the projection. Value represents a counter-clockwise rotation, in degrees, around the right vector. This rotation must be appliedafter the `ProjectionPoseYaw` rotation and before the `ProjectionPoseRoll` rotation.The value of this element **MUST** be in the -90 to 90 degree range, both inclusive.
public const ulong ProjectionPosePitch = 0x7674;
public static readonly ElementDescriptor ProjectionPosePitchDescriptor = new ElementDescriptor(ProjectionPosePitch, nameof(ProjectionPosePitch), ElementType.Float);
/// [Required] Specifies a roll rotation to the projection. Value represents acounter-clockwise rotation, in degrees, around the forward vector. Thisrotation must be applied after the `ProjectionPoseYaw` and`ProjectionPosePitch` rotations. The value of this element**MUST** be in the -180 to 180 degree range, both inclusive. Setting `ProjectionPoseRoll` to 180 or -180 degrees and`ProjectionPoseYaw` to 180 or -180 degrees with`ProjectionPosePitch` set to 0 degrees flips the image vertically.Setting `ProjectionPoseRoll` to 180 or -180 degrees with`ProjectionPoseYaw` and `ProjectionPosePitch` set to 0 degreesflips the image horizontally and vertically.
public const ulong ProjectionPoseRoll = 0x7675;
public static readonly ElementDescriptor ProjectionPoseRollDescriptor = new ElementDescriptor(ProjectionPoseRoll, nameof(ProjectionPoseRoll), ElementType.Float);
/// [Required] Specifies a yaw rotation to the projection. Value represents a clockwise rotation, in degrees, around the up vector. This rotation must be appliedbefore any `ProjectionPosePitch` or `ProjectionPoseRoll` rotations.The value of this element **MUST** be in the -180 to 180 degree range, both inclusive.Setting `ProjectionPoseYaw` to 180 or -180 degrees with `ProjectionPoseRoll` and `ProjectionPosePitch` set to 0 degrees flips the image horizontally.
public const ulong ProjectionPoseYaw = 0x7673;
public static readonly ElementDescriptor ProjectionPoseYawDescriptor = new ElementDescriptor(ProjectionPoseYaw, nameof(ProjectionPoseYaw), ElementType.Float);
/// Private data that only applies to a specific projection.* If `ProjectionType` equals 0 (rectangular),then this element **MUST NOT** be present.* If `ProjectionType` equals 1 (equirectangular), then this element **MUST** be present and contain the same binary data that would be stored insidean ISOBMFF Equirectangular Projection Box ("equi").* If `ProjectionType` equals 2 (cubemap), then this element **MUST** be present and contain the same binary data that would be storedinside an ISOBMFF Cubemap Projection Box ("cbmp").* If `ProjectionType` equals 3 (mesh), then this element **MUST** be present and contain the same binary data that would be stored insidean ISOBMFF Mesh Projection Box ("mshp").
public const ulong ProjectionPrivate = 0x7672;
public static readonly ElementDescriptor ProjectionPrivateDescriptor = new ElementDescriptor(ProjectionPrivate, nameof(ProjectionPrivate), ElementType.Binary);
/// [Required] Describes the projection used for this video track.
public const ulong ProjectionType = 0x7671;
public static readonly ElementDescriptor ProjectionTypeDescriptor = new ElementDescriptor(ProjectionType, nameof(ProjectionType), ElementType.UnsignedInteger);
/// [Required] Stereo-3D video mode. See (#multi-planar-and-3d-videos) for more details.
public const ulong StereoMode = 0x53B8;
public static readonly ElementDescriptor StereoModeDescriptor = new ElementDescriptor(StereoMode, nameof(StereoMode), ElementType.UnsignedInteger);
/// Specifies the uncompressed pixel format used for the `Track`'s data as a FourCC.This value is similar in scope to the biCompression value of AVI's `BITMAPINFO` [@?AVIFormat]. There is neither a definitive list of FourCC values nor an official registry. Some common values for YUV pixel formats can be found at [@?MSYUV8], [@?MSYUV16], and [@?FourCC-YUV]. Some common values for uncompressed RGB pixel formats can be found at [@?MSRGB] and [@?FourCC-RGB].
public const ulong UncompressedFourCC = 0x2EB524;
public static readonly ElementDescriptor UncompressedFourCCDescriptor = new ElementDescriptor(UncompressedFourCC, nameof(UncompressedFourCC), ElementType.Binary);
#endregion
}