From 60af42a80edbf24004c1662591721b9db454c248 Mon Sep 17 00:00:00 2001
From: XhmikosR <xhmikosr@users.sourceforge.net>
Date: Mon, 16 Aug 2010 12:52:56 +0000
Subject: muxers: applied astyle formatting

git-svn-id: https://mpc-hc.svn.sourceforge.net/svnroot/mpc-hc/trunk@2252 10f7b99b-c216-0410-bff0-8a66a9350fd8
---
 src/filters/muxer/MatroskaMuxer/MatroskaFile.h | 699 +++++++++++++------------
 1 file changed, 365 insertions(+), 334 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 80273dd76..feb94cd6c 100644
--- a/src/filters/muxer/MatroskaMuxer/MatroskaFile.h
+++ b/src/filters/muxer/MatroskaMuxer/MatroskaFile.h
@@ -1,20 +1,20 @@
-/* 
- *	Copyright (C) 2003-2006 Gabest
- *	http://www.gabest.org
+/*
+ *  Copyright (C) 2003-2006 Gabest
+ *  http://www.gabest.org
  *
  *  This Program is free software; you can redistribute it and/or modify
  *  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,264 +26,293 @@
 
 namespace MatroskaWriter
 {
-	typedef unsigned __int64 QWORD;
+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);}
+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);
-	};
+	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 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 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 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 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) {}
-	};
+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>
+template<class T>
+class CNode : public CAutoPtrList<T>
+{
+public:
+	QWORD Size(bool fWithHeader = true)
 	{
-	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
+		QWORD len = 0;
+		POSITION pos = GetHeadPosition();
+		while(pos) len += GetNext(pos)->Size(fWithHeader);
+		return len;
+	}
+	HRESULT Write(IStream* pStream)
 	{
-	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;
+		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
 					{
@@ -295,93 +324,95 @@ namespace MatroskaWriter
 						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);
-	};
+	CueTrackPosition(DWORD id = 0xB7);
+	QWORD Size(bool fWithHeader = true);
+	HRESULT Write(IStream* pStream);
+};
 
-	class Tags : public CID
-	{
-	public:
-		// TODO
+class CuePoint : public CID
+{
+public:
+	CUInt CueTime;
+	CNode<CueTrackPosition> CueTrackPositions;
 
-		Tags(DWORD id = 0x1254C367);
-		QWORD Size(bool fWithHeader = true);
-		HRESULT Write(IStream* pStream);
-	};
+	CuePoint(DWORD id = 0xBB);
+	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);
-	};
+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