From efbc9d9043ff8ff92716ddd00a5f61412d535593 Mon Sep 17 00:00:00 2001
From: XhmikosR <xhmikosr@users.sourceforge.net>
Date: Fri, 9 Apr 2010 14:12:59 +0000
Subject: revert r1783

git-svn-id: https://mpc-hc.svn.sourceforge.net/svnroot/mpc-hc/trunk@1785 10f7b99b-c216-0410-bff0-8a66a9350fd8
---
 src/filters/muxer/MatroskaMuxer/MatroskaFile.h | 731 ++++++++++++-------------
 1 file changed, 344 insertions(+), 387 deletions(-)

(limited to 'src/filters/muxer/MatroskaMuxer/MatroskaFile.h')

diff --git a/src/filters/muxer/MatroskaMuxer/MatroskaFile.h b/src/filters/muxer/MatroskaMuxer/MatroskaFile.h
index 3965ac6d8..80273dd76 100644
--- a/src/filters/muxer/MatroskaMuxer/MatroskaFile.h
+++ b/src/filters/muxer/MatroskaMuxer/MatroskaFile.h
@@ -1,4 +1,4 @@
-/*
+/* 
  *	Copyright (C) 2003-2006 Gabest
  *	http://www.gabest.org
  *
@@ -6,15 +6,15 @@
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2, or (at your option)
  *  any later version.
- *
+ *   
  *  This Program 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 General Public License for more details.
- *
+ *   
  *  You should have received a copy of the GNU General Public License
  *  along with GNU Make; see the file COPYING.  If not, write to
- *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  *  http://www.gnu.org/copyleft/gpl.html
  *
  */
@@ -26,304 +26,264 @@
 
 namespace MatroskaWriter
 {
-typedef unsigned __int64 QWORD;
-
-class CID
-{
-protected:
-    DWORD m_id;
-    QWORD HeaderSize(QWORD len);
-    HRESULT HeaderWrite(IStream* pStream);
-
-public:
-    CID(DWORD id);
-    DWORD GetID() const
-    {
-        return m_id;
-    }
-    virtual QWORD Size(bool fWithHeader = true);
-    virtual HRESULT Write(IStream* pStream);
-};
-
-class CLength : public CID
-{
-    UINT64 m_len;
-public:
-    CLength(UINT64 len = 0) : CID(0), m_len(len) {}
-    operator UINT64()
-    {
-        return m_len;
-    }
-    QWORD Size(bool fWithHeader = false);
-    HRESULT Write(IStream* pStream);
-};
-
-class CBinary : public CAtlArray<BYTE>, public CID
-{
-public:
-    CBinary(DWORD id) : CID(id) {}
-    CBinary& operator = (const CBinary& b)
-    {
-        Copy(b);
-        return(*this);
-    }
-    operator BYTE*()
-    {
-        return (BYTE*)GetData();
-    }
-    CBinary& Set(CStringA str)
-    {
-        SetCount(str.GetLength() + 1);
-        strcpy((char*)GetData(), str);
-        return(*this);
-    }
+	typedef unsigned __int64 QWORD;
+
+	class CID
+	{
+	protected:
+		DWORD m_id;
+		QWORD HeaderSize(QWORD len);
+		HRESULT HeaderWrite(IStream* pStream);
+
+	public:
+		CID(DWORD id);
+		DWORD GetID() const {return m_id;}
+		virtual QWORD Size(bool fWithHeader = true);
+		virtual HRESULT Write(IStream* pStream);
+	};
+
+	class CLength : public CID
+	{
+		UINT64 m_len;
+	public: 
+		CLength(UINT64 len = 0) : CID(0), m_len(len) {}
+		operator UINT64() {return m_len;}
+		QWORD Size(bool fWithHeader = false);
+		HRESULT Write(IStream* pStream);
+	};
+
+	class CBinary : public CAtlArray<BYTE>, public CID
+	{
+	public:
+		CBinary(DWORD id) : CID(id) {}
+		CBinary& operator = (const CBinary& b) {Copy(b); return(*this);}
+		operator BYTE*() {return (BYTE*)GetData();}
+		CBinary& Set(CStringA str) {SetCount(str.GetLength()+1); strcpy((char*)GetData(), str); return(*this);}
 //		CBinary& Set(CStringA str) {SetCount(str.GetLength()); memcpy((char*)GetData(), str, str.GetLength()); return(*this);}
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class CANSI : public CStringA, public CID
-{
-public:
-    CANSI(DWORD id) : CID(id) {}
-    CANSI& Set(CStringA str)
-    {
-        CStringA::operator = (str);
-        return(*this);
-    }
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class CUTF8 : public CStringW, public CID
-{
-public:
-    CUTF8(DWORD id) : CID(id) {}
-    CUTF8& Set(CStringW str)
-    {
-        CStringW::operator = (str);
-        return(*this);
-    }
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-template<class T, class BASE>
-class CSimpleVar : public CID
-{
-protected:
-    T m_val;
-    bool m_fSet;
-public:
-    explicit CSimpleVar(DWORD id, T val = 0) : CID(id), m_val(val)
-    {
-        m_fSet = !!val;
-    }
-    operator T()
-    {
-        return m_val;
-    }
-    BASE& Set(T val)
-    {
-        m_val = val;
-        m_fSet = true;
-        return(*(BASE*)this);
-    }
-    void UnSet()
-    {
-        m_fSet = false;
-    }
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class CUInt : public CSimpleVar<UINT64, CUInt>
-{
-public:
-    explicit CUInt(DWORD id, UINT64 val = 0) : CSimpleVar<UINT64, CUInt>(id, val) {}
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class CInt : public CSimpleVar<INT64, CInt>
-{
-public:
-    explicit CInt(DWORD id, INT64 val = 0) : CSimpleVar<INT64, CInt>(id, val) {}
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class CByte : public CSimpleVar<BYTE, CByte>
-{
-public:
-    explicit CByte(DWORD id, BYTE val = 0) : CSimpleVar<BYTE, CByte>(id, val) {}
-};
-
-class CShort : public CSimpleVar<short, CShort>
-{
-public:
-    explicit CShort(DWORD id, short val = 0) : CSimpleVar<short, CShort>(id, val) {}
-};
-
-class CFloat : public CSimpleVar<float, CFloat>
-{
-public:
-    explicit CFloat(DWORD id, float val = 0) : CSimpleVar<float, CFloat>(id, val) {}
-};
-
-template<class T>
-class CNode : public CAutoPtrList<T>
-{
-public:
-    QWORD Size(bool fWithHeader = true)
-    {
-        QWORD len = 0;
-        POSITION pos = GetHeadPosition();
-        while(pos) len += GetNext(pos)->Size(fWithHeader);
-        return len;
-    }
-    HRESULT Write(IStream* pStream)
-    {
-        HRESULT hr;
-        POSITION pos = GetHeadPosition();
-        while(pos) if(FAILED(hr = GetNext(pos)->Write(pStream))) return hr;
-        return S_OK;
-    }
-};
-
-class EBML : public CID
-{
-public:
-    CUInt EBMLVersion, EBMLReadVersion;
-    CUInt EBMLMaxIDLength, EBMLMaxSizeLength;
-    CANSI DocType;
-    CUInt DocTypeVersion, DocTypeReadVersion;
-
-    EBML(DWORD id = 0x1A45DFA3);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class Info : public CID
-{
-public:
-    CBinary SegmentUID, PrevUID, NextUID;
-    CUTF8 SegmentFilename, PrevFilename, NextFilename;
-    CUInt TimeCodeScale; // [ns], default: 1.000.000
-    CFloat Duration;
-    CInt DateUTC;
-    CUTF8 Title, MuxingApp, WritingApp;
-
-    Info(DWORD id = 0x1549A966);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class Video : public CID
-{
-public:
-    CUInt FlagInterlaced, StereoMode;
-    CUInt PixelWidth, PixelHeight, DisplayWidth, DisplayHeight, DisplayUnit;
-    CUInt AspectRatioType;
-    CUInt ColourSpace;
-    CFloat GammaValue;
-    CFloat FramePerSec;
-
-    Video(DWORD id = 0xE0);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class Audio : public CID
-{
-public:
-    CFloat SamplingFrequency;
-    CFloat OutputSamplingFrequency;
-    CUInt Channels;
-    CBinary ChannelPositions;
-    CUInt BitDepth;
-
-    Audio(DWORD id = 0xE1);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class TrackEntry : public CID
-{
-public:
-    enum {TypeVideo = 1, TypeAudio = 2, TypeComplex = 3, TypeLogo = 0x10, TypeSubtitle = 0x11, TypeControl = 0x20};
-    CUInt TrackNumber, TrackUID, TrackType;
-    CUInt FlagEnabled, FlagDefault, FlagLacing;
-    CUInt MinCache, MaxCache;
-    CUTF8 Name;
-    CANSI Language;
-    CBinary CodecID;
-    CBinary CodecPrivate;
-    CUTF8 CodecName;
-    CUTF8 CodecSettings;
-    CANSI CodecInfoURL;
-    CANSI CodecDownloadURL;
-    CUInt CodecDecodeAll;
-    CUInt TrackOverlay;
-    CUInt DefaultDuration;
-    enum {NoDesc = 0, DescVideo = 1, DescAudio = 2};
-    int DescType;
-    Video v;
-    Audio a;
-
-    TrackEntry(DWORD id = 0xAE);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class Track : public CID
-{
-public:
-    CNode<TrackEntry> TrackEntries;
-
-    Track(DWORD id = 0x1654AE6B);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class CBlock : public CID
-{
-public:
-    CLength TrackNumber;
-    REFERENCE_TIME TimeCode, TimeCodeStop;
-    CNode<CBinary> BlockData;
-
-    CBlock(DWORD id = 0xA1);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class BlockGroup : public CID
-{
-public:
-    CUInt BlockDuration;
-    CUInt ReferencePriority;
-    CInt ReferenceBlock;
-    CInt ReferenceVirtual;
-    CBinary CodecState;
-    CBlock Block;
+		QWORD Size(bool fWithHeader = true);
+		HRESULT Write(IStream* pStream);
+	};
+
+	class CANSI : public CStringA, public CID
+	{
+	public: 
+		CANSI(DWORD id) : CID(id) {}
+		CANSI& Set(CStringA str) {CStringA::operator = (str); return(*this);}
+		QWORD Size(bool fWithHeader = true);
+		HRESULT Write(IStream* pStream);
+	};
+
+	class CUTF8 : public CStringW, public CID
+	{
+	public: 
+		CUTF8(DWORD id) : CID(id) {}
+		CUTF8& Set(CStringW str) {CStringW::operator = (str); return(*this);}
+		QWORD Size(bool fWithHeader = true); 
+		HRESULT Write(IStream* pStream);
+	};
+
+	template<class T, class BASE>
+	class CSimpleVar : public CID
+	{
+	protected:
+		T m_val;
+		bool m_fSet;
+	public:
+		explicit CSimpleVar(DWORD id, T val = 0) : CID(id), m_val(val) {m_fSet = !!val;}
+		operator T() {return m_val;}
+		BASE& Set(T val) {m_val = val; m_fSet = true; return(*(BASE*)this);}
+		void UnSet() {m_fSet = false;}
+		QWORD Size(bool fWithHeader = true);
+		HRESULT Write(IStream* pStream);
+	};
+
+	class CUInt : public CSimpleVar<UINT64, CUInt>
+	{
+	public:
+		explicit CUInt(DWORD id, UINT64 val = 0) : CSimpleVar<UINT64, CUInt>(id, val) {}
+		QWORD Size(bool fWithHeader = true); 
+		HRESULT Write(IStream* pStream);
+	};
+
+	class CInt : public CSimpleVar<INT64, CInt>
+	{
+	public: 
+		explicit CInt(DWORD id, INT64 val = 0) : CSimpleVar<INT64, CInt>(id, val) {}
+		QWORD Size(bool fWithHeader = true);
+		HRESULT Write(IStream* pStream);
+	};
+
+	class CByte : public CSimpleVar<BYTE, CByte>
+	{
+	public: 
+		explicit CByte(DWORD id, BYTE val = 0) : CSimpleVar<BYTE, CByte>(id, val) {}
+	};
+
+	class CShort : public CSimpleVar<short, CShort>
+	{
+	public: 
+		explicit CShort(DWORD id, short val = 0) : CSimpleVar<short, CShort>(id, val) {}
+	};
+
+	class CFloat : public CSimpleVar<float, CFloat>
+	{
+	public: 
+		explicit CFloat(DWORD id, float val = 0) : CSimpleVar<float, CFloat>(id, val) {}
+	};
+
+	template<class T>
+	class CNode : public CAutoPtrList<T>
+	{
+	public: 
+		QWORD Size(bool fWithHeader = true)
+		{
+			QWORD len = 0;
+			POSITION pos = GetHeadPosition();
+			while(pos) len += GetNext(pos)->Size(fWithHeader);
+			return len;
+		}
+		HRESULT Write(IStream* pStream)
+		{
+			HRESULT hr;
+			POSITION pos = GetHeadPosition();
+			while(pos) if(FAILED(hr = GetNext(pos)->Write(pStream))) return hr;
+			return S_OK;
+		}
+	};
+
+	class EBML : public CID
+	{
+	public:
+		CUInt EBMLVersion, EBMLReadVersion;
+		CUInt EBMLMaxIDLength, EBMLMaxSizeLength;
+		CANSI DocType;
+		CUInt DocTypeVersion, DocTypeReadVersion;
+
+		EBML(DWORD id = 0x1A45DFA3);
+		QWORD Size(bool fWithHeader = true);
+		HRESULT Write(IStream* pStream);
+	};
+
+		class Info : public CID
+		{
+		public:
+			CBinary SegmentUID, PrevUID, NextUID;
+			CUTF8 SegmentFilename, PrevFilename, NextFilename;
+			CUInt TimeCodeScale; // [ns], default: 1.000.000
+			CFloat Duration;
+			CInt DateUTC;
+			CUTF8 Title, MuxingApp, WritingApp;
+
+			Info(DWORD id = 0x1549A966);
+			QWORD Size(bool fWithHeader = true);
+			HRESULT Write(IStream* pStream);
+		};
+
+				class Video : public CID
+				{
+				public:
+					CUInt FlagInterlaced, StereoMode;
+					CUInt PixelWidth, PixelHeight, DisplayWidth, DisplayHeight, DisplayUnit;
+					CUInt AspectRatioType;
+					CUInt ColourSpace;
+					CFloat GammaValue;
+					CFloat FramePerSec;
+
+					Video(DWORD id = 0xE0);
+					QWORD Size(bool fWithHeader = true);
+					HRESULT Write(IStream* pStream);
+				};
+
+				class Audio : public CID
+				{
+				public:
+					CFloat SamplingFrequency;
+					CFloat OutputSamplingFrequency;
+					CUInt Channels;
+					CBinary ChannelPositions;
+					CUInt BitDepth;
+
+					Audio(DWORD id = 0xE1);
+					QWORD Size(bool fWithHeader = true);
+					HRESULT Write(IStream* pStream);
+				};
+
+			class TrackEntry : public CID
+			{
+			public:
+				enum {TypeVideo = 1, TypeAudio = 2, TypeComplex = 3, TypeLogo = 0x10, TypeSubtitle = 0x11, TypeControl = 0x20};
+				CUInt TrackNumber, TrackUID, TrackType;
+				CUInt FlagEnabled, FlagDefault, FlagLacing;
+				CUInt MinCache, MaxCache;
+				CUTF8 Name;
+				CANSI Language;
+				CBinary CodecID;
+				CBinary CodecPrivate;
+				CUTF8 CodecName;
+				CUTF8 CodecSettings;
+				CANSI CodecInfoURL;
+				CANSI CodecDownloadURL;
+				CUInt CodecDecodeAll;
+				CUInt TrackOverlay;
+				CUInt DefaultDuration;
+				enum {NoDesc = 0, DescVideo = 1, DescAudio = 2};
+				int DescType;
+				Video v;
+				Audio a;
+
+				TrackEntry(DWORD id = 0xAE);
+				QWORD Size(bool fWithHeader = true);
+				HRESULT Write(IStream* pStream);
+			};
+
+		class Track : public CID
+		{
+		public:
+			CNode<TrackEntry> TrackEntries;
+
+			Track(DWORD id = 0x1654AE6B);
+			QWORD Size(bool fWithHeader = true);
+			HRESULT Write(IStream* pStream);
+		};
+
+				class CBlock : public CID
+				{
+				public:
+					CLength TrackNumber;
+					REFERENCE_TIME TimeCode, TimeCodeStop;
+					CNode<CBinary> BlockData;
+
+					CBlock(DWORD id = 0xA1);
+					QWORD Size(bool fWithHeader = true);
+					HRESULT Write(IStream* pStream);
+				};
+
+			class BlockGroup : public CID
+			{
+			public:
+				CUInt BlockDuration;
+				CUInt ReferencePriority;
+				CInt ReferenceBlock;
+				CInt ReferenceVirtual;
+				CBinary CodecState;
+				CBlock Block;
 //				CNode<TimeSlice> TimeSlices;
 
-    BlockGroup(DWORD id = 0xA0);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
+				BlockGroup(DWORD id = 0xA0);
+				QWORD Size(bool fWithHeader = true);
+				HRESULT Write(IStream* pStream);
+			};
 
-class Cluster : public CID
-{
-public:
-    CUInt TimeCode, Position, PrevSize;
-    CNode<BlockGroup> BlockGroups;
+		class Cluster : public CID
+		{
+		public:
+			CUInt TimeCode, Position, PrevSize;
+			CNode<BlockGroup> BlockGroups;
 
-    Cluster(DWORD id = 0x1F43B675);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
+			Cluster(DWORD id = 0x1F43B675);
+			QWORD Size(bool fWithHeader = true);
+			HRESULT Write(IStream* pStream);
+		};
 
 /*					class CueReference : public CID
 					{
@@ -335,96 +295,93 @@ public:
 						HRESULT Write(IStream* pStream);
 					};
 */
-class CueTrackPosition : public CID
-{
-public:
-    CUInt CueTrack, CueClusterPosition, CueBlockNumber, CueCodecState;
+				class CueTrackPosition : public CID
+				{
+				public:
+					CUInt CueTrack, CueClusterPosition, CueBlockNumber, CueCodecState;
 //					CNode<CueReference> CueReferences;
 
-    CueTrackPosition(DWORD id = 0xB7);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class CuePoint : public CID
-{
-public:
-    CUInt CueTime;
-    CNode<CueTrackPosition> CueTrackPositions;
-
-    CuePoint(DWORD id = 0xBB);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class Cue : public CID
-{
-public:
-    CNode<CuePoint> CuePoints;
-
-    Cue(DWORD id = 0x1C53BB6B);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class SeekID : public CID
-{
-    CID m_id;
-public:
-    SeekID(DWORD id = 0x53AB);
-    void Set(DWORD id)
-    {
-        m_id = id;
-    }
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class SeekHead : public CID
-{
-public:
-    SeekID ID;
-    CUInt Position;
-
-    SeekHead(DWORD id = 0x4DBB);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class Seek : public CID
-{
-public:
-    CNode<SeekHead> SeekHeads;
-
-    Seek(DWORD id = 0x114D9B74);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class Segment : public CID
-{
-public:
-    Segment(DWORD id = 0x18538067);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class Tags : public CID
-{
-public:
-    // TODO
-
-    Tags(DWORD id = 0x1254C367);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
-
-class Void : public CID
-{
-    QWORD m_len;
-public:
-    Void(QWORD len, DWORD id = 0xEC);
-    QWORD Size(bool fWithHeader = true);
-    HRESULT Write(IStream* pStream);
-};
+					CueTrackPosition(DWORD id = 0xB7);
+					QWORD Size(bool fWithHeader = true);
+					HRESULT Write(IStream* pStream);
+				};
+
+			class CuePoint : public CID
+			{
+			public:
+				CUInt CueTime;
+				CNode<CueTrackPosition> CueTrackPositions;
+
+				CuePoint(DWORD id = 0xBB);
+				QWORD Size(bool fWithHeader = true);
+				HRESULT Write(IStream* pStream);
+			};
+
+		class Cue : public CID
+		{
+		public:
+			CNode<CuePoint> CuePoints;
+
+			Cue(DWORD id = 0x1C53BB6B);
+			QWORD Size(bool fWithHeader = true);
+			HRESULT Write(IStream* pStream);
+		};
+
+				class SeekID : public CID
+				{
+					CID m_id;
+				public:
+					SeekID(DWORD id = 0x53AB);
+					void Set(DWORD id) {m_id = id;}
+					QWORD Size(bool fWithHeader = true);
+					HRESULT Write(IStream* pStream);
+				};
+
+			class SeekHead : public CID
+			{
+			public:
+				SeekID ID;
+				CUInt Position;
+
+				SeekHead(DWORD id = 0x4DBB);
+				QWORD Size(bool fWithHeader = true);
+				HRESULT Write(IStream* pStream);
+			};
+
+		class Seek : public CID
+		{
+		public:
+			CNode<SeekHead> SeekHeads;
+
+			Seek(DWORD id = 0x114D9B74);
+			QWORD Size(bool fWithHeader = true);
+			HRESULT Write(IStream* pStream);
+		};
+
+	class Segment : public CID
+	{
+	public:
+		Segment(DWORD id = 0x18538067);
+		QWORD Size(bool fWithHeader = true);
+		HRESULT Write(IStream* pStream);
+	};
+
+	class Tags : public CID
+	{
+	public:
+		// TODO
+
+		Tags(DWORD id = 0x1254C367);
+		QWORD Size(bool fWithHeader = true);
+		HRESULT Write(IStream* pStream);
+	};
+
+	class Void : public CID
+	{
+		QWORD m_len;
+	public:
+		Void(QWORD len, DWORD id = 0xEC);
+		QWORD Size(bool fWithHeader = true);
+		HRESULT Write(IStream* pStream);
+	};
 }
-- 
cgit v1.2.3