muxers: applied astyle formatting

git-svn-id: https://mpc-hc.svn.sourceforge.net/svnroot/mpc-hc/trunk@2252 10f7b99b-c216-0410-bff0-8a66a9350fd8

1 files changed, 365 insertions, 334 deletions

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);

+};

 }