diff --git a/src/add-ons/media/plugins/matroska/libmatroska/FileKax.cpp b/src/add-ons/media/plugins/matroska/libmatroska/FileKax.cpp new file mode 100644 index 0000000000..0385d1e85d --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/FileKax.cpp @@ -0,0 +1,449 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2003 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: FileKax.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme +*/ +//#include "StdInclude.h" +#include "matroska/FileKax.h" +//#include "Cluster.h" +//#include "Track.h" +//#include "Block.h" +//#include "Frame.h" +//#include "Version.h" + +START_LIBMATROSKA_NAMESPACE + +//typedef Track *TrackID; + +FileMatroska::FileMatroska(IOCallback & output) + :myFile(output) +#ifdef OLD + ,myCurrReadBlock(NULL) + ,myMinClusterSize(5*1024) // 5KB is the min size of a cluster + ,myMaxClusterSize(2*1024*1024) // 2MB is the max size of a cluster + ,myCurrReadBlockTrack(0) + ,myCurrWriteCluster(2*1024*1024) // myMaxClusterSize + ,myCurrReadCluster(NULL) + ,myReadBlockNumber(0) +#endif // OLD +{ +#ifdef OLD + myStreamInfo.MainHeaderSize = TypeHeader::default_size() + + ActualHeader::default_size() + + ExtendedInfo::default_size() + + ContentInfo::default_size(); + myStreamInfo.TrackEntrySize = Track::default_size(); + myStreamInfo.BlockHeadSize = BLOCK_HEADER_SIZE; + myStreamInfo.ClusterHeadSize = CLUSTER_HEADER_SIZE; + myStreamInfo.ClusterFootSize = CLUSTER_TRAILER_SIZE; +#endif // OLD +} + +FileMatroska::~FileMatroska() +{ +// if (myCurrCluster != NULL) +// throw 0; // there are some data left to write +// if (myCurrReadCluster != NULL || myCurrReadBlock != NULL) +// throw 0; // there are some data left to write +} + +#ifdef OLD +void FileMatroska::SetMaxClusterSize(const uint32 value) +{ + myMaxClusterSize = value; + myCurrWriteCluster.setMaxSize(value); +} + +void FileMatroska::Close(const uint32 aTimeLength) +{ + Flush(); + + // get the file size + myFile.setFilePointer(0,seek_end); + myMainHeader.type_SetSize(myFile.getFilePointer()); + + // rewrite the header at the beginning + myFile.setFilePointer(0,seek_beginning); + + // get the Track-entry size + uint32 track_entries_size = 0; + for (size_t i=0; idefault_size(); + } + + myStreamInfo.TrackEntriesSize = track_entries_size; + myStreamInfo.TimeLength = aTimeLength; + myMainHeader.Render(myFile, myStreamInfo); + + for (i=0; idefault_size(); + } + + std::string aStr = LIB_NAME; + aStr += " "; + aStr += VERSION; + myStreamInfo.EncoderLib = aStr; + + myStreamInfo.EncoderApp = aEncoderApp; + + myStreamInfo.TrackEntryPosition = 0 + myStreamInfo.MainHeaderSize; + myStreamInfo.TrackEntriesSize = myTracks.size() * myStreamInfo.TrackEntrySize; + + myStreamInfo.CodecEntryPosition = myStreamInfo.MainHeaderSize + myStreamInfo.TrackEntriesSize; + myStreamInfo.CodecEntrySize = 4; + for (i=0; iCodecSize(); + } + + // Main Header + uint32 result = myMainHeader.Render(myFile, myStreamInfo); + + // Track Entries + for (i=0; iRenderEntry(myFile, i+1); + } + myStreamInfo.ClusterPosition = myStreamInfo.CodecEntryPosition + myStreamInfo.CodecEntrySize; + + // Codec Header + result = CodecHeader::Render(myFile, myTracks); + + return result; + } + catch (exception & Ex) + { + throw Ex; + } +} + +/*! + \return 0 if the track was not created, or a valid track number +*/ +Track * FileMatroska::CreateTrack(const track_type aType) +{ + myTracks.push_back(new Track(aType)); + return myTracks.back(); +} + +/*Track *FileMatroska::findTrack(Track * aTrack) const +{ + for (size_t i=0; iSetName(aName); + } +} + +void FileMatroska::track_SetLaced(Track * aTrack, const bool bLaced) +{ + if (IsMyTrack(aTrack)) + { + aTrack->SetLaced(bLaced); + } +} + +bool FileMatroska::AddFrame(Track * aTrack, const uint32 aTimecode, const binary *aFrame, const uint32 aFrameSize, + const bool aKeyFrame, const bool aBFrame) +{ + try { + // make sure we know that track + if (IsMyTrack(aTrack)) + { + // pass the cluster to the track + // handle the creation of a new cluster if needed + if (aTrack->AddFrame(aTimecode, aFrame, aFrameSize, aKeyFrame, aBFrame)) + { + while (!aTrack->SerialiseBlock(myCurrWriteCluster)) + { + /// \todo handle errors + uint32 aNbBlock; + myStreamInfo.ClusterSize += myCurrWriteCluster.Render(myFile, aNbBlock); + myStreamInfo.NumberBlock += aNbBlock; + myCurrWriteCluster.Flush(); + } + } + return true; + } + return false; + } + catch (exception & Ex) + { + throw Ex; + } +} + +void FileMatroska::Flush() +{ + uint32 aNbBlock; + myStreamInfo.ClusterSize += myCurrWriteCluster.Render(myFile,aNbBlock); + myStreamInfo.NumberBlock += aNbBlock; +} + +uint32 FileMatroska::ReadHead() +{ + try { + uint32 result = myMainHeader.Read(myFile, myStreamInfo); + + return result; + } + catch (exception & Ex) + { + throw Ex; + } +} + +uint32 FileMatroska::ReadTracks() +{ + try { + uint32 result = 0; + + // seek to the start of the Track Entries + myFile.setFilePointer(myStreamInfo.TrackEntryPosition); + // get the number of Track Entries + uint8 TrackNumber = myStreamInfo.TrackEntriesSize / myStreamInfo.TrackEntrySize; + // read all the Track Entries + myTracks.clear(); + for (uint8 TrackIdx = 0; TrackIdx::const_iterator i = myTracks.begin(); i != myTracks.end(); i ++) + { + if (*i == aTrack) + break; + } + + if (i != myTracks.end()) + return true; + else + return false; +} + +void FileMatroska::SelectReadingTrack(Track * aTrack, bool select) +{ + if (IsMyTrack(aTrack)) + { + // here we have the right track + // check if it's not already selected + for (std::vector::iterator j = mySelectedTracks.begin(); + j != mySelectedTracks.end(); j ++) + { + if (*j == aTrack->TrackNumber()) + break; + } + + if (select && j == mySelectedTracks.end()) + mySelectedTracks.push_back(aTrack->TrackNumber()); + else if (!select && j != mySelectedTracks.end()) + mySelectedTracks.erase(j); + + std::sort(mySelectedTracks.begin(), mySelectedTracks.end()); + } +} + +inline bool FileMatroska::IsReadingTrack(const uint8 aTrackNumber) const +{ + for (std::vector::const_iterator trackIdx = mySelectedTracks.begin(); + trackIdx != mySelectedTracks.end() && *trackIdx < aTrackNumber; + trackIdx++) + {} + + if (trackIdx == mySelectedTracks.end()) + return false; + else + return true; +} + +// + +void FileMatroska::Track_GetInfo(const Track * aTrack, TrackInfo & aTrackInfo) const +{ + if (IsMyTrack(aTrack)) + { + aTrack->GetInfo(aTrackInfo); + } +} + +// Audio related getters/setters + +void FileMatroska::Track_GetInfo_Audio(const Track * aTrack, TrackInfoAudio & aTrackInfo) const +{ + if (IsMyTrack(aTrack)) + { + aTrack->GetInfoAudio(aTrackInfo); + } +} + +void FileMatroska::Track_SetInfo_Audio(Track * aTrack, const TrackInfoAudio & aTrackInfo) +{ + if (IsMyTrack(aTrack)) + { + aTrack->SetInfoAudio(aTrackInfo); + } +} + +// Video related getters/setters + +void FileMatroska::Track_GetInfo_Video(const Track * aTrack, TrackInfoVideo & aTrackInfo) const +{ + if (IsMyTrack(aTrack)) + { + aTrack->GetInfoVideo(aTrackInfo); + } +} + +void FileMatroska::Track_SetInfo_Video(Track * aTrack, const TrackInfoVideo & aTrackInfo) +{ + if (IsMyTrack(aTrack)) + { + aTrack->SetInfoVideo(aTrackInfo); + } +} + +/*! + \todo exit when there is no Block left +*/ +bool FileMatroska::ReadFrame(Track * & aTrack, uint32 & aTimecode, const binary * & aFrame, uint32 & aFrameSize, + bool & aKeyFrame, bool & aBFrame) +{ + if (myCurrReadBlockTrack == 0) + { + do { + if (myReadBlockNumber >= myStreamInfo.NumberBlock) + { +// myReadBlockNumber = myStreamInfo.NumberBlock; + return false; + } + + // get the next frame in the file + if (!myCurrReadCluster.BlockLeft()) + { + myCurrReadCluster.Flush(); + try { + myCurrReadCluster.FindHead(myFile); + } + catch (exception & Ex) + { + return false; + } + } + + myCurrReadCluster.GetBlock( myCurrReadBlock, myCurrReadBlockSize, myCurrReadBlockTrack ); + myReadBlockNumber++; + } while (!IsReadingTrack(myCurrReadBlockTrack)); + + // get the track associated (normally from myTracks) + aTrack = myTracks[myCurrReadBlockTrack-1]; + // get the next frame from the current block + aTrack->HandleBlock(myCurrReadBlock, myCurrReadBlockSize); + } + else + { + // get the track associated (normally from myTracks) + aTrack = myTracks[myCurrReadBlockTrack-1]; + } + + Frame * myReadFrame; + aTrack->GetNextFrame(aTimecode, myReadFrame, aKeyFrame, aBFrame); + aFrame = myReadFrame->buf(); + aFrameSize = myReadFrame->length(); + + if (aTrack->NoFrameLeft()) + { + aTrack->FlushBlock(); + myCurrReadBlockTrack = 0; + } + + return true; +} +#endif // OLD + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxAttached.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxAttached.cpp new file mode 100644 index 0000000000..73469656f9 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxAttached.cpp @@ -0,0 +1,80 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxAttached.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme +*/ +#include "matroska/KaxAttached.h" +#include "matroska/KaxContexts.h" + +// sub elements + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +EbmlSemantic KaxAttached_ContextList[5] = +{ + EbmlSemantic(true, true, KaxFileName::ClassInfos), + EbmlSemantic(true, true, KaxMimeType::ClassInfos), + EbmlSemantic(true, true, KaxFileData::ClassInfos), + EbmlSemantic(false, true, KaxFileDescription::ClassInfos), + EbmlSemantic(true, true, KaxFileUID::ClassInfos), +}; + +EbmlId KaxAttached_TheId (0x61A7, 2); +EbmlId KaxFileDescription_TheId(0x467E, 2); +EbmlId KaxFileName_TheId (0x466E, 2); +EbmlId KaxMimeType_TheId (0x4660, 2); +EbmlId KaxFileData_TheId (0x465C, 2); +EbmlId KaxFileUID_TheId (0x46AE, 2); + +const EbmlSemanticContext KaxAttached_Context = EbmlSemanticContext(countof(KaxAttached_ContextList), KaxAttached_ContextList, &KaxAttachments_Context, *GetKaxGlobal_Context, &KaxAttached::ClassInfos); +const EbmlSemanticContext KaxFileDescription_Context = EbmlSemanticContext(0, NULL, &KaxAttachments_Context, *GetKaxGlobal_Context, &KaxFileDescription::ClassInfos); +const EbmlSemanticContext KaxFileName_Context = EbmlSemanticContext(0, NULL, &KaxAttachments_Context, *GetKaxGlobal_Context, &KaxFileName::ClassInfos); +const EbmlSemanticContext KaxMimeType_Context = EbmlSemanticContext(0, NULL, &KaxAttachments_Context, *GetKaxGlobal_Context, &KaxMimeType::ClassInfos); +const EbmlSemanticContext KaxFileData_Context = EbmlSemanticContext(0, NULL, &KaxAttachments_Context, *GetKaxGlobal_Context, &KaxFileData::ClassInfos); +const EbmlSemanticContext KaxFileUID_Context = EbmlSemanticContext(0, NULL, &KaxAttachments_Context, *GetKaxGlobal_Context, &KaxFileUID::ClassInfos); + +const EbmlCallbacks KaxAttached::ClassInfos(KaxAttached::Create, KaxAttached_TheId, "AttachedFile", KaxAttached_Context); +const EbmlCallbacks KaxFileDescription::ClassInfos(KaxFileDescription::Create, KaxFileDescription_TheId, "FileDescription", KaxFileDescription_Context); +const EbmlCallbacks KaxFileName::ClassInfos(KaxFileName::Create, KaxFileName_TheId, "FileName", KaxFileName_Context); +const EbmlCallbacks KaxMimeType::ClassInfos(KaxMimeType::Create, KaxMimeType_TheId, "FileMimeType", KaxMimeType_Context); +const EbmlCallbacks KaxFileData::ClassInfos(KaxFileData::Create, KaxFileData_TheId, "FileData", KaxFileData_Context); +const EbmlCallbacks KaxFileUID::ClassInfos(KaxFileUID::Create, KaxFileUID_TheId, "FileUID", KaxFileUID_Context); + +KaxAttached::KaxAttached() + :EbmlMaster(KaxAttached_Context) +{ + SetSizeLength(2); // mandatory min size support (for easier updating) (2^(7*2)-2 = 16Ko) +} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxAttachments.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxAttachments.cpp new file mode 100644 index 0000000000..4a654faeda --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxAttachments.cpp @@ -0,0 +1,60 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxAttachments.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme +*/ +#include "matroska/KaxAttachments.h" +#include "matroska/KaxAttached.h" +#include "matroska/KaxContexts.h" + +using namespace LIBEBML_NAMESPACE; + +// sub elements +START_LIBMATROSKA_NAMESPACE + +EbmlSemantic KaxAttachments_ContextList[1] = +{ + EbmlSemantic(true, false, KaxAttached::ClassInfos), ///< EBMLVersion +}; + +const EbmlSemanticContext KaxAttachments_Context = EbmlSemanticContext(countof(KaxAttachments_ContextList), KaxAttachments_ContextList, &KaxSegment_Context, *GetKaxGlobal_Context, &KaxAttachments::ClassInfos); + +EbmlId KaxAttachments_TheId(0x1941A469, 4); +const EbmlCallbacks KaxAttachments::ClassInfos(KaxAttachments::Create, KaxAttachments_TheId, "Attachments", KaxAttachments_Context); + +KaxAttachments::KaxAttachments() + :EbmlMaster(KaxAttachments_Context) +{ + SetSizeLength(2); // mandatory min size support (for easier updating) (2^(7*2)-2 = 16Ko) +} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxBlock.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxBlock.cpp new file mode 100644 index 0000000000..f3b06e0fd3 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxBlock.cpp @@ -0,0 +1,903 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxBlock.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme + \author Julien Coloos +*/ +#include + +//#include + +#include "matroska/KaxBlock.h" +#include "matroska/KaxContexts.h" +#include "matroska/KaxBlockData.h" +#include "matroska/KaxCluster.h" + +START_LIBMATROSKA_NAMESPACE + +#if MATROSKA_VERSION == 1 +const EbmlSemantic KaxBlockGroup_ContextList[5] = +#else // MATROSKA_VERSION +const EbmlSemantic KaxBlockGroup_ContextList[8] = +#endif // MATROSKA_VERSION +{ + EbmlSemantic(true, true, KaxBlock::ClassInfos), +#if MATROSKA_VERSION >= 2 + EbmlSemantic(false, true, KaxBlockVirtual::ClassInfos), +#endif // MATROSKA_VERSION + EbmlSemantic(false, true, KaxBlockDuration::ClassInfos), + EbmlSemantic(false, true, KaxSlices::ClassInfos), + EbmlSemantic(true, true, KaxReferencePriority::ClassInfos), + EbmlSemantic(false, false, KaxReferenceBlock::ClassInfos), +#if MATROSKA_VERSION >= 2 + EbmlSemantic(false, true, KaxReferenceVirtual::ClassInfos), + EbmlSemantic(false, true, KaxBlockAdditions::ClassInfos), +#endif // MATROSKA_VERSION +}; + +#if MATROSKA_VERSION >= 2 +const EbmlSemantic KaxBlockAdditions_ContextList[1] = +{ + EbmlSemantic(true, false, KaxBlockMore::ClassInfos) +}; + +const EbmlSemantic KaxBlockMore_ContextList[2] = +{ + EbmlSemantic(true, true, KaxBlockAddID::ClassInfos), + EbmlSemantic(true, true, KaxBlockAdditional::ClassInfos) +}; +#endif // MATROSKA_VERSION + +EbmlId KaxBlockGroup_TheId (0xA0, 1); +EbmlId KaxBlock_TheId (0xA1, 1); +EbmlId KaxBlockDuration_TheId (0x9B, 1); +#if MATROSKA_VERSION >= 2 +EbmlId KaxBlockVirtual_TheId (0xA2, 1); +EbmlId KaxBlockAdditions_TheId (0x75A1, 2); +EbmlId KaxBlockMore_TheId (0xA6, 1); +EbmlId KaxBlockAddID_TheId (0xEE, 1); +EbmlId KaxBlockAdditional_TheId(0xA5, 1); +#endif // MATROSKA_VERSION + +const EbmlSemanticContext KaxBlockGroup_Context = EbmlSemanticContext(countof(KaxBlockGroup_ContextList), KaxBlockGroup_ContextList, &KaxCluster_Context, *GetKaxGlobal_Context, &KaxBlockGroup::ClassInfos); +const EbmlSemanticContext KaxBlock_Context = EbmlSemanticContext(0, NULL, &KaxBlockGroup_Context, *GetKaxGlobal_Context, &KaxBlock::ClassInfos); +const EbmlSemanticContext KaxBlockDuration_Context = EbmlSemanticContext(0, NULL, &KaxBlockGroup_Context, *GetKaxGlobal_Context, &KaxBlockDuration::ClassInfos); +#if MATROSKA_VERSION >= 2 +const EbmlSemanticContext KaxBlockVirtual_Context = EbmlSemanticContext(0, NULL, &KaxBlockGroup_Context, *GetKaxGlobal_Context, &KaxBlockVirtual::ClassInfos); +const EbmlSemanticContext KaxBlockAdditions_Context = EbmlSemanticContext(countof(KaxBlockAdditions_ContextList), KaxBlockAdditions_ContextList, &KaxBlockGroup_Context, *GetKaxGlobal_Context, &KaxBlockAdditions::ClassInfos); +const EbmlSemanticContext KaxBlockMore_Context = EbmlSemanticContext(countof(KaxBlockMore_ContextList), KaxBlockMore_ContextList, &KaxBlockAdditions_Context, *GetKaxGlobal_Context, &KaxBlockMore::ClassInfos); +const EbmlSemanticContext KaxBlockAddID_Context = EbmlSemanticContext(0, NULL, &KaxBlockMore_Context, *GetKaxGlobal_Context, &KaxBlockAddID::ClassInfos); +const EbmlSemanticContext KaxBlockAdditional_Context = EbmlSemanticContext(0, NULL, &KaxBlockMore_Context, *GetKaxGlobal_Context, &KaxBlockAdditional::ClassInfos); +#endif // MATROSKA_VERSION + +const EbmlCallbacks KaxBlockGroup::ClassInfos(KaxBlockGroup::Create, KaxBlockGroup_TheId, "BlockGroup", KaxBlockGroup_Context); +const EbmlCallbacks KaxBlock::ClassInfos(KaxBlock::Create, KaxBlock_TheId, "Block", KaxBlock_Context); +const EbmlCallbacks KaxBlockDuration::ClassInfos(KaxBlockDuration::Create, KaxBlockDuration_TheId, "BlockDuration", KaxBlockDuration_Context); +#if MATROSKA_VERSION >= 2 +const EbmlCallbacks KaxBlockVirtual::ClassInfos(KaxBlockVirtual::Create, KaxBlockVirtual_TheId, "BlockVirtual", KaxBlockVirtual_Context); +const EbmlCallbacks KaxBlockAdditions::ClassInfos(KaxBlockAdditions::Create, KaxBlockAdditions_TheId, "BlockAdditions", KaxBlockAdditions_Context); +const EbmlCallbacks KaxBlockMore::ClassInfos(KaxBlockMore::Create, KaxBlockMore_TheId, "BlockMore", KaxBlockMore_Context); +const EbmlCallbacks KaxBlockAddID::ClassInfos(KaxBlockAddID::Create, KaxBlockAddID_TheId, "BlockAddID", KaxBlockAddID_Context); +const EbmlCallbacks KaxBlockAdditional::ClassInfos(KaxBlockAdditional::Create, KaxBlockAdditional_TheId, "BlockAdditional", KaxBlockAdditional_Context); +#endif // MATROSKA_VERSION + +DataBuffer * DataBuffer::Clone() +{ + binary *ClonedData = new binary[mySize]; + memcpy(ClonedData, myBuffer ,mySize ); + + SimpleDataBuffer * result = new SimpleDataBuffer(ClonedData, mySize, 0); + result->bValidValue = bValidValue; + return result; +} + +SimpleDataBuffer::SimpleDataBuffer(const SimpleDataBuffer & ToClone) + :DataBuffer(new binary[ToClone.mySize], ToClone.mySize, myFreeBuffer) +{ + memcpy(myBuffer, ToClone.myBuffer ,mySize ); + bValidValue = ToClone.bValidValue; +} + +bool KaxBlock::ValidateSize() const +{ + return (Size >= 4); /// for the moment +} + +KaxBlock::~KaxBlock() +{ + ReleaseFrames(); +} + +KaxBlock::KaxBlock(const KaxBlock & ElementToClone) + :EbmlBinary(ElementToClone) + ,myBuffers(ElementToClone.myBuffers.size()) + ,Timecode(ElementToClone.Timecode) + ,LocalTimecode(ElementToClone.LocalTimecode) + ,bLocalTimecodeUsed(ElementToClone.bLocalTimecodeUsed) + ,TrackNumber(ElementToClone.TrackNumber) + ,bGap(ElementToClone.bGap) + ,ParentCluster(ElementToClone.ParentCluster) ///< \todo not exactly +{ + // add a clone of the list + std::vector::const_iterator Itr = ElementToClone.myBuffers.begin(); + std::vector::iterator myItr = myBuffers.begin(); + while (Itr != ElementToClone.myBuffers.end()) + { + *myItr = (*Itr)->Clone(); + Itr++; myItr++; + } +} + + +KaxBlockGroup::~KaxBlockGroup() +{ +//NOTE("KaxBlockGroup::~KaxBlockGroup"); +} + +KaxBlockGroup::KaxBlockGroup() + :EbmlMaster(KaxBlockGroup_Context) + ,ParentCluster(NULL) + ,ParentTrack(NULL) +{} + +#if MATROSKA_VERSION >= 2 +KaxBlockAdditions::KaxBlockAdditions() + :EbmlMaster(KaxBlockAdditions_Context) +{} + +KaxBlockMore::KaxBlockMore() + :EbmlMaster(KaxBlockMore_Context) +{} +#endif // MATROSKA_VERSION + +/*! + \todo handle flags + \todo hardcoded limit of the number of frames in a lace should be a parameter + \return true if more frames can be added to this Block +*/ +bool KaxBlock::AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, LacingType lacing) +{ + bValueIsSet = true; + if (myBuffers.size() == 0) { + // first frame + Timecode = timecode; + TrackNumber = track.TrackNumber(); + mLacing = lacing; + } + myBuffers.push_back(&buffer); + + // we don't allow more than 8 frames in a Block because the overhead improvement is minimal + if (myBuffers.size() >= 8) + return false; + + // decide wether a new frame can be added or not + // a frame in a lace is not efficient when the place necessary to code it in a lace is bigger + // than the size of a simple Block. That means more than 6 bytes (4 in struct + 2 for EBML) to code the size + return (buffer.Size() < 6*0xFF); +} + +/*! + \return Returns the lacing type that produces the smallest footprint. +*/ +LacingType KaxBlock::GetBestLacingType() const { + int XiphLacingSize, EbmlLacingSize, i; + bool SameSize = true; + + if (myBuffers.size() <= 1) + return LACING_NONE; + + XiphLacingSize = 1; // Number of laces is stored in 1 byte. + EbmlLacingSize = 1; + for (i = 0; i < (int)myBuffers.size() - 1; i++) { + if (myBuffers[i]->Size() != myBuffers[i + 1]->Size()) + SameSize = false; + XiphLacingSize += myBuffers[i]->Size() / 255 + 1; + } + EbmlLacingSize += CodedSizeLength(myBuffers[0]->Size(), 0); + for (i = 1; i < (int)myBuffers.size() - 1; i++) + EbmlLacingSize += CodedSizeLengthSigned(int64(myBuffers[i]->Size()) - int64(myBuffers[i - 1]->Size()), 0); + if (SameSize) + return LACING_FIXED; + else if (XiphLacingSize < EbmlLacingSize) + return LACING_XIPH; + else + return LACING_EBML; +} + +/*! + \todo handle gap flag +*/ +uint64 KaxBlock::UpdateSize(bool bSaveDefault, bool bForceRender) +{ + LacingType LacingHere; + assert(Data == NULL); // Data is not used for KaxBlock + assert(TrackNumber < 0x4000); // no more allowed for the moment + unsigned int i; + + // compute the final size of the data + switch (myBuffers.size()) { + case 0: + Size = 0; + break; + case 1: + Size = 4 + myBuffers[0]->Size(); + break; + default: + Size = 4 + 1; // 1 for the lacing head + if (mLacing == LACING_AUTO) + LacingHere = GetBestLacingType(); + else + LacingHere = mLacing; + switch (LacingHere) + { + case LACING_XIPH: + for (i=0; iSize() + (myBuffers[i]->Size() / 0xFF + 1); + } + break; + case LACING_EBML: + Size += myBuffers[0]->Size() + CodedSizeLength(myBuffers[0]->Size(), 0); + for (i=1; iSize() + + CodedSizeLengthSigned(int64(myBuffers[i]->Size()) - int64(myBuffers[i-1]->Size()), 0);; + } + break; + case LACING_FIXED: + for (i=0; iSize(); + } + break; + default: + assert(0); + } + // Size of the last frame (not in lace) + Size += myBuffers[i]->Size(); + break; + } + + if (TrackNumber >= 0x80) + Size++; // the size will be coded with one more octet + + return Size; +} + +#if MATROSKA_VERSION >= 2 +KaxBlockVirtual::KaxBlockVirtual(const KaxBlockVirtual & ElementToClone) + :EbmlBinary(ElementToClone) + ,Timecode(ElementToClone.Timecode) + ,TrackNumber(ElementToClone.TrackNumber) + ,ParentCluster(ElementToClone.ParentCluster) ///< \todo not exactly +{ + Data = DataBlock; +} + +/*! + \todo handle the gap flag +*/ +uint64 KaxBlockVirtual::UpdateSize(bool bSaveDefault, bool bForceRender) +{ + assert(TrackNumber < 0x4000); + binary *cursor = Data; + // fill data + if (TrackNumber < 0x80) { + *cursor++ = TrackNumber | 0x80; // set the first bit to 1 + } else { + *cursor++ = (TrackNumber >> 8) | 0x40; // set the second bit to 1 + *cursor++ = TrackNumber & 0xFF; + } + + assert(ParentCluster != NULL); + int16 ActualTimecode = ParentCluster->GetBlockLocalTimecode(Timecode); + big_int16 b16(ActualTimecode); + b16.Fill(cursor); + cursor += 2; + + *cursor++ = (0 << 0); // no gap + + return Size; +} +#endif // MATROSKA_VERSION + +/*! + \todo more optimisation is possible (render the Block head and don't copy the buffer in memory, care should be taken with the allocation of Data) + \todo the actual timecode to write should be retrieved from the Cluster from here +*/ +uint32 KaxBlock::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) +{ + if (myBuffers.size() == 0) { + return 0; + } else { + assert(TrackNumber < 0x4000); + binary BlockHead[5], *cursor = BlockHead; + unsigned int i; + + if (myBuffers.size() == 1) { + Size = 4; + mLacing = LACING_NONE; + } else { + if (mLacing == LACING_NONE) + mLacing = LACING_EBML; // supposedly the best of all + Size = 4 + 1; // 1 for the lacing head (number of laced elements) + } + if (TrackNumber > 0x80) + Size++; + + // write Block Head + if (TrackNumber < 0x80) { + *cursor++ = TrackNumber | 0x80; // set the first bit to 1 + } else { + *cursor++ = (TrackNumber >> 8) | 0x40; // set the second bit to 1 + *cursor++ = TrackNumber & 0xFF; + } + + assert(ParentCluster != NULL); + int16 ActualTimecode = ParentCluster->GetBlockLocalTimecode(Timecode); + big_int16 b16(ActualTimecode); + b16.Fill(cursor); + cursor += 2; + + *cursor = (0 << 0); // no gap + + if (mLacing == LACING_AUTO) { + mLacing = GetBestLacingType(); + } + + switch (mLacing) + { + case LACING_XIPH: + *cursor++ |= 0x2; + break; + case LACING_EBML: + *cursor++ |= 0x6; + break; + case LACING_FIXED: + *cursor++ |= 0x4; + break; + case LACING_NONE: + break; + default: + assert(0); + } + + output.writeFully(BlockHead, 4 + ((TrackNumber > 0x80) ? 1 : 0)); + + binary tmpValue; + switch (mLacing) + { + case LACING_XIPH: + // number of laces + tmpValue = myBuffers.size()-1; + output.writeFully(&tmpValue, 1); + + // set the size of each member in the lace + for (i=0; iSize(); + while (tmpSize >= 0xFF) { + output.writeFully(&tmpValue, 1); + Size++; + tmpSize -= 0xFF; + } + tmpValue = binary(tmpSize); + output.writeFully(&tmpValue, 1); + Size++; + } + break; + case LACING_EBML: + // number of laces + tmpValue = myBuffers.size()-1; + output.writeFully(&tmpValue, 1); + + { + int64 _Size; + int _CodedSize; + binary _FinalHead[8]; // 64 bits max coded size + + _Size = myBuffers[0]->Size(); + + _CodedSize = CodedSizeLength(_Size, 0); + + // first size in the lace is not a signed + CodedValueLength(_Size, _CodedSize, _FinalHead); + output.writeFully(_FinalHead, _CodedSize); + Size += _CodedSize; + + // set the size of each member in the lace + for (i=1; iSize()) - int64(myBuffers[i-1]->Size()); + _CodedSize = CodedSizeLengthSigned(_Size, 0); + CodedValueLengthSigned(_Size, _CodedSize, _FinalHead); + output.writeFully(_FinalHead, _CodedSize); + Size += _CodedSize; + } + } + break; + case LACING_FIXED: + // number of laces + tmpValue = myBuffers.size()-1; + output.writeFully(&tmpValue, 1); + break; + case LACING_NONE: + break; + default: + assert(0); + } + + // put the data of each frame + for (i=0; iBuffer(), myBuffers[i]->Size()); + Size += myBuffers[i]->Size(); + } + } + + return Size; +} + +uint64 KaxBlock::ReadInternalHead(IOCallback & input) +{ + binary Buffer[5], *cursor = Buffer; + uint64 Result = input.read(cursor, 4); + if (Result != 4) + return Result; + + // update internal values + TrackNumber = *cursor++; + if ((TrackNumber & 0x80) == 0) { + // there is extra data + if ((TrackNumber & 0x40) == 0) { + // We don't support track numbers that large ! + return Result; + } + Result += input.read(&Buffer[4], 1); + TrackNumber = (TrackNumber & 0x3F) << 8; + TrackNumber += *cursor++; + } else { + TrackNumber &= 0x7F; + } + + + big_int16 b16; + b16.Eval(cursor); + assert(ParentCluster != NULL); + Timecode = ParentCluster->GetBlockGlobalTimecode(int16(b16)); + bLocalTimecodeUsed = false; + cursor += 2; + + bGap = (*cursor && 0x01); + return Result; +} + +/*! + \todo better zero copy handling +*/ +uint64 KaxBlock::ReadData(IOCallback & input, ScopeMode ReadFully) +{ + uint64 Result; + + FirstFrameLocation = input.getFilePointer(); // will be updated accordingly below + + if (ReadFully == SCOPE_ALL_DATA) + { + Result = EbmlBinary::ReadData(input, ReadFully); + binary *cursor = Data; + uint8 BlockHeadSize = 4; + + // update internal values + TrackNumber = *cursor++; + if ((TrackNumber & 0x80) == 0) { + // there is extra data + if ((TrackNumber & 0x40) == 0) { + // We don't support track numbers that large ! + return Result; + } + TrackNumber = (TrackNumber & 0x3F) << 8; + TrackNumber += *cursor++; + BlockHeadSize++; + } else { + TrackNumber &= 0x7F; + } + + big_int16 b16; + b16.Eval(cursor); + LocalTimecode = int16(b16); + bLocalTimecodeUsed = true; + cursor += 2; + + bGap = (*cursor && 0x01); + mLacing = LacingType((*cursor++ & 0x06) >> 1); + + // put all Frames in the list + if (mLacing == LACING_NONE) { + FirstFrameLocation += cursor - Data; + DataBuffer * soloFrame = new DataBuffer(cursor, Size - BlockHeadSize); + myBuffers.push_back(soloFrame); + SizeList.resize(1); + SizeList[0] = Size - BlockHeadSize; + } else { + // read the number of frames in the lace + uint32 LastBufferSize = Size - BlockHeadSize - 1; // 1 for number of frame + uint8 FrameNum = *cursor++; // number of frames in the lace - 1 + // read the list of frame sizes + uint8 Index; + int32 FrameSize; + uint32 SizeRead; + uint64 SizeUnknown; + + SizeList.resize(FrameNum + 1); + + switch (mLacing) + { + case LACING_XIPH: + for (Index=0; Index> 1); + if (cursor == &_TempHead[4]) + { + _TempHead[0] = _TempHead[4]; + } else { + Result += input.read(_TempHead, 1); + } + + FirstFrameLocation += cursor - _TempHead; + + // put all Frames in the list + if (mLacing != LACING_NONE) { + // read the number of frames in the lace + uint32 LastBufferSize = Size - BlockHeadSize - 1; // 1 for number of frame + uint8 FrameNum = _TempHead[0]; // number of frames in the lace - 1 + // read the list of frame sizes + uint8 Index; + int32 FrameSize; + uint32 SizeRead; + uint64 SizeUnknown; + + SizeList.resize(FrameNum + 1); + + switch (mLacing) + { + case LACING_XIPH: + for (Index=0; Index(*this); + assert(ParentCluster != NULL); + theBlock.SetParent(*ParentCluster); + ParentTrack = &track; + return theBlock.AddFrame(track, timecode, buffer, lacing); +} + +bool KaxBlockGroup::AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, const KaxBlockGroup & PastBlock, LacingType lacing) +{ +// assert(past_timecode < 0); + + KaxBlock & theBlock = GetChild(*this); + assert(ParentCluster != NULL); + theBlock.SetParent(*ParentCluster); + ParentTrack = &track; + bool bRes = theBlock.AddFrame(track, timecode, buffer, lacing); + + KaxReferenceBlock & thePastRef = GetChild(*this); + thePastRef.SetReferencedBlock(PastBlock); + thePastRef.SetParentBlock(*this); + + return bRes; +} + +bool KaxBlockGroup::AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, const KaxBlockGroup & PastBlock, const KaxBlockGroup & ForwBlock, LacingType lacing) +{ +// assert(past_timecode < 0); + +// assert(forw_timecode > 0); + + KaxBlock & theBlock = GetChild(*this); + assert(ParentCluster != NULL); + theBlock.SetParent(*ParentCluster); + ParentTrack = &track; + bool bRes = theBlock.AddFrame(track, timecode, buffer, lacing); + + KaxReferenceBlock & thePastRef = GetChild(*this); + thePastRef.SetReferencedBlock(PastBlock); + thePastRef.SetParentBlock(*this); + + KaxReferenceBlock & theFutureRef = AddNewChild(*this); + theFutureRef.SetReferencedBlock(ForwBlock); + theFutureRef.SetParentBlock(*this); + + return bRes; +} + +/*! + \todo we may cache the reference to the timecode block +*/ +uint64 KaxBlockGroup::GlobalTimecode() const +{ + assert(ParentCluster != NULL); // impossible otherwise + KaxBlock & MyBlock = *static_cast(this->FindElt(KaxBlock::ClassInfos)); + return MyBlock.GlobalTimecode(); + +} + +uint16 KaxBlockGroup::TrackNumber() const +{ + KaxBlock & MyBlock = *static_cast(this->FindElt(KaxBlock::ClassInfos)); + return MyBlock.TrackNum(); +} + +uint64 KaxBlockGroup::ClusterPosition() const +{ + assert(ParentCluster != NULL); // impossible otherwise + return ParentCluster->GetPosition(); +} + +unsigned int KaxBlockGroup::ReferenceCount() const +{ + unsigned int Result = 0; + KaxReferenceBlock * MyBlockAdds = static_cast(FindFirstElt(KaxReferenceBlock::ClassInfos)); + if (MyBlockAdds != NULL) { + Result++; + while ((MyBlockAdds = static_cast(FindNextElt(*MyBlockAdds))) != NULL) + { + Result++; + } + } + return Result; +} + +const KaxReferenceBlock & KaxBlockGroup::Reference(unsigned int Index) const +{ + KaxReferenceBlock * MyBlockAdds = static_cast(FindFirstElt(KaxReferenceBlock::ClassInfos)); + assert(MyBlockAdds != NULL); // call of a non existing reference + + while (Index != 0) { + MyBlockAdds = static_cast(FindNextElt(*MyBlockAdds)); + assert(MyBlockAdds != NULL); + Index--; + } + return *MyBlockAdds; +} + +void KaxBlockGroup::ReleaseFrames() +{ + KaxBlock & MyBlock = *static_cast(this->FindElt(KaxBlock::ClassInfos)); + MyBlock.ReleaseFrames(); +} + +void KaxBlock::ReleaseFrames() +{ + // free the allocated Frames + int i; + for (i=myBuffers.size()-1; i>=0; i--) { + if (myBuffers[i] != NULL) { + myBuffers[i]->FreeBuffer(*myBuffers[i]); + delete myBuffers[i]; + myBuffers[i] = NULL; + } + } +} + +void KaxBlockGroup::SetBlockDuration(uint64 TimeLength) +{ + assert(ParentTrack != NULL); + int64 scale = ParentTrack->GlobalTimecodeScale(); + KaxBlockDuration & myDuration = *static_cast(FindFirstElt(KaxBlockDuration::ClassInfos, true)); + *(static_cast(&myDuration)) = TimeLength / uint64(scale); +} + +bool KaxBlockGroup::GetBlockDuration(uint64 &TheTimecode) const +{ + KaxBlockDuration * myDuration = static_cast(FindElt(KaxBlockDuration::ClassInfos)); + if (myDuration == NULL) { + return false; + } + + assert(ParentTrack != NULL); + TheTimecode = uint64(*myDuration) * ParentTrack->GlobalTimecodeScale(); + return true; +} + +void KaxBlock::SetParent(KaxCluster & aParentCluster) +{ + ParentCluster = &aParentCluster; + if (bLocalTimecodeUsed) { + Timecode = aParentCluster.GetBlockGlobalTimecode(LocalTimecode); + bLocalTimecodeUsed = false; + } +} + +int64 KaxBlock::GetDataPosition(size_t FrameNumber) +{ + int64 _Result = -1; + + if (bValueIsSet && FrameNumber < SizeList.size()) + { + _Result = FirstFrameLocation; + + size_t _Idx = 0; + while(FrameNumber--) + { + _Result += SizeList[_Idx++]; + } + } + + return _Result; +} + +int64 KaxBlock::GetFrameSize(size_t FrameNumber) +{ + int64 _Result = -1; + + if (/*bValueIsSet &&*/ FrameNumber < SizeList.size()) + { + _Result = SizeList[FrameNumber]; + } + + return _Result; +} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxBlockData.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxBlockData.cpp new file mode 100644 index 0000000000..db329e7a11 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxBlockData.cpp @@ -0,0 +1,121 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxBlockData.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme +*/ +#include + +#include "matroska/KaxBlockData.h" +#include "matroska/KaxContexts.h" +#include "matroska/KaxBlock.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +const EbmlSemantic KaxSlices_ContextList[1] = +{ + EbmlSemantic(false, false, KaxTimeSlice::ClassInfos), +}; + +const EbmlSemantic KaxTimeSlice_ContextList[5] = +{ + EbmlSemantic(false, true, KaxSliceLaceNumber::ClassInfos), + EbmlSemantic(false, true, KaxSliceFrameNumber::ClassInfos), + EbmlSemantic(false, true, KaxSliceBlockAddID::ClassInfos), + EbmlSemantic(false, true, KaxSliceDelay::ClassInfos), + EbmlSemantic(false, true, KaxSliceDuration::ClassInfos), +}; + +EbmlId KaxReferencePriority_TheId(0xFA, 1); +EbmlId KaxReferenceBlock_TheId (0xFB, 1); +EbmlId KaxSlices_TheId (0x8E, 1); +EbmlId KaxTimeSlice_TheId (0xE8, 1); +EbmlId KaxSliceLaceNumber_TheId (0xCC, 1); +EbmlId KaxSliceFrameNumber_TheId (0xCD, 1); +EbmlId KaxSliceBlockAddID_TheId (0xCB, 1); +EbmlId KaxSliceDelay_TheId (0xCE, 1); +EbmlId KaxSliceDuration_TheId (0xCF, 1); +#if MATROSKA_VERSION >= 2 +EbmlId KaxReferenceVirtual_TheId (0xFD, 1); +#endif // MATROSKA_VERSION + +const EbmlSemanticContext KaxReferencePriority_Context = EbmlSemanticContext(0, NULL, &KaxBlockGroup_Context, *GetKaxGlobal_Context, &KaxReferencePriority::ClassInfos); +const EbmlSemanticContext KaxReferenceBlock_Context = EbmlSemanticContext(0, NULL, &KaxBlockGroup_Context, *GetKaxGlobal_Context, &KaxReferenceBlock::ClassInfos); +const EbmlSemanticContext KaxSlices_Context = EbmlSemanticContext(countof(KaxSlices_ContextList), KaxSlices_ContextList, &KaxBlockGroup_Context, *GetKaxGlobal_Context, &KaxSlices::ClassInfos); +const EbmlSemanticContext KaxTimeSlice_Context = EbmlSemanticContext(countof(KaxTimeSlice_ContextList), KaxTimeSlice_ContextList, &KaxSlices_Context, *GetKaxGlobal_Context, &KaxTimeSlice::ClassInfos); +const EbmlSemanticContext KaxSliceLaceNumber_Context = EbmlSemanticContext(0, NULL, &KaxTimeSlice_Context, *GetKaxGlobal_Context, &KaxSliceLaceNumber::ClassInfos); +const EbmlSemanticContext KaxSliceFrameNumber_Context = EbmlSemanticContext(0, NULL, &KaxTimeSlice_Context, *GetKaxGlobal_Context, &KaxSliceFrameNumber::ClassInfos); +const EbmlSemanticContext KaxSliceBlockAddID_Context = EbmlSemanticContext(0, NULL, &KaxTimeSlice_Context, *GetKaxGlobal_Context, &KaxSliceBlockAddID::ClassInfos); +const EbmlSemanticContext KaxSliceDelay_Context = EbmlSemanticContext(0, NULL, &KaxTimeSlice_Context, *GetKaxGlobal_Context, &KaxSliceDelay::ClassInfos); +const EbmlSemanticContext KaxSliceDuration_Context = EbmlSemanticContext(0, NULL, &KaxTimeSlice_Context, *GetKaxGlobal_Context, &KaxSliceDuration::ClassInfos); +#if MATROSKA_VERSION >= 2 +const EbmlSemanticContext KaxReferenceVirtual_Context = EbmlSemanticContext(0, NULL, &KaxBlockGroup_Context, *GetKaxGlobal_Context, &KaxReferenceVirtual::ClassInfos); +#endif // MATROSKA_VERSION + +const EbmlCallbacks KaxReferencePriority::ClassInfos(KaxReferencePriority::Create, KaxReferencePriority_TheId, "FlagReferenced", KaxReferencePriority_Context); +const EbmlCallbacks KaxReferenceBlock::ClassInfos(KaxReferenceBlock::Create, KaxReferenceBlock_TheId, "ReferenceBlock", KaxReferenceBlock_Context); +const EbmlCallbacks KaxSlices::ClassInfos(KaxSlices::Create, KaxSlices_TheId, "Slices", KaxSlices_Context); +const EbmlCallbacks KaxTimeSlice::ClassInfos(KaxTimeSlice::Create, KaxTimeSlice_TheId, "TimeSlice", KaxTimeSlice_Context); +const EbmlCallbacks KaxSliceLaceNumber::ClassInfos(KaxSliceLaceNumber::Create, KaxSliceLaceNumber_TheId, "SliceLaceNumber", KaxSliceLaceNumber_Context); +const EbmlCallbacks KaxSliceFrameNumber::ClassInfos(KaxSliceFrameNumber::Create, KaxSliceFrameNumber_TheId, "SliceFrameNumber", KaxSliceFrameNumber_Context); +const EbmlCallbacks KaxSliceBlockAddID::ClassInfos(KaxSliceBlockAddID::Create, KaxSliceBlockAddID_TheId, "SliceBlockAddID", KaxSliceBlockAddID_Context); +const EbmlCallbacks KaxSliceDelay::ClassInfos(KaxSliceDelay::Create, KaxSliceDelay_TheId, "SliceDelay", KaxSliceDelay_Context); +const EbmlCallbacks KaxSliceDuration::ClassInfos(KaxSliceDuration::Create, KaxSliceDuration_TheId, "SliceDuration", KaxSliceDuration_Context); +#if MATROSKA_VERSION >= 2 +const EbmlCallbacks KaxReferenceVirtual::ClassInfos(KaxReferenceVirtual::Create, KaxReferenceVirtual_TheId, "ReferenceVirtual", KaxReferenceVirtual_Context); +#endif // MATROSKA_VERSION + +KaxSlices::KaxSlices() + :EbmlMaster(KaxSlices_Context) +{} + +KaxTimeSlice::KaxTimeSlice() + :EbmlMaster(KaxTimeSlice_Context) +{} + +const KaxBlockGroup & KaxReferenceBlock::RefBlock() const +{ + assert(RefdBlock != NULL); + return *RefdBlock; +} + +uint64 KaxReferenceBlock::UpdateSize(bool bSaveDefault, bool bForceRender) +{ + if (!bTimecodeSet) { + assert(RefdBlock != NULL); + assert(ParentBlock != NULL); + + Value = (int64(RefdBlock->GlobalTimecode()) - int64(ParentBlock->GlobalTimecode())) / int64(ParentBlock->GlobalTimecodeScale()); + } + return EbmlSInteger::UpdateSize(bSaveDefault, bForceRender); +} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxChapters.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxChapters.cpp new file mode 100644 index 0000000000..31707d1371 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxChapters.cpp @@ -0,0 +1,184 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxChapters.cpp 745 2004-09-04 16:29:03Z robux4 $ + \author Steve Lhomme +*/ +#include "matroska/KaxChapters.h" +#include "matroska/KaxContexts.h" + +// sub elements +START_LIBMATROSKA_NAMESPACE + +EbmlSemantic KaxChapters_ContextList[1] = +{ + EbmlSemantic(true, false, KaxEditionEntry::ClassInfos), +}; + +EbmlSemantic KaxEditionEntry_ContextList[5] = +{ + EbmlSemantic(false, true , KaxEditionUID::ClassInfos), + EbmlSemantic(true , true , KaxEditionFlagHidden::ClassInfos), + EbmlSemantic(true , true , KaxEditionFlagDefault::ClassInfos), + EbmlSemantic(true , true , KaxEditionProcessed::ClassInfos), + EbmlSemantic(true , false, KaxChapterAtom::ClassInfos), +}; + +EbmlSemantic KaxChapterAtom_ContextList[11] = +{ + EbmlSemantic(false, false, KaxChapterAtom::ClassInfos), + EbmlSemantic(true, true, KaxChapterUID::ClassInfos), + EbmlSemantic(true, true, KaxChapterTimeStart::ClassInfos), + EbmlSemantic(false, true, KaxChapterTimeEnd::ClassInfos), + EbmlSemantic(true , true, KaxChapterFlagHidden::ClassInfos), + EbmlSemantic(true , true, KaxChapterFlagEnabled::ClassInfos), + EbmlSemantic(false, true, KaxChapterPhysicalEquiv::ClassInfos), + EbmlSemantic(false, true, KaxChapterTrack::ClassInfos), + EbmlSemantic(false, false, KaxChapterDisplay::ClassInfos), + EbmlSemantic(false, false, KaxChapterProcess::ClassInfos), + EbmlSemantic(false, true, KaxChapterProcessedPrivate::ClassInfos), +}; + +EbmlSemantic KaxChapterTrack_ContextList[1] = +{ + EbmlSemantic(true, false, KaxChapterTrackNumber::ClassInfos), +}; + +EbmlSemantic KaxChapterDisplay_ContextList[3] = +{ + EbmlSemantic(true, true, KaxChapterString::ClassInfos), + EbmlSemantic(true, false, KaxChapterLanguage::ClassInfos), + EbmlSemantic(false, false, KaxChapterCountry::ClassInfos), +}; + +EbmlSemantic KaxChapterProcess_ContextList[2] = +{ + EbmlSemantic(true, true, KaxChapterProcessTime::ClassInfos), + EbmlSemantic(true, true, KaxChapterProcessCommand::ClassInfos), +}; + +const EbmlSemanticContext KaxChapters_Context = EbmlSemanticContext(countof(KaxChapters_ContextList), KaxChapters_ContextList, &KaxSegment_Context, *GetKaxGlobal_Context, &KaxChapters::ClassInfos); +const EbmlSemanticContext KaxEditionEntry_Context = EbmlSemanticContext(countof(KaxEditionEntry_ContextList), KaxEditionEntry_ContextList, &KaxChapters_Context, *GetKaxGlobal_Context, &KaxEditionEntry::ClassInfos); +const EbmlSemanticContext KaxEditionUID_Context = EbmlSemanticContext(0, NULL, &KaxEditionEntry_Context, *GetKaxGlobal_Context, &KaxEditionUID::ClassInfos); +const EbmlSemanticContext KaxEditionFlagHidden_Context = EbmlSemanticContext(0, NULL, &KaxEditionEntry_Context, *GetKaxGlobal_Context, &KaxEditionFlagHidden::ClassInfos); +const EbmlSemanticContext KaxEditionFlagDefault_Context = EbmlSemanticContext(0, NULL, &KaxEditionEntry_Context, *GetKaxGlobal_Context, &KaxEditionFlagDefault::ClassInfos); +const EbmlSemanticContext KaxEditionProcessed_Context = EbmlSemanticContext(0, NULL, &KaxEditionEntry_Context, *GetKaxGlobal_Context, &KaxEditionProcessed::ClassInfos); +const EbmlSemanticContext KaxChapterProcessedPrivate_Context = EbmlSemanticContext(0, NULL, &KaxEditionEntry_Context, *GetKaxGlobal_Context, &KaxChapterProcessedPrivate::ClassInfos); +const EbmlSemanticContext KaxChapterAtom_Context = EbmlSemanticContext(countof(KaxChapterAtom_ContextList), KaxChapterAtom_ContextList, &KaxEditionEntry_Context, *GetKaxGlobal_Context, &KaxChapterAtom::ClassInfos); +const EbmlSemanticContext KaxChapterTrack_Context = EbmlSemanticContext(countof(KaxChapterTrack_ContextList), KaxChapterTrack_ContextList, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterTrack::ClassInfos); +const EbmlSemanticContext KaxChapterDisplay_Context = EbmlSemanticContext(countof(KaxChapterDisplay_ContextList), KaxChapterDisplay_ContextList, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterDisplay::ClassInfos); +const EbmlSemanticContext KaxChapterUID_Context = EbmlSemanticContext(0, NULL, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterUID::ClassInfos); +const EbmlSemanticContext KaxChapterTimeStart_Context = EbmlSemanticContext(0, NULL, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterTimeStart::ClassInfos); +const EbmlSemanticContext KaxChapterTimeEnd_Context = EbmlSemanticContext(0, NULL, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterTimeEnd::ClassInfos); +const EbmlSemanticContext KaxChapterFlagHidden_Context = EbmlSemanticContext(0, NULL, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterFlagHidden::ClassInfos); +const EbmlSemanticContext KaxChapterFlagEnabled_Context = EbmlSemanticContext(0, NULL, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterFlagEnabled::ClassInfos); +const EbmlSemanticContext KaxChapterPhysicalEquiv_Context = EbmlSemanticContext(0, NULL, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterPhysicalEquiv::ClassInfos); +const EbmlSemanticContext KaxChapterTrackNumber_Context = EbmlSemanticContext(0, NULL, &KaxChapterTrack_Context, *GetKaxGlobal_Context, &KaxChapterTrackNumber::ClassInfos); +const EbmlSemanticContext KaxChapterString_Context = EbmlSemanticContext(0, NULL, &KaxChapterDisplay_Context, *GetKaxGlobal_Context, &KaxChapterString::ClassInfos); +const EbmlSemanticContext KaxChapterLanguage_Context = EbmlSemanticContext(0, NULL, &KaxChapterLanguage_Context, *GetKaxGlobal_Context, &KaxChapterLanguage::ClassInfos); +const EbmlSemanticContext KaxChapterCountry_Context = EbmlSemanticContext(0, NULL, &KaxChapterCountry_Context, *GetKaxGlobal_Context, &KaxChapterCountry::ClassInfos); +const EbmlSemanticContext KaxChapterProcess_Context = EbmlSemanticContext(countof(KaxChapterProcess_ContextList), KaxChapterProcess_ContextList, &KaxChapterAtom_Context, *GetKaxGlobal_Context, &KaxChapterProcess::ClassInfos); +const EbmlSemanticContext KaxChapterProcessTime_Context = EbmlSemanticContext(0, NULL, &KaxChapterProcess_Context, *GetKaxGlobal_Context, &KaxChapterProcessTime::ClassInfos); +const EbmlSemanticContext KaxChapterProcessCommand_Context = EbmlSemanticContext(0, NULL, &KaxChapterProcess_Context, *GetKaxGlobal_Context, &KaxChapterProcessCommand::ClassInfos); + +EbmlId KaxChapters_TheId (0x1043A770, 4); +EbmlId KaxEditionEntry_TheId (0x45B9, 2); +EbmlId KaxEditionUID_TheId (0x45BC, 2); +EbmlId KaxEditionFlagHidden_TheId (0x45BD, 2); +EbmlId KaxEditionFlagDefault_TheId (0x45DB, 2); +EbmlId KaxEditionProcessed_TheId (0x45DD, 2); +EbmlId KaxChapterProcessedPrivate_TheId(0x450D, 2); +EbmlId KaxChapterAtom_TheId (0xB6, 1); +EbmlId KaxChapterUID_TheId (0x73C4, 2); +EbmlId KaxChapterTimeStart_TheId (0x91, 1); +EbmlId KaxChapterTimeEnd_TheId (0x92, 1); +EbmlId KaxChapterFlagHidden_TheId (0x98, 1); +EbmlId KaxChapterFlagEnabled_TheId (0x4598, 2); +EbmlId KaxChapterPhysicalEquiv_TheId (0x63C3, 2); +EbmlId KaxChapterTrack_TheId (0x8F, 1); +EbmlId KaxChapterTrackNumber_TheId (0x89, 1); +EbmlId KaxChapterDisplay_TheId (0x80, 1); +EbmlId KaxChapterString_TheId (0x85, 1); +EbmlId KaxChapterLanguage_TheId (0x437C, 2); +EbmlId KaxChapterCountry_TheId (0x437E, 2); +EbmlId KaxChapterProcess_TheId (0x6944, 2); +EbmlId KaxChapterProcessTime_TheId (0x6922, 2); +EbmlId KaxChapterProcessCommand_TheId (0x6933, 2); + +const EbmlCallbacks KaxChapters::ClassInfos(KaxChapters::Create, KaxChapters_TheId, "Chapters", KaxChapters_Context); +const EbmlCallbacks KaxEditionEntry::ClassInfos(KaxEditionEntry::Create, KaxEditionEntry_TheId, "EditionEntry", KaxEditionEntry_Context); +const EbmlCallbacks KaxEditionUID::ClassInfos(KaxEditionUID::Create, KaxEditionUID_TheId, "EditionUID", KaxEditionUID_Context); +const EbmlCallbacks KaxEditionFlagHidden::ClassInfos(KaxEditionFlagHidden::Create, KaxEditionFlagHidden_TheId, "EditionFlagHidden", KaxEditionFlagHidden_Context); +const EbmlCallbacks KaxEditionFlagDefault::ClassInfos(KaxEditionFlagDefault::Create, KaxEditionFlagDefault_TheId, "EditionFlagDefault", KaxEditionFlagDefault_Context); +const EbmlCallbacks KaxEditionProcessed::ClassInfos(KaxEditionProcessed::Create, KaxEditionProcessed_TheId, "EditionProcessed", KaxEditionProcessed_Context); +const EbmlCallbacks KaxChapterProcessedPrivate::ClassInfos(KaxChapterProcessedPrivate::Create, KaxChapterProcessedPrivate_TheId, "ChapterProcessedPrivate", KaxChapterProcessedPrivate_Context); +const EbmlCallbacks KaxChapterAtom::ClassInfos(KaxChapterAtom::Create, KaxChapterAtom_TheId, "ChapterAtom", KaxChapterAtom_Context); +const EbmlCallbacks KaxChapterUID::ClassInfos(KaxChapterUID::Create, KaxChapterUID_TheId, "ChapterUID", KaxChapterUID_Context); +const EbmlCallbacks KaxChapterTimeStart::ClassInfos(KaxChapterTimeStart::Create, KaxChapterTimeStart_TheId, "ChapterTimeStart", KaxChapterTimeStart_Context); +const EbmlCallbacks KaxChapterTimeEnd::ClassInfos(KaxChapterTimeEnd::Create, KaxChapterTimeEnd_TheId, "ChapterTimeEnd", KaxChapterTimeEnd_Context); +const EbmlCallbacks KaxChapterFlagHidden::ClassInfos(KaxChapterFlagHidden::Create, KaxChapterFlagHidden_TheId, "ChapterFlagHidden", KaxChapterFlagHidden_Context); +const EbmlCallbacks KaxChapterFlagEnabled::ClassInfos(KaxChapterFlagEnabled::Create, KaxChapterFlagEnabled_TheId, "ChapterFlagEnabled", KaxChapterFlagEnabled_Context); +const EbmlCallbacks KaxChapterPhysicalEquiv::ClassInfos(KaxChapterPhysicalEquiv::Create, KaxChapterPhysicalEquiv_TheId, "ChapterPhysicalEquiv", KaxChapterPhysicalEquiv_Context); +const EbmlCallbacks KaxChapterTrack::ClassInfos(KaxChapterTrack::Create, KaxChapterTrack_TheId, "ChapterTrack", KaxChapterTrack_Context); +const EbmlCallbacks KaxChapterTrackNumber::ClassInfos(KaxChapterTrackNumber::Create, KaxChapterTrackNumber_TheId, "ChapterTrackNumber", KaxChapterTrackNumber_Context); +const EbmlCallbacks KaxChapterDisplay::ClassInfos(KaxChapterDisplay::Create, KaxChapterDisplay_TheId, "ChapterDisplay", KaxChapterDisplay_Context); +const EbmlCallbacks KaxChapterString::ClassInfos(KaxChapterString::Create, KaxChapterString_TheId, "ChapterString", KaxChapterString_Context); +const EbmlCallbacks KaxChapterLanguage::ClassInfos(KaxChapterLanguage::Create, KaxChapterLanguage_TheId, "ChapterLanguage", KaxChapterLanguage_Context); +const EbmlCallbacks KaxChapterCountry::ClassInfos(KaxChapterCountry::Create, KaxChapterCountry_TheId, "ChapterCountry", KaxChapterCountry_Context); +const EbmlCallbacks KaxChapterProcess::ClassInfos(KaxChapterProcess::Create, KaxChapterProcess_TheId, "ChapterProcess", KaxChapterProcess_Context); +const EbmlCallbacks KaxChapterProcessTime::ClassInfos(KaxChapterProcessTime::Create, KaxChapterProcessTime_TheId, "ChapterProcessTime", KaxChapterProcessTime_Context); +const EbmlCallbacks KaxChapterProcessCommand::ClassInfos(KaxChapterProcessCommand::Create, KaxChapterProcessCommand_TheId, "ChapterProcessCommand", KaxChapterProcessCommand_Context); + +KaxChapters::KaxChapters() + :EbmlMaster(KaxChapters_Context) +{} + +KaxEditionEntry::KaxEditionEntry() +:EbmlMaster(KaxEditionEntry_Context) +{} + +KaxChapterAtom::KaxChapterAtom() +:EbmlMaster(KaxChapterAtom_Context) +{} + +KaxChapterTrack::KaxChapterTrack() +:EbmlMaster(KaxChapterTrack_Context) +{} + +KaxChapterDisplay::KaxChapterDisplay() +:EbmlMaster(KaxChapterDisplay_Context) +{} + +KaxChapterProcess::KaxChapterProcess() +:EbmlMaster(KaxChapterProcess_Context) +{} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxCluster.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxCluster.cpp new file mode 100644 index 0000000000..4183270b80 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxCluster.cpp @@ -0,0 +1,234 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxCluster.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme +*/ +#include "matroska/KaxCluster.h" +#include "matroska/KaxClusterData.h" +#include "matroska/KaxBlock.h" +#include "matroska/KaxContexts.h" +#include "matroska/KaxSegment.h" + +// sub elements +START_LIBMATROSKA_NAMESPACE + +EbmlSemantic KaxCluster_ContextList[4] = +{ + EbmlSemantic(true, true, KaxClusterTimecode::ClassInfos), + EbmlSemantic(false, true, KaxClusterPrevSize::ClassInfos), + EbmlSemantic(true, false, KaxBlockGroup::ClassInfos), + EbmlSemantic(false, true, KaxClusterPosition::ClassInfos), +}; + +const EbmlSemanticContext KaxCluster_Context = EbmlSemanticContext(countof(KaxCluster_ContextList), KaxCluster_ContextList, &KaxSegment_Context, *GetKaxGlobal_Context, &KaxCluster::ClassInfos); + +EbmlId KaxCluster_TheId(0x1F43B675, 4); +const EbmlCallbacks KaxCluster::ClassInfos(KaxCluster::Create, KaxCluster_TheId, "Cluster", KaxCluster_Context); + +KaxCluster::KaxCluster() + :EbmlMaster(KaxCluster_Context) + ,currentNewBlock(NULL) + ,ParentSegment(NULL) + ,bFirstFrameInside(false) + ,bPreviousTimecodeIsSet(false) + ,bTimecodeScaleIsSet(false) +{} + +KaxCluster::KaxCluster(const KaxCluster & ElementToClone) + :EbmlMaster(ElementToClone) +{ + // update the parent of each children + std::vector::const_iterator Itr = ElementList.begin(); + while (Itr != ElementList.end()) + { + if (EbmlId(**Itr) == KaxBlockGroup::ClassInfos.GlobalId) { + static_cast(*Itr)->SetParent(*this); + } else if (EbmlId(**Itr) == KaxBlock::ClassInfos.GlobalId) { + static_cast(*Itr)->SetParent(*this); +#if MATROSKA_VERSION >= 2 + } else if (EbmlId(**Itr) == KaxBlockVirtual::ClassInfos.GlobalId) { + static_cast(*Itr)->SetParent(*this); +#endif // MATROSKA_VERSION + } + } +} + +bool KaxCluster::AddFrameInternal(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, const KaxBlockGroup * PastBlock, const KaxBlockGroup * ForwBlock, LacingType lacing) +{ + if (!bFirstFrameInside) { + bFirstFrameInside = true; + MinTimecode = MaxTimecode = timecode; + } else { + if (timecode < MinTimecode) + MinTimecode = timecode; + if (timecode > MaxTimecode) + MaxTimecode = timecode; + } + + MyNewBlock = NULL; + + if (lacing == LACING_NONE || !track.LacingEnabled()) { + currentNewBlock = NULL; + } + + // force creation of a new block + if (currentNewBlock == NULL || uint32(track.TrackNumber()) != uint32(currentNewBlock->TrackNumber()) || PastBlock != NULL || ForwBlock != NULL) { + KaxBlockGroup & aNewBlock = GetNewBlock(); + MyNewBlock = currentNewBlock = &aNewBlock; + currentNewBlock = &aNewBlock; + } + + if (PastBlock != NULL) { + if (ForwBlock != NULL) { + if (currentNewBlock->AddFrame(track, timecode, buffer, *PastBlock, *ForwBlock, lacing)) { + // more data are allowed in this Block + return true; + } else { + currentNewBlock = NULL; + return false; + } + } else { + if (currentNewBlock->AddFrame(track, timecode, buffer, *PastBlock, lacing)) { + // more data are allowed in this Block + return true; + } else { + currentNewBlock = NULL; + return false; + } + } + } else { + if (currentNewBlock->AddFrame(track, timecode, buffer, lacing)) { + // more data are allowed in this Block + return true; + } else { + currentNewBlock = NULL; + return false; + } + } +} + +bool KaxCluster::AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, LacingType lacing) +{ + return AddFrameInternal(track, timecode, buffer, MyNewBlock, NULL, NULL, lacing); +} + +bool KaxCluster::AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, const KaxBlockGroup & PastBlock, LacingType lacing) +{ + return AddFrameInternal(track, timecode, buffer, MyNewBlock, &PastBlock, NULL, lacing); +} + +bool KaxCluster::AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, const KaxBlockGroup & PastBlock, const KaxBlockGroup & ForwBlock, LacingType lacing) +{ + return AddFrameInternal(track, timecode, buffer, MyNewBlock, &PastBlock, &ForwBlock, lacing); +} + +/*! + \todo only put the Blocks written in the cue entries +*/ +uint32 KaxCluster::Render(IOCallback & output, KaxCues & CueToUpdate, bool bSaveDefault) +{ + // update the Timecode of the Cluster before writing + KaxClusterTimecode * Timecode = static_cast(this->FindElt(KaxClusterTimecode::ClassInfos)); + *static_cast(Timecode) = GlobalTimecode() / GlobalTimecodeScale(); + + uint32 Result = EbmlMaster::Render(output, bSaveDefault); + // For all Blocks add their position on the CueEntry + size_t Index; + + for (Index = 0; Index < ElementList.size(); Index++) { + if (EbmlId(*ElementList[Index]) == KaxBlockGroup::ClassInfos.GlobalId) { + CueToUpdate.PositionSet(*static_cast(ElementList[Index])); + } + } + return Result; +} + +/*! + \todo automatically choose valid timecode for the Cluster based on the previous cluster timecode (must be incremental) +*/ +uint64 KaxCluster::GlobalTimecode() const +{ + assert(bPreviousTimecodeIsSet); + uint64 result = MinTimecode; + + if (result < PreviousTimecode) + result = PreviousTimecode + 1; + + return result; +} + +/*! + \brief retrieve the relative + \todo !!! We need a way to know the TimecodeScale +*/ +int16 KaxCluster::GetBlockLocalTimecode(uint64 aGlobalTimecode) const +{ + int64 TimecodeDelay = (int64(aGlobalTimecode) - int64(GlobalTimecode())) / int64(GlobalTimecodeScale()); + assert(TimecodeDelay >= int16(0x8000) && TimecodeDelay <= int16(0x7FFF)); + return int16(TimecodeDelay); +} + +uint64 KaxCluster::GetBlockGlobalTimecode(int16 GlobalSavedTimecode) +{ + if (!bFirstFrameInside) { + KaxClusterTimecode * Timecode = static_cast(this->FindElt(KaxClusterTimecode::ClassInfos)); + assert (bFirstFrameInside); // use the InitTimecode() hack for now + MinTimecode = MaxTimecode = PreviousTimecode = *static_cast(Timecode); + bFirstFrameInside = true; + bPreviousTimecodeIsSet = true; + } + return int64(GlobalSavedTimecode * GlobalTimecodeScale()) + GlobalTimecode(); +} + +KaxBlockGroup & KaxCluster::GetNewBlock() +{ + KaxBlockGroup & MyBlock = AddNewChild(*this); + MyBlock.SetParent(*this); + return MyBlock; +} + +void KaxCluster::ReleaseFrames() +{ + size_t Index; + + for (Index = 0; Index < ElementList.size(); Index++) { + if (EbmlId(*ElementList[Index]) == KaxBlockGroup::ClassInfos.GlobalId) { + static_cast(ElementList[Index])->ReleaseFrames(); + } + } +} + +uint64 KaxCluster::GetPosition() const +{ + assert(ParentSegment != NULL); + return ParentSegment->GetRelativePosition(*this); +} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxClusterData.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxClusterData.cpp new file mode 100644 index 0000000000..8a5432e49f --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxClusterData.cpp @@ -0,0 +1,52 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxClusterData.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme +*/ +#include "matroska/KaxClusterData.h" +#include "matroska/KaxContexts.h" + +START_LIBMATROSKA_NAMESPACE + +EbmlId KaxClusterTimecode_TheId(0xE7, 1); +EbmlId KaxClusterPrevSize_TheId(0xAB, 1); +EbmlId KaxClusterPosition_TheId(0xA7, 1); + +const EbmlSemanticContext KaxClusterTimecode_Context = EbmlSemanticContext(0, NULL, &KaxCluster_Context, *GetKaxGlobal_Context, &KaxClusterTimecode::ClassInfos); +const EbmlSemanticContext KaxClusterPosition_Context = EbmlSemanticContext(0, NULL, &KaxCluster_Context, *GetKaxGlobal_Context, &KaxClusterPosition::ClassInfos); +const EbmlSemanticContext KaxClusterPrevSize_Context = EbmlSemanticContext(0, NULL, &KaxCluster_Context, *GetKaxGlobal_Context, &KaxClusterPrevSize::ClassInfos); + +const EbmlCallbacks KaxClusterTimecode::ClassInfos(KaxClusterTimecode::Create, KaxClusterTimecode_TheId, "ClusterTimecode", KaxClusterTimecode_Context); +const EbmlCallbacks KaxClusterPrevSize::ClassInfos(KaxClusterPrevSize::Create, KaxClusterPrevSize_TheId, "ClusterPrevSize", KaxClusterPrevSize_Context); +const EbmlCallbacks KaxClusterPosition::ClassInfos(KaxClusterPosition::Create, KaxClusterPosition_TheId, "ClusterPosition", KaxClusterPosition_Context); + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxContentEncoding.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxContentEncoding.cpp new file mode 100644 index 0000000000..f46e87b966 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxContentEncoding.cpp @@ -0,0 +1,254 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxContentEncoding.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Moritz Bunkus +*/ +#include "matroska/KaxContentEncoding.h" +#include "matroska/KaxContexts.h" + +START_LIBMATROSKA_NAMESPACE + +const EbmlSemantic KaxContentEncodings_ContextList[1] = { + EbmlSemantic(true, true, KaxContentEncoding::ClassInfos), +}; + +const EbmlSemantic KaxContentEncoding_ContextList[5] = { + EbmlSemantic(true, true, KaxContentEncodingOrder::ClassInfos), + EbmlSemantic(true, true, KaxContentEncodingScope::ClassInfos), + EbmlSemantic(true, true, KaxContentEncodingType::ClassInfos), + EbmlSemantic(false, true, KaxContentCompression::ClassInfos), + EbmlSemantic(false, true, KaxContentEncryption::ClassInfos), +}; + +const EbmlSemantic KaxContentCompression_ContextList[2] = { + EbmlSemantic(true, true, KaxContentCompAlgo::ClassInfos), + EbmlSemantic(false, true, KaxContentCompSettings::ClassInfos), +}; + +const EbmlSemantic KaxContentEncryption_ContextList[6] = { + EbmlSemantic(false, true, KaxContentEncAlgo::ClassInfos), + EbmlSemantic(false, true, KaxContentEncKeyID::ClassInfos), + EbmlSemantic(false, true, KaxContentSignature::ClassInfos), + EbmlSemantic(false, true, KaxContentSigKeyID::ClassInfos), + EbmlSemantic(false, true, KaxContentSigAlgo::ClassInfos), + EbmlSemantic(false, true, KaxContentSigHashAlgo::ClassInfos), +}; + +EbmlId KaxContentEncodings_TheId (0x6d80, 2); +EbmlId KaxContentEncoding_TheId (0x6240, 2); +EbmlId KaxContentEncodingOrder_TheId (0x5031, 2); +EbmlId KaxContentEncodingScope_TheId (0x5032, 2); +EbmlId KaxContentEncodingType_TheId (0x5033, 2); +EbmlId KaxContentCompression_TheId (0x5034, 2); +EbmlId KaxContentCompAlgo_TheId (0x4254, 2); +EbmlId KaxContentCompSettings_TheId (0x4255, 2); +EbmlId KaxContentEncryption_TheId (0x5035, 2); +EbmlId KaxContentEncAlgo_TheId (0x47e1, 2); +EbmlId KaxContentEncKeyID_TheId (0x47e2, 2); +EbmlId KaxContentSignature_TheId (0x47e3, 2); +EbmlId KaxContentSigKeyID_TheId (0x47e4, 2); +EbmlId KaxContentSigAlgo_TheId (0x47e5, 2); +EbmlId KaxContentSigHashAlgo_TheId (0x47e6, 2); + +const EbmlSemanticContext KaxContentEncodings_Context = +EbmlSemanticContext(countof(KaxContentEncodings_ContextList), + KaxContentEncodings_ContextList, &KaxTrackEntry_Context, + *GetKaxGlobal_Context, + &KaxContentEncodings::ClassInfos); + +const EbmlSemanticContext KaxContentEncoding_Context = +EbmlSemanticContext(countof(KaxContentEncoding_ContextList), + KaxContentEncoding_ContextList, + &KaxContentEncodings_Context, + *GetKaxGlobal_Context, + &KaxContentEncoding::ClassInfos); + +const EbmlSemanticContext KaxContentEncodingOrder_Context = +EbmlSemanticContext(0, NULL, &KaxContentEncoding_Context, + *GetKaxGlobal_Context, + &KaxContentEncodingOrder::ClassInfos); + +const EbmlSemanticContext KaxContentEncodingScope_Context = +EbmlSemanticContext(0, NULL, &KaxContentEncoding_Context, + *GetKaxGlobal_Context, + &KaxContentEncodingScope::ClassInfos); + +const EbmlSemanticContext KaxContentEncodingType_Context = +EbmlSemanticContext(0, NULL, &KaxContentEncoding_Context, + *GetKaxGlobal_Context, + &KaxContentEncodingType::ClassInfos); + +const EbmlSemanticContext KaxContentCompression_Context = +EbmlSemanticContext(countof(KaxContentCompression_ContextList), + KaxContentCompression_ContextList, + &KaxContentEncoding_Context, *GetKaxGlobal_Context, + &KaxContentCompression::ClassInfos); + +const EbmlSemanticContext KaxContentCompAlgo_Context = +EbmlSemanticContext(0, NULL, &KaxContentCompression_Context, + *GetKaxGlobal_Context, + &KaxContentCompAlgo::ClassInfos); + +const EbmlSemanticContext KaxContentCompSettings_Context = +EbmlSemanticContext(0, NULL, &KaxContentCompression_Context, + *GetKaxGlobal_Context, + &KaxContentCompSettings::ClassInfos); + +const EbmlSemanticContext KaxContentEncryption_Context = +EbmlSemanticContext(countof(KaxContentEncryption_ContextList), + KaxContentEncryption_ContextList, + &KaxContentEncoding_Context, *GetKaxGlobal_Context, + &KaxContentEncryption::ClassInfos); + +const EbmlSemanticContext KaxContentEncAlgo_Context = +EbmlSemanticContext(0, NULL, &KaxContentEncryption_Context, + *GetKaxGlobal_Context, + &KaxContentEncAlgo::ClassInfos); + +const EbmlSemanticContext KaxContentEncKeyID_Context = +EbmlSemanticContext(0, NULL, &KaxContentEncryption_Context, + *GetKaxGlobal_Context, + &KaxContentEncKeyID::ClassInfos); + +const EbmlSemanticContext KaxContentSignature_Context = +EbmlSemanticContext(0, NULL, &KaxContentEncryption_Context, + *GetKaxGlobal_Context, + &KaxContentSignature::ClassInfos); + +const EbmlSemanticContext KaxContentSigAlgo_Context = +EbmlSemanticContext(0, NULL, &KaxContentEncryption_Context, + *GetKaxGlobal_Context, + &KaxContentSigKeyID::ClassInfos); + +const EbmlSemanticContext KaxContentSigHashAlgo_Context = +EbmlSemanticContext(0, NULL, &KaxContentEncryption_Context, + *GetKaxGlobal_Context, + &KaxContentSigKeyID::ClassInfos); + +const EbmlSemanticContext KaxContentSigKeyID_Context = +EbmlSemanticContext(0, NULL, &KaxContentEncryption_Context, + *GetKaxGlobal_Context, + &KaxContentSigKeyID::ClassInfos); + +const EbmlCallbacks +KaxContentEncodings::ClassInfos(KaxContentEncodings::Create, + KaxContentEncodings_TheId, + "ContentEncodings", + KaxContentEncodings_Context); +const EbmlCallbacks +KaxContentEncoding::ClassInfos(KaxContentEncoding::Create, + KaxContentEncoding_TheId, + "ContentEncoding", + KaxContentEncoding_Context); +const EbmlCallbacks +KaxContentEncodingOrder::ClassInfos(KaxContentEncodingOrder::Create, + KaxContentEncodingOrder_TheId, + "ContentEncodingOrder", + KaxContentEncodingOrder_Context); +const EbmlCallbacks +KaxContentEncodingScope::ClassInfos(KaxContentEncodingScope::Create, + KaxContentEncodingScope_TheId, + "ContentEncodingScope", + KaxContentEncodingScope_Context); +const EbmlCallbacks +KaxContentEncodingType::ClassInfos(KaxContentEncodingType::Create, + KaxContentEncodingType_TheId, + "ContentEncodingType", + KaxContentEncodingType_Context); +const EbmlCallbacks +KaxContentCompression::ClassInfos(KaxContentCompression::Create, + KaxContentCompression_TheId, + "ContentCompression", + KaxContentCompression_Context); +const EbmlCallbacks +KaxContentCompAlgo::ClassInfos(KaxContentCompAlgo::Create, + KaxContentCompAlgo_TheId, + "ContentCompAlgo", + KaxContentCompAlgo_Context); +const EbmlCallbacks +KaxContentCompSettings::ClassInfos(KaxContentCompSettings::Create, + KaxContentCompSettings_TheId, + "ContentCompSettings", + KaxContentCompSettings_Context); +const EbmlCallbacks +KaxContentEncryption::ClassInfos(KaxContentEncryption::Create, + KaxContentEncryption_TheId, + "ContentEncryption", + KaxContentEncryption_Context); +const EbmlCallbacks +KaxContentEncAlgo::ClassInfos(KaxContentEncAlgo::Create, + KaxContentEncAlgo_TheId, + "ContentEncAlgo", + KaxContentEncAlgo_Context); +const EbmlCallbacks +KaxContentEncKeyID::ClassInfos(KaxContentEncKeyID::Create, + KaxContentEncKeyID_TheId, + "ContentEncKeyID", + KaxContentEncKeyID_Context); +const EbmlCallbacks +KaxContentSignature::ClassInfos(KaxContentSignature::Create, + KaxContentSignature_TheId, + "ContentSignature", + KaxContentSignature_Context); +const EbmlCallbacks +KaxContentSigAlgo::ClassInfos(KaxContentSigAlgo::Create, + KaxContentSigAlgo_TheId, + "ContentSigAlgo", + KaxContentSigAlgo_Context); +const EbmlCallbacks +KaxContentSigHashAlgo::ClassInfos(KaxContentSigHashAlgo::Create, + KaxContentSigHashAlgo_TheId, + "ContentSigHashAlgo", + KaxContentSigHashAlgo_Context); +const EbmlCallbacks +KaxContentSigKeyID::ClassInfos(KaxContentSigKeyID::Create, + KaxContentSigKeyID_TheId, + "ContentSigKeyID", + KaxContentSigKeyID_Context); + +KaxContentEncodings::KaxContentEncodings(): + EbmlMaster(KaxContentEncodings_Context) { +} + +KaxContentEncoding::KaxContentEncoding(): + EbmlMaster(KaxContentEncoding_Context) { +} + +KaxContentCompression::KaxContentCompression(): + EbmlMaster(KaxContentCompression_Context) { +} + +KaxContentEncryption::KaxContentEncryption(): + EbmlMaster(KaxContentEncryption_Context) { +} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxContexts.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxContexts.cpp new file mode 100644 index 0000000000..2e128ce171 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxContexts.cpp @@ -0,0 +1,48 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxContexts.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme +*/ +#include "ebml/EbmlContexts.h" +#include "matroska/KaxContexts.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +// for the moment +const EbmlSemanticContext & GetKaxGlobal_Context() +{ + return GetEbmlGlobal_Context(); +} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxCues.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxCues.cpp new file mode 100644 index 0000000000..e972102999 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxCues.cpp @@ -0,0 +1,139 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxCues.cpp 647 2004-07-14 13:29:48Z mosu $ + \author Steve Lhomme +*/ +#include + +#include "matroska/KaxCues.h" +#include "matroska/KaxCuesData.h" +#include "matroska/KaxContexts.h" +#include "ebml/EbmlStream.h" + +// sub elements +START_LIBMATROSKA_NAMESPACE + +EbmlSemantic KaxCues_ContextList[1] = +{ + EbmlSemantic(true, false, KaxCuePoint::ClassInfos), +}; + +const EbmlSemanticContext KaxCues_Context = EbmlSemanticContext(countof(KaxCues_ContextList), KaxCues_ContextList, &KaxSegment_Context, *GetKaxGlobal_Context, &KaxCues::ClassInfos); + +EbmlId KaxCues_TheId(0x1C53BB6B, 4); +const EbmlCallbacks KaxCues::ClassInfos(KaxCues::Create, KaxCues_TheId, "Cues", KaxCues_Context); + +KaxCues::KaxCues() + :EbmlMaster(KaxCues_Context) +{} + +KaxCues::~KaxCues() +{ + assert(myTempReferences.size() == 0); // otherwise that means you have added references and forgot to set the position +} + +bool KaxCues::AddBlockGroup(const KaxBlockGroup & BlockReference) +{ + // Do not add the element if it's already present. + std::vector::iterator ListIdx; + + for (ListIdx = myTempReferences.begin(); ListIdx != myTempReferences.end(); ListIdx++) + if (*ListIdx == &BlockReference) + return true; + + myTempReferences.push_back(&BlockReference); + return true; +} + +void KaxCues::PositionSet(const KaxBlockGroup & BlockReference) +{ + // look for the element in the temporary references + std::vector::iterator ListIdx; + + for (ListIdx = myTempReferences.begin(); ListIdx != myTempReferences.end(); ListIdx++) { + if (*ListIdx == &BlockReference) { + // found, now add the element to the entry list + KaxCuePoint & NewPoint = AddNewChild(*this); + NewPoint.PositionSet(BlockReference, GlobalTimecodeScale()); + myTempReferences.erase(ListIdx); + break; + } + } +} + +/*! + \warning Assume that the list has been sorted (Sort()) +*/ +const KaxCuePoint * KaxCues::GetTimecodePoint(uint64 aTimecode) const +{ + uint64 TimecodeToLocate = aTimecode / GlobalTimecodeScale(); + const KaxCuePoint * aPointPrev = NULL; + uint64 aPrevTime = 0; + const KaxCuePoint * aPointNext = NULL; + uint64 aNextTime = EBML_PRETTYLONGINT(0xFFFFFFFFFFFF); + + for (unsigned int i=0; i((*this)[i]); + // check the tile + const KaxCueTime *aTime = static_cast(tmp->FindFirstElt(KaxCueTime::ClassInfos)); + if (aTime != NULL) + { + uint64 _Time = uint64(*aTime); + if (_Time > aPrevTime && _Time < TimecodeToLocate) { + aPrevTime = _Time; + aPointPrev = tmp; + } + if (_Time < aNextTime && _Time > TimecodeToLocate) { + aNextTime= _Time; + aPointNext = tmp; + } + } + } + } + + return aPointPrev; +} + +uint64 KaxCues::GetTimecodePosition(uint64 aTimecode) const +{ + const KaxCuePoint * aPoint = GetTimecodePoint(aTimecode); + if (aPoint == NULL) + return 0; + + const KaxCueTrackPositions * aTrack = aPoint->GetSeekPosition(); + if (aTrack == NULL) + return 0; + + return aTrack->ClusterPosition(); +} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxCuesData.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxCuesData.cpp new file mode 100644 index 0000000000..3325f44b88 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxCuesData.cpp @@ -0,0 +1,279 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxCuesData.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme +*/ +#include + +#include "matroska/KaxCuesData.h" +#include "matroska/KaxContexts.h" +#include "matroska/KaxBlock.h" +#include "matroska/KaxBlockData.h" + +START_LIBMATROSKA_NAMESPACE + +EbmlSemantic KaxCuePoint_ContextList[2] = +{ + EbmlSemantic(true, true, KaxCueTime::ClassInfos), + EbmlSemantic(true, false, KaxCueTrackPositions::ClassInfos), +}; + +#if MATROSKA_VERSION == 1 +EbmlSemantic KaxCueTrackPositions_ContextList[3] = +#else // MATROSKA_VERSION +EbmlSemantic KaxCueTrackPositions_ContextList[5] = +#endif // MATROSKA_VERSION +{ + EbmlSemantic(true, true, KaxCueTrack::ClassInfos), + EbmlSemantic(true, true, KaxCueClusterPosition::ClassInfos), + EbmlSemantic(false, true, KaxCueBlockNumber::ClassInfos), +#if MATROSKA_VERSION >= 2 + EbmlSemantic(false, true, KaxCueCodecState::ClassInfos), + EbmlSemantic(false, false, KaxCueReference::ClassInfos), +#endif // MATROSKA_VERSION +}; + +#if MATROSKA_VERSION >= 2 +EbmlSemantic KaxCueReference_ContextList[4] = +{ + EbmlSemantic(true, true, KaxCueRefTime::ClassInfos), + EbmlSemantic(true, true, KaxCueRefCluster::ClassInfos), + EbmlSemantic(false, true, KaxCueRefNumber::ClassInfos), + EbmlSemantic(false, true, KaxCueRefCodecState::ClassInfos), +}; +#endif // MATROSKA_VERSION + +EbmlId KaxCuePoint_TheId (0xBB, 1); +EbmlId KaxCueTime_TheId (0xB3, 1); +EbmlId KaxCueTrackPositions_TheId (0xB7, 1); +EbmlId KaxCueTrack_TheId (0xF7, 1); +EbmlId KaxCueClusterPosition_TheId(0xF1, 1); +EbmlId KaxCueBlockNumber_TheId (0x5378, 2); +#if MATROSKA_VERSION >= 2 +EbmlId KaxCueCodecState_TheId (0xEA, 1); +EbmlId KaxCueReference_TheId (0xDB, 1); +EbmlId KaxCueRefTime_TheId (0x96, 1); +EbmlId KaxCueRefCluster_TheId (0x97, 1); +EbmlId KaxCueRefNumber_TheId (0x535F, 2); +EbmlId KaxCueRefCodecState_TheId (0xEB, 1); +#endif // MATROSKA_VERSION + +const EbmlSemanticContext KaxCuePoint_Context = EbmlSemanticContext(countof(KaxCuePoint_ContextList), KaxCuePoint_ContextList, &KaxCues_Context, *GetKaxGlobal_Context, &KaxCuePoint::ClassInfos); +const EbmlSemanticContext KaxCueTime_Context = EbmlSemanticContext(0, NULL, &KaxCuePoint_Context, *GetKaxGlobal_Context, &KaxCueTime::ClassInfos); +const EbmlSemanticContext KaxCueTrackPositions_Context = EbmlSemanticContext(countof(KaxCueTrackPositions_ContextList), KaxCueTrackPositions_ContextList, &KaxCuePoint_Context, *GetKaxGlobal_Context, &KaxCueTrackPositions::ClassInfos); +const EbmlSemanticContext KaxCueTrack_Context = EbmlSemanticContext(0, NULL, &KaxCueTrackPositions_Context, *GetKaxGlobal_Context, &KaxCueTrack::ClassInfos); +const EbmlSemanticContext KaxCueClusterPosition_Context = EbmlSemanticContext(0, NULL, &KaxCueTrackPositions_Context, *GetKaxGlobal_Context, &KaxCueClusterPosition::ClassInfos); +const EbmlSemanticContext KaxCueBlockNumber_Context = EbmlSemanticContext(0, NULL, &KaxCueTrackPositions_Context, *GetKaxGlobal_Context, &KaxCueBlockNumber::ClassInfos); +#if MATROSKA_VERSION >= 2 +const EbmlSemanticContext KaxCueCodecState_Context = EbmlSemanticContext(0, NULL, &KaxCueTrackPositions_Context, *GetKaxGlobal_Context, &KaxCueCodecState::ClassInfos); +const EbmlSemanticContext KaxCueReference_Context = EbmlSemanticContext(countof(KaxCueReference_ContextList), KaxCueReference_ContextList, &KaxCueTrackPositions_Context, *GetKaxGlobal_Context, &KaxCueReference::ClassInfos); +const EbmlSemanticContext KaxCueRefTime_Context = EbmlSemanticContext(0, NULL, &KaxCueReference_Context, *GetKaxGlobal_Context, &KaxCueRefTime::ClassInfos); +const EbmlSemanticContext KaxCueRefCluster_Context = EbmlSemanticContext(0, NULL, &KaxCueRefTime_Context, *GetKaxGlobal_Context, &KaxCueRefCluster::ClassInfos); +const EbmlSemanticContext KaxCueRefNumber_Context = EbmlSemanticContext(0, NULL, &KaxCueRefTime_Context, *GetKaxGlobal_Context, &KaxCueRefNumber::ClassInfos); +const EbmlSemanticContext KaxCueRefCodecState_Context = EbmlSemanticContext(0, NULL, &KaxCueRefTime_Context, *GetKaxGlobal_Context, &KaxCueRefCodecState::ClassInfos); +#endif // MATROSKA_VERSION + +const EbmlCallbacks KaxCuePoint::ClassInfos(KaxCuePoint::Create, KaxCuePoint_TheId, "CuePoint", KaxCuePoint_Context); +const EbmlCallbacks KaxCueTime::ClassInfos(KaxCueTime::Create, KaxCueTime_TheId, "CueTime", KaxCueTime_Context); +const EbmlCallbacks KaxCueTrackPositions::ClassInfos(KaxCueTrackPositions::Create, KaxCueTrackPositions_TheId, "CueTrackPositions", KaxCueTrackPositions_Context); +const EbmlCallbacks KaxCueTrack::ClassInfos(KaxCueTrack::Create, KaxCueTrack_TheId, "CueTrack", KaxCueTrack_Context); +const EbmlCallbacks KaxCueClusterPosition::ClassInfos(KaxCueClusterPosition::Create, KaxCueClusterPosition_TheId, "CueClusterPosition", KaxCueClusterPosition_Context); +const EbmlCallbacks KaxCueBlockNumber::ClassInfos(KaxCueBlockNumber::Create, KaxCueBlockNumber_TheId, "CueBlockNumber", KaxCueBlockNumber_Context); +#if MATROSKA_VERSION >= 2 +const EbmlCallbacks KaxCueCodecState::ClassInfos(KaxCueCodecState::Create, KaxCueCodecState_TheId, "CueCodecState", KaxCueCodecState_Context); +const EbmlCallbacks KaxCueReference::ClassInfos(KaxCueReference::Create, KaxCueReference_TheId, "CueReference", KaxCueReference_Context); +const EbmlCallbacks KaxCueRefTime::ClassInfos(KaxCueRefTime::Create, KaxCueRefTime_TheId, "CueRefTime", KaxCueRefTime_Context); +const EbmlCallbacks KaxCueRefCluster::ClassInfos(KaxCueRefCluster::Create, KaxCueRefCluster_TheId, "CueRefCluster", KaxCueRefCluster_Context); +const EbmlCallbacks KaxCueRefNumber::ClassInfos(KaxCueRefNumber::Create, KaxCueRefNumber_TheId, "CueRefNumber", KaxCueRefNumber_Context); +const EbmlCallbacks KaxCueRefCodecState::ClassInfos(KaxCueRefCodecState::Create, KaxCueRefCodecState_TheId, "CueRefCodecState", KaxCueRefCodecState_Context); +#endif // MATROSKA_VERSION + +KaxCuePoint::KaxCuePoint() + :EbmlMaster(KaxCuePoint_Context) +{} + +KaxCueTrackPositions::KaxCueTrackPositions() + :EbmlMaster(KaxCueTrackPositions_Context) +{} + +#if MATROSKA_VERSION >= 2 +KaxCueReference::KaxCueReference() + :EbmlMaster(KaxCueReference_Context) +{} +#endif // MATROSKA_VERSION + +/*! + \todo handle codec state checking + \todo remove duplicate references (reference to 2 frames that each reference the same frame) +*/ +void KaxCuePoint::PositionSet(const KaxBlockGroup & BlockReference, uint64 GlobalTimecodeScale) +{ + // fill me + KaxCueTime & NewTime = GetChild(*this); + *static_cast(&NewTime) = BlockReference.GlobalTimecode() / GlobalTimecodeScale; + + KaxCueTrackPositions & NewPositions = AddNewChild(*this); + KaxCueTrack & TheTrack = GetChild(NewPositions); + *static_cast(&TheTrack) = BlockReference.TrackNumber(); + + KaxCueClusterPosition & TheClustPos = GetChild(NewPositions); + *static_cast(&TheClustPos) = BlockReference.ClusterPosition(); + +#if MATROSKA_VERSION >= 2 + // handle reference use + if (BlockReference.ReferenceCount() != 0) + { + unsigned int i; + for (i=0; i(NewPositions); + NewRefs.AddReference(BlockReference.Reference(i).RefBlock(), GlobalTimecodeScale); + } + } +#endif // MATROSKA_VERSION + + bValueIsSet = true; +} + +#if MATROSKA_VERSION >= 2 +/*! + \todo handle codec state checking +*/ +void KaxCueReference::AddReference(const KaxBlockGroup & BlockReference, uint64 GlobalTimecodeScale) +{ + KaxCueRefTime & NewTime = GetChild(*this); + *static_cast(&NewTime) = BlockReference.GlobalTimecode() / GlobalTimecodeScale; + + KaxCueRefCluster & TheClustPos = GetChild(*this); + *static_cast(&TheClustPos) = BlockReference.ClusterPosition(); + +#ifdef OLD + // handle recursive reference use + if (BlockReference.ReferenceCount() != 0) + { + unsigned int i; + for (i=0; i(&EltB); + + // compare timecode + const KaxCueTime * TimeCodeA = static_cast(FindElt(KaxCueTime::ClassInfos)); + if (TimeCodeA == NULL) + return false; + + const KaxCueTime * TimeCodeB = static_cast(theEltB.FindElt(KaxCueTime::ClassInfos)); + if (TimeCodeB == NULL) + return false; + + if (*TimeCodeA < *TimeCodeB) + return true; + + if (*TimeCodeB < *TimeCodeA) + return false; + + // compare tracks (timecodes are equal) + const KaxCueTrack * TrackA = static_cast(FindElt(KaxCueTrack::ClassInfos)); + if (TrackA == NULL) + return false; + + const KaxCueTrack * TrackB = static_cast(theEltB.FindElt(KaxCueTrack::ClassInfos)); + if (TrackB == NULL) + return false; + + if (*TrackA < *TrackB) + return true; + + if (*TrackB < *TrackA) + return false; + + return false; +} + +bool KaxCuePoint::Timecode(uint64 & aTimecode, uint64 GlobalTimecodeScale) const +{ + const KaxCueTime *aTime = static_cast(FindFirstElt(KaxCueTime::ClassInfos)); + if (aTime == NULL) + return false; + aTimecode = uint64(*aTime) * GlobalTimecodeScale; + return true; +} + +/*! + \brief return the position of the Cluster to load +*/ +const KaxCueTrackPositions * KaxCuePoint::GetSeekPosition() const +{ + const KaxCueTrackPositions * result = NULL; + uint64 aPosition = EBML_PRETTYLONGINT(0xFFFFFFFFFFFFFFF); + // find the position of the "earlier" Cluster + const KaxCueTrackPositions *aPoss = static_cast(FindFirstElt(KaxCueTrackPositions::ClassInfos)); + while (aPoss != NULL) + { + const KaxCueClusterPosition *aPos = static_cast(aPoss->FindFirstElt(KaxCueClusterPosition::ClassInfos)); + if (aPos != NULL && uint64(*aPos) < aPosition) { + aPosition = uint64(*aPos); + result = aPoss; + } + + aPoss = static_cast(FindNextElt(*aPoss)); + } + return result; +} + +uint64 KaxCueTrackPositions::ClusterPosition() const +{ + const KaxCueClusterPosition *aPos = static_cast(FindFirstElt(KaxCueClusterPosition::ClassInfos)); + if (aPos == NULL) + return 0; + + return uint64(*aPos); +} + +uint16 KaxCueTrackPositions::TrackNumber() const +{ + const KaxCueTrack *aTrack = static_cast(FindFirstElt(KaxCueTrack::ClassInfos)); + if (aTrack == NULL) + return 0; + + return uint16(*aTrack); +} + + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxInfo.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxInfo.cpp new file mode 100644 index 0000000000..2f87fb1e7c --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxInfo.cpp @@ -0,0 +1,75 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxInfo.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme +*/ +#include "matroska/KaxInfo.h" +#include "matroska/KaxInfoData.h" + +#include "matroska/KaxContexts.h" + +// sub elements +START_LIBMATROSKA_NAMESPACE + +const EbmlSemantic KaxInfo_ContextList[12] = +{ + EbmlSemantic(false, true, KaxSegmentUID::ClassInfos), + EbmlSemantic(false, true, KaxSegmentFilename::ClassInfos), + EbmlSemantic(false, true, KaxPrevUID::ClassInfos), + EbmlSemantic(false, true, KaxPrevFilename::ClassInfos), + EbmlSemantic(false, true, KaxNextUID::ClassInfos), + EbmlSemantic(false, true, KaxNextFilename::ClassInfos), + EbmlSemantic(true, true, KaxTimecodeScale::ClassInfos), + EbmlSemantic(false, true, KaxDuration::ClassInfos), + EbmlSemantic(false, true, KaxDateUTC::ClassInfos), + EbmlSemantic(false, true, KaxTitle::ClassInfos), + EbmlSemantic(true, true, KaxMuxingApp::ClassInfos), + EbmlSemantic(true, true, KaxWritingApp::ClassInfos), +}; + +const EbmlSemanticContext KaxInfo_Context = EbmlSemanticContext(countof(KaxInfo_ContextList), KaxInfo_ContextList, &KaxSegment_Context, *GetKaxGlobal_Context, &KaxInfo::ClassInfos); +const EbmlSemanticContext KaxMuxingApp_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxMuxingApp::ClassInfos); +const EbmlSemanticContext KaxWritingApp_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxWritingApp::ClassInfos); + +EbmlId KaxInfo_TheId (0x1549A966, 4); +EbmlId KaxMuxingApp_TheId (0x4D80, 2); +EbmlId KaxWritingApp_TheId(0x5741, 2); + +const EbmlCallbacks KaxInfo::ClassInfos(KaxInfo::Create, KaxInfo_TheId, "Info", KaxInfo_Context); +const EbmlCallbacks KaxMuxingApp::ClassInfos(KaxMuxingApp::Create, KaxMuxingApp_TheId, "MuxingApp", KaxMuxingApp_Context); +const EbmlCallbacks KaxWritingApp::ClassInfos(KaxWritingApp::Create, KaxWritingApp_TheId, "WritingApp", KaxWritingApp_Context); + +KaxInfo::KaxInfo() + :EbmlMaster(KaxInfo_Context) +{} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxInfoData.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxInfoData.cpp new file mode 100644 index 0000000000..29e23bd176 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxInfoData.cpp @@ -0,0 +1,75 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxInfoData.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme + \author John Cannon +*/ +#include "matroska/KaxInfoData.h" +#include "matroska/KaxContexts.h" + +START_LIBMATROSKA_NAMESPACE + +EbmlId KaxSegmentUID_TheId (0x73A4, 2); +EbmlId KaxSegmentFilename_TheId(0x7384, 2); +EbmlId KaxPrevUID_TheId (0x3CB923, 3); +EbmlId KaxPrevFilename_TheId (0x3C83AB, 3); +EbmlId KaxNextUID_TheId (0x3EB923, 3); +EbmlId KaxNextFilename_TheId (0x3E83BB, 3); +EbmlId KaxTimecodeScale_TheId (0x2AD7B1, 3); +EbmlId KaxDuration_TheId (0x4489, 2); +EbmlId KaxDateUTC_TheId (0x4461, 2); +EbmlId KaxTitle_TheId (0x7BA9, 2); + +const EbmlSemanticContext KaxSegmentUID_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxSegmentUID::ClassInfos); +const EbmlSemanticContext KaxSegmentFilename_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxSegmentFilename::ClassInfos); +const EbmlSemanticContext KaxPrevUID_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxPrevUID::ClassInfos); +const EbmlSemanticContext KaxPrevFilename_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxPrevFilename::ClassInfos); +const EbmlSemanticContext KaxNextUID_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxNextUID::ClassInfos); +const EbmlSemanticContext KaxNextFilename_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxNextFilename::ClassInfos); +const EbmlSemanticContext KaxTimecodeScale_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxTimecodeScale::ClassInfos); +const EbmlSemanticContext KaxDuration_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxDuration::ClassInfos); +const EbmlSemanticContext KaxDateUTC_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxDateUTC::ClassInfos); +const EbmlSemanticContext KaxTitle_Context = EbmlSemanticContext(0, NULL, &KaxInfo_Context, *GetKaxGlobal_Context, &KaxTitle::ClassInfos); + + +const EbmlCallbacks KaxSegmentUID::ClassInfos(KaxSegmentUID::Create, KaxSegmentUID_TheId, "SegmentUID", KaxSegmentUID_Context); +const EbmlCallbacks KaxSegmentFilename::ClassInfos(KaxSegmentFilename::Create, KaxSegmentFilename_TheId, "SegmentFilename", KaxSegmentFilename_Context); +const EbmlCallbacks KaxPrevUID::ClassInfos(KaxPrevUID::Create, KaxPrevUID_TheId, "PrevUID", KaxPrevUID_Context); +const EbmlCallbacks KaxPrevFilename::ClassInfos(KaxPrevFilename::Create, KaxPrevFilename_TheId, "PrevFilename", KaxPrevFilename_Context); +const EbmlCallbacks KaxNextUID::ClassInfos(KaxNextUID::Create, KaxNextUID_TheId, "NextUID", KaxNextUID_Context); +const EbmlCallbacks KaxNextFilename::ClassInfos(KaxNextFilename::Create, KaxNextFilename_TheId, "NextFilename", KaxNextFilename_Context); +const EbmlCallbacks KaxTimecodeScale::ClassInfos(KaxTimecodeScale::Create, KaxTimecodeScale_TheId, "TimecodeScale", KaxTimecodeScale_Context); +const EbmlCallbacks KaxDuration::ClassInfos(KaxDuration::Create, KaxDuration_TheId, "Duration", KaxDuration_Context); +const EbmlCallbacks KaxDateUTC::ClassInfos(KaxDateUTC::Create, KaxDateUTC_TheId, "DateUTC", KaxDateUTC_Context); +const EbmlCallbacks KaxTitle::ClassInfos(KaxTitle::Create, KaxTitle_TheId, "Title", KaxTitle_Context); + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxSeekHead.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxSeekHead.cpp new file mode 100644 index 0000000000..571a4b9c86 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxSeekHead.cpp @@ -0,0 +1,181 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxSeekHead.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme +*/ +#include "matroska/KaxSeekHead.h" +#include "matroska/KaxContexts.h" +#include "matroska/KaxSegment.h" +#include "matroska/KaxCues.h" + +using namespace LIBEBML_NAMESPACE; + +// sub elements +START_LIBMATROSKA_NAMESPACE + +EbmlSemantic KaxSeekHead_ContextList[1] = +{ + EbmlSemantic(true, false, KaxSeek::ClassInfos), +}; + +EbmlSemantic KaxSeek_ContextList[2] = +{ + EbmlSemantic(true, true, KaxSeekID::ClassInfos), + EbmlSemantic(true, true, KaxSeekPosition::ClassInfos), +}; + +const EbmlSemanticContext KaxSeekHead_Context = EbmlSemanticContext(countof(KaxSeekHead_ContextList), KaxSeekHead_ContextList, &KaxSegment_Context, *GetKaxGlobal_Context, &KaxSeekHead::ClassInfos); +const EbmlSemanticContext KaxSeek_Context = EbmlSemanticContext(countof(KaxSeek_ContextList), KaxSeek_ContextList, &KaxSeekHead_Context, *GetKaxGlobal_Context, &KaxSeek::ClassInfos); +const EbmlSemanticContext KaxSeekID_Context = EbmlSemanticContext(0, NULL, &KaxSeek_Context, *GetKaxGlobal_Context, &KaxSeekID::ClassInfos); +const EbmlSemanticContext KaxSeekPosition_Context = EbmlSemanticContext(0, NULL, &KaxSeek_Context, *GetKaxGlobal_Context, &KaxSeekPosition::ClassInfos); + +EbmlId KaxSeekHead_TheId (0x114D9B74, 4); +EbmlId KaxSeek_TheId (0x4DBB, 2); +EbmlId KaxSeekID_TheId (0x53AB, 2); +EbmlId KaxSeekPosition_TheId(0x53AC, 2); + +const EbmlCallbacks KaxSeekHead::ClassInfos(KaxSeekHead::Create, KaxSeekHead_TheId, "SeekHeader", KaxSeekHead_Context); +const EbmlCallbacks KaxSeek::ClassInfos(KaxSeek::Create, KaxSeek_TheId, "SeekPoint", KaxSeek_Context); +const EbmlCallbacks KaxSeekID::ClassInfos(KaxSeekID::Create, KaxSeekID_TheId, "SeekID", KaxSeekID_Context); +const EbmlCallbacks KaxSeekPosition::ClassInfos(KaxSeekPosition::Create, KaxSeekPosition_TheId, "SeekPosition", KaxSeekPosition_Context); + +KaxSeekHead::KaxSeekHead() + :EbmlMaster(KaxSeekHead_Context) +{} + +KaxSeek::KaxSeek() + :EbmlMaster(KaxSeek_Context) +{} + +/*! + \todo verify that the element is not already in the list +*/ +void KaxSeekHead::IndexThis(const EbmlElement & aElt, const KaxSegment & ParentSegment) +{ + // create a new point + KaxSeek & aNewPoint = AddNewChild(*this); + + // add the informations to this element + KaxSeekPosition & aNewPos = GetChild(aNewPoint); + *static_cast(&aNewPos) = ParentSegment.GetRelativePosition(aElt); + + KaxSeekID & aNewID = GetChild(aNewPoint); + binary ID[4]; + for (int i=aElt.Generic().GlobalId.Length; i>0; i--) { + ID[4-i] = (aElt.Generic().GlobalId.Value >> 8*(i-1)) & 0xFF; + } + aNewID.CopyBuffer(ID, aElt.Generic().GlobalId.Length); +} + +KaxSeek * KaxSeekHead::FindFirstOf(const EbmlCallbacks & Callbacks) const +{ + // parse all the Entries and find the first to match the type + KaxSeek * aElt = static_cast(FindFirstElt(KaxSeek::ClassInfos)); + while (aElt != NULL) + { + KaxSeekID * aId = NULL; + for (unsigned int i = 0; iListSize(); i++) { + if (EbmlId(*(*aElt)[i]) == KaxSeekID::ClassInfos.GlobalId) { + aId = static_cast((*aElt)[i]); + EbmlId aEbmlId(aId->GetBuffer(), aId->GetSize()); + if (aEbmlId == Callbacks.GlobalId) + { + return aElt; + } + break; + } + } + aElt = static_cast(FindNextElt(*aElt)); + } + + return NULL; +} + +KaxSeek * KaxSeekHead::FindNextOf(const KaxSeek &aPrev) const +{ + unsigned int iIndex; + KaxSeek *tmp; + + // look for the previous in the list + for (iIndex = 0; iIndex(&aPrev)) + break; + } + + if (iIndex (ElementList[iIndex]); + if (tmp->IsEbmlId(aPrev)) + return tmp; + } + } + } + + return NULL; +} + +int64 KaxSeek::Location() const +{ + KaxSeekPosition *aPos = static_cast(FindFirstElt(KaxSeekPosition::ClassInfos)); + if (aPos == NULL) + return 0; + return uint64(*aPos); +} + +bool KaxSeek::IsEbmlId(const EbmlId & aId) const +{ + KaxSeekID *_Id = static_cast(FindFirstElt(KaxSeekID::ClassInfos)); + if (_Id == NULL) + return false; + EbmlId aEbmlId(_Id->GetBuffer(), _Id->GetSize()); + return (aId == aEbmlId); +} + +bool KaxSeek::IsEbmlId(const KaxSeek & aPoint) const +{ + KaxSeekID *_IdA = static_cast(FindFirstElt(KaxSeekID::ClassInfos)); + if (_IdA == NULL) + return false; + KaxSeekID *_IdB = static_cast(aPoint.FindFirstElt(KaxSeekID::ClassInfos)); + if (_IdB == NULL) + return false; + EbmlId aEbmlIdA(_IdA->GetBuffer(), _IdA->GetSize()); + EbmlId aEbmlIdB(_IdB->GetBuffer(), _IdB->GetSize()); + return (aEbmlIdA == aEbmlIdB); +} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxSegment.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxSegment.cpp new file mode 100644 index 0000000000..036054ad55 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxSegment.cpp @@ -0,0 +1,111 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxSegment.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme +*/ +#include "matroska/KaxSegment.h" +#include "ebml/EbmlHead.h" + +// sub elements +#include "matroska/KaxCluster.h" +#include "matroska/KaxSeekHead.h" +#include "matroska/KaxCues.h" +#include "matroska/KaxTracks.h" +#include "matroska/KaxInfo.h" +#include "matroska/KaxChapters.h" +#include "matroska/KaxAttachments.h" +#include "matroska/KaxTags.h" +#include "matroska/KaxContexts.h" + +START_LIBMATROSKA_NAMESPACE + +EbmlSemantic KaxMatroska_ContextList[2] = +{ + EbmlSemantic(true, true, EbmlHead::ClassInfos), + EbmlSemantic(true, false, KaxSegment::ClassInfos), +}; + +EbmlSemantic KaxSegment_ContextList[8] = +{ + EbmlSemantic(false, false, KaxCluster::ClassInfos), + EbmlSemantic(false, false, KaxSeekHead::ClassInfos), + EbmlSemantic(false, true, KaxCues::ClassInfos), + EbmlSemantic(false, false, KaxTracks::ClassInfos), + EbmlSemantic(true, true, KaxInfo::ClassInfos), + EbmlSemantic(false, true, KaxChapters::ClassInfos), + EbmlSemantic(false, true, KaxAttachments::ClassInfos), + EbmlSemantic(false, true, KaxTags::ClassInfos), +}; + +const EbmlSemanticContext KaxMatroska_Context = EbmlSemanticContext(countof(KaxMatroska_ContextList), KaxMatroska_ContextList, NULL, *GetKaxGlobal_Context, NULL); +const EbmlSemanticContext KaxSegment_Context = EbmlSemanticContext(countof(KaxSegment_ContextList), KaxSegment_ContextList, NULL, *GetKaxGlobal_Context, &KaxSegment::ClassInfos); + +EbmlId KaxSegment_TheId(0x18538067, 4); +const EbmlCallbacks KaxSegment::ClassInfos(KaxSegment::Create, KaxSegment_TheId, "Segment", KaxSegment_Context); + +KaxSegment::KaxSegment() + :EbmlMaster(KaxSegment_Context) +{ + SetSizeLength(5); // mandatory min size support (for easier updating) (2^(7*5)-2 = 32Go) + SetSizeInfinite(); // by default a segment is big and the size is unknown in advance +} + +KaxSegment::KaxSegment(const KaxSegment & ElementToClone) + :EbmlMaster(ElementToClone) +{ + // update the parent of each children + std::vector::const_iterator Itr = ElementList.begin(); + while (Itr != ElementList.end()) + { + if (EbmlId(**Itr) == KaxCluster::ClassInfos.GlobalId) { + static_cast(*Itr)->SetParent(*this); + } + } +} + + +uint64 KaxSegment::GetRelativePosition(uint64 aGlobalPosition) const +{ + return aGlobalPosition - GetElementPosition() - HeadSize(); +} + +uint64 KaxSegment::GetRelativePosition(const EbmlElement & Elt) const +{ + return GetRelativePosition(Elt.GetElementPosition()); +} + +uint64 KaxSegment::GetGlobalPosition(uint64 aRelativePosition) const +{ + return aRelativePosition + GetElementPosition() + HeadSize(); +} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxTag.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxTag.cpp new file mode 100644 index 0000000000..722f418900 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxTag.cpp @@ -0,0 +1,347 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxTag.cpp 733 2004-08-27 12:25:01Z robux4 $ + \author Jory Stone + \author Steve Lhomme +*/ +#include "matroska/KaxTag.h" +#include "matroska/KaxTagMulti.h" +#include "matroska/KaxContexts.h" + +using namespace LIBEBML_NAMESPACE; + +// sub elements +START_LIBMATROSKA_NAMESPACE + +EbmlSemantic KaxTag_ContextList[14] = +{ + EbmlSemantic(true, true, KaxTagTargets::ClassInfos), + EbmlSemantic(false, true, KaxTagGeneral::ClassInfos), + EbmlSemantic(false, true, KaxTagGenres::ClassInfos), + EbmlSemantic(false, true, KaxTagAudioSpecific::ClassInfos), + EbmlSemantic(false, true, KaxTagImageSpecific::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiCommercial::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiDate::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiEntity::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiIdentifier::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiLegal::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiTitle::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiAttachment::ClassInfos), +// EbmlSemantic(false, false, KaxTagLength::ClassInfos), +// EbmlSemantic(false, false, KaxTagPlaylistDelay::ClassInfos), +// EbmlSemantic(false, false, KaxTagUnsynchronisedText::ClassInfos), +// EbmlSemantic(false, false, KaxTagUserDefinedURL::ClassInfos), + EbmlSemantic(false, false, KaxTagMultiComment::ClassInfos), + EbmlSemantic(true, false, KaxTagSimple::ClassInfos), +}; + +EbmlSemantic KaxTagTargets_ContextList[6] = +{ + EbmlSemantic(false, true, KaxTagTargetTypeValue::ClassInfos), + EbmlSemantic(false, true, KaxTagTargetType::ClassInfos), + EbmlSemantic(false, false, KaxTagTrackUID::ClassInfos), + EbmlSemantic(false, false, KaxTagEditionUID::ClassInfos), + EbmlSemantic(false, false, KaxTagChapterUID::ClassInfos), + EbmlSemantic(false, false, KaxTagAttachmentUID::ClassInfos), +}; + +EbmlSemantic KaxTagGeneral_ContextList[17] = +{ + EbmlSemantic(false, true, KaxTagArchivalLocation::ClassInfos), + EbmlSemantic(false, true, KaxTagFile::ClassInfos), + EbmlSemantic(false, false, KaxTagKeywords::ClassInfos), + EbmlSemantic(false, true, KaxTagMood::ClassInfos), + EbmlSemantic(false, false, KaxTagRecordLocation::ClassInfos), + EbmlSemantic(false, true, KaxTagSource::ClassInfos), + EbmlSemantic(false, true, KaxTagSourceForm::ClassInfos), + EbmlSemantic(false, true, KaxTagProduct::ClassInfos), + EbmlSemantic(false, true, KaxTagOriginalMediaType::ClassInfos), + EbmlSemantic(false, true, KaxTagPlayCounter::ClassInfos), + EbmlSemantic(false, true, KaxTagPopularimeter::ClassInfos), + EbmlSemantic(false, true, KaxTagSubject::ClassInfos), + EbmlSemantic(false, true, KaxTagBibliography::ClassInfos), + EbmlSemantic(false, true, KaxTagLanguage::ClassInfos), + EbmlSemantic(false, true, KaxTagRating::ClassInfos), + EbmlSemantic(false, true, KaxTagEncoder::ClassInfos), + EbmlSemantic(false, true, KaxTagEncodeSettings::ClassInfos), +}; + +EbmlSemantic KaxTagGenres_ContextList[3] = +{ + EbmlSemantic(false, false, KaxTagAudioGenre::ClassInfos), + EbmlSemantic(false, false, KaxTagVideoGenre::ClassInfos), + EbmlSemantic(false, true, KaxTagSubGenre::ClassInfos), +}; + +EbmlSemantic KaxTagAudioSpecific_ContextList[10] = +{ + EbmlSemantic(false, true, KaxTagAudioPeak::ClassInfos), + EbmlSemantic(false, true, KaxTagAudioEncryption::ClassInfos), + EbmlSemantic(false, true, KaxTagAudioGain::ClassInfos), + EbmlSemantic(false, true, KaxTagBPM::ClassInfos), + EbmlSemantic(false, true, KaxTagDiscTrack::ClassInfos), + EbmlSemantic(false, true, KaxTagSetPart::ClassInfos), + EbmlSemantic(false, true, KaxTagEqualisation::ClassInfos), + EbmlSemantic(false, true, KaxTagInitialKey::ClassInfos), + EbmlSemantic(false, true, KaxTagOfficialAudioFileURL::ClassInfos), + EbmlSemantic(false, true, KaxTagOfficialAudioSourceURL::ClassInfos), +}; + +EbmlSemantic KaxTagImageSpecific_ContextList[6] = +{ + EbmlSemantic(false, true, KaxTagCaptureDPI::ClassInfos), + EbmlSemantic(false, true, KaxTagCaptureLightness::ClassInfos), + EbmlSemantic(false, true, KaxTagCapturePaletteSetting::ClassInfos), + EbmlSemantic(false, true, KaxTagCaptureSharpness::ClassInfos), + EbmlSemantic(false, true, KaxTagCropped::ClassInfos), + EbmlSemantic(false, true, KaxTagOriginalDimensions::ClassInfos), +}; + +EbmlSemantic KaxTagSimple_ContextList[6] = +{ + EbmlSemantic(true, true, KaxTagName::ClassInfos), + EbmlSemantic(true, true, KaxTagLangue::ClassInfos), + EbmlSemantic(true, true, KaxTagDefault::ClassInfos), + EbmlSemantic(false, true, KaxTagString::ClassInfos), + EbmlSemantic(false, true, KaxTagBinary::ClassInfos), + EbmlSemantic(false, false, KaxTagSimple::ClassInfos), +}; + +const EbmlSemanticContext KaxTag_Context = EbmlSemanticContext(countof(KaxTag_ContextList), KaxTag_ContextList, &KaxTags_Context, *GetKaxTagsGlobal_Context, &KaxTag::ClassInfos); +const EbmlSemanticContext KaxTagTargets_Context = EbmlSemanticContext(countof(KaxTagTargets_ContextList), KaxTagTargets_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagTargets::ClassInfos); +const EbmlSemanticContext KaxTagGeneral_Context = EbmlSemanticContext(countof(KaxTagGeneral_ContextList), KaxTagGeneral_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagGeneral::ClassInfos); +const EbmlSemanticContext KaxTagGenres_Context = EbmlSemanticContext(countof(KaxTagGenres_ContextList), KaxTagGenres_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagGenres::ClassInfos); +const EbmlSemanticContext KaxTagAudioSpecific_Context = EbmlSemanticContext(countof(KaxTagAudioSpecific_ContextList), KaxTagAudioSpecific_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagAudioSpecific::ClassInfos); +const EbmlSemanticContext KaxTagImageSpecific_Context = EbmlSemanticContext(countof(KaxTagImageSpecific_ContextList), KaxTagImageSpecific_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagImageSpecific::ClassInfos); +const EbmlSemanticContext KaxTagBibliography_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagBibliography::ClassInfos); +const EbmlSemanticContext KaxTagEncoder_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagEncoder::ClassInfos); +const EbmlSemanticContext KaxTagEncodeSettings_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagEncodeSettings::ClassInfos); +const EbmlSemanticContext KaxTagLanguage_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagLanguage::ClassInfos); +const EbmlSemanticContext KaxTagLength_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagLength::ClassInfos); +const EbmlSemanticContext KaxTagPlaylistDelay_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagPlaylistDelay::ClassInfos); +const EbmlSemanticContext KaxTagRating_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagRating::ClassInfos); +const EbmlSemanticContext KaxTagSubject_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagSubject::ClassInfos); +const EbmlSemanticContext KaxTagUnsynchronisedText_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagUnsynchronisedText::ClassInfos); +const EbmlSemanticContext KaxTagUserDefinedURL_Context = EbmlSemanticContext(0, NULL, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagUserDefinedURL::ClassInfos); +const EbmlSemanticContext KaxTagTargetTypeValue_Context = EbmlSemanticContext(0, NULL, &KaxTagTargets_Context, *GetKaxGlobal_Context, &KaxTagTargetTypeValue::ClassInfos); +const EbmlSemanticContext KaxTagTargetType_Context = EbmlSemanticContext(0, NULL, &KaxTagTargets_Context, *GetKaxGlobal_Context, &KaxTagTargetType::ClassInfos); +const EbmlSemanticContext KaxTagTrackUID_Context = EbmlSemanticContext(0, NULL, &KaxTagTargets_Context, *GetKaxGlobal_Context, &KaxTagTrackUID::ClassInfos); +const EbmlSemanticContext KaxTagEditionUID_Context = EbmlSemanticContext(0, NULL, &KaxTagTargets_Context, *GetKaxGlobal_Context, &KaxTagEditionUID::ClassInfos); +const EbmlSemanticContext KaxTagChapterUID_Context = EbmlSemanticContext(0, NULL, &KaxTagTargets_Context, *GetKaxGlobal_Context, &KaxTagChapterUID::ClassInfos); +const EbmlSemanticContext KaxTagAttachmentUID_Context = EbmlSemanticContext(0, NULL, &KaxTagTargets_Context, *GetKaxGlobal_Context, &KaxTagAttachmentUID::ClassInfos); +const EbmlSemanticContext KaxTagArchivalLocation_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagArchivalLocation::ClassInfos); +const EbmlSemanticContext KaxTagFile_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagFile::ClassInfos); +const EbmlSemanticContext KaxTagKeywords_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagKeywords::ClassInfos); +const EbmlSemanticContext KaxTagMood_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagMood::ClassInfos); +const EbmlSemanticContext KaxTagRecordLocation_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagRecordLocation::ClassInfos); +const EbmlSemanticContext KaxTagSource_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagSource::ClassInfos); +const EbmlSemanticContext KaxTagSourceForm_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagSourceForm::ClassInfos); +const EbmlSemanticContext KaxTagProduct_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagProduct::ClassInfos); +const EbmlSemanticContext KaxTagOriginalMediaType_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagOriginalMediaType::ClassInfos); +const EbmlSemanticContext KaxTagPlayCounter_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagPlayCounter::ClassInfos); +const EbmlSemanticContext KaxTagPopularimeter_Context = EbmlSemanticContext(0, NULL, &KaxTagGeneral_Context, *GetKaxGlobal_Context, &KaxTagPopularimeter::ClassInfos); +const EbmlSemanticContext KaxTagAudioGenre_Context = EbmlSemanticContext(0, NULL, &KaxTagGenres_Context, *GetKaxGlobal_Context, &KaxTagAudioGenre::ClassInfos); +const EbmlSemanticContext KaxTagVideoGenre_Context = EbmlSemanticContext(0, NULL, &KaxTagGenres_Context, *GetKaxGlobal_Context, &KaxTagVideoGenre::ClassInfos); +const EbmlSemanticContext KaxTagSubGenre_Context = EbmlSemanticContext(0, NULL, &KaxTagGenres_Context, *GetKaxGlobal_Context, &KaxTagSubGenre::ClassInfos); +const EbmlSemanticContext KaxTagAudioEncryption_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagAudioEncryption::ClassInfos); +const EbmlSemanticContext KaxTagAudioGain_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagAudioGain::ClassInfos); +const EbmlSemanticContext KaxTagAudioPeak_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagAudioPeak::ClassInfos); +const EbmlSemanticContext KaxTagBPM_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagBPM::ClassInfos); +const EbmlSemanticContext KaxTagDiscTrack_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagDiscTrack::ClassInfos); +const EbmlSemanticContext KaxTagSetPart_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagSetPart::ClassInfos); +const EbmlSemanticContext KaxTagEqualisation_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagEqualisation::ClassInfos); +const EbmlSemanticContext KaxTagInitialKey_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagInitialKey::ClassInfos); +const EbmlSemanticContext KaxTagOfficialAudioFileURL_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagOfficialAudioFileURL::ClassInfos); +const EbmlSemanticContext KaxTagOfficialAudioSourceURL_Context = EbmlSemanticContext(0, NULL, &KaxTagAudioSpecific_Context, *GetKaxGlobal_Context, &KaxTagOfficialAudioSourceURL::ClassInfos); +const EbmlSemanticContext KaxTagCaptureDPI_Context = EbmlSemanticContext(0, NULL, &KaxTagImageSpecific_Context, *GetKaxGlobal_Context, &KaxTagCaptureDPI::ClassInfos); +const EbmlSemanticContext KaxTagCaptureLightness_Context = EbmlSemanticContext(0, NULL, &KaxTagImageSpecific_Context, *GetKaxGlobal_Context, &KaxTagCaptureLightness::ClassInfos); +const EbmlSemanticContext KaxTagCapturePaletteSetting_Context = EbmlSemanticContext(0, NULL, &KaxTagImageSpecific_Context, *GetKaxGlobal_Context, &KaxTagCapturePaletteSetting::ClassInfos); +const EbmlSemanticContext KaxTagCaptureSharpness_Context = EbmlSemanticContext(0, NULL, &KaxTagImageSpecific_Context, *GetKaxGlobal_Context, &KaxTagCaptureSharpness::ClassInfos); +const EbmlSemanticContext KaxTagCropped_Context = EbmlSemanticContext(0, NULL, &KaxTagImageSpecific_Context, *GetKaxGlobal_Context, &KaxTagCropped::ClassInfos); +const EbmlSemanticContext KaxTagOriginalDimensions_Context = EbmlSemanticContext(0, NULL, &KaxTagImageSpecific_Context, *GetKaxGlobal_Context, &KaxTagOriginalDimensions::ClassInfos); + +const EbmlSemanticContext KaxTagSimple_Context = EbmlSemanticContext(countof(KaxTagSimple_ContextList), KaxTagSimple_ContextList, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagSimple::ClassInfos); +const EbmlSemanticContext KaxTagName_Context = EbmlSemanticContext(0, NULL, &KaxTagSimple_Context, *GetKaxGlobal_Context, &KaxTagName::ClassInfos); +const EbmlSemanticContext KaxTagLangue_Context = EbmlSemanticContext(0, NULL, &KaxTagSimple_Context, *GetKaxGlobal_Context, &KaxTagLangue::ClassInfos); +const EbmlSemanticContext KaxTagDefault_Context = EbmlSemanticContext(0, NULL, &KaxTagSimple_Context, *GetKaxGlobal_Context, &KaxTagDefault::ClassInfos); +const EbmlSemanticContext KaxTagString_Context = EbmlSemanticContext(0, NULL, &KaxTagSimple_Context, *GetKaxGlobal_Context, &KaxTagString::ClassInfos); +const EbmlSemanticContext KaxTagBinary_Context = EbmlSemanticContext(0, NULL, &KaxTagSimple_Context, *GetKaxGlobal_Context, &KaxTagBinary::ClassInfos); + +EbmlId KaxTag_TheId (0x7373, 2); +EbmlId KaxTagTargets_TheId (0x63C0, 2); +EbmlId KaxTagGeneral_TheId (0x67C9, 2); +EbmlId KaxTagGenres_TheId (0x6583, 2); +EbmlId KaxTagAudioSpecific_TheId (0x41C5, 2); +EbmlId KaxTagImageSpecific_TheId (0x4990, 2); +EbmlId KaxTagBibliography_TheId (0x4488, 2); +EbmlId KaxTagEncoder_TheId (0x4431, 2); +EbmlId KaxTagEncodeSettings_TheId (0x6526, 2); +EbmlId KaxTagLanguage_TheId (0x22B59F, 3); +EbmlId KaxTagLength_TheId (0x5243, 2); +EbmlId KaxTagPlaylistDelay_TheId (0x72CC, 2); +EbmlId KaxTagRating_TheId (0x52BC, 2); +EbmlId KaxTagSubject_TheId (0x49C1, 2); +EbmlId KaxTagUnsynchronisedText_TheId (0x874B, 2); +EbmlId KaxTagUserDefinedURL_TheId (0x434A, 2); +EbmlId KaxTagTargetTypeValue_TheId (0x68CA, 2); +EbmlId KaxTagTargetType_TheId (0x63CA, 2); +EbmlId KaxTagTrackUID_TheId (0x63C5, 2); +EbmlId KaxTagEditionUID_TheId (0x63C9, 2); +EbmlId KaxTagChapterUID_TheId (0x63C4, 2); +EbmlId KaxTagAttachmentUID_TheId (0x63C6, 2); +EbmlId KaxTagAudioGenre_TheId (0x65C2, 2); +EbmlId KaxTagVideoGenre_TheId (0x65A1, 2); +EbmlId KaxTagSubGenre_TheId (0x65AC, 2); +EbmlId KaxTagAudioEncryption_TheId (0x41B4, 2); +EbmlId KaxTagAudioGain_TheId (0x4199, 2); +EbmlId KaxTagAudioPeak_TheId (0x4189, 2); +EbmlId KaxTagBPM_TheId (0x41A1, 2); +EbmlId KaxTagDiscTrack_TheId (0x41B6, 2); +EbmlId KaxTagSetPart_TheId (0x416E, 2); +EbmlId KaxTagEqualisation_TheId (0x41B1, 2); +EbmlId KaxTagInitialKey_TheId (0x413A, 2); +EbmlId KaxTagOfficialAudioFileURL_TheId (0x4133, 2); +EbmlId KaxTagOfficialAudioSourceURL_TheId(0x413E, 2); +EbmlId KaxTagArchivalLocation_TheId (0x45A4, 2); +EbmlId KaxTagFile_TheId (0x454E, 2); +EbmlId KaxTagKeywords_TheId (0x458C, 2); +EbmlId KaxTagMood_TheId (0x45AE, 2); +EbmlId KaxTagRecordLocation_TheId (0x457E, 2); +EbmlId KaxTagSource_TheId (0x458A, 2); +EbmlId KaxTagSourceForm_TheId (0x45B5, 2); +EbmlId KaxTagProduct_TheId (0x45E3, 2); +EbmlId KaxTagOriginalMediaType_TheId (0x45A7, 2); +EbmlId KaxTagPlayCounter_TheId (0x4566, 2); +EbmlId KaxTagPopularimeter_TheId (0x4532, 2); +EbmlId KaxTagCaptureDPI_TheId (0x49C7, 2); +EbmlId KaxTagCaptureLightness_TheId (0x49E1, 2); +EbmlId KaxTagCapturePaletteSetting_TheId (0x4934, 2); +EbmlId KaxTagCaptureSharpness_TheId (0x4922, 2); +EbmlId KaxTagCropped_TheId (0x4987, 2); +EbmlId KaxTagOriginalDimensions_TheId (0x4933, 2); + +EbmlId KaxTagSimple_TheId (0x67C8, 2); +EbmlId KaxTagName_TheId (0x45A3, 2); +EbmlId KaxTagLangue_TheId (0x447A, 2); +EbmlId KaxTagDefault_TheId (0x44B4, 2); +EbmlId KaxTagString_TheId (0x4487, 2); +EbmlId KaxTagBinary_TheId (0x4485, 2); + +const EbmlCallbacks KaxTag::ClassInfos(KaxTag::Create, KaxTag_TheId, "Tag", KaxTag_Context); +const EbmlCallbacks KaxTagTargets::ClassInfos(KaxTagTargets::Create, KaxTagTargets_TheId, "TagTargets", KaxTagTargets_Context); +const EbmlCallbacks KaxTagGeneral::ClassInfos(KaxTagGeneral::Create, KaxTagGeneral_TheId, "TagGeneral", KaxTagGeneral_Context); +const EbmlCallbacks KaxTagGenres::ClassInfos(KaxTagGenres::Create, KaxTagGenres_TheId, "TagGenres", KaxTagGenres_Context); +const EbmlCallbacks KaxTagAudioSpecific::ClassInfos(KaxTagAudioSpecific::Create, KaxTagAudioSpecific_TheId, "TagAudioSpecific", KaxTagAudioSpecific_Context); +const EbmlCallbacks KaxTagImageSpecific::ClassInfos(KaxTagImageSpecific::Create, KaxTagImageSpecific_TheId, "TagImageSpecific", KaxTagImageSpecific_Context); +const EbmlCallbacks KaxTagBibliography::ClassInfos(KaxTagBibliography::Create, KaxTagBibliography_TheId, "Bibliography", KaxTagBibliography_Context); +const EbmlCallbacks KaxTagCaptureDPI::ClassInfos(KaxTagCaptureDPI::Create, KaxTagCaptureDPI_TheId, "CaptureDPI", KaxTagCaptureDPI_Context); +const EbmlCallbacks KaxTagCaptureLightness::ClassInfos(KaxTagCaptureLightness::Create, KaxTagCaptureLightness_TheId, "CaptureLightness", KaxTagCaptureLightness_Context); +const EbmlCallbacks KaxTagCapturePaletteSetting::ClassInfos(KaxTagCapturePaletteSetting::Create, KaxTagCapturePaletteSetting_TheId, "CapturePaletteSetting", KaxTagCapturePaletteSetting_Context); +const EbmlCallbacks KaxTagCaptureSharpness::ClassInfos(KaxTagCaptureSharpness::Create, KaxTagCaptureSharpness_TheId, "CaptureSharpness", KaxTagCaptureSharpness_Context); +const EbmlCallbacks KaxTagCropped::ClassInfos(KaxTagCropped::Create, KaxTagCropped_TheId, "Cropped", KaxTagCropped_Context); +const EbmlCallbacks KaxTagEncoder::ClassInfos(KaxTagEncoder::Create, KaxTagEncoder_TheId, "Encoder", KaxTagEncoder_Context); +const EbmlCallbacks KaxTagEncodeSettings::ClassInfos(KaxTagEncodeSettings::Create, KaxTagEncodeSettings_TheId, "EncodeSettings", KaxTagEncodeSettings_Context); +const EbmlCallbacks KaxTagLanguage::ClassInfos(KaxTagLanguage::Create, KaxTagLanguage_TheId, "Language", KaxTagLanguage_Context); +const EbmlCallbacks KaxTagLength::ClassInfos(KaxTagLength::Create, KaxTagLength_TheId, "Length", KaxTagLength_Context); +const EbmlCallbacks KaxTagOriginalDimensions::ClassInfos(KaxTagOriginalDimensions::Create, KaxTagOriginalDimensions_TheId, "OriginalDimensions", KaxTagOriginalDimensions_Context); +const EbmlCallbacks KaxTagPlaylistDelay::ClassInfos(KaxTagPlaylistDelay::Create, KaxTagPlaylistDelay_TheId, "PlaylistDelay", KaxTagPlaylistDelay_Context); +const EbmlCallbacks KaxTagRating::ClassInfos(KaxTagRating::Create, KaxTagRating_TheId, "Rating", KaxTagRating_Context); +const EbmlCallbacks KaxTagSubject::ClassInfos(KaxTagSubject::Create, KaxTagSubject_TheId, "Subject", KaxTagSubject_Context); +const EbmlCallbacks KaxTagUnsynchronisedText::ClassInfos(KaxTagUnsynchronisedText::Create, KaxTagUnsynchronisedText_TheId, "UnsynchronisedText", KaxTagUnsynchronisedText_Context); +const EbmlCallbacks KaxTagUserDefinedURL::ClassInfos(KaxTagUserDefinedURL::Create, KaxTagUserDefinedURL_TheId, "UserDefinedURL", KaxTagUserDefinedURL_Context); +const EbmlCallbacks KaxTagTargetTypeValue::ClassInfos(KaxTagTargetTypeValue::Create, KaxTagTargetTypeValue_TheId, "TagTargetTypeValue", KaxTagTargetTypeValue_Context); +const EbmlCallbacks KaxTagTargetType::ClassInfos(KaxTagTargetType::Create, KaxTagTargetType_TheId, "TagTargetType", KaxTagTargetType_Context); +const EbmlCallbacks KaxTagTrackUID::ClassInfos(KaxTagTrackUID::Create, KaxTagTrackUID_TheId, "TagTrackUID", KaxTagTrackUID_Context); +const EbmlCallbacks KaxTagEditionUID::ClassInfos(KaxTagEditionUID::Create, KaxTagEditionUID_TheId, "TagEditionUID", KaxTagEditionUID_Context); +const EbmlCallbacks KaxTagChapterUID::ClassInfos(KaxTagChapterUID::Create, KaxTagChapterUID_TheId, "TagChapterUID", KaxTagChapterUID_Context); +const EbmlCallbacks KaxTagAttachmentUID::ClassInfos(KaxTagAttachmentUID::Create, KaxTagAttachmentUID_TheId, "TagAttachmentUID", KaxTagAttachmentUID_Context); +const EbmlCallbacks KaxTagAudioGenre::ClassInfos(KaxTagAudioGenre::Create, KaxTagAudioGenre_TheId, "AudioGenre", KaxTagAudioGenre_Context); +const EbmlCallbacks KaxTagVideoGenre::ClassInfos(KaxTagVideoGenre::Create, KaxTagVideoGenre_TheId, "VideoGenre", KaxTagVideoGenre_Context); +const EbmlCallbacks KaxTagSubGenre::ClassInfos(KaxTagSubGenre::Create, KaxTagSubGenre_TheId, "SubGenre", KaxTagSubGenre_Context); +const EbmlCallbacks KaxTagAudioEncryption::ClassInfos(KaxTagAudioEncryption::Create, KaxTagAudioEncryption_TheId, "AudioEncryption", KaxTagAudioEncryption_Context); +const EbmlCallbacks KaxTagAudioGain::ClassInfos(KaxTagAudioGain::Create, KaxTagAudioGain_TheId, "AudioGain", KaxTagAudioGain_Context); +const EbmlCallbacks KaxTagAudioPeak::ClassInfos(KaxTagAudioPeak::Create, KaxTagAudioPeak_TheId, "AudioPeak", KaxTagAudioPeak_Context); +const EbmlCallbacks KaxTagBPM::ClassInfos(KaxTagBPM::Create, KaxTagBPM_TheId, "BPM", KaxTagBPM_Context); +const EbmlCallbacks KaxTagDiscTrack::ClassInfos(KaxTagDiscTrack::Create, KaxTagDiscTrack_TheId, "DiscTrack", KaxTagDiscTrack_Context); +const EbmlCallbacks KaxTagSetPart::ClassInfos(KaxTagSetPart::Create, KaxTagSetPart_TheId, "SetPart", KaxTagSetPart_Context); +const EbmlCallbacks KaxTagEqualisation::ClassInfos(KaxTagEqualisation::Create, KaxTagEqualisation_TheId, "Equalisation", KaxTagEqualisation_Context); +const EbmlCallbacks KaxTagInitialKey::ClassInfos(KaxTagInitialKey::Create, KaxTagInitialKey_TheId, "InitialKey", KaxTagInitialKey_Context); +const EbmlCallbacks KaxTagOfficialAudioFileURL::ClassInfos(KaxTagOfficialAudioFileURL::Create, KaxTagOfficialAudioFileURL_TheId, "OfficialAudioFileURL", KaxTagOfficialAudioFileURL_Context); +const EbmlCallbacks KaxTagOfficialAudioSourceURL::ClassInfos(KaxTagOfficialAudioSourceURL::Create, KaxTagOfficialAudioSourceURL_TheId, "AudioSourceURL", KaxTagOfficialAudioSourceURL_Context); +const EbmlCallbacks KaxTagArchivalLocation::ClassInfos(KaxTagArchivalLocation::Create, KaxTagArchivalLocation_TheId, "ArchivalLocation", KaxTagArchivalLocation_Context); +const EbmlCallbacks KaxTagFile::ClassInfos(KaxTagFile::Create, KaxTagFile_TheId, "File", KaxTagFile_Context); +const EbmlCallbacks KaxTagKeywords::ClassInfos(KaxTagKeywords::Create, KaxTagKeywords_TheId, "Keywords", KaxTagKeywords_Context); +const EbmlCallbacks KaxTagMood::ClassInfos(KaxTagMood::Create, KaxTagMood_TheId, "Mood", KaxTagMood_Context); +const EbmlCallbacks KaxTagRecordLocation::ClassInfos(KaxTagRecordLocation::Create, KaxTagRecordLocation_TheId, "RecordLocation", KaxTagRecordLocation_Context); +const EbmlCallbacks KaxTagSource::ClassInfos(KaxTagSource::Create, KaxTagSource_TheId, "Source", KaxTagSource_Context); +const EbmlCallbacks KaxTagSourceForm::ClassInfos(KaxTagSourceForm::Create, KaxTagSourceForm_TheId, "SourceForm", KaxTagSourceForm_Context); +const EbmlCallbacks KaxTagProduct::ClassInfos(KaxTagProduct::Create, KaxTagProduct_TheId, "Product", KaxTagProduct_Context); +const EbmlCallbacks KaxTagOriginalMediaType::ClassInfos(KaxTagOriginalMediaType::Create, KaxTagOriginalMediaType_TheId, "OriginalMediaType", KaxTagOriginalMediaType_Context); +const EbmlCallbacks KaxTagPlayCounter::ClassInfos(KaxTagPlayCounter::Create, KaxTagPlayCounter_TheId, "PlayCounter", KaxTagPlayCounter_Context); +const EbmlCallbacks KaxTagPopularimeter::ClassInfos(KaxTagPopularimeter::Create, KaxTagPopularimeter_TheId, "Popularimeter", KaxTagPopularimeter_Context); + +const EbmlCallbacks KaxTagSimple::ClassInfos(KaxTagSimple::Create, KaxTagSimple_TheId, "TagSimple", KaxTagSimple_Context); +const EbmlCallbacks KaxTagName::ClassInfos(KaxTagName::Create, KaxTagName_TheId, "TagName", KaxTagName_Context); +const EbmlCallbacks KaxTagLangue::ClassInfos(KaxTagLangue::Create, KaxTagLangue_TheId, "TagLanguage", KaxTagLangue_Context); +const EbmlCallbacks KaxTagDefault::ClassInfos(KaxTagDefault::Create, KaxTagDefault_TheId, "TagDefault", KaxTagDefault_Context); +const EbmlCallbacks KaxTagString::ClassInfos(KaxTagString::Create, KaxTagString_TheId, "TagString", KaxTagString_Context); +const EbmlCallbacks KaxTagBinary::ClassInfos(KaxTagBinary::Create, KaxTagBinary_TheId, "TagBinary", KaxTagBinary_Context); + +KaxTag::KaxTag() + :EbmlMaster(KaxTag_Context) +{} + +KaxTagTargets::KaxTagTargets() + :EbmlMaster(KaxTagTargets_Context) +{} + +KaxTagGeneral::KaxTagGeneral() + :EbmlMaster(KaxTagGeneral_Context) +{} + +KaxTagGenres::KaxTagGenres() + :EbmlMaster(KaxTagGenres_Context) +{} + +KaxTagAudioSpecific::KaxTagAudioSpecific() + :EbmlMaster(KaxTagAudioSpecific_Context) +{} + +KaxTagImageSpecific::KaxTagImageSpecific() + :EbmlMaster(KaxTagImageSpecific_Context) +{} + +KaxTagSimple::KaxTagSimple() + :EbmlMaster(KaxTagSimple_Context) +{} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxTagMulti.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxTagMulti.cpp new file mode 100644 index 0000000000..42e16183ec --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxTagMulti.cpp @@ -0,0 +1,404 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxTagMulti.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Jory Stone + \author Steve Lhomme +*/ +#include "matroska/KaxTagMulti.h" +#include "matroska/KaxContexts.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +EbmlSemantic KaxTagMultiGlobal_ContextList[1] = +{ + EbmlSemantic(false, false, KaxTagMultiComment::ClassInfos), +}; + +EbmlSemantic KaxTagMultiComment_ContextList[3] = +{ + EbmlSemantic(false, true, KaxTagMultiCommentName::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiCommentComments::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiCommentLanguage::ClassInfos), +}; + +EbmlSemantic KaxTagMultiCommercial_ContextList[1] = +{ + EbmlSemantic(true, false, KaxTagCommercial::ClassInfos), +}; + +EbmlSemantic KaxTagCommercial_ContextList[5] = +{ + EbmlSemantic(true, true, KaxTagMultiCommercialType::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiCommercialAddress::ClassInfos), + EbmlSemantic(false, false, KaxTagMultiCommercialURL::ClassInfos), + EbmlSemantic(false, false, KaxTagMultiCommercialEmail::ClassInfos), + EbmlSemantic(false, false, KaxTagMultiPrice::ClassInfos), +}; + +EbmlSemantic KaxTagMultiPrice_ContextList[3] = +{ + EbmlSemantic(false, true, KaxTagMultiPriceCurrency::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiPriceAmount::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiPricePriceDate::ClassInfos), +}; + +EbmlSemantic KaxTagMultiDate_ContextList[1] = +{ + EbmlSemantic(true, false, KaxTagDate::ClassInfos), +}; + +EbmlSemantic KaxTagDate_ContextList[3] = +{ + EbmlSemantic(true, true, KaxTagMultiDateType::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiDateDateBegin::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiDateDateEnd::ClassInfos), +}; + +EbmlSemantic KaxTagMultiEntity_ContextList[1] = +{ + EbmlSemantic(true, false, KaxTagEntity::ClassInfos), +}; + +EbmlSemantic KaxTagEntity_ContextList[5] = +{ + EbmlSemantic(true, true, KaxTagMultiEntityType::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiEntityName::ClassInfos), + EbmlSemantic(false, false, KaxTagMultiEntityURL::ClassInfos), + EbmlSemantic(false, false, KaxTagMultiEntityEmail::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiEntityAddress::ClassInfos), +}; + +EbmlSemantic KaxTagMultiIdentifier_ContextList[1] = +{ + EbmlSemantic(true, false, KaxTagIdentifier::ClassInfos), +}; + +EbmlSemantic KaxTagIdentifier_ContextList[3] = +{ + EbmlSemantic(true, true, KaxTagMultiIdentifierType::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiIdentifierBinary::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiIdentifierString::ClassInfos), +}; + +EbmlSemantic KaxTagMultiLegal_ContextList[1] = +{ + EbmlSemantic(true, false, KaxTagLegal::ClassInfos), +}; + +EbmlSemantic KaxTagLegal_ContextList[4] = +{ + EbmlSemantic(true, true, KaxTagMultiLegalType::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiLegalContent::ClassInfos), + EbmlSemantic(false, false, KaxTagMultiLegalURL::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiLegalAddress::ClassInfos), +}; + +EbmlSemantic KaxTagMultiTitle_ContextList[1] = +{ + EbmlSemantic(true, false, KaxTagTitle::ClassInfos), +}; + +EbmlSemantic KaxTagTitle_ContextList[8] = +{ + EbmlSemantic(true, true, KaxTagMultiTitleType::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiTitleName::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiTitleSubTitle::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiTitleEdition::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiTitleAddress::ClassInfos), + EbmlSemantic(false, false, KaxTagMultiTitleURL::ClassInfos), + EbmlSemantic(false, false, KaxTagMultiTitleEmail::ClassInfos), + EbmlSemantic(false, true, KaxTagMultiTitleLanguage::ClassInfos), +}; + +EbmlSemantic KaxTagMultiAttachment_ContextList[1] = +{ + EbmlSemantic(true, false, KaxTagAttachment::ClassInfos), +}; + +EbmlSemantic KaxTagAttachment_ContextList[1] = +{ + EbmlSemantic(false, true, KaxTagAttachmentID::ClassInfos), +}; + +const EbmlSemanticContext KaxTagMultiGlobal_Context = EbmlSemanticContext(countof(KaxTagMultiGlobal_ContextList), KaxTagMultiGlobal_ContextList, NULL, *GetKaxGlobal_Context, NULL); + +const EbmlSemanticContext KaxTagMultiComment_Context = EbmlSemanticContext(countof(KaxTagMultiComment_ContextList), KaxTagMultiComment_ContextList, &KaxTag_Context, *GetKaxGlobal_Context, &KaxTagMultiComment::ClassInfos); +const EbmlSemanticContext KaxTagMultiCommentName_Context = EbmlSemanticContext(0, NULL, &KaxTagMultiComment_Context, *GetKaxGlobal_Context, &KaxTagMultiCommentName::ClassInfos); +const EbmlSemanticContext KaxTagMultiCommentComments_Context = EbmlSemanticContext(0, NULL, &KaxTagMultiComment_Context, *GetKaxGlobal_Context, &KaxTagMultiCommentComments::ClassInfos); +const EbmlSemanticContext KaxTagMultiCommentLanguage_Context = EbmlSemanticContext(0, NULL, &KaxTagMultiComment_Context, *GetKaxGlobal_Context, &KaxTagMultiCommentLanguage::ClassInfos); + +const EbmlSemanticContext KaxTagMultiCommercial_Context = EbmlSemanticContext(countof(KaxTagMultiCommercial_ContextList), KaxTagMultiCommercial_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiCommercial::ClassInfos); +const EbmlSemanticContext KaxTagCommercial_Context = EbmlSemanticContext(countof(KaxTagCommercial_ContextList), KaxTagCommercial_ContextList, &KaxTagMultiCommercial_Context, *GetKaxTagsGlobal_Context, &KaxTagCommercial::ClassInfos); +const EbmlSemanticContext KaxTagMultiCommercialType_Context = EbmlSemanticContext(0, NULL, &KaxTagCommercial_Context, *GetKaxGlobal_Context, &KaxTagMultiCommercialType::ClassInfos); +const EbmlSemanticContext KaxTagMultiCommercialAddress_Context = EbmlSemanticContext(0, NULL, &KaxTagCommercial_Context, *GetKaxGlobal_Context, &KaxTagMultiCommercialAddress::ClassInfos); +const EbmlSemanticContext KaxTagMultiCommercialURL_Context = EbmlSemanticContext(0, NULL, &KaxTagCommercial_Context, *GetKaxGlobal_Context, &KaxTagMultiCommercialURL::ClassInfos); +const EbmlSemanticContext KaxTagMultiCommercialEmail_Context = EbmlSemanticContext(0, NULL, &KaxTagCommercial_Context, *GetKaxGlobal_Context, &KaxTagMultiCommercialEmail::ClassInfos); + +const EbmlSemanticContext KaxTagMultiPrice_Context = EbmlSemanticContext(countof(KaxTagMultiPrice_ContextList), KaxTagMultiPrice_ContextList, &KaxTagCommercial_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiPrice::ClassInfos); +const EbmlSemanticContext KaxTagMultiPriceCurrency_Context = EbmlSemanticContext(0, NULL, &KaxTagMultiPrice_Context, *GetKaxGlobal_Context, &KaxTagMultiPriceCurrency::ClassInfos); +const EbmlSemanticContext KaxTagMultiPriceAmount_Context = EbmlSemanticContext(0, NULL, &KaxTagMultiPrice_Context, *GetKaxGlobal_Context, &KaxTagMultiPriceAmount::ClassInfos); +const EbmlSemanticContext KaxTagMultiPricePriceDate_Context = EbmlSemanticContext(0, NULL, &KaxTagMultiPrice_Context, *GetKaxGlobal_Context, &KaxTagMultiPricePriceDate::ClassInfos); + +const EbmlSemanticContext KaxTagMultiDate_Context = EbmlSemanticContext(countof(KaxTagMultiDate_ContextList), KaxTagMultiDate_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiDate::ClassInfos); +const EbmlSemanticContext KaxTagDate_Context = EbmlSemanticContext(countof(KaxTagDate_ContextList), KaxTagDate_ContextList, &KaxTagMultiDate_Context, *GetKaxTagsGlobal_Context, &KaxTagDate::ClassInfos); +const EbmlSemanticContext KaxTagMultiDateType_Context = EbmlSemanticContext(0, NULL, &KaxTagDate_Context, *GetKaxGlobal_Context, &KaxTagMultiDateType::ClassInfos); +const EbmlSemanticContext KaxTagMultiDateDateBegin_Context = EbmlSemanticContext(0, NULL, &KaxTagDate_Context, *GetKaxGlobal_Context, &KaxTagMultiDateDateBegin::ClassInfos); +const EbmlSemanticContext KaxTagMultiDateDateEnd_Context = EbmlSemanticContext(0, NULL, &KaxTagDate_Context, *GetKaxGlobal_Context, &KaxTagMultiDateDateEnd::ClassInfos); + +const EbmlSemanticContext KaxTagMultiEntity_Context = EbmlSemanticContext(countof(KaxTagMultiEntity_ContextList), KaxTagMultiEntity_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiEntity::ClassInfos); +const EbmlSemanticContext KaxTagEntity_Context = EbmlSemanticContext(countof(KaxTagEntity_ContextList), KaxTagEntity_ContextList, &KaxTagMultiEntity_Context, *GetKaxTagsGlobal_Context, &KaxTagEntity::ClassInfos); +const EbmlSemanticContext KaxTagMultiEntityType_Context = EbmlSemanticContext(0, NULL, &KaxTagEntity_Context, *GetKaxGlobal_Context, &KaxTagMultiEntityType::ClassInfos); +const EbmlSemanticContext KaxTagMultiEntityName_Context = EbmlSemanticContext(0, NULL, &KaxTagEntity_Context, *GetKaxGlobal_Context, &KaxTagMultiEntityName::ClassInfos); +const EbmlSemanticContext KaxTagMultiEntityURL_Context = EbmlSemanticContext(0, NULL, &KaxTagEntity_Context, *GetKaxGlobal_Context, &KaxTagMultiEntityURL::ClassInfos); +const EbmlSemanticContext KaxTagMultiEntityEmail_Context = EbmlSemanticContext(0, NULL, &KaxTagEntity_Context, *GetKaxGlobal_Context, &KaxTagMultiEntityEmail::ClassInfos); +const EbmlSemanticContext KaxTagMultiEntityAddress_Context = EbmlSemanticContext(0, NULL, &KaxTagEntity_Context, *GetKaxGlobal_Context, &KaxTagMultiEntityAddress::ClassInfos); + +const EbmlSemanticContext KaxTagMultiIdentifier_Context = EbmlSemanticContext(countof(KaxTagMultiIdentifier_ContextList), KaxTagMultiIdentifier_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiIdentifier::ClassInfos); +const EbmlSemanticContext KaxTagIdentifier_Context = EbmlSemanticContext(countof(KaxTagIdentifier_ContextList), KaxTagIdentifier_ContextList, &KaxTagMultiIdentifier_Context, *GetKaxTagsGlobal_Context, &KaxTagIdentifier::ClassInfos); +const EbmlSemanticContext KaxTagMultiIdentifierType_Context = EbmlSemanticContext(0, NULL, &KaxTagIdentifier_Context, *GetKaxGlobal_Context, &KaxTagMultiIdentifierType::ClassInfos); +const EbmlSemanticContext KaxTagMultiIdentifierBinary_Context = EbmlSemanticContext(0, NULL, &KaxTagIdentifier_Context, *GetKaxGlobal_Context, &KaxTagMultiIdentifierBinary::ClassInfos); +const EbmlSemanticContext KaxTagMultiIdentifierString_Context = EbmlSemanticContext(0, NULL, &KaxTagIdentifier_Context, *GetKaxGlobal_Context, &KaxTagMultiIdentifierString::ClassInfos); + +const EbmlSemanticContext KaxTagMultiLegal_Context = EbmlSemanticContext(countof(KaxTagMultiLegal_ContextList), KaxTagMultiLegal_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiLegal::ClassInfos); +const EbmlSemanticContext KaxTagLegal_Context = EbmlSemanticContext(countof(KaxTagLegal_ContextList), KaxTagLegal_ContextList, &KaxTagMultiLegal_Context, *GetKaxTagsGlobal_Context, &KaxTagLegal::ClassInfos); +const EbmlSemanticContext KaxTagMultiLegalType_Context = EbmlSemanticContext(0, NULL, &KaxTagLegal_Context, *GetKaxGlobal_Context, &KaxTagMultiLegalType::ClassInfos); +const EbmlSemanticContext KaxTagMultiLegalContent_Context = EbmlSemanticContext(0, NULL, &KaxTagLegal_Context, *GetKaxGlobal_Context, &KaxTagMultiLegalContent::ClassInfos); +const EbmlSemanticContext KaxTagMultiLegalURL_Context = EbmlSemanticContext(0, NULL, &KaxTagLegal_Context, *GetKaxGlobal_Context, &KaxTagMultiLegalURL::ClassInfos); +const EbmlSemanticContext KaxTagMultiLegalAddress_Context = EbmlSemanticContext(0, NULL, &KaxTagLegal_Context, *GetKaxGlobal_Context, &KaxTagMultiLegalAddress::ClassInfos); + +const EbmlSemanticContext KaxTagMultiTitle_Context = EbmlSemanticContext(countof(KaxTagMultiTitle_ContextList), KaxTagMultiTitle_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiTitle::ClassInfos); +const EbmlSemanticContext KaxTagTitle_Context = EbmlSemanticContext(countof(KaxTagTitle_ContextList), KaxTagTitle_ContextList, &KaxTagMultiTitle_Context, *GetKaxTagsGlobal_Context, &KaxTagTitle::ClassInfos); +const EbmlSemanticContext KaxTagMultiTitleType_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleType::ClassInfos); +const EbmlSemanticContext KaxTagMultiTitleName_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleName::ClassInfos); +const EbmlSemanticContext KaxTagMultiTitleSubTitle_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleSubTitle::ClassInfos); +const EbmlSemanticContext KaxTagMultiTitleEdition_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleEdition::ClassInfos); +const EbmlSemanticContext KaxTagMultiTitleAddress_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleAddress::ClassInfos); +const EbmlSemanticContext KaxTagMultiTitleURL_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleURL::ClassInfos); +const EbmlSemanticContext KaxTagMultiTitleEmail_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleEmail::ClassInfos); +const EbmlSemanticContext KaxTagMultiTitleLanguage_Context = EbmlSemanticContext(0, NULL, &KaxTagTitle_Context, *GetKaxGlobal_Context, &KaxTagMultiTitleLanguage::ClassInfos); + +const EbmlSemanticContext KaxTagMultiAttachment_Context = EbmlSemanticContext(countof(KaxTagMultiAttachment_ContextList), KaxTagMultiAttachment_ContextList, &KaxTag_Context, *GetKaxTagsGlobal_Context, &KaxTagMultiAttachment::ClassInfos); +const EbmlSemanticContext KaxTagAttachment_Context = EbmlSemanticContext(countof(KaxTagAttachment_ContextList), KaxTagAttachment_ContextList, &KaxTagMultiAttachment_Context, *GetKaxTagsGlobal_Context, &KaxTagAttachment::ClassInfos); +const EbmlSemanticContext KaxTagAttachmentID_Context = EbmlSemanticContext(0, NULL, &KaxTagAttachment_Context, *GetKaxGlobal_Context, &KaxTagAttachmentID::ClassInfos); + +//The Muti Elements +EbmlId KaxTagMultiComment_TheId (0x5B7B, 2); +EbmlId KaxTagMultiCommentName_TheId (0x5F7D, 2); +EbmlId KaxTagMultiCommentComments_TheId (0x5F7C, 2); +EbmlId KaxTagMultiCommentLanguage_TheId (0x22B59D, 3); + +EbmlId KaxTagMultiCommercial_TheId (0x4DC7, 2); +EbmlId KaxTagCommercial_TheId (0x4EC7, 2); +EbmlId KaxTagMultiCommercialType_TheId (0x5BD7, 2); +EbmlId KaxTagMultiCommercialAddress_TheId (0x5BBB, 2); +EbmlId KaxTagMultiCommercialURL_TheId (0x5BDA, 2); +EbmlId KaxTagMultiCommercialEmail_TheId (0x5BC0, 2); + +EbmlId KaxTagMultiPrice_TheId (0x5BC3, 2); +EbmlId KaxTagMultiPriceCurrency_TheId (0x5B6C, 2); +EbmlId KaxTagMultiPriceAmount_TheId (0x5B6E, 2); +EbmlId KaxTagMultiPricePriceDate_TheId (0x5B6F, 2); + +EbmlId KaxTagMultiDate_TheId (0x4DC8, 2); +EbmlId KaxTagDate_TheId (0x4EC8, 2); +EbmlId KaxTagMultiDateType_TheId (0x5BD8, 2); +EbmlId KaxTagMultiDateDateBegin_TheId (0x4460, 2); +EbmlId KaxTagMultiDateDateEnd_TheId (0x4462, 2); + +EbmlId KaxTagMultiEntity_TheId (0x4DC9, 2); +EbmlId KaxTagEntity_TheId (0x4EC9, 2); +EbmlId KaxTagMultiEntityType_TheId (0x5BD9, 2); +EbmlId KaxTagMultiEntityName_TheId (0x5BED, 2); +EbmlId KaxTagMultiEntityAddress_TheId (0x5BDC, 2); +EbmlId KaxTagMultiEntityURL_TheId (0x5BDB, 2); +EbmlId KaxTagMultiEntityEmail_TheId (0x5BC1, 2); + +EbmlId KaxTagMultiIdentifier_TheId (0x4DC6, 2); +EbmlId KaxTagIdentifier_TheId (0x4EC6, 2); +EbmlId KaxTagMultiIdentifierType_TheId (0x5BAD, 2); +EbmlId KaxTagMultiIdentifierBinary_TheId (0x6B67, 2); +EbmlId KaxTagMultiIdentifierString_TheId (0x6B68, 2); + +EbmlId KaxTagMultiLegal_TheId (0x4DC5, 2); +EbmlId KaxTagLegal_TheId (0x4EC5, 2); +EbmlId KaxTagMultiLegalType_TheId (0x5BBD, 2); +EbmlId KaxTagMultiLegalContent_TheId (0x5BB2, 2); +EbmlId KaxTagMultiLegalURL_TheId (0x5B34, 2); +EbmlId KaxTagMultiLegalAddress_TheId (0x5B9B, 2); + +EbmlId KaxTagMultiTitle_TheId (0x4DC4, 2); +EbmlId KaxTagTitle_TheId (0x4EC4, 2); +EbmlId KaxTagMultiTitleType_TheId (0x5B7D, 2); +EbmlId KaxTagMultiTitleName_TheId (0x5BB9, 2); +EbmlId KaxTagMultiTitleSubTitle_TheId (0x5B5B, 2); +EbmlId KaxTagMultiTitleEdition_TheId (0x5BAE, 2); +EbmlId KaxTagMultiTitleAddress_TheId (0x5B33, 2); +EbmlId KaxTagMultiTitleURL_TheId (0x5BA9, 2); +EbmlId KaxTagMultiTitleEmail_TheId (0x5BC9, 2); +EbmlId KaxTagMultiTitleLanguage_TheId (0x22B59E, 3); + +EbmlId KaxTagMultiAttachment_TheId (0x4DC3, 2); +EbmlId KaxTagAttachment_TheId (0x4EC3, 2); +EbmlId KaxTagAttachmentID_TheId (0x5BA0, 2); + +const EbmlCallbacks KaxTagMultiComment::ClassInfos(KaxTagMultiComment::Create, KaxTagMultiComment_TheId, "MultiComment", KaxTagMultiComment_Context); +const EbmlCallbacks KaxTagMultiCommentName::ClassInfos(KaxTagMultiCommentName::Create, KaxTagMultiCommentName_TheId, "MultiCommentName", KaxTagMultiCommentName_Context); +const EbmlCallbacks KaxTagMultiCommentComments::ClassInfos(KaxTagMultiCommentComments::Create, KaxTagMultiCommentComments_TheId, "MultiCommentComments", KaxTagMultiCommentComments_Context); +const EbmlCallbacks KaxTagMultiCommentLanguage::ClassInfos(KaxTagMultiCommentLanguage::Create, KaxTagMultiCommentLanguage_TheId, "MultiCommentLanguage", KaxTagMultiCommentLanguage_Context); + +const EbmlCallbacks KaxTagMultiCommercial::ClassInfos(KaxTagMultiCommercial::Create, KaxTagMultiCommercial_TheId, "MultiCommercial", KaxTagMultiCommercial_Context); +const EbmlCallbacks KaxTagCommercial::ClassInfos(KaxTagCommercial::Create, KaxTagCommercial_TheId, "Commercial", KaxTagCommercial_Context); +const EbmlCallbacks KaxTagMultiCommercialType::ClassInfos(KaxTagMultiCommercialType::Create, KaxTagMultiCommercialType_TheId, "MultiCommercialType", KaxTagMultiCommercialType_Context); +const EbmlCallbacks KaxTagMultiCommercialAddress::ClassInfos(KaxTagMultiCommercialAddress::Create, KaxTagMultiCommercialAddress_TheId, "MultiCommercialAddress", KaxTagMultiCommercialAddress_Context); +const EbmlCallbacks KaxTagMultiCommercialURL::ClassInfos(KaxTagMultiCommercialURL::Create, KaxTagMultiCommercialURL_TheId, "MultiCommercialURL", KaxTagMultiCommercialURL_Context); +const EbmlCallbacks KaxTagMultiCommercialEmail::ClassInfos(KaxTagMultiCommercialEmail::Create, KaxTagMultiCommercialEmail_TheId, "MultiCommercialEmail", KaxTagMultiCommercialEmail_Context); + +const EbmlCallbacks KaxTagMultiPrice::ClassInfos(KaxTagMultiPrice::Create, KaxTagMultiPrice_TheId, "MultiPrice", KaxTagMultiPrice_Context); +const EbmlCallbacks KaxTagMultiPriceCurrency::ClassInfos(KaxTagMultiPriceCurrency::Create, KaxTagMultiPriceCurrency_TheId, "MultiPriceCurrency", KaxTagMultiPriceCurrency_Context); +const EbmlCallbacks KaxTagMultiPriceAmount::ClassInfos(KaxTagMultiPriceAmount::Create, KaxTagMultiPriceAmount_TheId, "MultiPriceAmount", KaxTagMultiPriceAmount_Context); +const EbmlCallbacks KaxTagMultiPricePriceDate::ClassInfos(KaxTagMultiPricePriceDate::Create, KaxTagMultiPricePriceDate_TheId, "MultiPricePriceDate", KaxTagMultiPricePriceDate_Context); + +const EbmlCallbacks KaxTagMultiDate::ClassInfos(KaxTagMultiDate::Create, KaxTagMultiDate_TheId, "MultiDate", KaxTagMultiDate_Context); +const EbmlCallbacks KaxTagDate::ClassInfos(KaxTagDate::Create, KaxTagDate_TheId, "Date", KaxTagDate_Context); +const EbmlCallbacks KaxTagMultiDateType::ClassInfos(KaxTagMultiDateType::Create, KaxTagMultiDateType_TheId, "MultiDateType", KaxTagMultiDateType_Context); +const EbmlCallbacks KaxTagMultiDateDateBegin::ClassInfos(KaxTagMultiDateDateBegin::Create, KaxTagMultiDateDateBegin_TheId, "MultiDateDateBegin", KaxTagMultiDateDateBegin_Context); +const EbmlCallbacks KaxTagMultiDateDateEnd::ClassInfos(KaxTagMultiDateDateEnd::Create, KaxTagMultiDateDateEnd_TheId, "MultiDateDateEnd", KaxTagMultiDateDateEnd_Context); + +const EbmlCallbacks KaxTagMultiEntity::ClassInfos(KaxTagMultiEntity::Create, KaxTagMultiEntity_TheId, "MultiEntity", KaxTagMultiEntity_Context); +const EbmlCallbacks KaxTagEntity::ClassInfos(KaxTagEntity::Create, KaxTagEntity_TheId, "Entity", KaxTagEntity_Context); +const EbmlCallbacks KaxTagMultiEntityType::ClassInfos(KaxTagMultiEntityType::Create, KaxTagMultiEntityType_TheId, "MultiEntityType", KaxTagMultiEntityType_Context); +const EbmlCallbacks KaxTagMultiEntityName::ClassInfos(KaxTagMultiEntityName::Create, KaxTagMultiEntityName_TheId, "MultiEntityName", KaxTagMultiEntityName_Context); +const EbmlCallbacks KaxTagMultiEntityURL::ClassInfos(KaxTagMultiEntityURL::Create, KaxTagMultiEntityURL_TheId, "MultiEntityURL", KaxTagMultiEntityURL_Context); +const EbmlCallbacks KaxTagMultiEntityEmail::ClassInfos(KaxTagMultiEntityEmail::Create, KaxTagMultiEntityEmail_TheId, "MultiEntityEmail", KaxTagMultiEntityEmail_Context); +const EbmlCallbacks KaxTagMultiEntityAddress::ClassInfos(KaxTagMultiEntityAddress::Create, KaxTagMultiEntityAddress_TheId, "MultiEntityAddress", KaxTagMultiEntityAddress_Context); + +const EbmlCallbacks KaxTagMultiIdentifier::ClassInfos(KaxTagMultiIdentifier::Create, KaxTagMultiIdentifier_TheId, "MultiIdentifier", KaxTagMultiIdentifier_Context); +const EbmlCallbacks KaxTagIdentifier::ClassInfos(KaxTagIdentifier::Create, KaxTagIdentifier_TheId, "Identifier", KaxTagIdentifier_Context); +const EbmlCallbacks KaxTagMultiIdentifierType::ClassInfos(KaxTagMultiIdentifierType::Create, KaxTagMultiIdentifierType_TheId, "TagMultiIdentifierType", KaxTagMultiIdentifierType_Context); +const EbmlCallbacks KaxTagMultiIdentifierBinary::ClassInfos(KaxTagMultiIdentifierBinary::Create, KaxTagMultiIdentifierBinary_TheId, "MultiIdentifierBinary", KaxTagMultiIdentifierBinary_Context); +const EbmlCallbacks KaxTagMultiIdentifierString::ClassInfos(KaxTagMultiIdentifierString::Create, KaxTagMultiIdentifierString_TheId, "MultiIdentifierString", KaxTagMultiIdentifierString_Context); + +const EbmlCallbacks KaxTagMultiLegal::ClassInfos(KaxTagMultiLegal::Create, KaxTagMultiLegal_TheId, "MultiLegal", KaxTagMultiLegal_Context); +const EbmlCallbacks KaxTagLegal::ClassInfos(KaxTagLegal::Create, KaxTagLegal_TheId, "Legal", KaxTagLegal_Context); +const EbmlCallbacks KaxTagMultiLegalType::ClassInfos(KaxTagMultiLegalType::Create, KaxTagMultiLegalType_TheId, "KaxTagMultiLegalType", KaxTagMultiLegalType_Context); +const EbmlCallbacks KaxTagMultiLegalContent::ClassInfos(KaxTagMultiLegalContent::Create, KaxTagMultiLegalContent_TheId, "TagMultiLegalContent", KaxTagMultiLegalContent_Context); +const EbmlCallbacks KaxTagMultiLegalURL::ClassInfos(KaxTagMultiLegalURL::Create, KaxTagMultiLegalURL_TheId, "KaxTagMultiLegalURL", KaxTagMultiLegalURL_Context); +const EbmlCallbacks KaxTagMultiLegalAddress::ClassInfos(KaxTagMultiLegalAddress::Create, KaxTagMultiLegalAddress_TheId, "KaxTagMultiLegalAddress", KaxTagMultiLegalAddress_Context); + +const EbmlCallbacks KaxTagMultiTitle::ClassInfos(KaxTagMultiTitle::Create, KaxTagMultiTitle_TheId, "MultiEntity", KaxTagMultiTitle_Context); +const EbmlCallbacks KaxTagTitle::ClassInfos(KaxTagTitle::Create, KaxTagTitle_TheId, "Entity", KaxTagTitle_Context); +const EbmlCallbacks KaxTagMultiTitleType::ClassInfos(KaxTagMultiTitleType::Create, KaxTagMultiTitleType_TheId, "MultiTitleType", KaxTagMultiTitleType_Context); +const EbmlCallbacks KaxTagMultiTitleName::ClassInfos(KaxTagMultiTitleName::Create, KaxTagMultiTitleName_TheId, "MultiTitleName", KaxTagMultiTitleName_Context); +const EbmlCallbacks KaxTagMultiTitleSubTitle::ClassInfos(KaxTagMultiTitleSubTitle::Create, KaxTagMultiTitleSubTitle_TheId, "MultiTitleSubTitle", KaxTagMultiTitleSubTitle_Context); +const EbmlCallbacks KaxTagMultiTitleEdition::ClassInfos(KaxTagMultiTitleEdition::Create, KaxTagMultiTitleEdition_TheId, "MultiTitleEdition", KaxTagMultiTitleEdition_Context); +const EbmlCallbacks KaxTagMultiTitleAddress::ClassInfos(KaxTagMultiTitleAddress::Create, KaxTagMultiTitleAddress_TheId, "MultiTitleAddress", KaxTagMultiTitleAddress_Context); +const EbmlCallbacks KaxTagMultiTitleURL::ClassInfos(KaxTagMultiTitleURL::Create, KaxTagMultiTitleURL_TheId, "MultiTitleURL", KaxTagMultiTitleURL_Context); +const EbmlCallbacks KaxTagMultiTitleEmail::ClassInfos(KaxTagMultiTitleEmail::Create, KaxTagMultiTitleEmail_TheId, "MultiTitleEmail", KaxTagMultiTitleEmail_Context); +const EbmlCallbacks KaxTagMultiTitleLanguage::ClassInfos(KaxTagMultiTitleLanguage::Create, KaxTagMultiTitleLanguage_TheId, "MultiTitleLanguage", KaxTagMultiTitleLanguage_Context); + +const EbmlCallbacks KaxTagMultiAttachment::ClassInfos(KaxTagMultiAttachment::Create, KaxTagMultiAttachment_TheId, "TagMultiAttachment", KaxTagMultiAttachment_Context); +const EbmlCallbacks KaxTagAttachment::ClassInfos(KaxTagAttachment::Create, KaxTagAttachment_TheId, "TagAttachment", KaxTagAttachment_Context); +const EbmlCallbacks KaxTagAttachmentID::ClassInfos(KaxTagAttachmentID::Create, KaxTagAttachmentID_TheId, "TagAttachmentID", KaxTagAttachmentID_Context); + +KaxTagMultiComment::KaxTagMultiComment() + :EbmlMaster(KaxTagMultiComment_Context) +{} + + +KaxTagMultiCommercial::KaxTagMultiCommercial() + :EbmlMaster(KaxTagMultiCommercial_Context) +{} + +KaxTagCommercial::KaxTagCommercial() + :EbmlMaster(KaxTagCommercial_Context) +{} + +KaxTagMultiPrice::KaxTagMultiPrice() + :EbmlMaster(KaxTagMultiPrice_Context) +{} + +KaxTagMultiDate::KaxTagMultiDate() + :EbmlMaster(KaxTagMultiDate_Context) +{} + +KaxTagDate::KaxTagDate() + :EbmlMaster(KaxTagDate_Context) +{} + +KaxTagMultiEntity::KaxTagMultiEntity() + :EbmlMaster(KaxTagMultiEntity_Context) +{} + +KaxTagEntity::KaxTagEntity() + :EbmlMaster(KaxTagEntity_Context) +{} + +KaxTagMultiLegal::KaxTagMultiLegal() + :EbmlMaster(KaxTagMultiLegal_Context) +{} + +KaxTagLegal::KaxTagLegal() + :EbmlMaster(KaxTagLegal_Context) +{} + +KaxTagMultiIdentifier::KaxTagMultiIdentifier() + :EbmlMaster(KaxTagMultiIdentifier_Context) +{} + +KaxTagIdentifier::KaxTagIdentifier() + :EbmlMaster(KaxTagIdentifier_Context) +{} + +KaxTagMultiTitle::KaxTagMultiTitle() + :EbmlMaster(KaxTagMultiTitle_Context) +{} + +KaxTagTitle::KaxTagTitle() + :EbmlMaster(KaxTagTitle_Context) +{} + +KaxTagMultiAttachment::KaxTagMultiAttachment() + :EbmlMaster(KaxTagMultiAttachment_Context) +{} + +KaxTagAttachment::KaxTagAttachment() + :EbmlMaster(KaxTagAttachment_Context) +{} + +const EbmlSemanticContext & GetKaxTagsGlobal_Context() +{ + return KaxTagMultiGlobal_Context; +} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxTags.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxTags.cpp new file mode 100644 index 0000000000..4b9b712433 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxTags.cpp @@ -0,0 +1,60 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxTags.cpp 711 2004-08-10 12:58:47Z robux4 $ + \author Steve Lhomme + \author Jory Stone +*/ +#include "matroska/KaxTags.h" +#include "matroska/KaxTag.h" +#include "matroska/KaxContexts.h" + +using namespace LIBEBML_NAMESPACE; + +// sub elements +START_LIBMATROSKA_NAMESPACE + +EbmlSemantic KaxTags_ContextList[1] = +{ + EbmlSemantic(true, false, KaxTag::ClassInfos), +}; + +const EbmlSemanticContext KaxTags_Context = EbmlSemanticContext(countof(KaxTags_ContextList), KaxTags_ContextList, &KaxSegment_Context, *GetKaxGlobal_Context, &KaxTags::ClassInfos); + +EbmlId KaxTags_TheId(0x1254C367, 4); + +const EbmlCallbacks KaxTags::ClassInfos(KaxTags::Create, KaxTags_TheId, "Tags", KaxTags_Context); + +KaxTags::KaxTags() + :EbmlMaster(KaxTags_Context) +{} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxTrackAudio.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxTrackAudio.cpp new file mode 100644 index 0000000000..7fc934d237 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxTrackAudio.cpp @@ -0,0 +1,88 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxTrackAudio.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme +*/ +#include "matroska/KaxTrackAudio.h" + +// sub elements +#include "matroska/KaxContexts.h" + +START_LIBMATROSKA_NAMESPACE + +#if MATROSKA_VERSION == 1 +const EbmlSemantic KaxTrackAudio_ContextList[4] = +#else // MATROSKA_VERSION +const EbmlSemantic KaxTrackAudio_ContextList[5] = +#endif // MATROSKA_VERSION +{ + EbmlSemantic(true , true, KaxAudioSamplingFreq::ClassInfos), + EbmlSemantic(true , true, KaxAudioChannels::ClassInfos), + EbmlSemantic(false, true, KaxAudioBitDepth::ClassInfos), + EbmlSemantic(false, true, KaxAudioOutputSamplingFreq::ClassInfos), +#if MATROSKA_VERSION >= 2 + EbmlSemantic(false, true, KaxAudioPosition::ClassInfos), +#endif // MATROSKA_VERSION +}; + +const EbmlSemanticContext KaxTrackAudio_Context = EbmlSemanticContext(countof(KaxTrackAudio_ContextList), KaxTrackAudio_ContextList, &KaxTrackEntry_Context, *GetKaxGlobal_Context, &KaxTrackAudio::ClassInfos); +const EbmlSemanticContext KaxAudioSamplingFreq_Context = EbmlSemanticContext(0, NULL, &KaxTrackAudio_Context, *GetKaxGlobal_Context, &KaxAudioSamplingFreq::ClassInfos); +const EbmlSemanticContext KaxAudioOutputSamplingFreq_Context = EbmlSemanticContext(0, NULL, &KaxTrackAudio_Context, *GetKaxGlobal_Context, &KaxAudioOutputSamplingFreq::ClassInfos); +const EbmlSemanticContext KaxAudioChannels_Context = EbmlSemanticContext(0, NULL, &KaxTrackAudio_Context, *GetKaxGlobal_Context, &KaxAudioChannels::ClassInfos); +const EbmlSemanticContext KaxAudioBitDepth_Context = EbmlSemanticContext(0, NULL, &KaxTrackAudio_Context, *GetKaxGlobal_Context, &KaxAudioBitDepth::ClassInfos); +#if MATROSKA_VERSION >= 2 +const EbmlSemanticContext KaxAudioPosition_Context = EbmlSemanticContext(0, NULL, &KaxTrackAudio_Context, *GetKaxGlobal_Context, &KaxAudioPosition::ClassInfos); +#endif // MATROSKA_VERSION + +EbmlId KaxTrackAudio_TheId (0xE1, 1); +EbmlId KaxAudioSamplingFreq_TheId(0xB5, 1); +EbmlId KaxAudioOutputSamplingFreq_TheId(0x78B5, 2); +EbmlId KaxAudioChannels_TheId (0x9F, 1); +EbmlId KaxAudioBitDepth_TheId (0x6264, 2); +#if MATROSKA_VERSION >= 2 +EbmlId KaxAudioPosition_TheId (0x7D7B, 2); +#endif // MATROSKA_VERSION + +const EbmlCallbacks KaxTrackAudio::ClassInfos(KaxTrackAudio::Create, KaxTrackAudio_TheId, "TrackAudio", KaxTrackAudio_Context); +const EbmlCallbacks KaxAudioSamplingFreq::ClassInfos(KaxAudioSamplingFreq::Create, KaxAudioSamplingFreq_TheId, "AudioSamplingFreq", KaxAudioSamplingFreq_Context); +const EbmlCallbacks KaxAudioOutputSamplingFreq::ClassInfos(KaxAudioOutputSamplingFreq::Create, KaxAudioOutputSamplingFreq_TheId, "AudioOutputSamplingFreq", KaxAudioOutputSamplingFreq_Context); +const EbmlCallbacks KaxAudioChannels::ClassInfos(KaxAudioChannels::Create, KaxAudioChannels_TheId, "AudioChannels", KaxAudioChannels_Context); +const EbmlCallbacks KaxAudioBitDepth::ClassInfos(KaxAudioBitDepth::Create, KaxAudioBitDepth_TheId, "AudioBitDepth", KaxAudioBitDepth_Context); +#if MATROSKA_VERSION >= 2 +const EbmlCallbacks KaxAudioPosition::ClassInfos(KaxAudioPosition::Create, KaxAudioPosition_TheId, "AudioPosition", KaxAudioPosition_Context); +#endif // MATROSKA_VERSION + +KaxTrackAudio::KaxTrackAudio() + :EbmlMaster(KaxTrackAudio_Context) +{} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxTrackEntryData.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxTrackEntryData.cpp new file mode 100644 index 0000000000..9f64fb33f4 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxTrackEntryData.cpp @@ -0,0 +1,110 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxTrackEntryData.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme + \author John Cannon +*/ +#include "matroska/KaxTrackEntryData.h" +#include "matroska/KaxContexts.h" + +START_LIBMATROSKA_NAMESPACE + +EbmlId KaxTrackNumber_TheId (0xD7, 1); +EbmlId KaxTrackUID_TheId (0x73C5, 2); +EbmlId KaxTrackType_TheId (0x83, 1); +EbmlId KaxTrackFlagDefault_TheId (0x88, 1); +EbmlId KaxTrackFlagLacing_TheId (0x9C, 1); +EbmlId KaxTrackMinCache_TheId (0x6DE7, 2); +EbmlId KaxTrackMaxCache_TheId (0x6DF8, 2); +EbmlId KaxTrackDefaultDuration_TheId (0x23E383, 3); +EbmlId KaxTrackTimecodeScale_TheId (0x23314F, 3); +EbmlId KaxTrackName_TheId (0x536E, 2); +EbmlId KaxTrackLanguage_TheId (0x22B59C, 3); +EbmlId KaxCodecID_TheId (0x86, 1); +EbmlId KaxCodecPrivate_TheId (0x63A2, 2); +EbmlId KaxCodecName_TheId (0x258688, 3); +#if MATROSKA_VERSION >= 2 +EbmlId KaxTrackFlagEnabled_TheId (0xB9, 1); +EbmlId KaxCodecSettings_TheId (0x3A9697, 3); +EbmlId KaxCodecInfoURL_TheId (0x3B4040, 3); +EbmlId KaxCodecDownloadURL_TheId (0x26B240, 3); +EbmlId KaxCodecDecodeAll_TheId (0xAA, 1); +EbmlId KaxTrackOverlay_TheId (0x6FAB, 2); +#endif // MATROSKA_VERSION + +const EbmlSemanticContext KaxTrackNumber_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxTrackNumber::ClassInfos); +const EbmlSemanticContext KaxTrackUID_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxTrackUID::ClassInfos); +const EbmlSemanticContext KaxTrackType_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxTrackType::ClassInfos); +const EbmlSemanticContext KaxTrackFlagDefault_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxTrackFlagDefault::ClassInfos); +const EbmlSemanticContext KaxTrackFlagLacing_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxTrackFlagLacing::ClassInfos); +const EbmlSemanticContext KaxTrackMinCache_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxTrackMinCache::ClassInfos); +const EbmlSemanticContext KaxTrackMaxCache_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxTrackMaxCache::ClassInfos); +const EbmlSemanticContext KaxTrackDefaultDuration_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxTrackDefaultDuration::ClassInfos); +const EbmlSemanticContext KaxTrackTimecodeScale_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxTrackTimecodeScale::ClassInfos); +const EbmlSemanticContext KaxTrackName_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxTrackName::ClassInfos); +const EbmlSemanticContext KaxTrackLanguage_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxTrackLanguage::ClassInfos); +const EbmlSemanticContext KaxCodecID_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxCodecID::ClassInfos); +const EbmlSemanticContext KaxCodecPrivate_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxCodecPrivate::ClassInfos); +const EbmlSemanticContext KaxCodecName_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxCodecName::ClassInfos); +#if MATROSKA_VERSION >= 2 +const EbmlSemanticContext KaxTrackFlagEnabled_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxTrackFlagEnabled::ClassInfos); +const EbmlSemanticContext KaxCodecSettings_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxCodecSettings::ClassInfos); +const EbmlSemanticContext KaxCodecInfoURL_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxCodecInfoURL::ClassInfos); +const EbmlSemanticContext KaxCodecDownloadURL_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxCodecDownloadURL::ClassInfos); +const EbmlSemanticContext KaxCodecDecodeAll_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxCodecDecodeAll::ClassInfos); +const EbmlSemanticContext KaxTrackOverlay_Context = EbmlSemanticContext(0, NULL, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxTrackOverlay::ClassInfos); +#endif // MATROSKA_VERSION + +const EbmlCallbacks KaxTrackNumber::ClassInfos(KaxTrackNumber::Create, KaxTrackNumber_TheId, "TrackNumber", KaxTrackNumber_Context); +const EbmlCallbacks KaxTrackUID::ClassInfos(KaxTrackUID::Create, KaxTrackUID_TheId, "TrackUID", KaxTrackUID_Context); +const EbmlCallbacks KaxTrackType::ClassInfos(KaxTrackType::Create, KaxTrackType_TheId, "TrackType", KaxTrackType_Context); +const EbmlCallbacks KaxTrackFlagDefault::ClassInfos(KaxTrackFlagDefault::Create, KaxTrackFlagDefault_TheId, "TrackFlagDefault", KaxTrackFlagDefault_Context); +const EbmlCallbacks KaxTrackFlagLacing::ClassInfos(KaxTrackFlagLacing::Create, KaxTrackFlagLacing_TheId, "TrackFlagLacing", KaxTrackFlagLacing_Context); +const EbmlCallbacks KaxTrackMinCache::ClassInfos(KaxTrackMinCache::Create, KaxTrackMinCache_TheId, "TrackMinCache", KaxTrackMinCache_Context); +const EbmlCallbacks KaxTrackMaxCache::ClassInfos(KaxTrackMaxCache::Create, KaxTrackMaxCache_TheId, "TrackMaxCache", KaxTrackMaxCache_Context); +const EbmlCallbacks KaxTrackDefaultDuration::ClassInfos(KaxTrackDefaultDuration::Create, KaxTrackDefaultDuration_TheId, "TrackDefaultDuration", KaxTrackDefaultDuration_Context); +const EbmlCallbacks KaxTrackTimecodeScale::ClassInfos(KaxTrackTimecodeScale::Create, KaxTrackTimecodeScale_TheId, "TrackTimecodeScale", KaxTrackTimecodeScale_Context); +const EbmlCallbacks KaxTrackName::ClassInfos(KaxTrackName::Create, KaxTrackName_TheId, "TrackName", KaxTrackName_Context); +const EbmlCallbacks KaxTrackLanguage::ClassInfos(KaxTrackLanguage::Create, KaxTrackLanguage_TheId, "TrackLanguage", KaxTrackLanguage_Context); +const EbmlCallbacks KaxCodecID::ClassInfos(KaxCodecID::Create, KaxCodecID_TheId, "CodecID", KaxCodecID_Context); +const EbmlCallbacks KaxCodecPrivate::ClassInfos(KaxCodecPrivate::Create, KaxCodecPrivate_TheId, "CodecPrivate", KaxCodecPrivate_Context); +const EbmlCallbacks KaxCodecName::ClassInfos(KaxCodecName::Create, KaxCodecName_TheId, "CodecName", KaxCodecName_Context); +#if MATROSKA_VERSION >= 2 +const EbmlCallbacks KaxTrackFlagEnabled::ClassInfos(KaxTrackFlagEnabled::Create, KaxTrackFlagEnabled_TheId, "TrackFlagEnabled", KaxTrackFlagEnabled_Context); +const EbmlCallbacks KaxCodecSettings::ClassInfos(KaxCodecSettings::Create, KaxCodecSettings_TheId, "CodecSettings", KaxCodecSettings_Context); +const EbmlCallbacks KaxCodecInfoURL::ClassInfos(KaxCodecInfoURL::Create, KaxCodecInfoURL_TheId, "CodecInfoURL", KaxCodecInfoURL_Context); +const EbmlCallbacks KaxCodecDownloadURL::ClassInfos(KaxCodecDownloadURL::Create, KaxCodecDownloadURL_TheId, "CodecDownloadURL", KaxCodecDownloadURL_Context); +const EbmlCallbacks KaxCodecDecodeAll::ClassInfos(KaxCodecDecodeAll::Create, KaxCodecDecodeAll_TheId, "CodecDecodeAll", KaxCodecDecodeAll_Context); +const EbmlCallbacks KaxTrackOverlay::ClassInfos(KaxTrackOverlay::Create, KaxTrackOverlay_TheId, "TrackOverlay", KaxTrackOverlay_Context); +#endif // MATROSKA_VERSION + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxTrackVideo.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxTrackVideo.cpp new file mode 100644 index 0000000000..64726d80f7 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxTrackVideo.cpp @@ -0,0 +1,134 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxTrackVideo.cpp 738 2004-08-30 09:21:46Z robux4 $ + \author Steve Lhomme +*/ +#include "matroska/KaxTrackVideo.h" + +// sub elements +#include "matroska/KaxContexts.h" + +START_LIBMATROSKA_NAMESPACE + +#if MATROSKA_VERSION == 1 +const EbmlSemantic KaxTrackVideo_ContextList[10] = +#else // MATROSKA_VERSION +const EbmlSemantic KaxTrackVideo_ContextList[15] = +#endif // MATROSKA_VERSION +{ + EbmlSemantic(true , true, KaxVideoPixelWidth::ClassInfos), + EbmlSemantic(true , true, KaxVideoPixelHeight::ClassInfos), + EbmlSemantic(false, true, KaxVideoPixelCropBottom::ClassInfos), + EbmlSemantic(false, true, KaxVideoPixelCropTop::ClassInfos), + EbmlSemantic(false, true, KaxVideoPixelCropLeft::ClassInfos), + EbmlSemantic(false, true, KaxVideoPixelCropRight::ClassInfos), + EbmlSemantic(false, true, KaxVideoDisplayWidth::ClassInfos), + EbmlSemantic(false, true, KaxVideoDisplayHeight::ClassInfos), + EbmlSemantic(false, true, KaxVideoColourSpace::ClassInfos), + EbmlSemantic(false, true, KaxVideoFrameRate::ClassInfos), +#if MATROSKA_VERSION >= 2 + EbmlSemantic(true , true, KaxVideoFlagInterlaced::ClassInfos), + EbmlSemantic(false, true, KaxVideoStereoMode::ClassInfos), + EbmlSemantic(false, true, KaxVideoDisplayUnit::ClassInfos), + EbmlSemantic(false, true, KaxVideoAspectRatio::ClassInfos), + EbmlSemantic(false, true, KaxVideoGamma::ClassInfos), +#endif // MATROSKA_VERSION +}; + +const EbmlSemanticContext KaxTrackVideo_Context = EbmlSemanticContext(countof(KaxTrackVideo_ContextList), KaxTrackVideo_ContextList, &KaxTrackEntry_Context, *GetKaxGlobal_Context, &KaxTrackVideo::ClassInfos); +const EbmlSemanticContext KaxVideoPixelWidth_Context = EbmlSemanticContext(0, NULL, &KaxTrackVideo_Context, *GetKaxGlobal_Context, &KaxVideoPixelWidth::ClassInfos); +const EbmlSemanticContext KaxVideoPixelHeight_Context = EbmlSemanticContext(0, NULL, &KaxTrackVideo_Context, *GetKaxGlobal_Context, &KaxVideoPixelHeight::ClassInfos); +const EbmlSemanticContext KaxVideoPixelCropBottom_Context = EbmlSemanticContext(0, NULL, &KaxTrackVideo_Context, *GetKaxGlobal_Context, &KaxVideoPixelCropBottom::ClassInfos); +const EbmlSemanticContext KaxVideoPixelCropTop_Context = EbmlSemanticContext(0, NULL, &KaxTrackVideo_Context, *GetKaxGlobal_Context, &KaxVideoPixelCropTop::ClassInfos); +const EbmlSemanticContext KaxVideoPixelCropRight_Context = EbmlSemanticContext(0, NULL, &KaxTrackVideo_Context, *GetKaxGlobal_Context, &KaxVideoPixelCropLeft::ClassInfos); +const EbmlSemanticContext KaxVideoPixelCropLeft_Context = EbmlSemanticContext(0, NULL, &KaxTrackVideo_Context, *GetKaxGlobal_Context, &KaxVideoPixelCropRight::ClassInfos); +const EbmlSemanticContext KaxVideoDisplayWidth_Context = EbmlSemanticContext(0, NULL, &KaxTrackVideo_Context, *GetKaxGlobal_Context, &KaxVideoDisplayWidth::ClassInfos); +const EbmlSemanticContext KaxVideoDisplayHeight_Context = EbmlSemanticContext(0, NULL, &KaxTrackVideo_Context, *GetKaxGlobal_Context, &KaxVideoDisplayHeight::ClassInfos); +const EbmlSemanticContext KaxVideoColourSpace_Context = EbmlSemanticContext(0, NULL, &KaxTrackVideo_Context, *GetKaxGlobal_Context, &KaxVideoColourSpace::ClassInfos); +const EbmlSemanticContext KaxVideoFrameRate_Context = EbmlSemanticContext(0, NULL, &KaxTrackVideo_Context, *GetKaxGlobal_Context, &KaxVideoFrameRate::ClassInfos); +#if MATROSKA_VERSION >= 2 +const EbmlSemanticContext KaxVideoFlagInterlaced_Context = EbmlSemanticContext(0, NULL, &KaxTrackVideo_Context, *GetKaxGlobal_Context, &KaxVideoFlagInterlaced::ClassInfos); +const EbmlSemanticContext KaxVideoStereoMode_Context = EbmlSemanticContext(0, NULL, &KaxTrackVideo_Context, *GetKaxGlobal_Context, &KaxVideoStereoMode::ClassInfos); +const EbmlSemanticContext KaxVideoDisplayUnit_Context = EbmlSemanticContext(0, NULL, &KaxTrackVideo_Context, *GetKaxGlobal_Context, &KaxVideoDisplayUnit::ClassInfos); +const EbmlSemanticContext KaxVideoAspectRatio_Context = EbmlSemanticContext(0, NULL, &KaxTrackVideo_Context, *GetKaxGlobal_Context, &KaxVideoAspectRatio::ClassInfos); +const EbmlSemanticContext KaxVideoGamma_Context = EbmlSemanticContext(0, NULL, &KaxTrackVideo_Context, *GetKaxGlobal_Context, &KaxVideoGamma::ClassInfos); +#endif // MATROSKA_VERSION + +EbmlId KaxTrackVideo_TheId (0xE0, 1); +EbmlId KaxVideoPixelWidth_TheId (0xB0, 1); +EbmlId KaxVideoPixelHeight_TheId (0xBA, 1); +EbmlId KaxVideoPixelCropBottom_TheId(0x54AA, 2); +EbmlId KaxVideoPixelCropTop_TheId (0x54BB, 2); +EbmlId KaxVideoPixelCropLeft_TheId (0x54CC, 2); +EbmlId KaxVideoPixelCropRight_TheId (0x54DD, 2); +EbmlId KaxVideoDisplayWidth_TheId (0x54B0, 2); +EbmlId KaxVideoDisplayHeight_TheId (0x54BA, 2); +EbmlId KaxVideoColourSpace_TheId (0x2EB524, 3); +EbmlId KaxVideoFrameRate_TheId (0x2383E3, 3); +#if MATROSKA_VERSION >= 2 +EbmlId KaxVideoFlagInterlaced_TheId (0x9A, 1); +EbmlId KaxVideoStereoMode_TheId (0x53B9, 2); +EbmlId KaxVideoDisplayUnit_TheId (0x54B2, 2); +EbmlId KaxVideoAspectRatio_TheId (0x54B3, 1); +EbmlId KaxVideoGamma_TheId (0x2FB523, 3); +#endif // MATROSKA_VERSION + +const EbmlCallbacks KaxTrackVideo::ClassInfos(KaxTrackVideo::Create, KaxTrackVideo_TheId, "TrackAudio", KaxTrackVideo_Context); +const EbmlCallbacks KaxVideoPixelWidth::ClassInfos(KaxVideoPixelWidth::Create, KaxVideoPixelWidth_TheId, "VideoPixelWidth", KaxVideoPixelWidth_Context); +const EbmlCallbacks KaxVideoPixelHeight::ClassInfos(KaxVideoPixelHeight::Create, KaxVideoPixelHeight_TheId, "VideoPixelHeight", KaxVideoPixelHeight_Context); +const EbmlCallbacks KaxVideoPixelCropBottom::ClassInfos(KaxVideoPixelCropBottom::Create, KaxVideoPixelCropBottom_TheId, "VideoPixelCropBottom", KaxVideoPixelCropBottom_Context); +const EbmlCallbacks KaxVideoPixelCropTop::ClassInfos(KaxVideoPixelCropTop::Create, KaxVideoPixelCropTop_TheId, "VideoPixelCropTop", KaxVideoPixelCropTop_Context); +const EbmlCallbacks KaxVideoPixelCropLeft::ClassInfos(KaxVideoPixelCropLeft::Create, KaxVideoPixelCropLeft_TheId, "VideoPixelCropLeft", KaxVideoPixelCropLeft_Context); +const EbmlCallbacks KaxVideoPixelCropRight::ClassInfos(KaxVideoPixelCropRight::Create, KaxVideoPixelCropRight_TheId, "VideoPixelCropRight", KaxVideoPixelCropRight_Context); +const EbmlCallbacks KaxVideoDisplayWidth::ClassInfos(KaxVideoDisplayWidth::Create, KaxVideoDisplayWidth_TheId, "VideoDisplayWidth", KaxVideoDisplayWidth_Context); +const EbmlCallbacks KaxVideoDisplayHeight::ClassInfos(KaxVideoDisplayHeight::Create, KaxVideoDisplayHeight_TheId, "VideoDisplayHeight", KaxVideoDisplayHeight_Context); +const EbmlCallbacks KaxVideoColourSpace::ClassInfos(KaxVideoColourSpace::Create, KaxVideoColourSpace_TheId, "VideoColourSpace", KaxVideoColourSpace_Context); +const EbmlCallbacks KaxVideoFrameRate::ClassInfos(KaxVideoFrameRate::Create, KaxVideoFrameRate_TheId, "VideoFrameRate", KaxVideoFrameRate_Context); +#if MATROSKA_VERSION >= 2 +const EbmlCallbacks KaxVideoFlagInterlaced::ClassInfos(KaxVideoFlagInterlaced::Create, KaxVideoFlagInterlaced_TheId, "VideoFlagInterlaced", KaxVideoFlagInterlaced_Context); +const EbmlCallbacks KaxVideoStereoMode::ClassInfos(KaxVideoStereoMode::Create, KaxVideoStereoMode_TheId, "VideoStereoMode", KaxVideoStereoMode_Context); +const EbmlCallbacks KaxVideoDisplayUnit::ClassInfos(KaxVideoDisplayUnit::Create, KaxVideoDisplayUnit_TheId, "VideoDisplayUnit", KaxVideoDisplayUnit_Context); +const EbmlCallbacks KaxVideoAspectRatio::ClassInfos(KaxVideoAspectRatio::Create, KaxVideoAspectRatio_TheId, "VideoAspectRatio", KaxVideoAspectRatio_Context); +const EbmlCallbacks KaxVideoGamma::ClassInfos(KaxVideoGamma::Create, KaxVideoGamma_TheId, "VideoGamma", KaxVideoGamma_Context); +#endif // MATROSKA_VERSION + +KaxTrackVideo::KaxTrackVideo() + :EbmlMaster(KaxTrackVideo_Context) +{} + +uint32 KaxVideoFrameRate::RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault) +{ + assert(false); // no you are not allowed to use this element ! + return 0; +} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxTracks.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxTracks.cpp new file mode 100644 index 0000000000..537ba77feb --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxTracks.cpp @@ -0,0 +1,110 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxTracks.cpp 740 2004-08-30 18:52:56Z mosu $ + \author Steve Lhomme +*/ +#include "matroska/KaxTracks.h" + +// sub elements +#include "matroska/KaxTrackEntryData.h" +#include "matroska/KaxTrackAudio.h" +#include "matroska/KaxTrackVideo.h" +#include "matroska/KaxContentEncoding.h" +#include "matroska/KaxContexts.h" + +START_LIBMATROSKA_NAMESPACE + +const EbmlSemantic KaxTracks_ContextList[1] = +{ + EbmlSemantic(true, false, KaxTrackEntry::ClassInfos), +}; + +#if MATROSKA_VERSION == 1 +const EbmlSemantic KaxTrackEntry_ContextList[17] = +#else // MATROSKA_VERSION +const EbmlSemantic KaxTrackEntry_ContextList[23] = +#endif // MATROSKA_VERSION +{ + EbmlSemantic(true , true, KaxTrackNumber::ClassInfos), + EbmlSemantic(true , true, KaxTrackUID::ClassInfos), + EbmlSemantic(true , true, KaxTrackType::ClassInfos), +#if MATROSKA_VERSION >= 2 + EbmlSemantic(true , true, KaxTrackFlagEnabled::ClassInfos), +#endif // MATROSKA_VERSION + EbmlSemantic(true , true, KaxTrackFlagDefault::ClassInfos), + EbmlSemantic(true , true, KaxTrackFlagLacing::ClassInfos), + EbmlSemantic(true , true, KaxTrackMinCache::ClassInfos), + EbmlSemantic(false, true, KaxTrackMaxCache::ClassInfos), + EbmlSemantic(false, true, KaxTrackDefaultDuration::ClassInfos), + EbmlSemantic(true , true, KaxTrackTimecodeScale::ClassInfos), + EbmlSemantic(false, true, KaxTrackName::ClassInfos), + EbmlSemantic(false, true, KaxTrackLanguage::ClassInfos), + EbmlSemantic(true , true, KaxCodecID::ClassInfos), + EbmlSemantic(false, true, KaxCodecPrivate::ClassInfos), + EbmlSemantic(false, true, KaxCodecName::ClassInfos), +#if MATROSKA_VERSION >= 2 + EbmlSemantic(false, true, KaxCodecSettings::ClassInfos), + EbmlSemantic(false, true, KaxCodecInfoURL::ClassInfos), + EbmlSemantic(false, true, KaxCodecDownloadURL::ClassInfos), + EbmlSemantic(true , true, KaxCodecDecodeAll::ClassInfos), + EbmlSemantic(false, true, KaxTrackOverlay::ClassInfos), +#endif // MATROSKA_VERSION + EbmlSemantic(false, true, KaxTrackAudio::ClassInfos), + EbmlSemantic(false, true, KaxTrackVideo::ClassInfos), + EbmlSemantic(false, true, KaxContentEncodings::ClassInfos), +}; + +const EbmlSemanticContext KaxTracks_Context = EbmlSemanticContext(countof(KaxTracks_ContextList), KaxTracks_ContextList, &KaxSegment_Context, *GetKaxGlobal_Context, &KaxTracks::ClassInfos); +const EbmlSemanticContext KaxTrackEntry_Context = EbmlSemanticContext(countof(KaxTrackEntry_ContextList), KaxTrackEntry_ContextList, &KaxTracks_Context, *GetKaxGlobal_Context, &KaxTrackEntry::ClassInfos); + +EbmlId KaxTracks_TheId (0x1654AE6B, 4); +EbmlId KaxTrackEntry_TheId(0xAE, 1); + +const EbmlCallbacks KaxTracks::ClassInfos(KaxTracks::Create, KaxTracks_TheId, "Tracks", KaxTracks_Context); +const EbmlCallbacks KaxTrackEntry::ClassInfos(KaxTrackEntry::Create, KaxTrackEntry_TheId, "TrackEntry", KaxTrackEntry_Context); + +KaxTracks::KaxTracks() + :EbmlMaster(KaxTracks_Context) +{} + +KaxTrackEntry::KaxTrackEntry() + :EbmlMaster(KaxTrackEntry_Context) + ,bGlobalTimecodeScaleIsSet(false) +{} + +void KaxTrackEntry::EnableLacing(bool bEnable) +{ + KaxTrackFlagLacing & myLacing = GetChild(*this); + *(static_cast(&myLacing)) = bEnable ? 1 : 0; +} + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/KaxVersion.cpp b/src/add-ons/media/plugins/matroska/libmatroska/KaxVersion.cpp new file mode 100644 index 0000000000..6ed03d2cf7 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/KaxVersion.cpp @@ -0,0 +1,40 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxVersion.cpp 640 2004-07-09 21:05:36Z mosu $ + \author Steve Lhomme +*/ + +#include "matroska/KaxVersion.h" + +START_LIBMATROSKA_NAMESPACE + +END_LIBMATROSKA_NAMESPACE diff --git a/src/add-ons/media/plugins/matroska/libmatroska/LICENSE.LGPL b/src/add-ons/media/plugins/matroska/libmatroska/LICENSE.LGPL new file mode 100644 index 0000000000..b1e3f5a263 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/LICENSE.LGPL @@ -0,0 +1,504 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + + diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/FileKax.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/FileKax.h new file mode 100644 index 0000000000..8160a89221 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/FileKax.h @@ -0,0 +1,152 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: FileKax.h,v 1.5 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_FILE_H +#define LIBMATROSKA_FILE_H + +//#include + +#include "matroska/KaxTypes.h" +#include "ebml/IOCallback.h" +//#include "MainHeader.h" +//#include "TrackType.h" +//#include "StreamInfo.h" +//#include "Cluster.h" +//#include "CodecHeader.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +//class Track; +//class Frame; + +/*! + \class MATROSKA_DLL_API FileMatroska + \brief General container of all the parameters and data of an Matroska file + \todo Handle the filename and next filename + \todo Handle the IOCallback selection/type +*/ +class MATROSKA_DLL_API FileMatroska { + public: + FileMatroska(IOCallback & output); + ~FileMatroska(); +#ifdef OLD + uint32 RenderHead(const std::string & aEncoderApp); + uint32 ReadHead(); + uint32 ReadTracks(); + uint32 ReadCodec(); + void Close(const uint32 aTimeLength); + + inline void type_SetInfo(const std::string & aStr) {myMainHeader.type_SetInfo(aStr);} + inline void type_SetAds(const std::string & aStr) {myMainHeader.type_SetAds(aStr);} + inline void type_SetSize(const std::string & aStr) {myMainHeader.type_SetSize(aStr);} + inline void type_SetSize(const uint64 aSize) {myMainHeader.type_SetSize(aSize);} + + inline uint8 GetTrackNumber() const { return myTracks.size(); } + + void track_SetName(Track * aTrack, const std::string & aName); + void track_SetLaced(Track * aTrack, const bool bLaced = true); + + Track * CreateTrack(const track_type aType); + inline Track * GetTrack(const uint8 aTrackNb) const + { + if (aTrackNb > myTracks.size()) + return NULL; + else + return myTracks[aTrackNb-1]; + } + + void Track_GetInfo(const Track * aTrack, TrackInfo & aTrackInfo) const; + + void Track_SetInfo_Audio(Track * aTrack, const TrackInfoAudio & aTrackInfo); + void Track_GetInfo_Audio(const Track * aTrack, TrackInfoAudio & aTrackInfo) const; + + void Track_SetInfo_Video(Track * aTrack, const TrackInfoVideo & aTrackInfo); + void Track_GetInfo_Video(const Track * aTrack, TrackInfoVideo & aTrackInfo) const; + + void SelectReadingTrack(Track * aTrack, bool select = true); + + /*! + \return wether the frame has been added or not + */ + bool AddFrame(Track * aTrack, const uint32 aTimecode, const binary *aFrame, const uint32 aFrameSize, + const bool aKeyFrame = true, const bool aBFrame = false); + + /*! + \return wether the frame has been read or not + */ + bool ReadFrame(Track * & aTrack, uint32 & aTimecode, const binary * & aFrame, uint32 & aFrameSize, + bool & aKeyFrame, bool & aBFrame); + + /* + Render the pending cluster to file + */ + void Flush(); + + void SetMaxClusterSize(const uint32 value); + void SetMinClusterSize(const uint32 value) {myMinClusterSize = value;} + + protected: + MainHeader myMainHeader; + + std::vector myTracks; + std::vector mySelectedTracks; + +// Track *findTrack(Track * aTrack) const; + + Cluster myCurrWriteCluster; /// \todo merge with the write one ? + uint32 myReadBlockNumber; + Cluster myCurrReadCluster; + binary * myCurrReadBlock; ///< The buffer containing the current read block + uint32 myCurrReadBlockSize; ///< The size of the buffer containing the current read block + uint8 myCurrReadBlockTrack; ///< The track number of the current track to read + + uint32 myMaxClusterSize; + uint32 myMinClusterSize; + + StreamInfo myStreamInfo; + + CodecHeader myCodecHeader; + + inline bool IsMyTrack(const Track * aTrack) const; + inline bool IsReadingTrack(const uint8 aTrackNum) const; +#endif // OLD + IOCallback & myFile; + +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // FILE_KAX_HPP diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxAttached.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxAttached.h new file mode 100644 index 0000000000..72ec25cfe5 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxAttached.h @@ -0,0 +1,130 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxAttached.h,v 1.8 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_ATTACHED_H +#define LIBMATROSKA_ATTACHED_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" +#include "ebml/EbmlUnicodeString.h" +#include "ebml/EbmlString.h" +#include "ebml/EbmlBinary.h" +#include "ebml/EbmlUInteger.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class MATROSKA_DLL_API KaxAttached : public EbmlMaster { + public: + KaxAttached(); + KaxAttached(const KaxAttached & ElementToClone) : EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxAttached);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + + operator const EbmlId &() const {return ClassInfos.GlobalId;} + bool IsYourId(const EbmlId & TestId) const; + EbmlElement * Clone() const {return new KaxAttached(*this);} +}; + +class MATROSKA_DLL_API KaxFileDescription : public EbmlUnicodeString { + public: + KaxFileDescription() {} + KaxFileDescription(const KaxFileDescription & ElementToClone) : EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxFileDescription);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + + operator const EbmlId &() const {return ClassInfos.GlobalId;} + bool IsYourId(const EbmlId & TestId) const; + EbmlElement * Clone() const {return new KaxFileDescription(*this);} +}; + +class MATROSKA_DLL_API KaxFileName : public EbmlUnicodeString { + public: + KaxFileName() {} + KaxFileName(const KaxFileName & ElementToClone) : EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxFileName);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + + operator const EbmlId &() const {return ClassInfos.GlobalId;} + bool IsYourId(const EbmlId & TestId) const; + EbmlElement * Clone() const {return new KaxFileName(*this);} +}; + +class MATROSKA_DLL_API KaxMimeType : public EbmlString { + public: + KaxMimeType() {} + KaxMimeType(const KaxMimeType & ElementToClone) : EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxMimeType);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + + operator const EbmlId &() const {return ClassInfos.GlobalId;} + bool IsYourId(const EbmlId & TestId) const; + EbmlElement * Clone() const {return new KaxMimeType(*this);} +}; + +class MATROSKA_DLL_API KaxFileData : public EbmlBinary { + public: + KaxFileData() {} + KaxFileData(const KaxFileData & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxFileData);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + bool ValidateSize() const {return true;} // we don't mind about what's inside + static const EbmlCallbacks ClassInfos; + + operator const EbmlId &() const {return ClassInfos.GlobalId;} + bool IsYourId(const EbmlId & TestId) const; + EbmlElement * Clone() const {return new KaxFileData(*this);} +}; + +class MATROSKA_DLL_API KaxFileUID : public EbmlUInteger { + public: + KaxFileUID() {} + KaxFileUID(const KaxFileUID & ElementToClone) : EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxFileUID);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + + operator const EbmlId &() const {return ClassInfos.GlobalId;} + bool IsYourId(const EbmlId & TestId) const; + EbmlElement * Clone() const {return new KaxFileUID(*this);} +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_ATTACHED_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxAttachments.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxAttachments.h new file mode 100644 index 0000000000..ead8cb16e4 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxAttachments.h @@ -0,0 +1,58 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxAttachments.h,v 1.8 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_ATTACHEMENTS_H +#define LIBMATROSKA_ATTACHEMENTS_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class MATROSKA_DLL_API KaxAttachments : public EbmlMaster { + public: + KaxAttachments(); + KaxAttachments(const KaxAttachments & ElementToClone) : EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxAttachments);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxAttachments(*this);} +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_ATTACHEMENTS_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxBlock.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxBlock.h new file mode 100644 index 0000000000..980f361f0e --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxBlock.h @@ -0,0 +1,357 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \todo add a PureBlock class to group functionalities between Block and BlockVirtual + \version \$Id: KaxBlock.h,v 1.24 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme + \author Julien Coloos +*/ +#ifndef LIBMATROSKA_BLOCK_H +#define LIBMATROSKA_BLOCK_H + +#include + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlBinary.h" +#include "ebml/EbmlMaster.h" +#include "matroska/KaxTracks.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class KaxCluster; +class KaxReferenceBlock; + +class MATROSKA_DLL_API DataBuffer { + protected: + binary * myBuffer; + uint32 mySize; + bool bValidValue; + bool (*myFreeBuffer)(const DataBuffer & aBuffer); // method to free the internal buffer + + public: + DataBuffer(binary * aBuffer, uint32 aSize, bool (*aFreeBuffer)(const DataBuffer & aBuffer) = NULL) + :myBuffer(aBuffer) + ,mySize(aSize) + ,bValidValue(true) + ,myFreeBuffer(aFreeBuffer) + {} + virtual binary * Buffer() {return myBuffer;} + virtual uint32 & Size() {return mySize;}; + virtual const binary * Buffer() const {return myBuffer;} + virtual const uint32 Size() const {return mySize;}; + bool FreeBuffer(const DataBuffer & aBuffer) { + bool bResult = true; + if (myBuffer != NULL && myFreeBuffer != NULL && bValidValue) { + bResult = myFreeBuffer(aBuffer); + myBuffer = NULL; + bValidValue = false; + } + return bResult; + } + + virtual DataBuffer * Clone(); +}; + +/*! + \warning the binary buffer should be allocated with the new binary* operator : "new binary[your_size]" +*/ +class MATROSKA_DLL_API SimpleDataBuffer : public DataBuffer { + public: + SimpleDataBuffer(binary * aBuffer, uint32 aSize, uint32 aOffset, bool (*aFreeBuffer)(const DataBuffer & aBuffer) = myFreeBuffer) + :DataBuffer(aBuffer + aOffset, aSize, aFreeBuffer) + ,Offset(aOffset) + ,BaseBuffer(aBuffer) + {} + + DataBuffer * Clone() {return new SimpleDataBuffer(*this);} + + protected: + uint32 Offset; + binary * BaseBuffer; + + static bool myFreeBuffer(const DataBuffer & aBuffer) + { + delete[] static_cast(&aBuffer)->BaseBuffer; + return true; + } + + SimpleDataBuffer(const SimpleDataBuffer & ToClone); +}; + +/*! + \note the data is copied locally, it can be freed right away +* / +class MATROSKA_DLL_API NotSoSimpleDataBuffer : public SimpleDataBuffer { + public: + NotSoSimpleDataBuffer(binary * aBuffer, uint32 aSize, uint32 aOffset) + :SimpleDataBuffer(new binary[aSize - aOffset], aSize, 0) + { + memcpy(BaseBuffer, aBuffer + aOffset, aSize - aOffset); + } +}; +*/ + +class MATROSKA_DLL_API KaxBlockGroup : public EbmlMaster { + public: + KaxBlockGroup(); + KaxBlockGroup(const KaxBlockGroup & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxBlockGroup);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxBlockGroup(*this);} + + ~KaxBlockGroup(); + + /*! + \brief Addition of a frame without references + */ + bool AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, LacingType lacing = LACING_AUTO); + /*! + \brief Addition of a frame with a backward reference (P frame) + */ + bool AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, const KaxBlockGroup & PastBlock, LacingType lacing = LACING_AUTO); + + /*! + \brief Addition of a frame with a backward+forward reference (B frame) + */ + bool AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, const KaxBlockGroup & PastBlock, const KaxBlockGroup & ForwBlock, LacingType lacing = LACING_AUTO); + + void SetParent(KaxCluster & aParentCluster) { + ParentCluster = &aParentCluster; + } + + void SetParentTrack(const KaxTrackEntry & aParentTrack) { + ParentTrack = &aParentTrack; + } + + /*! + \brief Set the duration of the contained frame(s) (for the total number of frames) + */ + void SetBlockDuration(uint64 TimeLength); + bool GetBlockDuration(uint64 &TheTimecode) const; + + /*! + \return the global timecode of this Block (not just the delta to the Cluster) + */ + uint64 GlobalTimecode() const; + uint64 GlobalTimecodeScale() const { + assert(ParentTrack != NULL); + return ParentTrack->GlobalTimecodeScale(); + } + + uint16 TrackNumber() const; + + uint64 ClusterPosition() const; + + /*! + \return the number of references to other frames + */ + unsigned int ReferenceCount() const; + const KaxReferenceBlock & Reference(unsigned int Index) const; + + /*! + \brief release all the frames of all Blocks + */ + void ReleaseFrames(); + + protected: + KaxCluster * ParentCluster; + const KaxTrackEntry * ParentTrack; +}; + +class MATROSKA_DLL_API KaxBlock : public EbmlBinary { + public: + KaxBlock() :bLocalTimecodeUsed(false), bGap(false), mLacing(LACING_AUTO), ParentCluster(NULL) {} + KaxBlock(const KaxBlock & ElementToClone); + ~KaxBlock(); + static EbmlElement & Create() {return *(new KaxBlock);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + bool ValidateSize() const; + + uint16 TrackNum() const {return TrackNumber;} + /*! + \todo !!!! This method needs to be changes ! + */ + uint64 GlobalTimecode() const {return Timecode;} + + /*! + \note override this function to generate the Data/Size on the fly, unlike the usual binary elements + */ + uint64 UpdateSize(bool bSaveDefault = false, bool bForceRender = false); + uint64 ReadData(IOCallback & input, ScopeMode ReadFully = SCOPE_ALL_DATA); + + /*! + \brief Only read the head of the Block (not internal data) + \note convenient when you are parsing the file quickly + */ + uint64 ReadInternalHead(IOCallback & input); + + unsigned int NumberFrames() const { return SizeList.size();} + DataBuffer & GetBuffer(unsigned int iIndex) {return *myBuffers[iIndex];} + + bool AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, LacingType lacing = LACING_AUTO); + + /*! + \brief release all the frames of all Blocks + */ + void ReleaseFrames(); + + void SetParent(KaxCluster & aParentCluster); + + EbmlElement * Clone() const {return new KaxBlock(*this);} + + /*! + \return Returns the lacing type that produces the smallest footprint. + */ + LacingType GetBestLacingType() const; + + /*! + \param FrameNumber 0 for the first frame + \return the position in the stream for a given frame + \note return -1 if the position doesn't exist + */ + int64 GetDataPosition(size_t FrameNumber = 0); + + /*! + \param FrameNumber 0 for the first frame + \return the size of a given frame + \note return -1 if the position doesn't exist + */ + int64 GetFrameSize(size_t FrameNumber = 0); + + protected: + std::vector myBuffers; + std::vector SizeList; + uint64 Timecode; // temporary timecode of the first frame, non scaled + int16 LocalTimecode; + bool bLocalTimecodeUsed; + uint16 TrackNumber; + bool bGap; + LacingType mLacing; + uint64 FirstFrameLocation; + + uint32 RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault = false); + + KaxCluster * ParentCluster; +}; + +class MATROSKA_DLL_API KaxBlockDuration : public EbmlUInteger { + public: + KaxBlockDuration() {} + KaxBlockDuration(const KaxBlockDuration & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxBlockDuration);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxBlockDuration(*this);} +}; + +#if MATROSKA_VERSION >= 2 +class MATROSKA_DLL_API KaxBlockVirtual : public EbmlBinary { + public: + KaxBlockVirtual() :ParentCluster(NULL) {Data = DataBlock; Size = countof(DataBlock);} + KaxBlockVirtual(const KaxBlockVirtual & ElementToClone); + static EbmlElement & Create() {return *(new KaxBlockVirtual);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + bool ValidateSize() const {return true;} + + /*! + \note override this function to generate the Data/Size on the fly, unlike the usual binary elements + */ + uint64 UpdateSize(bool bSaveDefault = false, bool bForceRender = false); + + void SetParent(const KaxCluster & aParentCluster) {ParentCluster = &aParentCluster;} + + EbmlElement * Clone() const {return new KaxBlockVirtual(*this);} + + protected: + uint64 Timecode; // temporary timecode of the first frame if there are more than one + uint16 TrackNumber; + binary DataBlock[5]; + + const KaxCluster * ParentCluster; +}; + +class MATROSKA_DLL_API KaxBlockAdditional : public EbmlBinary { + public: + KaxBlockAdditional() {} + KaxBlockAdditional(const KaxBlockAdditional & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxBlockAdditional);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + bool ValidateSize() const {return true;} + + EbmlElement * Clone() const {return new KaxBlockAdditional(*this);} +}; + +class MATROSKA_DLL_API KaxBlockAdditions : public EbmlMaster { + public: + KaxBlockAdditions(); + KaxBlockAdditions(const KaxBlockAdditions & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxBlockAdditions);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxBlockAdditions(*this);} +}; + +class MATROSKA_DLL_API KaxBlockMore : public EbmlMaster { + public: + KaxBlockMore(); + KaxBlockMore(const KaxBlockMore & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxBlockMore);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxBlockMore(*this);} +}; + +class MATROSKA_DLL_API KaxBlockAddID : public EbmlUInteger { + public: + KaxBlockAddID() {} + KaxBlockAddID(const KaxBlockAddID & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxBlockAddID);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxBlockAddID(*this);} +}; +#endif // MATROSKA_VERSION + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_BLOCK_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxBlockData.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxBlockData.h new file mode 100644 index 0000000000..cb3232553e --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxBlockData.h @@ -0,0 +1,180 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxBlockData.h,v 1.10 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_BLOCK_ADDITIONAL_H +#define LIBMATROSKA_BLOCK_ADDITIONAL_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" +#include "ebml/EbmlUInteger.h" +#include "ebml/EbmlSInteger.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class KaxReferenceBlock; +class KaxBlockGroup; + +class MATROSKA_DLL_API KaxReferencePriority : public EbmlUInteger { + public: + KaxReferencePriority() :EbmlUInteger(0) {} + KaxReferencePriority(const KaxReferencePriority & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxReferencePriority);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxReferencePriority(*this);} +}; + +/*! + \brief element used for B frame-likes +*/ +class MATROSKA_DLL_API KaxReferenceBlock : public EbmlSInteger { + public: + KaxReferenceBlock() :RefdBlock(NULL), ParentBlock(NULL) {bTimecodeSet = false;} + KaxReferenceBlock(const KaxReferenceBlock & ElementToClone) :EbmlSInteger(ElementToClone), bTimecodeSet(ElementToClone.bTimecodeSet) {} + static EbmlElement & Create() {return *(new KaxReferenceBlock);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxReferenceBlock(*this);} + + /*! + \brief override this method to compute the timecode value + */ + virtual uint64 UpdateSize(bool bSaveDefault = false, bool bForceRender = false); + + const KaxBlockGroup & RefBlock() const; + void SetReferencedBlock(const KaxBlockGroup & aRefdBlock) {RefdBlock = &aRefdBlock; bValueIsSet = true;} + void SetParentBlock(const KaxBlockGroup & aParentBlock) {ParentBlock = &aParentBlock;} + + protected: + const KaxBlockGroup * RefdBlock; + const KaxBlockGroup * ParentBlock; + void SetReferencedTimecode(int64 refTimecode) {Value = refTimecode; bTimecodeSet = true; bValueIsSet = true;}; + bool bTimecodeSet; +}; + +#if MATROSKA_VERSION >= 2 +class MATROSKA_DLL_API KaxReferenceVirtual : public EbmlSInteger { + public: + KaxReferenceVirtual() {} + KaxReferenceVirtual(const KaxReferenceVirtual & ElementToClone) :EbmlSInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxReferenceVirtual);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxReferenceVirtual(*this);} +}; +#endif // MATROSKA_VERSION + +class MATROSKA_DLL_API KaxTimeSlice : public EbmlMaster { + public: + KaxTimeSlice(); + KaxTimeSlice(const KaxTimeSlice & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTimeSlice);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTimeSlice(*this);} +}; + +class MATROSKA_DLL_API KaxSlices : public EbmlMaster { + public: + KaxSlices(); + KaxSlices(const KaxSlices & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxSlices);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxSlices(*this);} +}; + +class MATROSKA_DLL_API KaxSliceLaceNumber : public EbmlUInteger { + public: + KaxSliceLaceNumber() :EbmlUInteger(0) {} + KaxSliceLaceNumber(const KaxSliceLaceNumber & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxSliceLaceNumber);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxSliceLaceNumber(*this);} +}; + +class MATROSKA_DLL_API KaxSliceFrameNumber : public EbmlUInteger { + public: + KaxSliceFrameNumber() :EbmlUInteger(0) {} + KaxSliceFrameNumber(const KaxSliceFrameNumber & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxSliceFrameNumber);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxSliceFrameNumber(*this);} +}; + +class MATROSKA_DLL_API KaxSliceBlockAddID : public EbmlUInteger { + public: + KaxSliceBlockAddID() :EbmlUInteger(0) {} + KaxSliceBlockAddID(const KaxSliceBlockAddID & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxSliceBlockAddID);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxSliceBlockAddID(*this);} +}; + +class MATROSKA_DLL_API KaxSliceDelay : public EbmlUInteger { + public: + KaxSliceDelay() :EbmlUInteger(0) {} + KaxSliceDelay(const KaxSliceDelay & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxSliceDelay);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxSliceDelay(*this);} +}; + +class MATROSKA_DLL_API KaxSliceDuration : public EbmlUInteger { + public: + KaxSliceDuration() {} + KaxSliceDuration(const KaxSliceDuration & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxSliceDuration);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxSliceDuration(*this);} +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_BLOCK_ADDITIONAL_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxChapters.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxChapters.h new file mode 100644 index 0000000000..3ff34b4ff7 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxChapters.h @@ -0,0 +1,306 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxChapters.h,v 1.9 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_CHAPTERS_H +#define LIBMATROSKA_CHAPTERS_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" +#include "ebml/EbmlUInteger.h" +#include "ebml/EbmlUnicodeString.h" +#include "ebml/EbmlString.h" +#include "ebml/EbmlBinary.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class MATROSKA_DLL_API KaxChapters : public EbmlMaster { + public: + KaxChapters(); + KaxChapters(const KaxChapters & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapters);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapters(*this);} +}; + +class MATROSKA_DLL_API KaxEditionEntry : public EbmlMaster { + public: + KaxEditionEntry(); + KaxEditionEntry(const KaxEditionEntry & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxEditionEntry);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxEditionEntry(*this);} +}; + +class MATROSKA_DLL_API KaxEditionUID : public EbmlUInteger { +public: + KaxEditionUID() {} + KaxEditionUID(const KaxEditionUID & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxEditionUID);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxEditionUID(*this);} +}; + +class MATROSKA_DLL_API KaxEditionFlagHidden : public EbmlUInteger { +public: + KaxEditionFlagHidden(): EbmlUInteger(0) {} + KaxEditionFlagHidden(const KaxEditionFlagHidden & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxEditionFlagHidden);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxEditionFlagHidden(*this);} +}; + +class MATROSKA_DLL_API KaxEditionFlagDefault : public EbmlUInteger { +public: + KaxEditionFlagDefault(): EbmlUInteger(0) {} + KaxEditionFlagDefault(const KaxEditionFlagDefault & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxEditionFlagDefault);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxEditionFlagDefault(*this);} +}; + +class MATROSKA_DLL_API KaxEditionProcessed : public EbmlUInteger { +public: + KaxEditionProcessed(): EbmlUInteger(0) {} + KaxEditionProcessed(const KaxEditionProcessed & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxEditionProcessed);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxEditionProcessed(*this);} +}; + +class MATROSKA_DLL_API KaxChapterProcessedPrivate : public EbmlBinary { +public: + KaxChapterProcessedPrivate() {} + KaxChapterProcessedPrivate(const KaxChapterProcessedPrivate & ElementToClone) :EbmlBinary(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterProcessedPrivate);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterProcessedPrivate(*this);} + bool ValidateSize() const {return true;} +}; + +class MATROSKA_DLL_API KaxChapterAtom : public EbmlMaster { +public: + KaxChapterAtom(); + KaxChapterAtom(const KaxChapterAtom & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterAtom);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterAtom(*this);} +}; + +class MATROSKA_DLL_API KaxChapterUID : public EbmlUInteger { +public: + KaxChapterUID() {} + KaxChapterUID(const KaxChapterUID & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterUID);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterUID(*this);} +}; + +class MATROSKA_DLL_API KaxChapterTimeStart : public EbmlUInteger { +public: + KaxChapterTimeStart() {} + KaxChapterTimeStart(const KaxChapterTimeStart & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterTimeStart);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterTimeStart(*this);} +}; + +class MATROSKA_DLL_API KaxChapterTimeEnd : public EbmlUInteger { +public: + KaxChapterTimeEnd() {} + KaxChapterTimeEnd(const KaxChapterTimeEnd & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterTimeEnd);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterTimeEnd(*this);} +}; + +class MATROSKA_DLL_API KaxChapterFlagHidden : public EbmlUInteger { +public: + KaxChapterFlagHidden(): EbmlUInteger(0) {} + KaxChapterFlagHidden(const KaxChapterFlagHidden & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterFlagHidden);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterFlagHidden(*this);} +}; + +class MATROSKA_DLL_API KaxChapterFlagEnabled : public EbmlUInteger { +public: + KaxChapterFlagEnabled(): EbmlUInteger(1) {} + KaxChapterFlagEnabled(const KaxChapterFlagEnabled & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterFlagEnabled);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterFlagEnabled(*this);} +}; + +class MATROSKA_DLL_API KaxChapterPhysicalEquiv : public EbmlUInteger { +public: + KaxChapterPhysicalEquiv(): EbmlUInteger() {} + KaxChapterPhysicalEquiv(const KaxChapterPhysicalEquiv & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterPhysicalEquiv);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterPhysicalEquiv(*this);} +}; + +class MATROSKA_DLL_API KaxChapterTrack : public EbmlMaster { +public: + KaxChapterTrack(); + KaxChapterTrack(const KaxChapterTrack & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterTrack);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterTrack(*this);} +}; + +class MATROSKA_DLL_API KaxChapterTrackNumber : public EbmlUInteger { +public: + KaxChapterTrackNumber() {} + KaxChapterTrackNumber(const KaxChapterTrackNumber & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterTrackNumber);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterTrackNumber(*this);} +}; + +class MATROSKA_DLL_API KaxChapterDisplay : public EbmlMaster { +public: + KaxChapterDisplay(); + KaxChapterDisplay(const KaxChapterDisplay & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterDisplay);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterDisplay(*this);} +}; + +class MATROSKA_DLL_API KaxChapterString : public EbmlUnicodeString { +public: + KaxChapterString() {} + KaxChapterString(const KaxChapterString & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterString);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterString(*this);} +}; + +class MATROSKA_DLL_API KaxChapterLanguage : public EbmlString { +public: + KaxChapterLanguage() :EbmlString("eng") {} + KaxChapterLanguage(const KaxChapterLanguage & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterLanguage);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterLanguage(*this);} +}; + +class MATROSKA_DLL_API KaxChapterCountry : public EbmlString { +public: + KaxChapterCountry() :EbmlString() {} + KaxChapterCountry(const KaxChapterCountry & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterCountry);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterCountry(*this);} +}; + +class MATROSKA_DLL_API KaxChapterProcess : public EbmlMaster { +public: + KaxChapterProcess(); + KaxChapterProcess(const KaxChapterProcess & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterProcess);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterProcess(*this);} +}; + +class MATROSKA_DLL_API KaxChapterProcessTime : public EbmlUInteger { +public: + KaxChapterProcessTime() {} + KaxChapterProcessTime(const KaxChapterProcessTime & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterProcessTime);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterProcessTime(*this);} +}; + +class MATROSKA_DLL_API KaxChapterProcessCommand : public EbmlBinary { +public: + KaxChapterProcessCommand() {} + KaxChapterProcessCommand(const KaxChapterProcessCommand & ElementToClone) :EbmlBinary(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxChapterProcessCommand);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxChapterProcessCommand(*this);} + bool ValidateSize() const {return true;} +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_CHAPTERS_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxCluster.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxCluster.h new file mode 100644 index 0000000000..2b9e38d5e8 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxCluster.h @@ -0,0 +1,154 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxCluster.h,v 1.10 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme + \author Julien Coloos + +*/ +#ifndef LIBMATROSKA_CLUSTER_H +#define LIBMATROSKA_CLUSTER_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" +#include "matroska/KaxTracks.h" +#include "matroska/KaxBlock.h" +#include "matroska/KaxCues.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class KaxSegment; + +class MATROSKA_DLL_API KaxCluster : public EbmlMaster { + public: + KaxCluster(); + KaxCluster(const KaxCluster & ElementToClone); + static EbmlElement & Create() {return *(new KaxCluster);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCluster(*this);} + + /*! + \brief Addition of a frame without references + + \param the timecode is expressed in nanoseconds, relative to the beggining of the Segment + */ + bool AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, LacingType lacing = LACING_AUTO); + /*! + \brief Addition of a frame with a backward reference (P frame) + \param the timecode is expressed in nanoseconds, relative to the beggining of the Segment + + */ + bool AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, const KaxBlockGroup & PastBlock, LacingType lacing = LACING_AUTO); + + /*! + \brief Addition of a frame with a backward+forward reference (B frame) + \param the timecode is expressed in nanoseconds, relative to the beggining of the Segment + + */ + bool AddFrame(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, const KaxBlockGroup & PastBlock, const KaxBlockGroup & ForwBlock, LacingType lacing = LACING_AUTO); + + /*! + \brief Render the data to the stream and retrieve the position of BlockGroups for later cue entries + */ + uint32 Render(IOCallback & output, KaxCues & CueToUpdate, bool bSaveDefault = false); + + /*! + \return the global timecode of this Cluster + */ + uint64 GlobalTimecode() const; + + KaxBlockGroup & GetNewBlock(); + + /*! + \brief release all the frames of all Blocks + \note this is a convenience to be able to keep Clusters+Blocks in memory (for future reference) withouht being a memory hog + */ + void ReleaseFrames(); + + /*! + \brief return the position offset compared to the beggining of the Segment + */ + uint64 GetPosition() const; + + void SetParent(const KaxSegment & aParentSegment) {ParentSegment = &aParentSegment;} + + void SetPreviousTimecode(uint64 aPreviousTimecode, int64 aTimecodeScale) { + bPreviousTimecodeIsSet = true; + PreviousTimecode = aPreviousTimecode; + SetGlobalTimecodeScale(aTimecodeScale); + } + + /*! + \note dirty hack to get the mandatory data back after reading + \todo there should be a better way to get mandatory data + */ + void InitTimecode(uint64 aTimecode, int64 aTimecodeScale) { + SetGlobalTimecodeScale(aTimecodeScale); + MinTimecode = MaxTimecode = PreviousTimecode = aTimecode * TimecodeScale; + bFirstFrameInside = bPreviousTimecodeIsSet = true; + } + + int16 GetBlockLocalTimecode(uint64 GlobalTimecode) const; + + uint64 GetBlockGlobalTimecode(int16 LocalTimecode); + + void SetGlobalTimecodeScale(uint64 aGlobalTimecodeScale) { + TimecodeScale = aGlobalTimecodeScale; + bTimecodeScaleIsSet = true; + } + uint64 GlobalTimecodeScale() const { + assert(bTimecodeScaleIsSet); + return TimecodeScale; + } + + protected: + KaxBlockGroup * currentNewBlock; + const KaxSegment * ParentSegment; + + uint64 MinTimecode, MaxTimecode, PreviousTimecode; + int64 TimecodeScale; + + bool bFirstFrameInside; // used to speed research + bool bPreviousTimecodeIsSet; + bool bTimecodeScaleIsSet; + + /*! + \note method used internally + */ + bool AddFrameInternal(const KaxTrackEntry & track, uint64 timecode, DataBuffer & buffer, KaxBlockGroup * & MyNewBlock, const KaxBlockGroup * PastBlock, const KaxBlockGroup * ForwBlock, LacingType lacing); + +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_CLUSTER_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxClusterData.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxClusterData.h new file mode 100644 index 0000000000..e9bf40ac5f --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxClusterData.h @@ -0,0 +1,80 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxClusterData.h,v 1.9 2004/04/21 19:50:10 mosu Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_CLUSTER_DATA_H +#define LIBMATROSKA_CLUSTER_DATA_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlUInteger.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class MATROSKA_DLL_API KaxClusterTimecode : public EbmlUInteger { + public: + KaxClusterTimecode() {} + KaxClusterTimecode(const KaxClusterTimecode & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxClusterTimecode);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxClusterTimecode(*this);} +}; + +class MATROSKA_DLL_API KaxClusterPosition : public EbmlUInteger { + public: + KaxClusterPosition() {} + KaxClusterPosition(const KaxClusterPosition & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxClusterPosition);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxClusterPosition(*this);} +}; + +class MATROSKA_DLL_API KaxClusterPrevSize : public EbmlUInteger { + public: + KaxClusterPrevSize() {} + KaxClusterPrevSize(const KaxClusterPrevSize & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxClusterPrevSize);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxClusterPrevSize(*this);} +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_CLUSTER_DATA_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxConfig.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxConfig.h new file mode 100644 index 0000000000..5b65cd6482 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxConfig.h @@ -0,0 +1,70 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxConfig.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme + \author Moritz Bunkus +*/ +#ifndef LIBMATROSKA_CONFIG_H +#define LIBMATROSKA_CONFIG_H + +#define LIBMATROSKA_NAMESPACE libmatroska + +#if defined(NO_NAMESPACE) // for older GCC +# define START_LIBMATROSKA_NAMESPACE +# define END_LIBMATROSKA_NAMESPACE +#else // NO_NAMESPACE +# define START_LIBMATROSKA_NAMESPACE namespace LIBMATROSKA_NAMESPACE { +# define END_LIBMATROSKA_NAMESPACE }; +#endif // NO_NAMESPACE + +// There are special implementations for certain platforms. For example on Windows +// we use the Win32 file API. here we set the appropriate macros. +#if defined(_WIN32)||defined(WIN32) + +# if defined(MATROSKA_DLL) +# if defined(MATROSKA_DLL_EXPORT) +# define MATROSKA_DLL_API __declspec(dllexport) +# else // MATROSKA_DLL_EXPORT +# define MATROSKA_DLL_API __declspec(dllimport) +# endif // MATROSKA_DLL_EXPORT +# else // MATROSKA_DLL +# define MATROSKA_DLL_API +# endif // MATROSKA_DLL + +#else +# define MATROSKA_DLL_API +#endif + +#if !defined(MATROSKA_VERSION) +#define MATROSKA_VERSION 1 +#endif // MATROSKA_VERSION + + +#endif // LIBMATROSKA_CONFIG_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxContentEncoding.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxContentEncoding.h new file mode 100644 index 0000000000..d1b241c575 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxContentEncoding.h @@ -0,0 +1,250 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxContentEncoding.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $ + \author Moritz Bunkus +*/ +#ifndef LIBMATROSKA_CONTENT_ENCODING_H +#define LIBMATROSKA_CONTENT_ENCODING_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" +#include "ebml/EbmlUInteger.h" +#include "ebml/EbmlBinary.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class MATROSKA_DLL_API KaxContentEncodings: public EbmlMaster { +public: + static const EbmlCallbacks ClassInfos; + + KaxContentEncodings(); + KaxContentEncodings(const KaxContentEncodings &ElementToClone): + EbmlMaster(ElementToClone) {} + static EbmlElement &Create() { return *(new KaxContentEncodings); } + const EbmlCallbacks &Generic() const { return ClassInfos; } + operator const EbmlId &() const { return ClassInfos.GlobalId; } + EbmlElement *Clone() const { return new KaxContentEncodings(*this); } +}; + +class MATROSKA_DLL_API KaxContentEncoding: public EbmlMaster { +public: + static const EbmlCallbacks ClassInfos; + + KaxContentEncoding(); + KaxContentEncoding(const KaxContentEncoding &ElementToClone): + EbmlMaster(ElementToClone) {} + static EbmlElement &Create() { return *(new KaxContentEncoding); } + const EbmlCallbacks &Generic() const { return ClassInfos; } + operator const EbmlId &() const { return ClassInfos.GlobalId; } + EbmlElement *Clone() const { return new KaxContentEncoding(*this); } +}; + +class MATROSKA_DLL_API KaxContentEncodingOrder: public EbmlUInteger { +public: + static const EbmlCallbacks ClassInfos; + + KaxContentEncodingOrder(): EbmlUInteger(0) {} + KaxContentEncodingOrder(const KaxContentEncodingOrder &ElementToClone): + EbmlUInteger(ElementToClone) {} + static EbmlElement &Create() { return *(new KaxContentEncodingOrder); } + const EbmlCallbacks &Generic() const { return ClassInfos; } + operator const EbmlId &() const { return ClassInfos.GlobalId; } + EbmlElement *Clone() const { return new KaxContentEncodingOrder(*this); } +}; + +class MATROSKA_DLL_API KaxContentEncodingScope: public EbmlUInteger { +public: + static const EbmlCallbacks ClassInfos; + + KaxContentEncodingScope(): EbmlUInteger(1) {} + KaxContentEncodingScope(const KaxContentEncodingScope &ElementToClone): + EbmlUInteger(ElementToClone) {} + static EbmlElement &Create() { return *(new KaxContentEncodingScope); } + const EbmlCallbacks &Generic() const { return ClassInfos; } + operator const EbmlId &() const { return ClassInfos.GlobalId; } + EbmlElement *Clone() const { return new KaxContentEncodingScope(*this); } +}; + +class MATROSKA_DLL_API KaxContentEncodingType: public EbmlUInteger { +public: + static const EbmlCallbacks ClassInfos; + + KaxContentEncodingType(): EbmlUInteger(0) {} + KaxContentEncodingType(const KaxContentEncodingType &ElementToClone): + EbmlUInteger(ElementToClone) {} + static EbmlElement &Create() { return *(new KaxContentEncodingType); } + const EbmlCallbacks &Generic() const { return ClassInfos; } + operator const EbmlId &() const { return ClassInfos.GlobalId; } + EbmlElement *Clone() const { return new KaxContentEncodingType(*this); } +}; + +class MATROSKA_DLL_API KaxContentCompression: public EbmlMaster { +public: + static const EbmlCallbacks ClassInfos; + + KaxContentCompression(); + KaxContentCompression(const KaxContentCompression &ElementToClone): + EbmlMaster(ElementToClone) {} + static EbmlElement &Create() { return *(new KaxContentCompression); } + const EbmlCallbacks &Generic() const { return ClassInfos; } + operator const EbmlId &() const { return ClassInfos.GlobalId; } + EbmlElement *Clone() const { return new KaxContentCompression(*this); } +}; + +class MATROSKA_DLL_API KaxContentCompAlgo: public EbmlUInteger { +public: + static const EbmlCallbacks ClassInfos; + + KaxContentCompAlgo(): EbmlUInteger(0) {} + KaxContentCompAlgo(const KaxContentCompAlgo &ElementToClone): + EbmlUInteger(ElementToClone) {} + static EbmlElement &Create() { return *(new KaxContentCompAlgo); } + const EbmlCallbacks &Generic() const { return ClassInfos; } + operator const EbmlId &() const { return ClassInfos.GlobalId; } + EbmlElement *Clone() const { return new KaxContentCompAlgo(*this); } +}; + +class MATROSKA_DLL_API KaxContentCompSettings: public EbmlBinary { +public: + static const EbmlCallbacks ClassInfos; + + KaxContentCompSettings() {} + KaxContentCompSettings(const KaxContentCompSettings &ElementToClone): + EbmlBinary(ElementToClone) {} + static EbmlElement &Create() { return *(new KaxContentCompSettings); } + const EbmlCallbacks &Generic() const { return ClassInfos; } + operator const EbmlId &() const { return ClassInfos.GlobalId; } + EbmlElement *Clone() const { + return new KaxContentCompSettings(*this); + } + bool ValidateSize(void) const { return true; } +}; + +class MATROSKA_DLL_API KaxContentEncryption: public EbmlMaster { +public: + static const EbmlCallbacks ClassInfos; + + KaxContentEncryption(); + KaxContentEncryption(const KaxContentEncryption &ElementToClone): + EbmlMaster(ElementToClone) {} + static EbmlElement &Create() { return *(new KaxContentEncryption); } + const EbmlCallbacks &Generic() const { return ClassInfos; } + operator const EbmlId &() const { return ClassInfos.GlobalId; } + EbmlElement *Clone() const { return new KaxContentEncryption(*this); } +}; + +class MATROSKA_DLL_API KaxContentEncAlgo: public EbmlUInteger { +public: + static const EbmlCallbacks ClassInfos; + + KaxContentEncAlgo(): EbmlUInteger(0) {} + KaxContentEncAlgo(const KaxContentEncAlgo &ElementToClone): + EbmlUInteger(ElementToClone) {} + static EbmlElement &Create() { return *(new KaxContentEncAlgo); } + const EbmlCallbacks &Generic() const { return ClassInfos; } + operator const EbmlId &() const { return ClassInfos.GlobalId; } + EbmlElement *Clone() const { return new KaxContentEncAlgo(*this); } +}; + +class MATROSKA_DLL_API KaxContentEncKeyID: public EbmlBinary { +public: + static const EbmlCallbacks ClassInfos; + + KaxContentEncKeyID() {} + KaxContentEncKeyID(const KaxContentEncKeyID &ElementToClone): + EbmlBinary(ElementToClone) {} + static EbmlElement &Create() { return *(new KaxContentEncKeyID); } + const EbmlCallbacks &Generic() const { return ClassInfos; } + operator const EbmlId &() const { return ClassInfos.GlobalId; } + EbmlElement *Clone() const { return new KaxContentEncKeyID(*this); } + bool ValidateSize(void) const { return true; } +}; + +class MATROSKA_DLL_API KaxContentSignature: public EbmlBinary { +public: + static const EbmlCallbacks ClassInfos; + + KaxContentSignature() {} + KaxContentSignature(const KaxContentSignature &ElementToClone): + EbmlBinary(ElementToClone) {} + static EbmlElement &Create() { return *(new KaxContentSignature); } + const EbmlCallbacks &Generic() const { return ClassInfos; } + operator const EbmlId &() const { return ClassInfos.GlobalId; } + EbmlElement *Clone() const { return new KaxContentSignature(*this); } + bool ValidateSize(void) const { return true; } +}; + +class MATROSKA_DLL_API KaxContentSigKeyID: public EbmlBinary { +public: + static const EbmlCallbacks ClassInfos; + + KaxContentSigKeyID() {} + KaxContentSigKeyID(const KaxContentSigKeyID &ElementToClone): + EbmlBinary(ElementToClone) {} + static EbmlElement &Create() { return *(new KaxContentSigKeyID); } + const EbmlCallbacks &Generic() const { return ClassInfos; } + operator const EbmlId &() const { return ClassInfos.GlobalId; } + EbmlElement *Clone() const { return new KaxContentSigKeyID(*this); } + bool ValidateSize(void) const { return true; } +}; + +class MATROSKA_DLL_API KaxContentSigAlgo: public EbmlUInteger { +public: + static const EbmlCallbacks ClassInfos; + + KaxContentSigAlgo() {} + KaxContentSigAlgo(const KaxContentSigAlgo &ElementToClone): + EbmlUInteger(ElementToClone) {} + static EbmlElement &Create() { return *(new KaxContentSigAlgo); } + const EbmlCallbacks &Generic() const { return ClassInfos; } + operator const EbmlId &() const { return ClassInfos.GlobalId; } + EbmlElement *Clone() const { return new KaxContentSigAlgo(*this); } +}; + +class MATROSKA_DLL_API KaxContentSigHashAlgo: public EbmlUInteger { +public: + static const EbmlCallbacks ClassInfos; + + KaxContentSigHashAlgo() {} + KaxContentSigHashAlgo(const KaxContentSigHashAlgo &ElementToClone): + EbmlUInteger(ElementToClone) {} + static EbmlElement &Create() { return *(new KaxContentSigHashAlgo); } + const EbmlCallbacks &Generic() const { return ClassInfos; } + operator const EbmlId &() const { return ClassInfos.GlobalId; } + EbmlElement *Clone() const { return new KaxContentSigHashAlgo(*this); } +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_CONTENT_ENCODING_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxContexts.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxContexts.h new file mode 100644 index 0000000000..882932bc94 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxContexts.h @@ -0,0 +1,86 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxContexts.h,v 1.6 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_CONTEXTS_H +#define LIBMATROSKA_CONTEXTS_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlElement.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +extern const EbmlSemanticContext MATROSKA_DLL_API KaxSegment_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxAttachments_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxAttached_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxFileDescription_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxFileName_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxMimeType_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxFileData_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxChapters_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxCluster_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxTags_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxTag_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxBlockGroup_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxReferencePriority_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxReferenceBlock_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxReferenceVirtual_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxCues_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxInfo_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxSeekHead_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxTracks_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackEntry_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackNumber_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackType_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackFlagEnabled_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackFlagDefault_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackFlagLacing_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackName_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackLanguage_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxCodecID_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxCodecPrivate_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxCodecName_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxCodecSettings_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxCodecInfoURL_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxCodecDownloadURL_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxCodecDecodeAll_Context; +extern const EbmlSemanticContext MATROSKA_DLL_API KaxTrackOverlay_Context; + +extern const EbmlSemanticContext & MATROSKA_DLL_API GetKaxGlobal_Context(); +extern const EbmlSemanticContext & MATROSKA_DLL_API GetKaxTagsGlobal_Context(); + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_CONTEXTS_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxCues.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxCues.h new file mode 100644 index 0000000000..b657fe27f5 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxCues.h @@ -0,0 +1,96 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxCues.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_CUES_H +#define LIBMATROSKA_CUES_H + +#include + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" +#include "matroska/KaxBlock.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class KaxCuePoint; + +class MATROSKA_DLL_API KaxCues : public EbmlMaster { + public: + KaxCues(); + KaxCues(const KaxCues & ElementToClone) :EbmlMaster(ElementToClone) {} + ~KaxCues(); + static EbmlElement & Create() {return *(new KaxCues);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCues(*this);} + + bool AddBlockGroup(const KaxBlockGroup & BlockReference); + + /*! + \brief Indicate that the position for this Block is set + */ + void PositionSet(const KaxBlockGroup & BlockReference); + + /*! + \brief override to sort by timecode/track + */ + uint32 Render(IOCallback & output, bool bSaveDefault = false) { + Sort(); + return EbmlMaster::Render(output, bSaveDefault); + } + + uint64 GetTimecodePosition(uint64 aTimecode) const; + const KaxCuePoint * GetTimecodePoint(uint64 aTimecode) const; + + void SetGlobalTimecodeScale(uint64 aGlobalTimecodeScale) { + mGlobalTimecodeScale = aGlobalTimecodeScale; + bGlobalTimecodeScaleIsSet = true; + } + uint64 GlobalTimecodeScale() const { + assert(bGlobalTimecodeScaleIsSet); + return mGlobalTimecodeScale; + } + + protected: + std::vector myTempReferences; + bool bGlobalTimecodeScaleIsSet; + uint64 mGlobalTimecodeScale; +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_CUES_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxCuesData.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxCuesData.h new file mode 100644 index 0000000000..5169f16b9f --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxCuesData.h @@ -0,0 +1,194 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxCuesData.h,v 1.8 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_CUES_DATA_H +#define LIBMATROSKA_CUES_DATA_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlUInteger.h" +#include "ebml/EbmlMaster.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class KaxBlockGroup; +class KaxCueTrackPositions; + +class MATROSKA_DLL_API KaxCuePoint : public EbmlMaster { + public: + KaxCuePoint(); + KaxCuePoint(const KaxCuePoint & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCuePoint);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCuePoint(*this);} + void PositionSet(const KaxBlockGroup & BlockReference, uint64 GlobalTimecodeScale); + + bool operator<(const EbmlElement & EltB) const; + + const KaxCueTrackPositions * GetSeekPosition() const; + bool Timecode(uint64 & aTimecode, uint64 GlobalTimecodeScale) const; +}; + +class MATROSKA_DLL_API KaxCueTime : public EbmlUInteger { + public: + KaxCueTime() {} + KaxCueTime(const KaxCueTime & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCueTime);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCueTime(*this);} +}; + +class MATROSKA_DLL_API KaxCueTrackPositions : public EbmlMaster { + public: + KaxCueTrackPositions(); + KaxCueTrackPositions(const KaxCueTrackPositions & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCueTrackPositions);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCueTrackPositions(*this);} + + uint64 ClusterPosition() const; + uint16 TrackNumber() const; +}; + +class MATROSKA_DLL_API KaxCueTrack : public EbmlUInteger { + public: + KaxCueTrack() {} + KaxCueTrack(const KaxCueTrack & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCueTrack);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCueTrack(*this);} +}; + +class MATROSKA_DLL_API KaxCueClusterPosition : public EbmlUInteger { + public: + KaxCueClusterPosition() {} + KaxCueClusterPosition(const KaxCueClusterPosition & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCueClusterPosition);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCueClusterPosition(*this);} +}; + +class MATROSKA_DLL_API KaxCueBlockNumber : public EbmlUInteger { + public: + KaxCueBlockNumber() :EbmlUInteger(1) {} + KaxCueBlockNumber(const KaxCueBlockNumber & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCueBlockNumber);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCueBlockNumber(*this);} +}; + +#if MATROSKA_VERSION >= 2 +class MATROSKA_DLL_API KaxCueCodecState : public EbmlUInteger { + public: + KaxCueCodecState() :EbmlUInteger(0) {} + KaxCueCodecState(const KaxCueCodecState & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCueCodecState);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCueCodecState(*this);} +}; + +class MATROSKA_DLL_API KaxCueReference : public EbmlMaster { + public: + KaxCueReference(); + KaxCueReference(const KaxCueReference & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCueReference);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCueReference(*this);} + + void AddReference(const KaxBlockGroup & BlockReferenced, uint64 GlobalTimecodeScale); +}; + +class MATROSKA_DLL_API KaxCueRefTime : public EbmlUInteger { + public: + KaxCueRefTime() {} + KaxCueRefTime(const KaxCueRefTime & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCueRefTime);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCueRefTime(*this);} +}; + +class MATROSKA_DLL_API KaxCueRefCluster : public EbmlUInteger { + public: + KaxCueRefCluster() {} + KaxCueRefCluster(const KaxCueRefCluster & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCueRefCluster);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCueRefCluster(*this);} +}; + +class MATROSKA_DLL_API KaxCueRefNumber : public EbmlUInteger { + public: + KaxCueRefNumber() :EbmlUInteger(1) {} + KaxCueRefNumber(const KaxCueRefNumber & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCueRefNumber);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCueRefNumber(*this);} +}; + +class MATROSKA_DLL_API KaxCueRefCodecState : public EbmlUInteger { + public: + KaxCueRefCodecState() :EbmlUInteger(0) {} + KaxCueRefCodecState(const KaxCueRefCodecState & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCueRefCodecState);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCueRefCodecState(*this);} +}; +#endif // MATROSKA_VERSION + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_CUES_DATA_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxInfo.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxInfo.h new file mode 100644 index 0000000000..5ba569b12f --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxInfo.h @@ -0,0 +1,81 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxInfo.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_INFO_H +#define LIBMATROSKA_INFO_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" +#include "ebml/EbmlUnicodeString.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class MATROSKA_DLL_API KaxInfo : public EbmlMaster { + public: + KaxInfo(); + KaxInfo(const KaxInfo & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxInfo);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxInfo(*this);} +}; + +class MATROSKA_DLL_API KaxMuxingApp : public EbmlUnicodeString { + public: + KaxMuxingApp() {} + KaxMuxingApp(const KaxMuxingApp & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxMuxingApp);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxMuxingApp(*this);} +}; + +class MATROSKA_DLL_API KaxWritingApp : public EbmlUnicodeString { + public: + KaxWritingApp() {} + KaxWritingApp(const KaxWritingApp & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxWritingApp);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxWritingApp(*this);} +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_INFO_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxInfoData.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxInfoData.h new file mode 100644 index 0000000000..07af462952 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxInfoData.h @@ -0,0 +1,166 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxInfoData.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme + \author John Cannon + \author Moritz Bunkus +*/ +#ifndef LIBMATROSKA_INFO_DATA_H +#define LIBMATROSKA_INFO_DATA_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlUInteger.h" +#include "ebml/EbmlFloat.h" +#include "ebml/EbmlUnicodeString.h" +#include "ebml/EbmlBinary.h" +#include "ebml/EbmlDate.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class MATROSKA_DLL_API KaxSegmentUID : public EbmlBinary { + public: + KaxSegmentUID() {} + KaxSegmentUID(const KaxSegmentUID & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxSegmentUID);} + bool ValidateSize() const { return (Size == 16);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxSegmentUID(*this);} +}; + +class MATROSKA_DLL_API KaxSegmentFilename : public EbmlUnicodeString { + public: + KaxSegmentFilename() {} + KaxSegmentFilename(const KaxSegmentFilename & ElementToClone) :EbmlUnicodeString(ElementToClone){} + static EbmlElement & Create() {return *(new KaxSegmentFilename);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxSegmentFilename(*this);} +}; + +class MATROSKA_DLL_API KaxPrevUID : public EbmlBinary { + public: + KaxPrevUID() {} + KaxPrevUID(const KaxPrevUID & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxPrevUID);} + bool ValidateSize() const { return (Size == 16);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxPrevUID(*this);} +}; + +class MATROSKA_DLL_API KaxPrevFilename : public EbmlUnicodeString { + public: + KaxPrevFilename() :EbmlUnicodeString() {} + KaxPrevFilename(const KaxPrevFilename & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxPrevFilename);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxPrevFilename(*this);} +}; + +class MATROSKA_DLL_API KaxNextUID : public EbmlBinary { + public: + KaxNextUID() {} + KaxNextUID(const KaxNextUID & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxNextUID);} + bool ValidateSize() const { return (Size == 16);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxNextUID(*this);} +}; + +class MATROSKA_DLL_API KaxNextFilename : public EbmlUnicodeString { + public: + KaxNextFilename() {} + KaxNextFilename(const KaxNextFilename & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxNextFilename);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxNextFilename(*this);} +}; + +class MATROSKA_DLL_API KaxTimecodeScale : public EbmlUInteger { + public: + KaxTimecodeScale() :EbmlUInteger(1000000) {} + KaxTimecodeScale(const KaxTimecodeScale & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTimecodeScale);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTimecodeScale(*this);} +}; + +class MATROSKA_DLL_API KaxDuration : public EbmlFloat { + public: + KaxDuration(): EbmlFloat(FLOAT_64) {} + KaxDuration(const KaxDuration & ElementToClone) :EbmlFloat(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxDuration);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxDuration(*this);} +}; + +class MATROSKA_DLL_API KaxDateUTC : public EbmlDate { + public: + KaxDateUTC() {} + KaxDateUTC(const KaxDateUTC & ElementToClone) :EbmlDate(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxDateUTC);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxDateUTC(*this);} +}; + +class MATROSKA_DLL_API KaxTitle : public EbmlUnicodeString { + public: + KaxTitle() {} + KaxTitle(const KaxTitle & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTitle);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTitle(*this);} +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_INFO_DATA_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxSeekHead.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxSeekHead.h new file mode 100644 index 0000000000..1b269fc254 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxSeekHead.h @@ -0,0 +1,110 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxSeekHead.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_SEEK_HEAD_H +#define LIBMATROSKA_SEEK_HEAD_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" +#include "ebml/EbmlBinary.h" +#include "ebml/EbmlUInteger.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class KaxSegment; +class KaxSeek; + +class MATROSKA_DLL_API KaxSeekHead : public EbmlMaster { + public: + KaxSeekHead(); + KaxSeekHead(const KaxSeekHead & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxSeekHead);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxSeekHead(*this);} + + /*! + \brief add an element to index in the Meta Seek data + \note the element should already be written in the file + */ + void IndexThis(const EbmlElement & aElt, const KaxSegment & ParentSegment); + + KaxSeek * FindFirstOf(const EbmlCallbacks & Callbacks) const; + KaxSeek * FindNextOf(const KaxSeek &aPrev) const; +}; + +class MATROSKA_DLL_API KaxSeek : public EbmlMaster { + public: + KaxSeek(); + KaxSeek(const KaxSeek & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxSeek);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxSeek(*this);} + + int64 Location() const; + bool IsEbmlId(const EbmlId & aId) const; + bool IsEbmlId(const KaxSeek & aPoint) const; +}; + +class MATROSKA_DLL_API KaxSeekID : public EbmlBinary { + public: + KaxSeekID() {} + KaxSeekID(const KaxSeekID & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxSeekID);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + bool ValidateSize() const {return Size <= 4;} + EbmlElement * Clone() const {return new KaxSeekID(*this);} +}; + +class MATROSKA_DLL_API KaxSeekPosition : public EbmlUInteger { + public: + KaxSeekPosition() {} + KaxSeekPosition(const KaxSeekPosition & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxSeekPosition);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxSeekPosition(*this);} +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_SEEK_HEAD_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxSegment.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxSegment.h new file mode 100644 index 0000000000..50fc6e0288 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxSegment.h @@ -0,0 +1,69 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxSegment.h,v 1.8 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_SEGMENT_H +#define LIBMATROSKA_SEGMENT_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class MATROSKA_DLL_API KaxSegment : public EbmlMaster { + public: + KaxSegment(); + KaxSegment(const KaxSegment & ElementToClone); + static EbmlElement & Create() {return *(new KaxSegment);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxSegment(*this);} + + /*! + \brief give the position of the element in the segment + */ + uint64 GetRelativePosition(const EbmlElement & Elt) const; + uint64 GetRelativePosition(uint64 aGlobalPosition) const; + + /*! + \brief give the position of the element in the file + */ + uint64 GetGlobalPosition(uint64 aRelativePosition) const; +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_SEGMENT_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTag.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTag.h new file mode 100644 index 0000000000..9f47fe01ca --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTag.h @@ -0,0 +1,699 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxTag.h,v 1.9 2004/04/14 23:26:17 robux4 Exp $ + \author Jory Stone + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_TAG_H +#define LIBMATROSKA_TAG_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" +#include "ebml/EbmlFloat.h" +#include "ebml/EbmlSInteger.h" +#include "ebml/EbmlUInteger.h" +#include "ebml/EbmlString.h" +#include "ebml/EbmlUnicodeString.h" +#include "ebml/EbmlBinary.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class MATROSKA_DLL_API KaxTag : public EbmlMaster { + public: + KaxTag(); + KaxTag(const KaxTag & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTag);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTag(*this);} +}; + +class MATROSKA_DLL_API KaxTagTargets : public EbmlMaster { + public: + KaxTagTargets(); + KaxTagTargets(const KaxTagTargets & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagTargets);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagTargets(*this);} +}; + +class MATROSKA_DLL_API KaxTagGeneral : public EbmlMaster { + public: + KaxTagGeneral(); + KaxTagGeneral(const KaxTagGeneral & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagGeneral);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagGeneral(*this);} +}; + +class MATROSKA_DLL_API KaxTagGenres : public EbmlMaster { + public: + KaxTagGenres(); + KaxTagGenres(const KaxTagGenres & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagGenres);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagGenres(*this);} +}; + +class MATROSKA_DLL_API KaxTagAudioSpecific : public EbmlMaster { + public: + KaxTagAudioSpecific(); + KaxTagAudioSpecific(const KaxTagAudioSpecific & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagAudioSpecific);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagAudioSpecific(*this);} +}; + +class MATROSKA_DLL_API KaxTagImageSpecific : public EbmlMaster { + public: + KaxTagImageSpecific(); + KaxTagImageSpecific(const KaxTagImageSpecific & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagImageSpecific);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagImageSpecific(*this);} +}; + +class MATROSKA_DLL_API KaxTagTargetTypeValue : public EbmlUInteger { + public: + KaxTagTargetTypeValue() :EbmlUInteger(50) {} + KaxTagTargetTypeValue(const KaxTagTargetTypeValue & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagTargetTypeValue);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagTargetTypeValue(*this);} +}; + +class MATROSKA_DLL_API KaxTagTargetType : public EbmlString { + public: + KaxTagTargetType() {} + KaxTagTargetType(const KaxTagTargetType & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagTargetType);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagTargetType(*this);} +}; + +class MATROSKA_DLL_API KaxTagTrackUID : public EbmlUInteger { + public: + KaxTagTrackUID() :EbmlUInteger(0) {} + KaxTagTrackUID(const KaxTagTrackUID & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagTrackUID);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagTrackUID(*this);} +}; + +class MATROSKA_DLL_API KaxTagEditionUID : public EbmlUInteger { + public: + KaxTagEditionUID() :EbmlUInteger(0) {} + KaxTagEditionUID(const KaxTagEditionUID & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagEditionUID);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagEditionUID(*this);} +}; + +class MATROSKA_DLL_API KaxTagChapterUID : public EbmlUInteger { + public: + KaxTagChapterUID() :EbmlUInteger(0) {} + KaxTagChapterUID(const KaxTagChapterUID & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagChapterUID);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagChapterUID(*this);} +}; + +class MATROSKA_DLL_API KaxTagAttachmentUID : public EbmlUInteger { + public: + KaxTagAttachmentUID() :EbmlUInteger(0) {} + KaxTagAttachmentUID(const KaxTagAttachmentUID & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagAttachmentUID);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagAttachmentUID(*this);} +}; + +class MATROSKA_DLL_API KaxTagArchivalLocation : public EbmlUnicodeString { + public: + KaxTagArchivalLocation() {} + KaxTagArchivalLocation(const KaxTagArchivalLocation & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagArchivalLocation);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagArchivalLocation(*this);} +}; + +class MATROSKA_DLL_API KaxTagAudioEncryption : public EbmlBinary { + public: + KaxTagAudioEncryption() {} + KaxTagAudioEncryption(const KaxTagAudioEncryption & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxTagAudioEncryption);} + bool ValidateSize() const {return true;} // we don't mind about what's inside + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagAudioEncryption(*this);} +}; + +class MATROSKA_DLL_API KaxTagAudioGain : public EbmlFloat { + public: + KaxTagAudioGain() {} + KaxTagAudioGain(const KaxTagAudioGain & ElementToClone) :EbmlFloat(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagAudioGain);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagAudioGain(*this);} +}; + +class MATROSKA_DLL_API KaxTagAudioGenre : public EbmlString { + public: + KaxTagAudioGenre() {} + KaxTagAudioGenre(const KaxTagAudioGenre & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagAudioGenre);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagAudioGenre(*this);} +}; + +class MATROSKA_DLL_API KaxTagAudioPeak : public EbmlFloat { + public: + KaxTagAudioPeak() {} + KaxTagAudioPeak(const KaxTagAudioPeak & ElementToClone) :EbmlFloat(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagAudioPeak);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagAudioPeak(*this);} +}; + +class MATROSKA_DLL_API KaxTagBibliography : public EbmlUnicodeString { + public: + KaxTagBibliography() {} + KaxTagBibliography(const KaxTagBibliography & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagBibliography);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagBibliography(*this);} +}; + +class MATROSKA_DLL_API KaxTagBPM : public EbmlFloat { + public: + KaxTagBPM() {} + KaxTagBPM(const KaxTagBPM & ElementToClone) :EbmlFloat(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagBPM);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagBPM(*this);} +}; + +class MATROSKA_DLL_API KaxTagCaptureDPI : public EbmlUInteger { + public: + KaxTagCaptureDPI() {} + KaxTagCaptureDPI(const KaxTagCaptureDPI & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagCaptureDPI);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagCaptureDPI(*this);} +}; + +class MATROSKA_DLL_API KaxTagCaptureLightness : public EbmlBinary { + public: + KaxTagCaptureLightness() {} + KaxTagCaptureLightness(const KaxTagCaptureLightness & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxTagCaptureLightness);} + bool ValidateSize() const {return true;} // we don't mind about what's inside + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagCaptureLightness(*this);} +}; + +class MATROSKA_DLL_API KaxTagCapturePaletteSetting : public EbmlUInteger { + public: + KaxTagCapturePaletteSetting() {} + KaxTagCapturePaletteSetting(const KaxTagCapturePaletteSetting & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagCapturePaletteSetting);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagCapturePaletteSetting(*this);} +}; + +class MATROSKA_DLL_API KaxTagCaptureSharpness : public EbmlBinary { + public: + KaxTagCaptureSharpness() {} + KaxTagCaptureSharpness(const KaxTagCaptureSharpness & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxTagCaptureSharpness);} + bool ValidateSize() const {return true;} // we don't mind about what's inside + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagCaptureSharpness(*this);} +}; + +class MATROSKA_DLL_API KaxTagCropped : public EbmlUnicodeString { + public: + KaxTagCropped() {} + KaxTagCropped(const KaxTagCropped & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagCropped);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagCropped(*this);} +}; + +class MATROSKA_DLL_API KaxTagDiscTrack : public EbmlUInteger { + public: + KaxTagDiscTrack() {} + KaxTagDiscTrack(const KaxTagDiscTrack & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagDiscTrack);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagDiscTrack(*this);} +}; + +class MATROSKA_DLL_API KaxTagEncoder : public EbmlUnicodeString { + public: + KaxTagEncoder() {} + KaxTagEncoder(const KaxTagEncoder & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagEncoder);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagEncoder(*this);} +}; + +class MATROSKA_DLL_API KaxTagEncodeSettings : public EbmlUnicodeString { + public: + KaxTagEncodeSettings() {} + KaxTagEncodeSettings(const KaxTagEncodeSettings & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagEncodeSettings);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagEncodeSettings(*this);} +}; + +class MATROSKA_DLL_API KaxTagEqualisation : public EbmlBinary { + public: + KaxTagEqualisation() {} + KaxTagEqualisation(const KaxTagEqualisation & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxTagEqualisation);} + bool ValidateSize() const {return true;} // we don't mind about what's inside + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagEqualisation(*this);} +}; + +class MATROSKA_DLL_API KaxTagFile : public EbmlUnicodeString { + public: + KaxTagFile() {} + KaxTagFile(const KaxTagFile & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagFile);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagFile(*this);} +}; + +class MATROSKA_DLL_API KaxTagInitialKey : public EbmlString { + public: + KaxTagInitialKey() {} + KaxTagInitialKey(const KaxTagInitialKey & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagInitialKey);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagInitialKey(*this);} +}; + +class MATROSKA_DLL_API KaxTagKeywords : public EbmlUnicodeString { + public: + KaxTagKeywords() {} + KaxTagKeywords(const KaxTagKeywords & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagKeywords);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagKeywords(*this);} +}; + +class MATROSKA_DLL_API KaxTagLanguage : public EbmlString { + public: + KaxTagLanguage() {} + KaxTagLanguage(const KaxTagLanguage & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagLanguage);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagLanguage(*this);} +}; + +class MATROSKA_DLL_API KaxTagLength : public EbmlUInteger { + public: + KaxTagLength() {} + KaxTagLength(const KaxTagLength & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagLength);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagLength(*this);} +}; + +class MATROSKA_DLL_API KaxTagMood : public EbmlUnicodeString { + public: + KaxTagMood() {} + KaxTagMood(const KaxTagMood & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMood);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMood(*this);} +}; + +class MATROSKA_DLL_API KaxTagOfficialAudioFileURL : public EbmlString { + public: + KaxTagOfficialAudioFileURL() {} + KaxTagOfficialAudioFileURL(const KaxTagOfficialAudioFileURL & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagOfficialAudioFileURL);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagOfficialAudioFileURL(*this);} +}; + +class MATROSKA_DLL_API KaxTagOfficialAudioSourceURL : public EbmlString { + public: + KaxTagOfficialAudioSourceURL() {} + KaxTagOfficialAudioSourceURL(const KaxTagOfficialAudioSourceURL & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagOfficialAudioSourceURL);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagOfficialAudioSourceURL(*this);} +}; + +class MATROSKA_DLL_API KaxTagOriginalDimensions : public EbmlString { + public: + KaxTagOriginalDimensions() {} + KaxTagOriginalDimensions(const KaxTagOriginalDimensions & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagOriginalDimensions);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagOriginalDimensions(*this);} +}; + +class MATROSKA_DLL_API KaxTagOriginalMediaType : public EbmlUnicodeString { + public: + KaxTagOriginalMediaType() {} + KaxTagOriginalMediaType(const KaxTagOriginalMediaType & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagOriginalMediaType);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagOriginalMediaType(*this);} +}; + +class MATROSKA_DLL_API KaxTagPlayCounter : public EbmlUInteger { + public: + KaxTagPlayCounter() {} + KaxTagPlayCounter(const KaxTagPlayCounter & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagPlayCounter);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagPlayCounter(*this);} +}; + +class MATROSKA_DLL_API KaxTagPlaylistDelay : public EbmlUInteger { + public: + KaxTagPlaylistDelay() {} + KaxTagPlaylistDelay(const KaxTagPlaylistDelay & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagPlaylistDelay);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagPlaylistDelay(*this);} +}; + +class MATROSKA_DLL_API KaxTagPopularimeter : public EbmlSInteger { + public: + KaxTagPopularimeter() {} + KaxTagPopularimeter(const KaxTagPopularimeter & ElementToClone) :EbmlSInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagPopularimeter);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagPopularimeter(*this);} +}; + +class MATROSKA_DLL_API KaxTagProduct : public EbmlUnicodeString { + public: + KaxTagProduct() {} + KaxTagProduct(const KaxTagProduct & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagProduct);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagProduct(*this);} +}; + +class MATROSKA_DLL_API KaxTagRating : public EbmlBinary { + public: + KaxTagRating() {} + KaxTagRating(const KaxTagRating & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxTagRating);} + bool ValidateSize() const {return true;} // we don't mind about what's inside + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagRating(*this);} +}; + +class MATROSKA_DLL_API KaxTagRecordLocation : public EbmlString { + public: + KaxTagRecordLocation() {} + KaxTagRecordLocation(const KaxTagRecordLocation & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagRecordLocation);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagRecordLocation(*this);} +}; + +class MATROSKA_DLL_API KaxTagSetPart : public EbmlUInteger { + public: + KaxTagSetPart() {} + KaxTagSetPart(const KaxTagSetPart & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagSetPart);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagSetPart(*this);} +}; + +class MATROSKA_DLL_API KaxTagSource : public EbmlUnicodeString { + public: + KaxTagSource() {} + KaxTagSource(const KaxTagSource & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagSource);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagSource(*this);} +}; + +class MATROSKA_DLL_API KaxTagSourceForm : public EbmlUnicodeString { + public: + KaxTagSourceForm() {} + KaxTagSourceForm(const KaxTagSourceForm & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagSourceForm);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagSourceForm(*this);} +}; + +class MATROSKA_DLL_API KaxTagSubGenre : public EbmlString { + public: + KaxTagSubGenre() {} + KaxTagSubGenre(const KaxTagSubGenre & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagSubGenre);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagSubGenre(*this);} +}; + +class MATROSKA_DLL_API KaxTagSubject : public EbmlUnicodeString { + public: + KaxTagSubject() {} + KaxTagSubject(const KaxTagSubject & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagSubject);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagSubject(*this);} +}; + +class MATROSKA_DLL_API KaxTagUnsynchronisedText : public EbmlUnicodeString { + public: + KaxTagUnsynchronisedText() {} + KaxTagUnsynchronisedText(const KaxTagUnsynchronisedText & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagUnsynchronisedText);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagUnsynchronisedText(*this);} +}; + +class MATROSKA_DLL_API KaxTagUserDefinedURL : public EbmlString { + public: + KaxTagUserDefinedURL() {} + KaxTagUserDefinedURL(const KaxTagUserDefinedURL & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagUserDefinedURL);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagUserDefinedURL(*this);} +}; + +class MATROSKA_DLL_API KaxTagVideoGenre : public EbmlBinary { + public: + KaxTagVideoGenre() {} + KaxTagVideoGenre(const KaxTagVideoGenre & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxTagVideoGenre);} + bool ValidateSize() const {return (Size >= 2);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagVideoGenre(*this);} +}; + +class MATROSKA_DLL_API KaxTagSimple : public EbmlMaster { + public: + KaxTagSimple(); + KaxTagSimple(const KaxTagSimple & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagSimple);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagSimple(*this);} +}; + +class MATROSKA_DLL_API KaxTagName : public EbmlUnicodeString { + public: + KaxTagName() {} + KaxTagName(const KaxTagName & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagName);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagName(*this);} +}; + +class MATROSKA_DLL_API KaxTagLangue : public EbmlString { + public: + KaxTagLangue(): EbmlString("und") {} + KaxTagLangue(const KaxTagLangue & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagLangue);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagLangue(*this);} +}; + +class MATROSKA_DLL_API KaxTagDefault : public EbmlUInteger { + public: + KaxTagDefault() :EbmlUInteger(1) {} + KaxTagDefault(const KaxTagTrackUID & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagDefault);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagDefault(*this);} +}; + +class MATROSKA_DLL_API KaxTagString : public EbmlUnicodeString { + public: + KaxTagString() {} + KaxTagString(const KaxTagString & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagString);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagString(*this);} +}; + +class MATROSKA_DLL_API KaxTagBinary : public EbmlBinary { + public: + KaxTagBinary() {} + KaxTagBinary(const KaxTagBinary & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxTagBinary);} + bool ValidateSize() const {return (Size >= 0);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagBinary(*this);} +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_TAG_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTagMulti.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTagMulti.h new file mode 100644 index 0000000000..3a4d99badb --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTagMulti.h @@ -0,0 +1,745 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxTagMulti.h,v 1.9 2004/04/14 23:26:17 robux4 Exp $ + \author Jory Stone + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_TAGMULTI_H +#define LIBMATROSKA_TAGMULTI_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" +#include "ebml/EbmlDate.h" +#include "ebml/EbmlFloat.h" +#include "ebml/EbmlSInteger.h" +#include "ebml/EbmlUInteger.h" +#include "ebml/EbmlString.h" +#include "ebml/EbmlUnicodeString.h" +#include "ebml/EbmlBinary.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +enum KaxTagMultiCommercialTypes { + KaxTagMultiCommercialType_FilePurchase = 1, //Information on where to purchase this file. This is akin to the WPAY tag in ID3. + KaxTagMultiCommercialType_ItemPurchase, //Information on where to purchase this album. This is akin to the WCOM tag in ID3. + KaxTagMultiCommercialType_Owner //Information on the purchase that occurred for this file. This is akin to the OWNE tag in ID3. +}; +enum KaxTagMultiDateTypes { + KaxTagMultiDateType_EncodingDate = 1, //The time that the encoding of this item was completed. This is akin to the TDEN tag in ID3. + KaxTagMultiDateType_RecordingDate, //The time that the recording began, and finished. This is akin to the TDRC tag in ID3. + KaxTagMultiDateType_ReleaseDate, //The time that the item was originaly released. This is akin to the TDRL tag in ID3. + KaxTagMultiDateType_OriginalReleaseDate, //The time that the item was originaly released if it is a remake. This is akin to the TDOR tag in ID3. + KaxTagMultiDateType_TaggingDate, //The time that the tags were done for this item. This is akin to the TDTG tag in ID3. + KaxTagMultiDateType_DigitizingDate //The time that the item was tranfered to a digital medium. This is akin to the IDIT tag in RIFF +}; +enum KaxTagMultiEntitiesTypes { + KaxTagMultiEntitiesType_LyricistTextWriter = 1, //The person that wrote the words/script for this item. This is akin to the TEXT tag in ID3. + KaxTagMultiEntitiesType_Composer, //The name of the composer of this item. This is akin to the TCOM tag in ID3. + KaxTagMultiEntitiesType_LeadPerformerSoloist, //This is akin to the TPE1 tag in ID3. + KaxTagMultiEntitiesType_BandOrchestraAccompaniment, //This is akin to the TPE2 tag in ID3. + KaxTagMultiEntitiesType_OriginalLyricistTextWriter, //This is akin to the TOLY tag in ID3. + KaxTagMultiEntitiesType_OriginalArtistPerformer, //This is akin to the TOPE tag in ID3. + KaxTagMultiEntitiesType_OriginalAlbumMovieShowTitle, //This is akin to the TOAL tag in ID3. + KaxTagMultiEntitiesType_ConductorPerformerRefinement, //This is akin to the TPE3 tag in ID3. + KaxTagMultiEntitiesType_InterpretedRemixedBy, //This is akin to the TPE4 tag in ID3. + KaxTagMultiEntitiesType_Director, //This is akin to the IART tag in RIFF + KaxTagMultiEntitiesType_ProducedBy, //This is akin to the IPRO tag in Extended RIFF + KaxTagMultiEntitiesType_Cinematographer, //This is akin to the ICNM tag in Extended RIFF + KaxTagMultiEntitiesType_ProductionDesigner, //This is akin to the IPDS tag in Extended RIFF + KaxTagMultiEntitiesType_CostumeDesigner, //This is akin to the ICDS tag in Extended RIFF + KaxTagMultiEntitiesType_ProductionStudio, //This is akin to the ISTD tag in Extended RIFF + KaxTagMultiEntitiesType_DistributedBy, //This is akin to the IDST tag in Extended RIFF + KaxTagMultiEntitiesType_CommissionedBy, //This is akin to the ICMS tag in RIFF + KaxTagMultiEntitiesType_Engineer, //This is akin to the IENG tag in RIFF + KaxTagMultiEntitiesType_EditedBy, //This is akin to the IEDT tag in Extended RIFF + KaxTagMultiEntitiesType_EncodedBy, //This is akin to the TENC tag in ID3. + KaxTagMultiEntitiesType_RippedBy, //This is akin to the IRIP tag in Extended RIFF + KaxTagMultiEntitiesType_InvolvedPeopleList, //A very general tag for everyone else that wants to be listed. This is akin to the TMCL tag in ID3. + KaxTagMultiEntitiesType_InternetRadioStationName, //This is akin to the TSRN tag in ID3. + KaxTagMultiEntitiesType_Publisher //This is akin to the TPUB tag in ID3. +}; + +enum KaxTagMultiIdentifierTypes { + KaxTagMultiIdentifierType_ISRC = 1, //String, The International Standard Recording Code + KaxTagMultiIdentifierType_CDIdentifier, //Binary, This is a binary dump of the TOC of the CDROM that this item was taken from. This holds the same information as the MCDI in ID3. + KaxTagMultiIdentifierType_ISBN, //String, International Standard Book Number + KaxTagMultiIdentifierType_Catalog, //String, sometimes the EAN/UPC, often some letters followed by some numbers + KaxTagMultiIdentifierType_EAN, //String, EAN-13 bar code identifier + KaxTagMultiIdentifierType_UPC, //String, UPC-A bar code identifier + KaxTagMultiIdentifierType_LabelCode, //String, Typically printed as ________ (LC) xxxx) ~~~~~~~~ or _________ (LC) 0xxxx) ~~~~~~~~~ on CDs medias or covers, where xxxx is a 4-digit number. + KaxTagMultiIdentifierType_LCCN, //String, Library of Congress Control Number + KaxTagMultiIdentifierType_UniqueFileIdentifier, //Binary, This used for a dump of the UFID field in ID3. This field would only be used if the item was pulled from an MP3. + CDROM_CD_TEXT_PACK_TOC_INFO2 //Binary +}; + +enum KaxTagMultiLegalTypes { + KaxTagMultiLegalType_Copyright = 1, //The copyright information as per the copyright holder. This is akin to the TCOP tag in ID3. + KaxTagMultiLegalType_ProductionCopyright, //The copyright information as per the production copyright holder. This is akin to the TPRO tag in ID3. + KaxTagMultiLegalType_TermsOfUse //The terms of use for this item. This is akin to the USER tag in ID3. +}; + +enum KaxTagMultiTitleTypes { + KaxTagMultiTitleType_TrackTitle = 1, + //The title of this item. In the case of a track, the Name element should be identical to the Name element. + //For example, for music you might label this "Canon in D", or for video's audio track you might use "English 5.1" This is akin to the TIT2 tag in ID3. + KaxTagMultiTitleType_AlbumMovieShowTitle, + //This is the name given to a grouping of tracks and/or chapters. + //For example, all video, audio, and subtitle tracks for a movie would be grouped under this and be given the name of the movie. + //All tracks for a particular CD would be grouped together under the title of the CD, or if all tracks for a CD were recorded as a single track, seperated by chapters, the same would apply. + //You could use this to label episode 3 of The Simpsons. This is akin to the TALB tag in ID3. + KaxTagMultiTitleType_SetTitle, //This would be used to label a set of ID 2. For example, season 13 of The Simpsons. + KaxTagMultiTitleType_Series //This would be used to label a set of ID 3. For example, The Simpsons. +}; + +class MATROSKA_DLL_API KaxTagMultiComment : public EbmlMaster { + public: + KaxTagMultiComment(); + KaxTagMultiComment(const KaxTagMultiComment & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiComment);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiComment(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiCommentName : public EbmlString { + public: + KaxTagMultiCommentName() {} + KaxTagMultiCommentName(const KaxTagMultiCommentName & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiCommentName);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiCommentName(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiCommentComments : public EbmlUnicodeString { + public: + KaxTagMultiCommentComments() {} + KaxTagMultiCommentComments(const KaxTagMultiCommentComments & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiCommentComments);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiCommentComments(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiCommentLanguage : public EbmlString { + public: + KaxTagMultiCommentLanguage() {} + KaxTagMultiCommentLanguage(const KaxTagMultiCommentLanguage & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiCommentLanguage);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiCommentLanguage(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiCommercial : public EbmlMaster { + public: + KaxTagMultiCommercial(); + KaxTagMultiCommercial(const KaxTagMultiCommercial & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiCommercial);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiCommercial(*this);} +}; + +class MATROSKA_DLL_API KaxTagCommercial : public EbmlMaster { + public: + KaxTagCommercial(); + KaxTagCommercial(const KaxTagCommercial & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagCommercial);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagCommercial(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiCommercialType : public EbmlUInteger { + public: + KaxTagMultiCommercialType() {} + KaxTagMultiCommercialType(const KaxTagMultiCommercialType & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiCommercialType);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiCommercialType(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiCommercialAddress : public EbmlUnicodeString { + public: + KaxTagMultiCommercialAddress() {} + KaxTagMultiCommercialAddress(const KaxTagMultiCommercialAddress & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiCommercialAddress);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiCommercialAddress(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiCommercialURL : public EbmlString { + public: + KaxTagMultiCommercialURL() {} + KaxTagMultiCommercialURL(const KaxTagMultiCommercialURL & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiCommercialURL);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiCommercialURL(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiCommercialEmail : public EbmlString { + public: + KaxTagMultiCommercialEmail() {} + KaxTagMultiCommercialEmail(const KaxTagMultiCommercialEmail & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiCommercialEmail);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiCommercialEmail(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiPrice : public EbmlMaster { + public: + KaxTagMultiPrice(); + KaxTagMultiPrice(const KaxTagMultiPrice & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiPrice);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiPrice(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiPriceCurrency : public EbmlString { + public: + KaxTagMultiPriceCurrency() {} + KaxTagMultiPriceCurrency(const KaxTagMultiPriceCurrency & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiPriceCurrency);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiPriceCurrency(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiPriceAmount : public EbmlFloat { + public: + KaxTagMultiPriceAmount() :EbmlFloat() {} + KaxTagMultiPriceAmount(const KaxTagMultiPriceAmount & ElementToClone) :EbmlFloat(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiPriceAmount);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiPriceAmount(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiPricePriceDate : public EbmlDate { + public: + KaxTagMultiPricePriceDate() :EbmlDate() {} + KaxTagMultiPricePriceDate(const KaxTagMultiPricePriceDate & ElementToClone) :EbmlDate(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiPricePriceDate);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiPricePriceDate(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiDate : public EbmlMaster { + public: + KaxTagMultiDate(); + KaxTagMultiDate(const KaxTagMultiDate & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiDate);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiDate(*this);} +}; + +class MATROSKA_DLL_API KaxTagDate : public EbmlMaster { + public: + KaxTagDate(); + KaxTagDate(const KaxTagDate & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagDate);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagDate(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiDateType : public EbmlUInteger { + public: + KaxTagMultiDateType() {} + KaxTagMultiDateType(const KaxTagMultiDateType & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiDateType);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiDateType(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiDateDateBegin : public EbmlDate { + public: + KaxTagMultiDateDateBegin() :EbmlDate() {} + KaxTagMultiDateDateBegin(const KaxTagMultiDateDateBegin & ElementToClone) :EbmlDate(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiDateDateBegin);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiDateDateBegin(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiDateDateEnd : public EbmlDate { + public: + KaxTagMultiDateDateEnd() :EbmlDate() {} + KaxTagMultiDateDateEnd(const KaxTagMultiDateDateEnd & ElementToClone) :EbmlDate(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiDateDateEnd);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiDateDateEnd(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiEntity : public EbmlMaster { + public: + KaxTagMultiEntity(); + KaxTagMultiEntity(const KaxTagMultiEntity & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiEntity);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiEntity(*this);} +}; + +class MATROSKA_DLL_API KaxTagEntity : public EbmlMaster { + public: + KaxTagEntity(); + KaxTagEntity(const KaxTagEntity & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagEntity);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagEntity(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiEntityType : public EbmlUInteger { + public: + KaxTagMultiEntityType() {} + KaxTagMultiEntityType(const KaxTagMultiEntityType & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiEntityType);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiEntityType(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiEntityName : public EbmlUnicodeString { + public: + KaxTagMultiEntityName() {} + KaxTagMultiEntityName(const KaxTagMultiEntityName & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiEntityName);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiEntityName(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiEntityAddress : public EbmlUnicodeString { + public: + KaxTagMultiEntityAddress() {} + KaxTagMultiEntityAddress(const KaxTagMultiEntityAddress & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiEntityAddress);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiEntityAddress(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiEntityURL : public EbmlString { + public: + KaxTagMultiEntityURL() {} + KaxTagMultiEntityURL(const KaxTagMultiEntityURL & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiEntityURL);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiEntityURL(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiEntityEmail : public EbmlString { + public: + KaxTagMultiEntityEmail() {} + KaxTagMultiEntityEmail(const KaxTagMultiEntityEmail & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiEntityEmail);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiEntityEmail(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiIdentifier : public EbmlMaster { + public: + KaxTagMultiIdentifier(); + KaxTagMultiIdentifier(const KaxTagMultiIdentifier & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiIdentifier);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiIdentifier(*this);} +}; + +class MATROSKA_DLL_API KaxTagIdentifier : public EbmlMaster { + public: + KaxTagIdentifier(); + KaxTagIdentifier(const KaxTagIdentifier & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagIdentifier);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagIdentifier(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiIdentifierType : public EbmlUInteger { + public: + KaxTagMultiIdentifierType() {} + KaxTagMultiIdentifierType(const KaxTagMultiIdentifierType & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiIdentifierType);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiIdentifierType(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiIdentifierBinary : public EbmlBinary { + public: + KaxTagMultiIdentifierBinary() {} + KaxTagMultiIdentifierBinary(const KaxTagMultiIdentifierBinary & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxTagMultiIdentifierBinary);} + bool ValidateSize() const {return true;} // we don't mind about what's inside + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiIdentifierBinary(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiIdentifierString : public EbmlUnicodeString { + public: + KaxTagMultiIdentifierString() {} + KaxTagMultiIdentifierString(const KaxTagMultiIdentifierString & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiIdentifierString);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiIdentifierString(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiLegal : public EbmlMaster { + public: + KaxTagMultiLegal(); + KaxTagMultiLegal(const KaxTagMultiLegal & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiLegal);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiLegal(*this);} +}; + +class MATROSKA_DLL_API KaxTagLegal : public EbmlMaster { + public: + KaxTagLegal(); + KaxTagLegal(const KaxTagLegal & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagLegal);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagLegal(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiLegalType : public EbmlUInteger { + public: + KaxTagMultiLegalType() {} + KaxTagMultiLegalType(const KaxTagMultiLegalType & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiLegalType);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiLegalType(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiLegalContent : public EbmlUnicodeString { + public: + KaxTagMultiLegalContent() {} + KaxTagMultiLegalContent(const KaxTagMultiLegalContent & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiLegalContent);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiLegalContent(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiLegalURL : public EbmlString { + public: + KaxTagMultiLegalURL() {} + KaxTagMultiLegalURL(const KaxTagMultiLegalURL & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiLegalURL);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiLegalURL(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiLegalAddress : public EbmlUnicodeString { + public: + KaxTagMultiLegalAddress() {} + KaxTagMultiLegalAddress(const KaxTagMultiLegalAddress & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiLegalAddress);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiLegalAddress(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiTitle : public EbmlMaster { + public: + KaxTagMultiTitle(); + KaxTagMultiTitle(const KaxTagMultiTitle & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiTitle);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiTitle(*this);} +}; + +class MATROSKA_DLL_API KaxTagTitle : public EbmlMaster { + public: + KaxTagTitle(); + KaxTagTitle(const KaxTagTitle & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagTitle);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagTitle(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiTitleType : public EbmlUInteger { + public: + KaxTagMultiTitleType() {} + KaxTagMultiTitleType(const KaxTagMultiTitleType & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiTitleType);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiTitleType(*this);} +}; + + +class MATROSKA_DLL_API KaxTagMultiTitleName : public EbmlUnicodeString { + public: + KaxTagMultiTitleName() {} + KaxTagMultiTitleName(const KaxTagMultiTitleName & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiTitleName);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiTitleName(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiTitleSubTitle : public EbmlUnicodeString { + public: + KaxTagMultiTitleSubTitle() {} + KaxTagMultiTitleSubTitle(const KaxTagMultiTitleSubTitle & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiTitleSubTitle);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiTitleSubTitle(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiTitleEdition : public EbmlUnicodeString { + public: + KaxTagMultiTitleEdition() {} + KaxTagMultiTitleEdition(const KaxTagMultiTitleEdition & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiTitleEdition);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiTitleEdition(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiTitleAddress : public EbmlUnicodeString { + public: + KaxTagMultiTitleAddress() {} + KaxTagMultiTitleAddress(const KaxTagMultiTitleAddress & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiTitleAddress);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiTitleAddress(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiTitleURL : public EbmlString { + public: + KaxTagMultiTitleURL() {} + KaxTagMultiTitleURL(const KaxTagMultiTitleURL & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiTitleURL);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiTitleURL(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiTitleEmail : public EbmlString { + public: + KaxTagMultiTitleEmail() {} + KaxTagMultiTitleEmail(const KaxTagMultiTitleEmail & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiTitleEmail);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiTitleEmail(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiTitleLanguage : public EbmlString { + public: + KaxTagMultiTitleLanguage() {} + KaxTagMultiTitleLanguage(const KaxTagMultiTitleLanguage & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiTitleLanguage);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiTitleLanguage(*this);} +}; + +class MATROSKA_DLL_API KaxTagMultiAttachment : public EbmlMaster { + public: + KaxTagMultiAttachment(); + KaxTagMultiAttachment(const KaxTagMultiAttachment & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagMultiAttachment);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagMultiAttachment(*this);} +}; + +class MATROSKA_DLL_API KaxTagAttachment : public EbmlMaster { + public: + KaxTagAttachment(); + KaxTagAttachment(const KaxTagAttachment & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagAttachment);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagAttachment(*this);} +}; + +class MATROSKA_DLL_API KaxTagAttachmentID : public EbmlUInteger { + public: + KaxTagAttachmentID() {} + KaxTagAttachmentID(const KaxTagAttachmentID & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTagAttachmentID);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTagAttachmentID(*this);} +}; + +/* +class MATROSKA_DLL_API KaxTagBPM : public EbmlFloat { + public: + KaxTagBPM() :EbmlFloat() {} + static EbmlElement & Create() {return *(new KaxTagBPM);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} +}; + +class MATROSKA_DLL_API KaxTagPopularimeter : public EbmlSInteger { + public: + KaxTagPopularimeter() {} + static EbmlElement & Create() {return *(new KaxTagPopularimeter);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} +}; + +class MATROSKA_DLL_API KaxTagRating : public EbmlBinary { + public: + KaxTagRating() {} + static EbmlElement & Create() {return *(new KaxTagRating);} + bool ValidateSize() const {return true;} // we don't mind about what's inside + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} +}; + +class MATROSKA_DLL_API KaxTagSetPart : public EbmlUInteger { + public: + KaxTagSetPart() {} + static EbmlElement & Create() {return *(new KaxTagSetPart);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} +}; + +class MATROSKA_DLL_API KaxTagUserDefinedURL : public EbmlString { + public: + KaxTagUserDefinedURL() {} + static EbmlElement & Create() {return *(new KaxTagUserDefinedURL);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} +}; + +class MATROSKA_DLL_API KaxTagVideoSecondaryGenre : public EbmlBinary { + public: + KaxTagVideoSecondaryGenre() {} + static EbmlElement & Create() {return *(new KaxTagVideoSecondaryGenre);} + bool ValidateSize() const {return (Size >= 4);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} +}; + +class MATROSKA_DLL_API KaxWritingApp : public EbmlUnicodeString { + public: + KaxWritingApp() {} + static EbmlElement & Create() {return *(new KaxWritingApp);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} +};*/ + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_TAGMULTI_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTags.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTags.h new file mode 100644 index 0000000000..f6c4375144 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTags.h @@ -0,0 +1,58 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxTags.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_TAGS_H +#define LIBMATROSKA_TAGS_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class MATROSKA_DLL_API KaxTags : public EbmlMaster { + public: + KaxTags(); + KaxTags(const KaxTags & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTags);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTags(*this);} +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_TAGS_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTrackAudio.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTrackAudio.h new file mode 100644 index 0000000000..ffbe2595d2 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTrackAudio.h @@ -0,0 +1,119 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxTrackAudio.h,v 1.11 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_TRACK_AUDIO_H +#define LIBMATROSKA_TRACK_AUDIO_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" +#include "ebml/EbmlFloat.h" +#include "ebml/EbmlUInteger.h" +#include "ebml/EbmlBinary.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class MATROSKA_DLL_API KaxTrackAudio : public EbmlMaster { + public: + KaxTrackAudio(); + KaxTrackAudio(const KaxTrackAudio & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackAudio);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackAudio(*this);} +}; + +class MATROSKA_DLL_API KaxAudioSamplingFreq : public EbmlFloat { + public: + KaxAudioSamplingFreq() :EbmlFloat(8000.0) {} + KaxAudioSamplingFreq(const KaxAudioSamplingFreq & ElementToClone) :EbmlFloat(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxAudioSamplingFreq);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxAudioSamplingFreq(*this);} +}; + +class MATROSKA_DLL_API KaxAudioOutputSamplingFreq : public EbmlFloat { + public: + KaxAudioOutputSamplingFreq() :EbmlFloat() {} + KaxAudioOutputSamplingFreq(const KaxAudioOutputSamplingFreq & ElementToClone) :EbmlFloat(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxAudioOutputSamplingFreq);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxAudioOutputSamplingFreq(*this);} +}; + +class MATROSKA_DLL_API KaxAudioChannels : public EbmlUInteger { + public: + KaxAudioChannels() :EbmlUInteger(1) {} + KaxAudioChannels(const KaxAudioChannels & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxAudioChannels);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxAudioChannels(*this);} +}; + +#if MATROSKA_VERSION >= 2 +class MATROSKA_DLL_API KaxAudioPosition : public EbmlBinary { + public: + KaxAudioPosition() {} + KaxAudioPosition(const KaxAudioPosition & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxAudioPosition);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + bool ValidateSize(void) const {return true;} + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxAudioPosition(*this);} +}; +#endif // MATROSKA_VERSION + +class MATROSKA_DLL_API KaxAudioBitDepth : public EbmlUInteger { + public: + KaxAudioBitDepth() {} + KaxAudioBitDepth(const KaxAudioBitDepth & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxAudioBitDepth);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxAudioBitDepth(*this);} +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_TRACK_AUDIO_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTrackEntryData.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTrackEntryData.h new file mode 100644 index 0000000000..1f33944df6 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTrackEntryData.h @@ -0,0 +1,277 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxTrackEntryData.h,v 1.9 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme + \author John Cannon +*/ +#ifndef LIBMATROSKA_TRACK_ENTRY_DATA_H +#define LIBMATROSKA_TRACK_ENTRY_DATA_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlUInteger.h" +#include "ebml/EbmlFloat.h" +#include "ebml/EbmlString.h" +#include "ebml/EbmlUnicodeString.h" +#include "ebml/EbmlBinary.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class MATROSKA_DLL_API KaxTrackNumber : public EbmlUInteger { + public: + KaxTrackNumber() {} + KaxTrackNumber(const KaxTrackNumber & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackNumber);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackNumber(*this);} +}; + +class MATROSKA_DLL_API KaxTrackUID : public EbmlUInteger { + public: + KaxTrackUID() {} + KaxTrackUID(const KaxTrackUID & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackUID);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackUID(*this);} +}; + +class MATROSKA_DLL_API KaxTrackType : public EbmlUInteger { + public: + KaxTrackType() {} + KaxTrackType(const KaxTrackType & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackType);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackType(*this);} +}; + +#if MATROSKA_VERSION >= 2 +class MATROSKA_DLL_API KaxTrackFlagEnabled : public EbmlUInteger { + public: + KaxTrackFlagEnabled() :EbmlUInteger(1) {} + KaxTrackFlagEnabled(const KaxTrackFlagEnabled & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackFlagEnabled);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackFlagEnabled(*this);} +}; +#endif // MATROSKA_VERSION + +class MATROSKA_DLL_API KaxTrackFlagDefault : public EbmlUInteger { + public: + KaxTrackFlagDefault() :EbmlUInteger(1) {} + KaxTrackFlagDefault(const KaxTrackFlagDefault & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackFlagDefault);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackFlagDefault(*this);} +}; + +class MATROSKA_DLL_API KaxTrackFlagLacing : public EbmlUInteger { + public: + KaxTrackFlagLacing() :EbmlUInteger(1) {} + KaxTrackFlagLacing(const KaxTrackFlagLacing & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackFlagLacing);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackFlagLacing(*this);} +}; + +class MATROSKA_DLL_API KaxTrackMinCache : public EbmlUInteger { + public: + KaxTrackMinCache() :EbmlUInteger(0) {} + KaxTrackMinCache(const KaxTrackMinCache & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackMinCache);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackMinCache(*this);} +}; + +class MATROSKA_DLL_API KaxTrackMaxCache : public EbmlUInteger { + public: + KaxTrackMaxCache() {} + KaxTrackMaxCache(const KaxTrackMaxCache & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackMaxCache);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackMaxCache(*this);} +}; + +class MATROSKA_DLL_API KaxTrackDefaultDuration : public EbmlUInteger { + public: + KaxTrackDefaultDuration() {} + KaxTrackDefaultDuration(const KaxTrackDefaultDuration & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackDefaultDuration);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackDefaultDuration(*this);} +}; + +class MATROSKA_DLL_API KaxTrackTimecodeScale : public EbmlFloat { + public: + KaxTrackTimecodeScale() :EbmlFloat(1.0) {} + KaxTrackTimecodeScale(const KaxTrackTimecodeScale & ElementToClone) :EbmlFloat(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackTimecodeScale);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackTimecodeScale(*this);} +}; + +class MATROSKA_DLL_API KaxTrackName : public EbmlUnicodeString { + public: + KaxTrackName() {} + KaxTrackName(const KaxTrackName & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackName);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackName(*this);} +}; + +class MATROSKA_DLL_API KaxTrackLanguage : public EbmlString { + public: + KaxTrackLanguage() :EbmlString("eng") {} + KaxTrackLanguage(const KaxTrackLanguage & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackLanguage);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackLanguage(*this);} +}; + +class MATROSKA_DLL_API KaxCodecID : public EbmlString { + public: + KaxCodecID() {} + KaxCodecID(const KaxCodecID & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCodecID);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCodecID(*this);} +}; + +class MATROSKA_DLL_API KaxCodecPrivate : public EbmlBinary { + public: + KaxCodecPrivate() {} + KaxCodecPrivate(const KaxCodecPrivate & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxCodecPrivate);} + bool ValidateSize() const {return true;} // we don't mind about what's inside + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCodecPrivate(*this);} +}; + +class MATROSKA_DLL_API KaxCodecName : public EbmlUnicodeString { + public: + KaxCodecName() {} + KaxCodecName(const KaxCodecName & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCodecName);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCodecName(*this);} +}; + +#if MATROSKA_VERSION >= 2 +class MATROSKA_DLL_API KaxCodecSettings : public EbmlUnicodeString { + public: + KaxCodecSettings() {} + KaxCodecSettings(const KaxCodecSettings & ElementToClone) :EbmlUnicodeString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCodecSettings);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCodecSettings(*this);} +}; + +class MATROSKA_DLL_API KaxCodecInfoURL : public EbmlString { + public: + KaxCodecInfoURL() {} + KaxCodecInfoURL(const KaxCodecInfoURL & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCodecInfoURL);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCodecInfoURL(*this);} +}; + +class MATROSKA_DLL_API KaxCodecDownloadURL : public EbmlString { + public: + KaxCodecDownloadURL() {} + KaxCodecDownloadURL(const KaxCodecDownloadURL & ElementToClone) :EbmlString(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCodecDownloadURL);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCodecDownloadURL(*this);} +}; + +class MATROSKA_DLL_API KaxCodecDecodeAll : public EbmlUInteger { + public: + KaxCodecDecodeAll() :EbmlUInteger(1) {} + KaxCodecDecodeAll(const KaxCodecDecodeAll & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxCodecDecodeAll);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxCodecDecodeAll(*this);} +}; + +class MATROSKA_DLL_API KaxTrackOverlay : public EbmlUInteger { + public: + KaxTrackOverlay() {} + KaxTrackOverlay(const KaxTrackOverlay & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackOverlay);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackOverlay(*this);} +}; +#endif // MATROSKA_VERSION + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_TRACK_ENTRY_DATA_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTrackVideo.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTrackVideo.h new file mode 100644 index 0000000000..92c0cf30d3 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTrackVideo.h @@ -0,0 +1,235 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxTrackVideo.h,v 1.9 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_TRACK_VIDEO_H +#define LIBMATROSKA_TRACK_VIDEO_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" +#include "ebml/EbmlUInteger.h" +#include "ebml/EbmlBinary.h" +#include "ebml/EbmlFloat.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class MATROSKA_DLL_API KaxTrackVideo : public EbmlMaster { + public: + KaxTrackVideo(); + KaxTrackVideo(const KaxTrackVideo & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackVideo);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackVideo(*this);} +}; + +#if MATROSKA_VERSION >= 2 +class MATROSKA_DLL_API KaxVideoFlagInterlaced : public EbmlUInteger { + public: + KaxVideoFlagInterlaced() :EbmlUInteger(0) {} + KaxVideoFlagInterlaced(const KaxVideoFlagInterlaced & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxVideoFlagInterlaced);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxVideoFlagInterlaced(*this);} +}; + +class MATROSKA_DLL_API KaxVideoStereoMode : public EbmlUInteger { + public: + KaxVideoStereoMode() :EbmlUInteger(0) {} + KaxVideoStereoMode(const KaxVideoStereoMode & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxVideoStereoMode);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxVideoStereoMode(*this);} +}; +#endif // MATROSKA_VERSION + +class MATROSKA_DLL_API KaxVideoPixelWidth : public EbmlUInteger { + public: + KaxVideoPixelWidth() {} + KaxVideoPixelWidth(const KaxVideoPixelWidth & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxVideoPixelWidth);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxVideoPixelWidth(*this);} +}; + +class MATROSKA_DLL_API KaxVideoPixelHeight : public EbmlUInteger { + public: + KaxVideoPixelHeight() {} + KaxVideoPixelHeight(const KaxVideoPixelHeight & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxVideoPixelHeight);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxVideoPixelHeight(*this);} +}; + +class MATROSKA_DLL_API KaxVideoPixelCropBottom : public EbmlUInteger { + public: + KaxVideoPixelCropBottom(): EbmlUInteger(0) {} + KaxVideoPixelCropBottom(const KaxVideoPixelCropBottom & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxVideoPixelCropBottom);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxVideoPixelCropBottom(*this);} +}; + +class MATROSKA_DLL_API KaxVideoPixelCropTop : public EbmlUInteger { + public: + KaxVideoPixelCropTop(): EbmlUInteger(0) {} + KaxVideoPixelCropTop(const KaxVideoPixelCropTop & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxVideoPixelCropTop);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxVideoPixelCropTop(*this);} +}; + +class MATROSKA_DLL_API KaxVideoPixelCropLeft : public EbmlUInteger { + public: + KaxVideoPixelCropLeft(): EbmlUInteger(0) {} + KaxVideoPixelCropLeft(const KaxVideoPixelCropLeft & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxVideoPixelCropLeft);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxVideoPixelCropLeft(*this);} +}; + +class MATROSKA_DLL_API KaxVideoPixelCropRight : public EbmlUInteger { + public: + KaxVideoPixelCropRight(): EbmlUInteger(0) {} + KaxVideoPixelCropRight(const KaxVideoPixelCropRight & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxVideoPixelCropRight);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxVideoPixelCropRight(*this);} +}; + +class MATROSKA_DLL_API KaxVideoDisplayWidth : public EbmlUInteger { + public: + KaxVideoDisplayWidth() {} + KaxVideoDisplayWidth(const KaxVideoDisplayWidth & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxVideoDisplayWidth);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxVideoDisplayWidth(*this);} +}; + +class MATROSKA_DLL_API KaxVideoDisplayHeight : public EbmlUInteger { + public: + KaxVideoDisplayHeight() {} + KaxVideoDisplayHeight(const KaxVideoDisplayHeight & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxVideoDisplayHeight);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxVideoDisplayHeight(*this);} +}; + +#if MATROSKA_VERSION >= 2 +class MATROSKA_DLL_API KaxVideoDisplayUnit : public EbmlUInteger { + public: + KaxVideoDisplayUnit() {} + KaxVideoDisplayUnit(const KaxVideoDisplayUnit & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxVideoDisplayUnit);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxVideoDisplayUnit(*this);} +}; + +class MATROSKA_DLL_API KaxVideoAspectRatio : public EbmlUInteger { + public: + KaxVideoAspectRatio() {} + KaxVideoAspectRatio(const KaxVideoAspectRatio & ElementToClone) :EbmlUInteger(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxVideoAspectRatio);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxVideoAspectRatio(*this);} +}; +#endif // MATROSKA_VERSION + +class MATROSKA_DLL_API KaxVideoColourSpace : public EbmlBinary { + public: + KaxVideoColourSpace() {} + KaxVideoColourSpace(const KaxVideoColourSpace & ElementToClone) :EbmlBinary(ElementToClone){} + static EbmlElement & Create() {return *(new KaxVideoColourSpace);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + bool ValidateSize(void) const {return (Size == 4);} + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxVideoColourSpace(*this);} +}; + +#if MATROSKA_VERSION >= 2 +class MATROSKA_DLL_API KaxVideoGamma : public EbmlFloat { + public: + KaxVideoGamma() {} + KaxVideoGamma(const KaxVideoGamma & ElementToClone) :EbmlFloat(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxVideoGamma);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxVideoGamma(*this);} +}; +#endif // MATROSKA_VERSION + +class MATROSKA_DLL_API KaxVideoFrameRate : public EbmlFloat { + public: + KaxVideoFrameRate() {} + KaxVideoFrameRate(const KaxVideoFrameRate & ElementToClone) :EbmlFloat(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxVideoFrameRate);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + uint32 RenderData(IOCallback & output, bool bForceRender, bool bSaveDefault); + EbmlElement * Clone() const {return new KaxVideoFrameRate(*this);} +}; + + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_TRACK_VIDEO_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTracks.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTracks.h new file mode 100644 index 0000000000..408736ddae --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTracks.h @@ -0,0 +1,96 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxTracks.h,v 1.7 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_TRACKS_H +#define LIBMATROSKA_TRACKS_H + +#include "matroska/KaxTypes.h" +#include "ebml/EbmlMaster.h" +#include "ebml/EbmlUInteger.h" +#include "matroska/KaxTrackEntryData.h" + +using namespace LIBEBML_NAMESPACE; + +START_LIBMATROSKA_NAMESPACE + +class MATROSKA_DLL_API KaxTracks : public EbmlMaster { + public: + KaxTracks(); + KaxTracks(const KaxTracks & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTracks);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTracks(*this);} +}; + +class MATROSKA_DLL_API KaxTrackEntry : public EbmlMaster { + public: + KaxTrackEntry(); + KaxTrackEntry(const KaxTrackEntry & ElementToClone) :EbmlMaster(ElementToClone) {} + static EbmlElement & Create() {return *(new KaxTrackEntry);} + const EbmlCallbacks & Generic() const {return ClassInfos;} + static const EbmlCallbacks ClassInfos; + operator const EbmlId &() const {return ClassInfos.GlobalId;} + EbmlElement * Clone() const {return new KaxTrackEntry(*this);} + + EbmlUInteger & TrackNumber() const { return *(static_cast(FindElt(KaxTrackNumber::ClassInfos))); } + + void EnableLacing(bool bEnable = true); + + /*! + \note lacing set by default + */ + inline bool LacingEnabled() const { + KaxTrackFlagLacing * myLacing = static_cast(FindFirstElt(KaxTrackFlagLacing::ClassInfos)); + return((myLacing == NULL) || (uint8(*myLacing) != 0)); + } + + void SetGlobalTimecodeScale(uint64 aGlobalTimecodeScale) { + mGlobalTimecodeScale = aGlobalTimecodeScale; + bGlobalTimecodeScaleIsSet = true; + } + uint64 GlobalTimecodeScale() const { + assert(bGlobalTimecodeScaleIsSet); + return mGlobalTimecodeScale; + } + + protected: + bool bGlobalTimecodeScaleIsSet; + uint64 mGlobalTimecodeScale; +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_TRACKS_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTypes.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTypes.h new file mode 100644 index 0000000000..42413faf95 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxTypes.h @@ -0,0 +1,53 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2003 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxTypes.h,v 1.4 2004/04/14 23:26:17 robux4 Exp $ +*/ +#ifndef LIBMATROSKA_TYPES_H +#define LIBMATROSKA_TYPES_H + +#include "matroska/KaxConfig.h" +#include "ebml/EbmlTypes.h" +#include "matroska/c/libmatroska_t.h" + +START_LIBMATROSKA_NAMESPACE + +enum LacingType { + LACING_NONE = 0, + LACING_XIPH, + LACING_FIXED, + LACING_EBML, + LACING_AUTO +}; + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_TYPES_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxVersion.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxVersion.h new file mode 100644 index 0000000000..fc515cbb3d --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/KaxVersion.h @@ -0,0 +1,54 @@ +/**************************************************************************** +** +** +** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file + \version \$Id: KaxVersion.h,v 1.13 2004/04/23 16:46:07 mosu Exp $ + \author Steve Lhomme +*/ +#ifndef LIBMATROSKA_VERSION_H +#define LIBMATROSKA_VERSION_H + +#include + +#include "ebml/EbmlConfig.h" +#include "matroska/KaxConfig.h" + +START_LIBMATROSKA_NAMESPACE + +#define LIBMATROSKA_VERSION 000704 + +static const std::string KaxCodeVersion = "0.7.4"; +static const std::string KaxCodeDate = __TIMESTAMP__; + +/*! + \todo Improve the CRC/ECC system (backward and forward possible ?) to fit streaming/live writing/simple reading +*/ + +END_LIBMATROSKA_NAMESPACE + +#endif // LIBMATROSKA_VERSION_H diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/c/libmatroska.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/c/libmatroska.h new file mode 100644 index 0000000000..36f7a1da1e --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/c/libmatroska.h @@ -0,0 +1,119 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2003 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information. +** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file libmatroska.h + \version \$Id: libmatroska.h,v 1.2 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme + \author Ingo Ralf Blum + + \brief C API to the libmatroska library + \note These are the functions that should be exported (visible from outisde the library) + \todo Put a function here for all the MUST in the Matroska spec + \todo Put a brief description of each function, and a description of the params and return value + \todo Change the int values to sized types +*/ + +#ifndef _LIBMATROSKA_H_INCLUDED_ +#define _LIBMATROSKA_H_INCLUDED_ + +#include "libmatroska_t.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef OLD + +/*! + \fn int matroska_plug_log(matroska_error_callback) + \brief Attach a callback to be informed when error occurs + \param callback The callback that will be called when logging occurs \return 0 if successfull +*/ +int matroska_plug_log(matroska_error_callback callback); + +/*! + \fn int matroska_unplug_log(matroska_error_callback) + \brief Unattach an attached callback to be informed when error occurs + \param callback The callback that was called when logging occurs \return 0 if successfull +*/ +int matroska_unplug_log(matroska_error_callback callback); + +/*! + \fn matroska_id matroska_open_file(c_string,matroska_file_mode) + \brief Open an instance of an Matroska file + \param string The name of the file to open (including OS depedant path) \param mode The mode to open the file (read, write, etc) + \return NULL if the opening failed or an ID that will be used to access this file from the API +*/ +matroska_stream MATROSKA_EXPORT matroska_open_stream_file(c_string string, open_mode mode); + +matroska_id MATROSKA_EXPORT matroska_open_stream(matroska_stream a_stream); + +/*! + \fn matroska_id matroska_open_url(c_string) + \brief Open an instance of an Matroska file from a URL + \param string The name of the URL to open \return NULL if the opening failed or an ID that will be used to access this file from the API + \warning Open only for reading ? + \note It requires that Curl is compiled or installed +*/ +matroska_id matroska_open_url(c_string string); + +/*! + \fn int matroska_close(matroska_id) + \brief Close the specified Matroska instance + \param id The instance to close \return 0 if successfull +*/ +void MATROSKA_EXPORT matroska_close(matroska_id id); + +void MATROSKA_EXPORT matroska_end(matroska_id id, uint32 totaltime); + +matroska_track MATROSKA_EXPORT matroska_create_track(matroska_id id, enum track_type type); + +void MATROSKA_EXPORT matroska_read_head(matroska_id id); +void MATROSKA_EXPORT matroska_read_tracks(matroska_id id); + +uint8 MATROSKA_EXPORT matroska_get_number_track(matroska_id id); + +matroska_track MATROSKA_EXPORT matroska_get_track(matroska_id id, uint8 track_index); + +void MATROSKA_EXPORT matroska_get_track_info(matroska_id id, matroska_track track, track_info * infos); + +/* +int matroska_track_write_block(matroska_track, void* buffer, unsigned int size); +int matroska_track_close(matroska_track); +*/ + +#endif /* OLD */ + +#ifdef __cplusplus +} +#endif + +#endif /* _LIBMATROSKA_H_INCLUDED_ */ diff --git a/src/add-ons/media/plugins/matroska/libmatroska/matroska/c/libmatroska_t.h b/src/add-ons/media/plugins/matroska/libmatroska/matroska/c/libmatroska_t.h new file mode 100644 index 0000000000..64a3424926 --- /dev/null +++ b/src/add-ons/media/plugins/matroska/libmatroska/matroska/c/libmatroska_t.h @@ -0,0 +1,107 @@ +/**************************************************************************** +** libmatroska : parse Matroska files, see http://www.matroska.org/ +** +** +** +** Copyright (C) 2002-2003 Steve Lhomme. All rights reserved. +** +** This file is part of libmatroska. +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or (at your option) any later version. +** +** This library is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** Lesser General Public License for more details. +** +** You should have received a copy of the GNU Lesser General Public +** License along with this library; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** See http://www.matroska.org/license/lgpl/ for LGPL licensing information.** +** Contact license@matroska.org if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +/*! + \file libmatroska_t.h + \version \$Id: libmatroska_t.h,v 1.3 2004/04/14 23:26:17 robux4 Exp $ + \author Steve Lhomme + \author Ingo Ralf Blum + + \brief Misc type definitions for the C API of libmatroska + + \note These types should be compiler/language independant (just platform dependant) + \todo recover the sized types (uint16, int32, etc) here too (or maybe here only) +*/ + +#ifndef _LIBMATROSKA_T_H_INCLUDED_ +#define _LIBMATROSKA_T_H_INCLUDED_ + +#include "ebml/c/libebml_t.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/*! + \enum track_type +*/ +typedef enum track_type { + track_video = 0x01, ///< Rectangle-shaped non-transparent pictures aka video + track_audio = 0x02, ///< Anything you can hear + track_complex = 0x03, ///< Audio and video in same track, used by DV + + track_logo = 0x10, ///< Overlay-pictures, displayed over video + track_subtitle = 0x11, ///< Text-subtitles. One track contains one language and only one track can be active (player-side configuration) + + track_control = 0x20 ///< Control-codes for menus and other stuff +} track_type; + +/*! + \enum matroska_error_t + \brief a callback that the library use to inform of errors happening + \note this should be used by the libmatroska internals +*/ +typedef enum { + error_null_pointer ///< NULL pointer where something else is expected +} matroska_error_t; + +typedef void *matroska_stream; + +/*! + \var void* matroska_id + \brief UID used to access an Matroska file instance +*/ +typedef void* matroska_id; +/*! + \var void* matroska_track + \brief UID used to access a track +*/ +typedef void* matroska_track; +/*! + \var char* c_string + \brief C-String, ie a buffer with characters terminated by \0 +*/ +typedef char* c_string; +/*! + \var unsigned int matroska_file_mode + \brief A bit buffer, each bit representing a value for the file opening + \todo replace the unsigned int by a sized type (8 or 16 bits) +*/ +typedef char * matroska_file_mode; +/*! + \var void (*matroska_error_callback)(matroska_error_t error_code, char* error_message) + \brief a callback that the library use to inform of errors happening +*/ +typedef void (*matroska_error_callback)(matroska_error_t error_code, char* error_message); + +#ifdef __cplusplus +} +#endif + +#endif /* _LIBMATROSKA_T_H_INCLUDED_ */