apply the new astyle command; use 4 spaces for indentation and k&r style

Note: if you have any local patches just run astyle.bat

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

8 files changed, 1210 insertions, 1210 deletions

diff --git a/src/filters/reader/CDDAReader/CDDAReader.cpp b/src/filters/reader/CDDAReader/CDDAReader.cpp
index d5558e47a..5b33b21e2 100644
--- a/src/filters/reader/CDDAReader/CDDAReader.cpp
+++ b/src/filters/reader/CDDAReader/CDDAReader.cpp
@@ -29,51 +29,51 @@
 #include "../../../DSUtil/DSUtil.h"

 

 #define RAW_SECTOR_SIZE 2352

-#define MSF2UINT(hgs) ((hgs[1]*4500)+(hgs[2]*75)+(hgs[3]))

+#define MSF2UINT(hgs)   ((hgs[1] * 4500) + (hgs[2] * 75) + (hgs[3]))

 

 #ifdef REGISTER_FILTER

 

 const AMOVIESETUP_MEDIATYPE sudPinTypesOut[] = {

-	{&MEDIATYPE_Stream,	&MEDIASUBTYPE_WAVE},

+    {&MEDIATYPE_Stream, &MEDIASUBTYPE_WAVE},

 };

 

 const AMOVIESETUP_PIN sudOpPin[] = {

-	{L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, _countof(sudPinTypesOut), sudPinTypesOut},

+    {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, _countof(sudPinTypesOut), sudPinTypesOut},

 };

 

 const AMOVIESETUP_FILTER sudFilter[] = {

-	{&__uuidof(CCDDAReader), CCDDAReaderName, MERIT_NORMAL, _countof(sudOpPin), sudOpPin, CLSID_LegacyAmFilterCategory}

+    {&__uuidof(CCDDAReader), CCDDAReaderName, MERIT_NORMAL, _countof(sudOpPin), sudOpPin, CLSID_LegacyAmFilterCategory}

 };

 

 CFactoryTemplate g_Templates[] = {

-	{sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CCDDAReader>, NULL, &sudFilter[0]}

+    {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CCDDAReader>, NULL, &sudFilter[0]}

 };

 

 int g_cTemplates = _countof(g_Templates);

 

 STDAPI DllRegisterServer()

 {

-	SetRegKeyValue(

-		_T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{54A35221-2C8D-4a31-A5DF-6D809847E393}"),

-		_T("0"), _T("0,4,,52494646,8,4,,43444441")); // "RIFFxxxxCDDA"

+    SetRegKeyValue(

+        _T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{54A35221-2C8D-4a31-A5DF-6D809847E393}"),

+        _T("0"), _T("0,4,,52494646,8,4,,43444441")); // "RIFFxxxxCDDA"

 

-	SetRegKeyValue(

-		_T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{54A35221-2C8D-4a31-A5DF-6D809847E393}"),

-		_T("Source Filter"), _T("{54A35221-2C8D-4a31-A5DF-6D809847E393}"));

+    SetRegKeyValue(

+        _T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{54A35221-2C8D-4a31-A5DF-6D809847E393}"),

+        _T("Source Filter"), _T("{54A35221-2C8D-4a31-A5DF-6D809847E393}"));

 

-	SetRegKeyValue(

-		_T("Media Type\\Extensions"), _T(".cda"),

-		_T("Source Filter"), _T("{54A35221-2C8D-4a31-A5DF-6D809847E393}"));

+    SetRegKeyValue(

+        _T("Media Type\\Extensions"), _T(".cda"),

+        _T("Source Filter"), _T("{54A35221-2C8D-4a31-A5DF-6D809847E393}"));

 

-	return AMovieDllRegisterServer2(TRUE);

+    return AMovieDllRegisterServer2(TRUE);

 }

 

 STDAPI DllUnregisterServer()

 {

-	DeleteRegKey(_T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{54A35221-2C8D-4a31-A5DF-6D809847E393}"));

-	DeleteRegKey(_T("Media Type\\Extensions"), _T(".cda"));

+    DeleteRegKey(_T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{54A35221-2C8D-4a31-A5DF-6D809847E393}"));

+    DeleteRegKey(_T("Media Type\\Extensions"), _T(".cda"));

 

-	return AMovieDllRegisterServer2(FALSE);

+    return AMovieDllRegisterServer2(FALSE);

 }

 

 #include "../../FilterApp.h"

@@ -87,11 +87,11 @@ CFilterApp theApp;
 //

 

 CCDDAReader::CCDDAReader(IUnknown* pUnk, HRESULT* phr)

-	: CAsyncReader(NAME("CCDDAReader"), pUnk, &m_stream, phr, __uuidof(this))

+    : CAsyncReader(NAME("CCDDAReader"), pUnk, &m_stream, phr, __uuidof(this))

 {

-	if (phr) {

-		*phr = S_OK;

-	}

+    if (phr) {

+        *phr = S_OK;

+    }

 }

 

 CCDDAReader::~CCDDAReader()

@@ -100,393 +100,393 @@ CCDDAReader::~CCDDAReader()
 

 STDMETHODIMP CCDDAReader::NonDelegatingQueryInterface(REFIID riid, void** ppv)

 {

-	CheckPointer(ppv, E_POINTER);

+    CheckPointer(ppv, E_POINTER);

 

-	return

-		QI(IFileSourceFilter)

-		QI2(IAMMediaContent)

-		__super::NonDelegatingQueryInterface(riid, ppv);

+    return

+        QI(IFileSourceFilter)

+        QI2(IAMMediaContent)

+        __super::NonDelegatingQueryInterface(riid, ppv);

 }

 

 // IFileSourceFilter

 

 STDMETHODIMP CCDDAReader::Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt)

 {

-	if (!m_stream.Load(pszFileName)) {

-		return E_FAIL;

-	}

+    if (!m_stream.Load(pszFileName)) {

+        return E_FAIL;

+    }

 

-	m_fn = pszFileName;

+    m_fn = pszFileName;

 

-	CMediaType mt;

-	mt.majortype = MEDIATYPE_Stream;

-	mt.subtype = MEDIASUBTYPE_WAVE;

-	m_mt = mt;

+    CMediaType mt;

+    mt.majortype = MEDIATYPE_Stream;

+    mt.subtype = MEDIASUBTYPE_WAVE;

+    m_mt = mt;

 

-	return S_OK;

+    return S_OK;

 }

 

 STDMETHODIMP CCDDAReader::GetCurFile(LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt)

 {

-	CheckPointer(ppszFileName, E_POINTER);

+    CheckPointer(ppszFileName, E_POINTER);

 

-	*ppszFileName = (LPOLESTR)CoTaskMemAlloc((m_fn.GetLength()+1)*sizeof(WCHAR));

-	if (!(*ppszFileName)) {

-		return E_OUTOFMEMORY;

-	}

+    *ppszFileName = (LPOLESTR)CoTaskMemAlloc((m_fn.GetLength() + 1) * sizeof(WCHAR));

+    if (!(*ppszFileName)) {

+        return E_OUTOFMEMORY;

+    }

 

-	wcscpy_s(*ppszFileName, m_fn.GetLength() + 1, m_fn);

+    wcscpy_s(*ppszFileName, m_fn.GetLength() + 1, m_fn);

 

-	return S_OK;

+    return S_OK;

 }

 

 // IAMMediaContent

 

 STDMETHODIMP CCDDAReader::GetTypeInfoCount(UINT* pctinfo)

 {

-	return E_NOTIMPL;

+    return E_NOTIMPL;

 }

 

 STDMETHODIMP CCDDAReader::GetTypeInfo(UINT itinfo, LCID lcid, ITypeInfo** pptinfo)

 {

-	return E_NOTIMPL;

+    return E_NOTIMPL;

 }

 

 STDMETHODIMP CCDDAReader::GetIDsOfNames(REFIID riid, OLECHAR** rgszNames, UINT cNames, LCID lcid, DISPID* rgdispid)

 {

-	return E_NOTIMPL;

+    return E_NOTIMPL;

 }

 

 STDMETHODIMP CCDDAReader::Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pdispparams, VARIANT* pvarResult, EXCEPINFO* pexcepinfo, UINT* puArgErr)

 {

-	return E_NOTIMPL;

+    return E_NOTIMPL;

 }

 

 STDMETHODIMP CCDDAReader::get_AuthorName(BSTR* pbstrAuthorName)

 {

-	CheckPointer(pbstrAuthorName, E_POINTER);

-	CString str = m_stream.m_trackArtist;

-	if (str.IsEmpty()) {

-		str = m_stream.m_discArtist;

-	}

-	*pbstrAuthorName = str.AllocSysString();

-	return S_OK;

+    CheckPointer(pbstrAuthorName, E_POINTER);

+    CString str = m_stream.m_trackArtist;

+    if (str.IsEmpty()) {

+        str = m_stream.m_discArtist;

+    }

+    *pbstrAuthorName = str.AllocSysString();

+    return S_OK;

 }

 

 STDMETHODIMP CCDDAReader::get_Title(BSTR* pbstrTitle)

 {

-	CheckPointer(pbstrTitle, E_POINTER);

-	CString str = m_stream.m_trackTitle;

-	if (str.IsEmpty()) {

-		str = m_stream.m_discTitle;

-	}

-	*pbstrTitle = str.AllocSysString();

-	return S_OK;

+    CheckPointer(pbstrTitle, E_POINTER);

+    CString str = m_stream.m_trackTitle;

+    if (str.IsEmpty()) {

+        str = m_stream.m_discTitle;

+    }

+    *pbstrTitle = str.AllocSysString();

+    return S_OK;

 }

 

 STDMETHODIMP CCDDAReader::get_Rating(BSTR* pbstrRating)

 {

-	return E_NOTIMPL;

+    return E_NOTIMPL;

 }

 

 STDMETHODIMP CCDDAReader::get_Description(BSTR* pbstrDescription)

 {

-	return E_NOTIMPL;

+    return E_NOTIMPL;

 }

 

 STDMETHODIMP CCDDAReader::get_Copyright(BSTR* pbstrCopyright)

 {

-	return E_NOTIMPL;

+    return E_NOTIMPL;

 }

 

 STDMETHODIMP CCDDAReader::get_BaseURL(BSTR* pbstrBaseURL)

 {

-	return E_NOTIMPL;

+    return E_NOTIMPL;

 }

 

 STDMETHODIMP CCDDAReader::get_LogoURL(BSTR* pbstrLogoURL)

 {

-	return E_NOTIMPL;

+    return E_NOTIMPL;

 }

 

 STDMETHODIMP CCDDAReader::get_LogoIconURL(BSTR* pbstrLogoURL)

 {

-	return E_NOTIMPL;

+    return E_NOTIMPL;

 }

 

 STDMETHODIMP CCDDAReader::get_WatermarkURL(BSTR* pbstrWatermarkURL)

 {

-	return E_NOTIMPL;

+    return E_NOTIMPL;

 }

 

 STDMETHODIMP CCDDAReader::get_MoreInfoURL(BSTR* pbstrMoreInfoURL)

 {

-	return E_NOTIMPL;

+    return E_NOTIMPL;

 }

 

 STDMETHODIMP CCDDAReader::get_MoreInfoBannerImage(BSTR* pbstrMoreInfoBannerImage)

 {

-	return E_NOTIMPL;

+    return E_NOTIMPL;

 }

 

 STDMETHODIMP CCDDAReader::get_MoreInfoBannerURL(BSTR* pbstrMoreInfoBannerURL)

 {

-	return E_NOTIMPL;

+    return E_NOTIMPL;

 }

 

 STDMETHODIMP CCDDAReader::get_MoreInfoText(BSTR* pbstrMoreInfoText)

 {

-	return E_NOTIMPL;

+    return E_NOTIMPL;

 }

 

 // CCDDAStream

 

 CCDDAStream::CCDDAStream()

 {

-	m_hDrive = INVALID_HANDLE_VALUE;

+    m_hDrive = INVALID_HANDLE_VALUE;

 

-	m_llPosition = m_llLength = 0;

+    m_llPosition = m_llLength = 0;

 

-	memset(&m_TOC, 0, sizeof(m_TOC));

-	m_nStartSector = m_nStopSector = 0;

+    memset(&m_TOC, 0, sizeof(m_TOC));

+    m_nStartSector = m_nStopSector = 0;

 

-	memset(&m_header, 0, sizeof(m_header));

-	m_header.riff.hdr.chunkID = RIFFID;

-	m_header.riff.WAVE = WAVEID;

-	m_header.frm.hdr.chunkID = FormatID;

-	m_header.frm.hdr.chunkSize = sizeof(m_header.frm.pcm);

-	m_header.frm.pcm.wf.wFormatTag = WAVE_FORMAT_PCM;

-	m_header.frm.pcm.wf.nSamplesPerSec = 44100;

-	m_header.frm.pcm.wf.nChannels = 2;

-	m_header.frm.pcm.wBitsPerSample = 16;

-	m_header.frm.pcm.wf.nBlockAlign = m_header.frm.pcm.wf.nChannels * m_header.frm.pcm.wBitsPerSample / 8;

-	m_header.frm.pcm.wf.nAvgBytesPerSec = m_header.frm.pcm.wf.nSamplesPerSec * m_header.frm.pcm.wf.nBlockAlign;

-	m_header.data.hdr.chunkID = DataID;

+    memset(&m_header, 0, sizeof(m_header));

+    m_header.riff.hdr.chunkID = RIFFID;

+    m_header.riff.WAVE = WAVEID;

+    m_header.frm.hdr.chunkID = FormatID;

+    m_header.frm.hdr.chunkSize = sizeof(m_header.frm.pcm);

+    m_header.frm.pcm.wf.wFormatTag = WAVE_FORMAT_PCM;

+    m_header.frm.pcm.wf.nSamplesPerSec = 44100;

+    m_header.frm.pcm.wf.nChannels = 2;

+    m_header.frm.pcm.wBitsPerSample = 16;

+    m_header.frm.pcm.wf.nBlockAlign = m_header.frm.pcm.wf.nChannels * m_header.frm.pcm.wBitsPerSample / 8;

+    m_header.frm.pcm.wf.nAvgBytesPerSec = m_header.frm.pcm.wf.nSamplesPerSec * m_header.frm.pcm.wf.nBlockAlign;

+    m_header.data.hdr.chunkID = DataID;

 }

 

 CCDDAStream::~CCDDAStream()

 {

-	if (m_hDrive != INVALID_HANDLE_VALUE) {

-		CloseHandle(m_hDrive);

-		m_hDrive = INVALID_HANDLE_VALUE;

-	}

+    if (m_hDrive != INVALID_HANDLE_VALUE) {

+        CloseHandle(m_hDrive);

+        m_hDrive = INVALID_HANDLE_VALUE;

+    }

 }

 

 bool CCDDAStream::Load(const WCHAR* fnw)

 {

-	CString path(fnw);

-

-	int iDriveLetter = path.Find(_T(":\\"))-1;

-	int iTrackIndex = CString(path).MakeLower().Find(_T(".cda"))-1;

-	if (iDriveLetter < 0 || iTrackIndex <= iDriveLetter) {

-		return false;

-	}

-

-	CString drive = CString(_T("\\\\.\\")) + path[iDriveLetter] + _T(":");

-	while (iTrackIndex > 0 && _istdigit(path[iTrackIndex-1])) {

-		iTrackIndex--;

-	}

-	if (1 != _stscanf_s(path.Mid(iTrackIndex), _T("%d"), &iTrackIndex)) {

-		return false;

-	}

-

-	if (m_hDrive != INVALID_HANDLE_VALUE) {

-		CloseHandle(m_hDrive);

-		m_hDrive = INVALID_HANDLE_VALUE;

-	}

-

-	m_hDrive = CreateFile(drive, GENERIC_READ, FILE_SHARE_READ, NULL,

-						  OPEN_EXISTING, FILE_ATTRIBUTE_READONLY|FILE_FLAG_SEQUENTIAL_SCAN, (HANDLE)NULL);

-	if (m_hDrive == INVALID_HANDLE_VALUE) {

-		return false;

-	}

-

-	DWORD BytesReturned;

-	if (!DeviceIoControl(m_hDrive, IOCTL_CDROM_READ_TOC, NULL, 0, &m_TOC, sizeof(m_TOC), &BytesReturned, 0)

-			|| !(m_TOC.FirstTrack <= iTrackIndex && iTrackIndex <= m_TOC.LastTrack)) {

-		CloseHandle(m_hDrive);

-		m_hDrive = INVALID_HANDLE_VALUE;

-		return false;

-	}

-

-	// MMC-3 Draft Revision 10g: Table 222 - Q Sub-channel control field

-	m_TOC.TrackData[iTrackIndex-1].Control &= 5;

-	if (!(m_TOC.TrackData[iTrackIndex-1].Control == 0 || m_TOC.TrackData[iTrackIndex-1].Control == 1)) {

-		CloseHandle(m_hDrive);

-		m_hDrive = INVALID_HANDLE_VALUE;

-		return false;

-	}

-

-	if (m_TOC.TrackData[iTrackIndex-1].Control&8) {

-		m_header.frm.pcm.wf.nChannels = 4;

-	}

-

-	m_nStartSector = MSF2UINT(m_TOC.TrackData[iTrackIndex-1].Address) - 150;//MSF2UINT(m_TOC.TrackData[0].Address);

-	m_nStopSector = MSF2UINT(m_TOC.TrackData[iTrackIndex].Address) - 150;//MSF2UINT(m_TOC.TrackData[0].Address);

-

-	m_llLength = (m_nStopSector-m_nStartSector)*RAW_SECTOR_SIZE;

-

-	m_header.riff.hdr.chunkSize = (long)(m_llLength + sizeof(m_header) - 8);

-	m_header.data.hdr.chunkSize = (long)(m_llLength);

-

-	do {

-		CDROM_READ_TOC_EX TOCEx;

-		memset(&TOCEx, 0, sizeof(TOCEx));

-		TOCEx.Format = CDROM_READ_TOC_EX_FORMAT_CDTEXT;

-		TOCEx.SessionTrack = iTrackIndex;

-		WORD size = 0;

-		ASSERT(MINIMUM_CDROM_READ_TOC_EX_SIZE == sizeof(size));

-		if (!DeviceIoControl(m_hDrive, IOCTL_CDROM_READ_TOC_EX, &TOCEx, sizeof(TOCEx), &size, sizeof(size), &BytesReturned, 0)) {

-			break;

-		}

-

-		size = ((size>>8)|(size<<8)) + sizeof(size);

-

-		CAutoVectorPtr<BYTE> pCDTextData;

-		pCDTextData.Allocate(size);

-		memset(pCDTextData, 0, size);

-

-		if (!DeviceIoControl(m_hDrive, IOCTL_CDROM_READ_TOC_EX, &TOCEx, sizeof(TOCEx), pCDTextData, size, &BytesReturned, 0)) {

-			break;

-		}

-

-		size = (WORD)(BytesReturned - sizeof(CDROM_TOC_CD_TEXT_DATA));

-		CDROM_TOC_CD_TEXT_DATA_BLOCK* pDesc = ((CDROM_TOC_CD_TEXT_DATA*)(BYTE*)pCDTextData)->Descriptors;

-

-		CStringArray str[16];

-		for (int i = 0; i < 16; i++) {

-			str[i].SetSize(1+m_TOC.LastTrack);

-		}

-		CString last;

-

-		for (int i = 0; size >= sizeof(CDROM_TOC_CD_TEXT_DATA_BLOCK); i++, size -= sizeof(CDROM_TOC_CD_TEXT_DATA_BLOCK), pDesc++) {

-			if (pDesc->TrackNumber > m_TOC.LastTrack) {

-				continue;

-			}

-

-			const int lenU = _countof(pDesc->Text);

-			const int lenW = _countof(pDesc->WText);

-

-			CString text = !pDesc->Unicode

-						   ? CString(CStringA((CHAR*)pDesc->Text, lenU))

-						   : CString(CStringW((WCHAR*)pDesc->WText, lenW));

-

-			int tlen = text.GetLength();

-			CString tmp = (tlen < 12-1)

-						  ? (!pDesc->Unicode

-							 ? CString(CStringA((CHAR*)pDesc->Text+tlen+1, lenU-(tlen+1)))

-							 : CString(CStringW((WCHAR*)pDesc->WText+tlen+1, lenW-(tlen+1))))

-							  : _T("");

-

-			if ((pDesc->PackType -= 0x80) >= 0x10) {

-				continue;

-			}

-

-			if (pDesc->CharacterPosition == 0) {

-				str[pDesc->PackType][pDesc->TrackNumber] = text;

-			} else if (pDesc->CharacterPosition <= 0xf) {

-				if (pDesc->CharacterPosition < 0xf && last.GetLength() > 0) {

-					str[pDesc->PackType][pDesc->TrackNumber] = last + text;

-				} else {

-					str[pDesc->PackType][pDesc->TrackNumber] += text;

-				}

-			}

-

-			last = tmp;

-		}

-

-		m_discTitle = str[0][0];

-		m_trackTitle = str[0][iTrackIndex];

-		m_discArtist = str[1][0];

-		m_trackArtist = str[1][iTrackIndex];

-	} while (0);

-

-

-	return true;

+    CString path(fnw);

+

+    int iDriveLetter = path.Find(_T(":\\")) - 1;

+    int iTrackIndex = CString(path).MakeLower().Find(_T(".cda")) - 1;

+    if (iDriveLetter < 0 || iTrackIndex <= iDriveLetter) {

+        return false;

+    }

+

+    CString drive = CString(_T("\\\\.\\")) + path[iDriveLetter] + _T(":");

+    while (iTrackIndex > 0 && _istdigit(path[iTrackIndex - 1])) {

+        iTrackIndex--;

+    }

+    if (1 != _stscanf_s(path.Mid(iTrackIndex), _T("%d"), &iTrackIndex)) {

+        return false;

+    }

+

+    if (m_hDrive != INVALID_HANDLE_VALUE) {

+        CloseHandle(m_hDrive);

+        m_hDrive = INVALID_HANDLE_VALUE;

+    }

+

+    m_hDrive = CreateFile(drive, GENERIC_READ, FILE_SHARE_READ, NULL,

+                          OPEN_EXISTING, FILE_ATTRIBUTE_READONLY | FILE_FLAG_SEQUENTIAL_SCAN, (HANDLE)NULL);

+    if (m_hDrive == INVALID_HANDLE_VALUE) {

+        return false;

+    }

+

+    DWORD BytesReturned;

+    if (!DeviceIoControl(m_hDrive, IOCTL_CDROM_READ_TOC, NULL, 0, &m_TOC, sizeof(m_TOC), &BytesReturned, 0)

+            || !(m_TOC.FirstTrack <= iTrackIndex && iTrackIndex <= m_TOC.LastTrack)) {

+        CloseHandle(m_hDrive);

+        m_hDrive = INVALID_HANDLE_VALUE;

+        return false;

+    }

+

+    // MMC-3 Draft Revision 10g: Table 222 - Q Sub-channel control field

+    m_TOC.TrackData[iTrackIndex - 1].Control &= 5;

+    if (!(m_TOC.TrackData[iTrackIndex - 1].Control == 0 || m_TOC.TrackData[iTrackIndex - 1].Control == 1)) {

+        CloseHandle(m_hDrive);

+        m_hDrive = INVALID_HANDLE_VALUE;

+        return false;

+    }

+

+    if (m_TOC.TrackData[iTrackIndex - 1].Control & 8) {

+        m_header.frm.pcm.wf.nChannels = 4;

+    }

+

+    m_nStartSector = MSF2UINT(m_TOC.TrackData[iTrackIndex - 1].Address) - 150; //MSF2UINT(m_TOC.TrackData[0].Address);

+    m_nStopSector = MSF2UINT(m_TOC.TrackData[iTrackIndex].Address) - 150;//MSF2UINT(m_TOC.TrackData[0].Address);

+

+    m_llLength = (m_nStopSector - m_nStartSector) * RAW_SECTOR_SIZE;

+

+    m_header.riff.hdr.chunkSize = (long)(m_llLength + sizeof(m_header) - 8);

+    m_header.data.hdr.chunkSize = (long)(m_llLength);

+

+    do {

+        CDROM_READ_TOC_EX TOCEx;

+        memset(&TOCEx, 0, sizeof(TOCEx));

+        TOCEx.Format = CDROM_READ_TOC_EX_FORMAT_CDTEXT;

+        TOCEx.SessionTrack = iTrackIndex;

+        WORD size = 0;

+        ASSERT(MINIMUM_CDROM_READ_TOC_EX_SIZE == sizeof(size));

+        if (!DeviceIoControl(m_hDrive, IOCTL_CDROM_READ_TOC_EX, &TOCEx, sizeof(TOCEx), &size, sizeof(size), &BytesReturned, 0)) {

+            break;

+        }

+

+        size = ((size >> 8) | (size << 8)) + sizeof(size);

+

+        CAutoVectorPtr<BYTE> pCDTextData;

+        pCDTextData.Allocate(size);

+        memset(pCDTextData, 0, size);

+

+        if (!DeviceIoControl(m_hDrive, IOCTL_CDROM_READ_TOC_EX, &TOCEx, sizeof(TOCEx), pCDTextData, size, &BytesReturned, 0)) {

+            break;

+        }

+

+        size = (WORD)(BytesReturned - sizeof(CDROM_TOC_CD_TEXT_DATA));

+        CDROM_TOC_CD_TEXT_DATA_BLOCK* pDesc = ((CDROM_TOC_CD_TEXT_DATA*)(BYTE*)pCDTextData)->Descriptors;

+

+        CStringArray str[16];

+        for (int i = 0; i < 16; i++) {

+            str[i].SetSize(1 + m_TOC.LastTrack);

+        }

+        CString last;

+

+        for (int i = 0; size >= sizeof(CDROM_TOC_CD_TEXT_DATA_BLOCK); i++, size -= sizeof(CDROM_TOC_CD_TEXT_DATA_BLOCK), pDesc++) {

+            if (pDesc->TrackNumber > m_TOC.LastTrack) {

+                continue;

+            }

+

+            const int lenU = _countof(pDesc->Text);

+            const int lenW = _countof(pDesc->WText);

+

+            CString text = !pDesc->Unicode

+                           ? CString(CStringA((CHAR*)pDesc->Text, lenU))

+                           : CString(CStringW((WCHAR*)pDesc->WText, lenW));

+

+            int tlen = text.GetLength();

+            CString tmp = (tlen < 12 - 1)

+                          ? (!pDesc->Unicode

+                             ? CString(CStringA((CHAR*)pDesc->Text + tlen + 1, lenU - (tlen + 1)))

+                             : CString(CStringW((WCHAR*)pDesc->WText + tlen + 1, lenW - (tlen + 1))))

+                              : _T("");

+

+            if ((pDesc->PackType -= 0x80) >= 0x10) {

+                continue;

+            }

+

+            if (pDesc->CharacterPosition == 0) {

+                str[pDesc->PackType][pDesc->TrackNumber] = text;

+            } else if (pDesc->CharacterPosition <= 0xf) {

+                if (pDesc->CharacterPosition < 0xf && last.GetLength() > 0) {

+                    str[pDesc->PackType][pDesc->TrackNumber] = last + text;

+                } else {

+                    str[pDesc->PackType][pDesc->TrackNumber] += text;

+                }

+            }

+

+            last = tmp;

+        }

+

+        m_discTitle = str[0][0];

+        m_trackTitle = str[0][iTrackIndex];

+        m_discArtist = str[1][0];

+        m_trackArtist = str[1][iTrackIndex];

+    } while (0);

+

+

+    return true;

 }

 

 HRESULT CCDDAStream::SetPointer(LONGLONG llPos)

 {

-	if (llPos < 0 || llPos > m_llLength) {

-		return S_FALSE;

-	}

-	m_llPosition = llPos;

-	return S_OK;

+    if (llPos < 0 || llPos > m_llLength) {

+        return S_FALSE;

+    }

+    m_llPosition = llPos;

+    return S_OK;

 }

 

 HRESULT CCDDAStream::Read(PBYTE pbBuffer, DWORD dwBytesToRead, BOOL bAlign, LPDWORD pdwBytesRead)

 {

-	CAutoLock lck(&m_csLock);

+    CAutoLock lck(&m_csLock);

 

-	BYTE buff[RAW_SECTOR_SIZE];

+    BYTE buff[RAW_SECTOR_SIZE];

 

-	PBYTE pbBufferOrg = pbBuffer;

-	LONGLONG pos = m_llPosition;

-	size_t len = (size_t)dwBytesToRead;

+    PBYTE pbBufferOrg = pbBuffer;

+    LONGLONG pos = m_llPosition;

+    size_t len = (size_t)dwBytesToRead;

 

-	if (pos < sizeof(m_header) && len > 0) {

-		size_t l = (size_t)min(len, sizeof(m_header) - pos);

-		memcpy(pbBuffer, &((BYTE*)&m_header)[pos], l);

-		pbBuffer += l;

-		pos += l;

-		len -= l;

-	}

+    if (pos < sizeof(m_header) && len > 0) {

+        size_t l = (size_t)min(len, sizeof(m_header) - pos);

+        memcpy(pbBuffer, &((BYTE*)&m_header)[pos], l);

+        pbBuffer += l;

+        pos += l;

+        len -= l;

+    }

 

-	pos -= sizeof(m_header);

+    pos -= sizeof(m_header);

 

-	while (pos >= 0 && pos < m_llLength && len > 0) {

-		RAW_READ_INFO rawreadinfo;

-		rawreadinfo.SectorCount = 1;

-		rawreadinfo.TrackMode = CDDA;

+    while (pos >= 0 && pos < m_llLength && len > 0) {

+        RAW_READ_INFO rawreadinfo;

+        rawreadinfo.SectorCount = 1;

+        rawreadinfo.TrackMode = CDDA;

 

-		UINT sector = m_nStartSector + int(pos/RAW_SECTOR_SIZE);

-		__int64 offset = pos%RAW_SECTOR_SIZE;

+        UINT sector = m_nStartSector + int(pos / RAW_SECTOR_SIZE);

+        __int64 offset = pos % RAW_SECTOR_SIZE;

 

-		rawreadinfo.DiskOffset.QuadPart = sector*2048;

-		DWORD BytesReturned = 0;

-		BOOL b = DeviceIoControl(

-					 m_hDrive, IOCTL_CDROM_RAW_READ,

-					 &rawreadinfo, sizeof(rawreadinfo),

-					 buff, RAW_SECTOR_SIZE,

-					 &BytesReturned, 0);

-		UNREFERENCED_PARAMETER(b);

+        rawreadinfo.DiskOffset.QuadPart = sector * 2048;

+        DWORD BytesReturned = 0;

+        BOOL b = DeviceIoControl(

+                     m_hDrive, IOCTL_CDROM_RAW_READ,

+                     &rawreadinfo, sizeof(rawreadinfo),

+                     buff, RAW_SECTOR_SIZE,

+                     &BytesReturned, 0);

+        UNREFERENCED_PARAMETER(b);

 

-		size_t l = (size_t)min(min(len, size_t(RAW_SECTOR_SIZE - offset)), size_t(m_llLength - pos));

-		memcpy(pbBuffer, &buff[offset], l);

+        size_t l = (size_t)min(min(len, size_t(RAW_SECTOR_SIZE - offset)), size_t(m_llLength - pos));

+        memcpy(pbBuffer, &buff[offset], l);

 

-		pbBuffer += l;

-		pos += l;

-		len -= l;

-	}

+        pbBuffer += l;

+        pos += l;

+        len -= l;

+    }

 

-	if (pdwBytesRead) {

-		*pdwBytesRead = pbBuffer - pbBufferOrg;

-	}

-	m_llPosition += pbBuffer - pbBufferOrg;

+    if (pdwBytesRead) {

+        *pdwBytesRead = pbBuffer - pbBufferOrg;

+    }

+    m_llPosition += pbBuffer - pbBufferOrg;

 

-	return S_OK;

+    return S_OK;

 }

 

 LONGLONG CCDDAStream::Size(LONGLONG* pSizeAvailable)

 {

-	LONGLONG size = sizeof(m_header) + m_llLength;

-	if (pSizeAvailable) {

-		*pSizeAvailable = size;

-	}

-	return size;

+    LONGLONG size = sizeof(m_header) + m_llLength;

+    if (pSizeAvailable) {

+        *pSizeAvailable = size;

+    }

+    return size;

 }

 

 DWORD CCDDAStream::Alignment()

 {

-	return 1;

+    return 1;

 }

 

 void CCDDAStream::Lock()

 {

-	m_csLock.Lock();

+    m_csLock.Lock();

 }

 

 void CCDDAStream::Unlock()

 {

-	m_csLock.Unlock();

+    m_csLock.Unlock();

 }

diff --git a/src/filters/reader/CDDAReader/CDDAReader.h b/src/filters/reader/CDDAReader/CDDAReader.h
index af33cae90..2ed9f2daf 100644
--- a/src/filters/reader/CDDAReader/CDDAReader.h
+++ b/src/filters/reader/CDDAReader/CDDAReader.h
@@ -33,104 +33,104 @@
 #define CCDDAReaderName L"MPC CDDA Reader"

 

 typedef struct {

-	UINT chunkID;

-	long chunkSize;

+    UINT chunkID;

+    long chunkSize;

 } ChunkHeader;

 

 #define RIFFID 'FFIR'

 #define WAVEID 'EVAW'

 typedef struct {

-	ChunkHeader hdr;

-	UINT WAVE;

+    ChunkHeader hdr;

+    UINT WAVE;

 } RIFFChunk;

 

 #define FormatID ' tmf'

 typedef struct {

-	ChunkHeader hdr;

-	PCMWAVEFORMAT pcm;

+    ChunkHeader hdr;

+    PCMWAVEFORMAT pcm;

 } FormatChunk;

 

 #define DataID 'atad'

 typedef struct {

-	ChunkHeader hdr;

+    ChunkHeader hdr;

 } DataChunk;

 

 typedef struct {

-	RIFFChunk riff;

-	FormatChunk frm;

-	DataChunk data;

+    RIFFChunk riff;

+    FormatChunk frm;

+    DataChunk data;

 } WAVEChunck;

 

 class CCDDAStream : public CAsyncStream

 {

 private:

-	CCritSec m_csLock;

+    CCritSec m_csLock;

 

-	LONGLONG m_llPosition, m_llLength;

+    LONGLONG m_llPosition, m_llLength;

 

-	HANDLE m_hDrive;

-	CDROM_TOC m_TOC;

-	UINT m_nFirstSector, m_nStartSector, m_nStopSector;

+    HANDLE m_hDrive;

+    CDROM_TOC m_TOC;

+    UINT m_nFirstSector, m_nStartSector, m_nStopSector;

 

-	WAVEChunck m_header;

+    WAVEChunck m_header;

 

 public:

-	CCDDAStream();

-	virtual ~CCDDAStream();

+    CCDDAStream();

+    virtual ~CCDDAStream();

 

-	CString m_discTitle, m_trackTitle;

-	CString m_discArtist, m_trackArtist;

+    CString m_discTitle, m_trackTitle;

+    CString m_discArtist, m_trackArtist;

 

-	bool Load(const WCHAR* fnw);

+    bool Load(const WCHAR* fnw);

 

-	// overrides

-	HRESULT SetPointer(LONGLONG llPos);

-	HRESULT Read(PBYTE pbBuffer, DWORD dwBytesToRead, BOOL bAlign, LPDWORD pdwBytesRead);

-	LONGLONG Size(LONGLONG* pSizeAvailable);

-	DWORD Alignment();

-	void Lock();

-	void Unlock();

+    // overrides

+    HRESULT SetPointer(LONGLONG llPos);

+    HRESULT Read(PBYTE pbBuffer, DWORD dwBytesToRead, BOOL bAlign, LPDWORD pdwBytesRead);

+    LONGLONG Size(LONGLONG* pSizeAvailable);

+    DWORD Alignment();

+    void Lock();

+    void Unlock();

 };

 

 class __declspec(uuid("54A35221-2C8D-4a31-A5DF-6D809847E393"))

-	CCDDAReader

-	: public CAsyncReader

-	, public IFileSourceFilter

-	, public IAMMediaContent

+    CCDDAReader

+    : public CAsyncReader

+    , public IFileSourceFilter

+    , public IAMMediaContent

 {

-	CCDDAStream m_stream;

-	CStringW m_fn;

+    CCDDAStream m_stream;

+    CStringW m_fn;

 

 public:

-	CCDDAReader(IUnknown* pUnk, HRESULT* phr);

-	~CCDDAReader();

-

-	DECLARE_IUNKNOWN;

-	STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv);

-

-	// IFileSourceFilter

-

-	STDMETHODIMP Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt);

-	STDMETHODIMP GetCurFile(LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt);

-

-	// IAMMediaContent

-

-	STDMETHODIMP GetTypeInfoCount(UINT* pctinfo);

-	STDMETHODIMP GetTypeInfo(UINT itinfo, LCID lcid, ITypeInfo** pptinfo);

-	STDMETHODIMP GetIDsOfNames(REFIID riid, OLECHAR** rgszNames, UINT cNames, LCID lcid, DISPID* rgdispid);

-	STDMETHODIMP Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pdispparams, VARIANT* pvarResult, EXCEPINFO* pexcepinfo, UINT* puArgErr);

-

-	STDMETHODIMP get_AuthorName(BSTR* pbstrAuthorName);

-	STDMETHODIMP get_Title(BSTR* pbstrTitle);

-	STDMETHODIMP get_Rating(BSTR* pbstrRating);

-	STDMETHODIMP get_Description(BSTR* pbstrDescription);

-	STDMETHODIMP get_Copyright(BSTR* pbstrCopyright);

-	STDMETHODIMP get_BaseURL(BSTR* pbstrBaseURL);

-	STDMETHODIMP get_LogoURL(BSTR* pbstrLogoURL);

-	STDMETHODIMP get_LogoIconURL(BSTR* pbstrLogoURL);

-	STDMETHODIMP get_WatermarkURL(BSTR* pbstrWatermarkURL);

-	STDMETHODIMP get_MoreInfoURL(BSTR* pbstrMoreInfoURL);

-	STDMETHODIMP get_MoreInfoBannerImage(BSTR* pbstrMoreInfoBannerImage);

-	STDMETHODIMP get_MoreInfoBannerURL(BSTR* pbstrMoreInfoBannerURL);

-	STDMETHODIMP get_MoreInfoText(BSTR* pbstrMoreInfoText);

+    CCDDAReader(IUnknown* pUnk, HRESULT* phr);

+    ~CCDDAReader();

+

+    DECLARE_IUNKNOWN;

+    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv);

+

+    // IFileSourceFilter

+

+    STDMETHODIMP Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt);

+    STDMETHODIMP GetCurFile(LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt);

+

+    // IAMMediaContent

+

+    STDMETHODIMP GetTypeInfoCount(UINT* pctinfo);

+    STDMETHODIMP GetTypeInfo(UINT itinfo, LCID lcid, ITypeInfo** pptinfo);

+    STDMETHODIMP GetIDsOfNames(REFIID riid, OLECHAR** rgszNames, UINT cNames, LCID lcid, DISPID* rgdispid);

+    STDMETHODIMP Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pdispparams, VARIANT* pvarResult, EXCEPINFO* pexcepinfo, UINT* puArgErr);

+

+    STDMETHODIMP get_AuthorName(BSTR* pbstrAuthorName);

+    STDMETHODIMP get_Title(BSTR* pbstrTitle);

+    STDMETHODIMP get_Rating(BSTR* pbstrRating);

+    STDMETHODIMP get_Description(BSTR* pbstrDescription);

+    STDMETHODIMP get_Copyright(BSTR* pbstrCopyright);

+    STDMETHODIMP get_BaseURL(BSTR* pbstrBaseURL);

+    STDMETHODIMP get_LogoURL(BSTR* pbstrLogoURL);

+    STDMETHODIMP get_LogoIconURL(BSTR* pbstrLogoURL);

+    STDMETHODIMP get_WatermarkURL(BSTR* pbstrWatermarkURL);

+    STDMETHODIMP get_MoreInfoURL(BSTR* pbstrMoreInfoURL);

+    STDMETHODIMP get_MoreInfoBannerImage(BSTR* pbstrMoreInfoBannerImage);

+    STDMETHODIMP get_MoreInfoBannerURL(BSTR* pbstrMoreInfoBannerURL);

+    STDMETHODIMP get_MoreInfoText(BSTR* pbstrMoreInfoText);

 };

diff --git a/src/filters/reader/CDXAReader/CDXAReader.cpp b/src/filters/reader/CDXAReader/CDXAReader.cpp
index 64beb50d7..6d9e32687 100644
--- a/src/filters/reader/CDXAReader/CDXAReader.cpp
+++ b/src/filters/reader/CDXAReader/CDXAReader.cpp
@@ -33,82 +33,82 @@
 /////////

 

 static DWORD EDC_crctable[256] = {

-	0x00000000l, 0x90910101l, 0x91210201l, 0x01b00300l,

-	0x92410401l, 0x02d00500l, 0x03600600l, 0x93f10701l,

-	0x94810801l, 0x04100900l, 0x05a00a00l, 0x95310b01l,

-	0x06c00c00l, 0x96510d01l, 0x97e10e01l, 0x07700f00l,

-	0x99011001l, 0x09901100l, 0x08201200l, 0x98b11301l,

-	0x0b401400l, 0x9bd11501l, 0x9a611601l, 0x0af01700l,

-	0x0d801800l, 0x9d111901l, 0x9ca11a01l, 0x0c301b00l,

-	0x9fc11c01l, 0x0f501d00l, 0x0ee01e00l, 0x9e711f01l,

-	0x82012001l, 0x12902100l, 0x13202200l, 0x83b12301l,

-	0x10402400l, 0x80d12501l, 0x81612601l, 0x11f02700l,

-	0x16802800l, 0x86112901l, 0x87a12a01l, 0x17302b00l,

-	0x84c12c01l, 0x14502d00l, 0x15e02e00l, 0x85712f01l,

-	0x1b003000l, 0x8b913101l, 0x8a213201l, 0x1ab03300l,

-	0x89413401l, 0x19d03500l, 0x18603600l, 0x88f13701l,

-	0x8f813801l, 0x1f103900l, 0x1ea03a00l, 0x8e313b01l,

-	0x1dc03c00l, 0x8d513d01l, 0x8ce13e01l, 0x1c703f00l,

-	0xb4014001l, 0x24904100l, 0x25204200l, 0xb5b14301l,

-	0x26404400l, 0xb6d14501l, 0xb7614601l, 0x27f04700l,

-	0x20804800l, 0xb0114901l, 0xb1a14a01l, 0x21304b00l,

-	0xb2c14c01l, 0x22504d00l, 0x23e04e00l, 0xb3714f01l,

-	0x2d005000l, 0xbd915101l, 0xbc215201l, 0x2cb05300l,

-	0xbf415401l, 0x2fd05500l, 0x2e605600l, 0xbef15701l,

-	0xb9815801l, 0x29105900l, 0x28a05a00l, 0xb8315b01l,

-	0x2bc05c00l, 0xbb515d01l, 0xbae15e01l, 0x2a705f00l,

-	0x36006000l, 0xa6916101l, 0xa7216201l, 0x37b06300l,

-	0xa4416401l, 0x34d06500l, 0x35606600l, 0xa5f16701l,

-	0xa2816801l, 0x32106900l, 0x33a06a00l, 0xa3316b01l,

-	0x30c06c00l, 0xa0516d01l, 0xa1e16e01l, 0x31706f00l,

-	0xaf017001l, 0x3f907100l, 0x3e207200l, 0xaeb17301l,

-	0x3d407400l, 0xadd17501l, 0xac617601l, 0x3cf07700l,

-	0x3b807800l, 0xab117901l, 0xaaa17a01l, 0x3a307b00l,

-	0xa9c17c01l, 0x39507d00l, 0x38e07e00l, 0xa8717f01l,

-	0xd8018001l, 0x48908100l, 0x49208200l, 0xd9b18301l,

-	0x4a408400l, 0xdad18501l, 0xdb618601l, 0x4bf08700l,

-	0x4c808800l, 0xdc118901l, 0xdda18a01l, 0x4d308b00l,

-	0xdec18c01l, 0x4e508d00l, 0x4fe08e00l, 0xdf718f01l,

-	0x41009000l, 0xd1919101l, 0xd0219201l, 0x40b09300l,

-	0xd3419401l, 0x43d09500l, 0x42609600l, 0xd2f19701l,

-	0xd5819801l, 0x45109900l, 0x44a09a00l, 0xd4319b01l,

-	0x47c09c00l, 0xd7519d01l, 0xd6e19e01l, 0x46709f00l,

-	0x5a00a000l, 0xca91a101l, 0xcb21a201l, 0x5bb0a300l,

-	0xc841a401l, 0x58d0a500l, 0x5960a600l, 0xc9f1a701l,

-	0xce81a801l, 0x5e10a900l, 0x5fa0aa00l, 0xcf31ab01l,

-	0x5cc0ac00l, 0xcc51ad01l, 0xcde1ae01l, 0x5d70af00l,

-	0xc301b001l, 0x5390b100l, 0x5220b200l, 0xc2b1b301l,

-	0x5140b400l, 0xc1d1b501l, 0xc061b601l, 0x50f0b700l,

-	0x5780b800l, 0xc711b901l, 0xc6a1ba01l, 0x5630bb00l,

-	0xc5c1bc01l, 0x5550bd00l, 0x54e0be00l, 0xc471bf01l,

-	0x6c00c000l, 0xfc91c101l, 0xfd21c201l, 0x6db0c300l,

-	0xfe41c401l, 0x6ed0c500l, 0x6f60c600l, 0xfff1c701l,

-	0xf881c801l, 0x6810c900l, 0x69a0ca00l, 0xf931cb01l,

-	0x6ac0cc00l, 0xfa51cd01l, 0xfbe1ce01l, 0x6b70cf00l,

-	0xf501d001l, 0x6590d100l, 0x6420d200l, 0xf4b1d301l,

-	0x6740d400l, 0xf7d1d501l, 0xf661d601l, 0x66f0d700l,

-	0x6180d800l, 0xf111d901l, 0xf0a1da01l, 0x6030db00l,

-	0xf3c1dc01l, 0x6350dd00l, 0x62e0de00l, 0xf271df01l,

-	0xee01e001l, 0x7e90e100l, 0x7f20e200l, 0xefb1e301l,

-	0x7c40e400l, 0xecd1e501l, 0xed61e601l, 0x7df0e700l,

-	0x7a80e800l, 0xea11e901l, 0xeba1ea01l, 0x7b30eb00l,

-	0xe8c1ec01l, 0x7850ed00l, 0x79e0ee00l, 0xe971ef01l,

-	0x7700f000l, 0xe791f101l, 0xe621f201l, 0x76b0f300l,

-	0xe541f401l, 0x75d0f500l, 0x7460f600l, 0xe4f1f701l,

-	0xe381f801l, 0x7310f900l, 0x72a0fa00l, 0xe231fb01l,

-	0x71c0fc00l, 0xe151fd01l, 0xe0e1fe01l, 0x7070ff00l

+    0x00000000l, 0x90910101l, 0x91210201l, 0x01b00300l,

+    0x92410401l, 0x02d00500l, 0x03600600l, 0x93f10701l,

+    0x94810801l, 0x04100900l, 0x05a00a00l, 0x95310b01l,

+    0x06c00c00l, 0x96510d01l, 0x97e10e01l, 0x07700f00l,

+    0x99011001l, 0x09901100l, 0x08201200l, 0x98b11301l,

+    0x0b401400l, 0x9bd11501l, 0x9a611601l, 0x0af01700l,

+    0x0d801800l, 0x9d111901l, 0x9ca11a01l, 0x0c301b00l,

+    0x9fc11c01l, 0x0f501d00l, 0x0ee01e00l, 0x9e711f01l,

+    0x82012001l, 0x12902100l, 0x13202200l, 0x83b12301l,

+    0x10402400l, 0x80d12501l, 0x81612601l, 0x11f02700l,

+    0x16802800l, 0x86112901l, 0x87a12a01l, 0x17302b00l,

+    0x84c12c01l, 0x14502d00l, 0x15e02e00l, 0x85712f01l,

+    0x1b003000l, 0x8b913101l, 0x8a213201l, 0x1ab03300l,

+    0x89413401l, 0x19d03500l, 0x18603600l, 0x88f13701l,

+    0x8f813801l, 0x1f103900l, 0x1ea03a00l, 0x8e313b01l,

+    0x1dc03c00l, 0x8d513d01l, 0x8ce13e01l, 0x1c703f00l,

+    0xb4014001l, 0x24904100l, 0x25204200l, 0xb5b14301l,

+    0x26404400l, 0xb6d14501l, 0xb7614601l, 0x27f04700l,

+    0x20804800l, 0xb0114901l, 0xb1a14a01l, 0x21304b00l,

+    0xb2c14c01l, 0x22504d00l, 0x23e04e00l, 0xb3714f01l,

+    0x2d005000l, 0xbd915101l, 0xbc215201l, 0x2cb05300l,

+    0xbf415401l, 0x2fd05500l, 0x2e605600l, 0xbef15701l,

+    0xb9815801l, 0x29105900l, 0x28a05a00l, 0xb8315b01l,

+    0x2bc05c00l, 0xbb515d01l, 0xbae15e01l, 0x2a705f00l,

+    0x36006000l, 0xa6916101l, 0xa7216201l, 0x37b06300l,

+    0xa4416401l, 0x34d06500l, 0x35606600l, 0xa5f16701l,

+    0xa2816801l, 0x32106900l, 0x33a06a00l, 0xa3316b01l,

+    0x30c06c00l, 0xa0516d01l, 0xa1e16e01l, 0x31706f00l,

+    0xaf017001l, 0x3f907100l, 0x3e207200l, 0xaeb17301l,

+    0x3d407400l, 0xadd17501l, 0xac617601l, 0x3cf07700l,

+    0x3b807800l, 0xab117901l, 0xaaa17a01l, 0x3a307b00l,

+    0xa9c17c01l, 0x39507d00l, 0x38e07e00l, 0xa8717f01l,

+    0xd8018001l, 0x48908100l, 0x49208200l, 0xd9b18301l,

+    0x4a408400l, 0xdad18501l, 0xdb618601l, 0x4bf08700l,

+    0x4c808800l, 0xdc118901l, 0xdda18a01l, 0x4d308b00l,

+    0xdec18c01l, 0x4e508d00l, 0x4fe08e00l, 0xdf718f01l,

+    0x41009000l, 0xd1919101l, 0xd0219201l, 0x40b09300l,

+    0xd3419401l, 0x43d09500l, 0x42609600l, 0xd2f19701l,

+    0xd5819801l, 0x45109900l, 0x44a09a00l, 0xd4319b01l,

+    0x47c09c00l, 0xd7519d01l, 0xd6e19e01l, 0x46709f00l,

+    0x5a00a000l, 0xca91a101l, 0xcb21a201l, 0x5bb0a300l,

+    0xc841a401l, 0x58d0a500l, 0x5960a600l, 0xc9f1a701l,

+    0xce81a801l, 0x5e10a900l, 0x5fa0aa00l, 0xcf31ab01l,

+    0x5cc0ac00l, 0xcc51ad01l, 0xcde1ae01l, 0x5d70af00l,

+    0xc301b001l, 0x5390b100l, 0x5220b200l, 0xc2b1b301l,

+    0x5140b400l, 0xc1d1b501l, 0xc061b601l, 0x50f0b700l,

+    0x5780b800l, 0xc711b901l, 0xc6a1ba01l, 0x5630bb00l,

+    0xc5c1bc01l, 0x5550bd00l, 0x54e0be00l, 0xc471bf01l,

+    0x6c00c000l, 0xfc91c101l, 0xfd21c201l, 0x6db0c300l,

+    0xfe41c401l, 0x6ed0c500l, 0x6f60c600l, 0xfff1c701l,

+    0xf881c801l, 0x6810c900l, 0x69a0ca00l, 0xf931cb01l,

+    0x6ac0cc00l, 0xfa51cd01l, 0xfbe1ce01l, 0x6b70cf00l,

+    0xf501d001l, 0x6590d100l, 0x6420d200l, 0xf4b1d301l,

+    0x6740d400l, 0xf7d1d501l, 0xf661d601l, 0x66f0d700l,

+    0x6180d800l, 0xf111d901l, 0xf0a1da01l, 0x6030db00l,

+    0xf3c1dc01l, 0x6350dd00l, 0x62e0de00l, 0xf271df01l,

+    0xee01e001l, 0x7e90e100l, 0x7f20e200l, 0xefb1e301l,

+    0x7c40e400l, 0xecd1e501l, 0xed61e601l, 0x7df0e700l,

+    0x7a80e800l, 0xea11e901l, 0xeba1ea01l, 0x7b30eb00l,

+    0xe8c1ec01l, 0x7850ed00l, 0x79e0ee00l, 0xe971ef01l,

+    0x7700f000l, 0xe791f101l, 0xe621f201l, 0x76b0f300l,

+    0xe541f401l, 0x75d0f500l, 0x7460f600l, 0xe4f1f701l,

+    0xe381f801l, 0x7310f900l, 0x72a0fa00l, 0xe231fb01l,

+    0x71c0fc00l, 0xe151fd01l, 0xe0e1fe01l, 0x7070ff00l

 };

 

 static DWORD build_edc(const void* in, unsigned from, unsigned upto)

 {

-	const BYTE* p = (BYTE*)in + from;

-	DWORD result = 0;

+    const BYTE* p = (BYTE*)in + from;

+    DWORD result = 0;

 

-	for (; from < upto; from++) {

-		result = EDC_crctable[(result ^ *p++) & 0xffL] ^ (result >> 8);

-	}

+    for (; from < upto; from++) {

+        result = EDC_crctable[(result ^ *p++) & 0xffL] ^ (result >> 8);

+    }

 

-	return result;

+    return result;

 }

 

 /////////

@@ -116,41 +116,41 @@ static DWORD build_edc(const void* in, unsigned from, unsigned upto)
 #ifdef REGISTER_FILTER

 

 const AMOVIESETUP_MEDIATYPE sudPinTypesOut[] = {

-	{&MEDIATYPE_Stream, &MEDIASUBTYPE_NULL}

+    {&MEDIATYPE_Stream, &MEDIASUBTYPE_NULL}

 };

 

 const AMOVIESETUP_PIN sudOpPin[] = {

-	{L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, _countof(sudPinTypesOut), sudPinTypesOut}

+    {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, _countof(sudPinTypesOut), sudPinTypesOut}

 };

 

 const AMOVIESETUP_FILTER sudFilter[] = {

-	{&__uuidof(CCDXAReader), CCDXAReaderName, MERIT_NORMAL, _countof(sudOpPin), sudOpPin, CLSID_LegacyAmFilterCategory}

+    {&__uuidof(CCDXAReader), CCDXAReaderName, MERIT_NORMAL, _countof(sudOpPin), sudOpPin, CLSID_LegacyAmFilterCategory}

 };

 

 CFactoryTemplate g_Templates[] = {

-	{sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CCDXAReader>, NULL, &sudFilter[0]}

+    {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CCDXAReader>, NULL, &sudFilter[0]}

 };

 

 int g_cTemplates = _countof(g_Templates);

 

 STDAPI DllRegisterServer()

 {

-	SetRegKeyValue(

-		_T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{D367878E-F3B8-4235-A968-F378EF1B9A44}"),

-		_T("0"), _T("0,4,,52494646,8,4,,43445841")); // "RIFFxxxxCDXA"

+    SetRegKeyValue(

+        _T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{D367878E-F3B8-4235-A968-F378EF1B9A44}"),

+        _T("0"), _T("0,4,,52494646,8,4,,43445841")); // "RIFFxxxxCDXA"

 

-	SetRegKeyValue(

-		_T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{D367878E-F3B8-4235-A968-F378EF1B9A44}"),

-		_T("Source Filter"), _T("{D367878E-F3B8-4235-A968-F378EF1B9A44}"));

+    SetRegKeyValue(

+        _T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{D367878E-F3B8-4235-A968-F378EF1B9A44}"),

+        _T("Source Filter"), _T("{D367878E-F3B8-4235-A968-F378EF1B9A44}"));

 

-	return AMovieDllRegisterServer2(TRUE);

+    return AMovieDllRegisterServer2(TRUE);

 }

 

 STDAPI DllUnregisterServer()

 {

-	DeleteRegKey(_T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{D367878E-F3B8-4235-A968-F378EF1B9A44}"));

+    DeleteRegKey(_T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{D367878E-F3B8-4235-A968-F378EF1B9A44}"));

 

-	return AMovieDllRegisterServer2(FALSE);

+    return AMovieDllRegisterServer2(FALSE);

 }

 

 #include "../../FilterApp.h"

@@ -164,11 +164,11 @@ CFilterApp theApp;
 //

 

 CCDXAReader::CCDXAReader(IUnknown* pUnk, HRESULT* phr)

-	: CAsyncReader(NAME("CCDXAReader"), pUnk, &m_stream, phr, __uuidof(this))

+    : CAsyncReader(NAME("CCDXAReader"), pUnk, &m_stream, phr, __uuidof(this))

 {

-	if (phr) {

-		*phr = S_OK;

-	}

+    if (phr) {

+        *phr = S_OK;

+    }

 }

 

 CCDXAReader::~CCDXAReader()

@@ -177,365 +177,365 @@ CCDXAReader::~CCDXAReader()
 

 STDMETHODIMP CCDXAReader::NonDelegatingQueryInterface(REFIID riid, void** ppv)

 {

-	return

-		QI(IFileSourceFilter)

-		__super::NonDelegatingQueryInterface(riid, ppv);

+    return

+        QI(IFileSourceFilter)

+        __super::NonDelegatingQueryInterface(riid, ppv);

 }

 

-STDMETHODIMP CCDXAReader::Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE *pmt)

+STDMETHODIMP CCDXAReader::Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt)

 {

-	CMediaType mt;

-	m_mt = mt;

+    CMediaType mt;

+    m_mt = mt;

 

-	if (!m_stream.Load(pszFileName)) {

-		return E_FAIL;

-	}

+    if (!m_stream.Load(pszFileName)) {

+        return E_FAIL;

+    }

 

-	m_fn = pszFileName;

+    m_fn = pszFileName;

 

-	mt.majortype = MEDIATYPE_Stream;

-	mt.subtype = m_stream.m_subtype;

-	m_mt = mt;

+    mt.majortype = MEDIATYPE_Stream;

+    mt.subtype = m_stream.m_subtype;

+    m_mt = mt;

 

-	return S_OK;

+    return S_OK;

 }

 

 STDMETHODIMP CCDXAReader::GetCurFile(LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt)

 {

-	if (!ppszFileName) {

-		return E_POINTER;

-	}

+    if (!ppszFileName) {

+        return E_POINTER;

+    }

 

-	*ppszFileName = (LPOLESTR)CoTaskMemAlloc((m_fn.GetLength()+1)*sizeof(WCHAR));

-	if (!(*ppszFileName)) {

-		return E_OUTOFMEMORY;

-	}

+    *ppszFileName = (LPOLESTR)CoTaskMemAlloc((m_fn.GetLength() + 1) * sizeof(WCHAR));

+    if (!(*ppszFileName)) {

+        return E_OUTOFMEMORY;

+    }

 

-	wcscpy_s(*ppszFileName, m_fn.GetLength() + 1, m_fn);

+    wcscpy_s(*ppszFileName, m_fn.GetLength() + 1, m_fn);

 

-	return S_OK;

+    return S_OK;

 }

 

 // CCDXAStream

 

 CCDXAStream::CCDXAStream()

 {

-	m_subtype = MEDIASUBTYPE_NULL;

+    m_subtype = MEDIASUBTYPE_NULL;

 

-	m_hFile = INVALID_HANDLE_VALUE;

+    m_hFile = INVALID_HANDLE_VALUE;

 

-	m_llPosition = m_llLength = 0;

-	m_nFirstSector = 0;

-	m_nBufferedSector = -1;

+    m_llPosition = m_llLength = 0;

+    m_nFirstSector = 0;

+    m_nBufferedSector = -1;

 }

 

 CCDXAStream::~CCDXAStream()

 {

-	if (m_hFile != INVALID_HANDLE_VALUE) {

-		CloseHandle(m_hFile);

-		m_hFile = INVALID_HANDLE_VALUE;

-	}

+    if (m_hFile != INVALID_HANDLE_VALUE) {

+        CloseHandle(m_hFile);

+        m_hFile = INVALID_HANDLE_VALUE;

+    }

 }

 

 bool CCDXAStream::Load(const WCHAR* fnw)

 {

-	if (m_hFile != INVALID_HANDLE_VALUE) {

-		CloseHandle(m_hFile);

-		m_hFile = INVALID_HANDLE_VALUE;

-	}

-

-	m_hFile = CreateFile(CString(fnw), GENERIC_READ, FILE_SHARE_READ, NULL,

-						 OPEN_EXISTING, FILE_ATTRIBUTE_READONLY|FILE_FLAG_SEQUENTIAL_SCAN, (HANDLE)NULL);

-	if (m_hFile == INVALID_HANDLE_VALUE) {

-		return false;

-	}

-

-	BYTE hdr[RIFFCDXA_HEADER_SIZE];

-	DWORD NumberOfBytesRead;

-	if (!ReadFile(m_hFile, (LPVOID)hdr, RIFFCDXA_HEADER_SIZE, &NumberOfBytesRead, NULL)

-			|| *((DWORD*)&hdr[0]) != 'FFIR' || *((DWORD*)&hdr[8]) != 'AXDC'

-			|| *((DWORD*)&hdr[4]) != (*((DWORD*)&hdr[0x28])+0x24)) {

-		CloseHandle(m_hFile);

-		m_hFile = INVALID_HANDLE_VALUE;

-		return false;

-	}

-

-	LARGE_INTEGER size = {0, 0};

-	GetFileSizeEx(m_hFile, &size);

-

-	m_llLength = int((size.QuadPart - RIFFCDXA_HEADER_SIZE) / RAW_SECTOR_SIZE) * RAW_DATA_SIZE;

-

-	if (!LookForMediaSubType()) {

-		m_llPosition = m_llLength = 0;

-		CloseHandle(m_hFile);

-		m_hFile = INVALID_HANDLE_VALUE;

-		return false;

-	}

-

-	m_llPosition = 0;

-

-	m_nBufferedSector = -1;

-

-	return true;

+    if (m_hFile != INVALID_HANDLE_VALUE) {

+        CloseHandle(m_hFile);

+        m_hFile = INVALID_HANDLE_VALUE;

+    }

+

+    m_hFile = CreateFile(CString(fnw), GENERIC_READ, FILE_SHARE_READ, NULL,

+                         OPEN_EXISTING, FILE_ATTRIBUTE_READONLY | FILE_FLAG_SEQUENTIAL_SCAN, (HANDLE)NULL);

+    if (m_hFile == INVALID_HANDLE_VALUE) {

+        return false;

+    }

+

+    BYTE hdr[RIFFCDXA_HEADER_SIZE];

+    DWORD NumberOfBytesRead;

+    if (!ReadFile(m_hFile, (LPVOID)hdr, RIFFCDXA_HEADER_SIZE, &NumberOfBytesRead, NULL)

+            || *((DWORD*)&hdr[0]) != 'FFIR' || *((DWORD*)&hdr[8]) != 'AXDC'

+            || *((DWORD*)&hdr[4]) != (*((DWORD*)&hdr[0x28]) + 0x24)) {

+        CloseHandle(m_hFile);

+        m_hFile = INVALID_HANDLE_VALUE;

+        return false;

+    }

+

+    LARGE_INTEGER size = {0, 0};

+    GetFileSizeEx(m_hFile, &size);

+

+    m_llLength = int((size.QuadPart - RIFFCDXA_HEADER_SIZE) / RAW_SECTOR_SIZE) * RAW_DATA_SIZE;

+

+    if (!LookForMediaSubType()) {

+        m_llPosition = m_llLength = 0;

+        CloseHandle(m_hFile);

+        m_hFile = INVALID_HANDLE_VALUE;

+        return false;

+    }

+

+    m_llPosition = 0;

+

+    m_nBufferedSector = -1;

+

+    return true;

 }

 

 HRESULT CCDXAStream::SetPointer(LONGLONG llPos)

 {

-	return (llPos >= 0 && llPos < m_llLength) ? m_llPosition = llPos, S_OK : S_FALSE;

+    return (llPos >= 0 && llPos < m_llLength) ? m_llPosition = llPos, S_OK : S_FALSE;

 }

 

 HRESULT CCDXAStream::Read(PBYTE pbBuffer, DWORD dwBytesToRead, BOOL bAlign, LPDWORD pdwBytesRead)

 {

-	CAutoLock lck(&m_csLock);

+    CAutoLock lck(&m_csLock);

 

-	PBYTE pbBufferOrg = pbBuffer;

-	LONGLONG pos = m_llPosition;

+    PBYTE pbBufferOrg = pbBuffer;

+    LONGLONG pos = m_llPosition;

 

-	while (pos >= 0 && pos < m_llLength && dwBytesToRead > 0) {

-		UINT sector = m_nFirstSector + int(pos/RAW_DATA_SIZE);

-		__int64 offset = pos%RAW_DATA_SIZE;

+    while (pos >= 0 && pos < m_llLength && dwBytesToRead > 0) {

+        UINT sector = m_nFirstSector + int(pos / RAW_DATA_SIZE);

+        __int64 offset = pos % RAW_DATA_SIZE;

 

-		if (m_nBufferedSector != (int)sector) {

-			LARGE_INTEGER FilePointer;

-			FilePointer.QuadPart = RIFFCDXA_HEADER_SIZE + sector*RAW_SECTOR_SIZE;

-			SetFilePointerEx(m_hFile, FilePointer, &FilePointer, FILE_BEGIN);

+        if (m_nBufferedSector != (int)sector) {

+            LARGE_INTEGER FilePointer;

+            FilePointer.QuadPart = RIFFCDXA_HEADER_SIZE + sector * RAW_SECTOR_SIZE;

+            SetFilePointerEx(m_hFile, FilePointer, &FilePointer, FILE_BEGIN);

 

-			memset(m_sector, 0, sizeof(m_sector));

+            memset(m_sector, 0, sizeof(m_sector));

 

-			DWORD NumberOfBytesRead = 0;

+            DWORD NumberOfBytesRead = 0;

 

-			int nRetries = 3;

-			while (nRetries--) {

-				NumberOfBytesRead = 0;

-				if (!ReadFile(m_hFile, m_sector, RAW_SECTOR_SIZE, &NumberOfBytesRead, NULL)

-						|| NumberOfBytesRead != RAW_SECTOR_SIZE) {

-					break;

-				}

+            int nRetries = 3;

+            while (nRetries--) {

+                NumberOfBytesRead = 0;

+                if (!ReadFile(m_hFile, m_sector, RAW_SECTOR_SIZE, &NumberOfBytesRead, NULL)

+                        || NumberOfBytesRead != RAW_SECTOR_SIZE) {

+                    break;

+                }

 

-				if (*(DWORD*)&m_sector[RAW_SECTOR_SIZE-4] == 0) { // no CRC? it happens...

-					break;

-				}

+                if (*(DWORD*)&m_sector[RAW_SECTOR_SIZE - 4] == 0) { // no CRC? it happens...

+                    break;

+                }

 

-				if (build_edc(m_sector, RAW_SYNC_SIZE + RAW_HEADER_SIZE, RAW_SECTOR_SIZE) == 0) {

-					break;

-				}

+                if (build_edc(m_sector, RAW_SYNC_SIZE + RAW_HEADER_SIZE, RAW_SECTOR_SIZE) == 0) {

+                    break;

+                }

 

-				TRACE(_T("CCDXAStream: CRC error at sector %d (fp=0x%I64x, retriesleft=%d)\n"), sector, FilePointer.QuadPart, nRetries);

-			}

+                TRACE(_T("CCDXAStream: CRC error at sector %d (fp=0x%I64x, retriesleft=%d)\n"), sector, FilePointer.QuadPart, nRetries);

+            }

 

-			m_nBufferedSector = sector;

-		}

+            m_nBufferedSector = sector;

+        }

 

-		DWORD l = (DWORD)min(dwBytesToRead, min(RAW_DATA_SIZE - offset, m_llLength - pos));

-		memcpy(pbBuffer, &m_sector[RAW_SYNC_SIZE + RAW_HEADER_SIZE + RAW_SUBHEADER_SIZE + offset], l);

+        DWORD l = (DWORD)min(dwBytesToRead, min(RAW_DATA_SIZE - offset, m_llLength - pos));

+        memcpy(pbBuffer, &m_sector[RAW_SYNC_SIZE + RAW_HEADER_SIZE + RAW_SUBHEADER_SIZE + offset], l);

 

-		pbBuffer += l;

-		pos += l;

-		dwBytesToRead -= l;

-	}

+        pbBuffer += l;

+        pos += l;

+        dwBytesToRead -= l;

+    }

 

-	if (pdwBytesRead) {

-		*pdwBytesRead = pbBuffer - pbBufferOrg;

-	}

-	m_llPosition += pbBuffer - pbBufferOrg;

+    if (pdwBytesRead) {

+        *pdwBytesRead = pbBuffer - pbBufferOrg;

+    }

+    m_llPosition += pbBuffer - pbBufferOrg;

 

-	if (dwBytesToRead != 0) {

-		return S_FALSE;

-	}

+    if (dwBytesToRead != 0) {

+        return S_FALSE;

+    }

 

-	return S_OK;

+    return S_OK;

 }

 

 LONGLONG CCDXAStream::Size(LONGLONG* pSizeAvailable)

 {

-	if (pSizeAvailable) {

-		*pSizeAvailable = m_llLength;

-	}

-	return m_llLength;

+    if (pSizeAvailable) {

+        *pSizeAvailable = m_llLength;

+    }

+    return m_llLength;

 }

 

 DWORD CCDXAStream::Alignment()

 {

-	return 1;

+    return 1;

 }

 

 void CCDXAStream::Lock()

 {

-	m_csLock.Lock();

+    m_csLock.Lock();

 }

 

 void CCDXAStream::Unlock()

 {

-	m_csLock.Unlock();

+    m_csLock.Unlock();

 }

 

 //

 

 bool CCDXAStream::LookForMediaSubType()

 {

-	BYTE buff[RAW_DATA_SIZE];

-

-	m_subtype = MEDIASUBTYPE_NULL;

-

-	m_llPosition = 0;

-

-	for (int iSectorsRead = 0;

-			Read(buff, RAW_DATA_SIZE, 1, NULL) == S_OK && iSectorsRead < 1000;

-			iSectorsRead++) {

-		if (*((DWORD*)&buff[0]) == 0xba010000) {

-			m_llPosition = 0;

-			m_llLength -= iSectorsRead*RAW_DATA_SIZE;

-			m_nFirstSector = iSectorsRead;

-

-			if ((buff[4]&0xc4) == 0x44) {

-				m_subtype = MEDIASUBTYPE_MPEG2_PROGRAM;

-			} else if ((buff[4]&0xf1) == 0x21) {

-				m_subtype = MEDIASUBTYPE_MPEG1System;

-			}

-

-			return !!(m_subtype != MEDIASUBTYPE_NULL);

-		} else if (*((DWORD*)&buff[0]) == 'SggO') {

-			m_llPosition = 0;

-			m_llLength -= iSectorsRead*RAW_DATA_SIZE;

-			m_nFirstSector = iSectorsRead;

-

-			m_subtype = MEDIASUBTYPE_Ogg;

-

-			return true;

-		} else if (*((DWORD*)&buff[0]) == 0xA3DF451A) {

-			m_llPosition = 0;

-			m_llLength -= iSectorsRead*RAW_DATA_SIZE;

-			m_nFirstSector = iSectorsRead;

-

-			m_subtype = MEDIASUBTYPE_Matroska;

-

-			return true;

-		} else if (*((DWORD*)&buff[0]) == 'FMR.') {

-			m_llPosition = 0;

-			m_llLength -= iSectorsRead*RAW_DATA_SIZE;

-			m_nFirstSector = iSectorsRead;

-

-			m_subtype = MEDIASUBTYPE_RealMedia;

-

-			return true;

-		} else if (*((DWORD*)&buff[0]) == 'FFIR' && *((DWORD*)&buff[8]) == ' IVA') {

-			m_llPosition = 0;

-			m_llLength = min(m_llLength, *((DWORD*)&buff[4])+8);

-			m_nFirstSector = iSectorsRead;

-

-			m_subtype = MEDIASUBTYPE_Avi;

-

-			return true;

-		} else if (*((DWORD*)&buff[4]) == 'voom' || *((DWORD*)&buff[4]) == 'tadm'

-				   || *((DWORD*)&buff[4]) == 'pytf' && *((DWORD*)&buff[8]) == 'mosi' && *((DWORD*)&buff[16]) == '14pm') {

-			m_llPosition = 0;

-			m_llLength -= iSectorsRead*RAW_DATA_SIZE;

-			m_nFirstSector = iSectorsRead;

-

-			m_subtype = MEDIASUBTYPE_QTMovie;

-

-			return true;

-		}

-	}

-

-	m_llPosition = 0;

-

-	CRegKey majorkey;

-	CString majortype = _T("\\Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}");

-	if (ERROR_SUCCESS == majorkey.Open(HKEY_CLASSES_ROOT, majortype, KEY_READ)) {

-		TCHAR subtype[256+1];

-		DWORD len = 256;

-		for (int i = 0; ERROR_SUCCESS == majorkey.EnumKey(i, subtype, &len); i++, len = 256) {

-			CRegKey subkey;

-			if (ERROR_SUCCESS != subkey.Open(HKEY_CLASSES_ROOT, majortype + _T("\\") + subtype, KEY_READ)) {

-				continue;

-			}

-

-			for (int j = 0; true; j++) {

-				TCHAR number[10];

-				_stprintf_s(number, _countof(number), _T("%d"), j);

-

-				TCHAR pattern[256+1];

-				ULONG len = 256;

-				if (ERROR_SUCCESS != subkey.QueryStringValue(number, pattern, &len)) {

-					break;

-				}

-

-				CString p = pattern;

-				p += ',';

-

-				__int64 offset = 0;

-				DWORD cb = 0;

-				CAtlArray<BYTE> mask, val;

-

-				int nMatches = 0, nTries = 0;

-

-				for (int k = 0, l; nTries >= 0 && (l = p.Find(',', k)) >= 0; k = l+1, nTries++) {

-					CString s = p.Mid(k, l-k);

-					TRACE(s + '\n');

-

-					TCHAR* end = NULL;

-

-					switch (nTries&3) {

-						case 0:

-							offset = _tcstol(s, &end, 10);

-							break;

-						case 1:

-							cb = _tcstol(s, &end, 10);

-							break;

-						case 2:

-							CStringToBin(s, mask);

-							break;

-						case 3:

-							CStringToBin(s, val);

-							break;

-						default:

-							nTries = -1;

-							break;

-					}

-

-					if (nTries >= 0 && (nTries&3) == 3) {

-						if (cb > 0 && val.GetCount() > 0 && cb == val.GetCount()) {

-							if (offset >= 0 && S_OK == SetPointer(offset)

-									|| S_OK == SetPointer(m_llLength + offset)) {

-								CAutoVectorPtr<BYTE> pData;

-								if (pData.Allocate(cb)) {

-									DWORD BytesRead = 0;

-									if (S_OK == Read(pData, cb, 1, &BytesRead) && cb == BytesRead) {

-										if (mask.GetCount() < cb) {

-											size_t i = mask.GetCount();

-											mask.SetCount(cb);

-											for (; i < cb; i++) {

-												mask[i] = 0xff;

-											}

-										}

-

-										for (unsigned int i = 0; i < cb; i++) {

-											pData[i] &= (BYTE)mask[i];

-										}

-

-										if (memcmp(pData, val.GetData(), cb) == 0) {

-											nMatches++;

-										}

-									}

-								}

-							}

-

-							offset = 0;

-							cb = 0;

-							mask.RemoveAll();

-							val.RemoveAll();

-						}

-					}

-				}

-

-				if (nMatches > 0 && nMatches*4 == nTries) {

-					m_subtype = GUIDFromCString(subtype);

-					return S_OK;

-				}

-			}

-		}

-	}

-

-	return false;

+    BYTE buff[RAW_DATA_SIZE];

+

+    m_subtype = MEDIASUBTYPE_NULL;

+

+    m_llPosition = 0;

+

+    for (int iSectorsRead = 0;

+            Read(buff, RAW_DATA_SIZE, 1, NULL) == S_OK && iSectorsRead < 1000;

+            iSectorsRead++) {

+        if (*((DWORD*)&buff[0]) == 0xba010000) {

+            m_llPosition = 0;

+            m_llLength -= iSectorsRead * RAW_DATA_SIZE;

+            m_nFirstSector = iSectorsRead;

+

+            if ((buff[4] & 0xc4) == 0x44) {

+                m_subtype = MEDIASUBTYPE_MPEG2_PROGRAM;

+            } else if ((buff[4] & 0xf1) == 0x21) {

+                m_subtype = MEDIASUBTYPE_MPEG1System;

+            }

+

+            return !!(m_subtype != MEDIASUBTYPE_NULL);

+        } else if (*((DWORD*)&buff[0]) == 'SggO') {

+            m_llPosition = 0;

+            m_llLength -= iSectorsRead * RAW_DATA_SIZE;

+            m_nFirstSector = iSectorsRead;

+

+            m_subtype = MEDIASUBTYPE_Ogg;

+

+            return true;

+        } else if (*((DWORD*)&buff[0]) == 0xA3DF451A) {

+            m_llPosition = 0;

+            m_llLength -= iSectorsRead * RAW_DATA_SIZE;

+            m_nFirstSector = iSectorsRead;

+

+            m_subtype = MEDIASUBTYPE_Matroska;

+

+            return true;

+        } else if (*((DWORD*)&buff[0]) == 'FMR.') {

+            m_llPosition = 0;

+            m_llLength -= iSectorsRead * RAW_DATA_SIZE;

+            m_nFirstSector = iSectorsRead;

+

+            m_subtype = MEDIASUBTYPE_RealMedia;

+

+            return true;

+        } else if (*((DWORD*)&buff[0]) == 'FFIR' && *((DWORD*)&buff[8]) == ' IVA') {

+            m_llPosition = 0;

+            m_llLength = min(m_llLength, *((DWORD*)&buff[4]) + 8);

+            m_nFirstSector = iSectorsRead;

+

+            m_subtype = MEDIASUBTYPE_Avi;

+

+            return true;

+        } else if (*((DWORD*)&buff[4]) == 'voom' || *((DWORD*)&buff[4]) == 'tadm'

+                   || *((DWORD*)&buff[4]) == 'pytf' && *((DWORD*)&buff[8]) == 'mosi' && *((DWORD*)&buff[16]) == '14pm') {

+            m_llPosition = 0;

+            m_llLength -= iSectorsRead * RAW_DATA_SIZE;

+            m_nFirstSector = iSectorsRead;

+

+            m_subtype = MEDIASUBTYPE_QTMovie;

+

+            return true;

+        }

+    }

+

+    m_llPosition = 0;

+

+    CRegKey majorkey;

+    CString majortype = _T("\\Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}");

+    if (ERROR_SUCCESS == majorkey.Open(HKEY_CLASSES_ROOT, majortype, KEY_READ)) {

+        TCHAR subtype[256 + 1];

+        DWORD len = 256;

+        for (int i = 0; ERROR_SUCCESS == majorkey.EnumKey(i, subtype, &len); i++, len = 256) {

+            CRegKey subkey;

+            if (ERROR_SUCCESS != subkey.Open(HKEY_CLASSES_ROOT, majortype + _T("\\") + subtype, KEY_READ)) {

+                continue;

+            }

+

+            for (int j = 0; true; j++) {

+                TCHAR number[10];

+                _stprintf_s(number, _countof(number), _T("%d"), j);

+

+                TCHAR pattern[256 + 1];

+                ULONG len = 256;

+                if (ERROR_SUCCESS != subkey.QueryStringValue(number, pattern, &len)) {

+                    break;

+                }

+

+                CString p = pattern;

+                p += ',';

+

+                __int64 offset = 0;

+                DWORD cb = 0;

+                CAtlArray<BYTE> mask, val;

+

+                int nMatches = 0, nTries = 0;

+

+                for (int k = 0, l; nTries >= 0 && (l = p.Find(',', k)) >= 0; k = l + 1, nTries++) {

+                    CString s = p.Mid(k, l - k);

+                    TRACE(s + '\n');

+

+                    TCHAR* end = NULL;

+

+                    switch (nTries & 3) {

+                        case 0:

+                            offset = _tcstol(s, &end, 10);

+                            break;

+                        case 1:

+                            cb = _tcstol(s, &end, 10);

+                            break;

+                        case 2:

+                            CStringToBin(s, mask);

+                            break;

+                        case 3:

+                            CStringToBin(s, val);

+                            break;

+                        default:

+                            nTries = -1;

+                            break;

+                    }

+

+                    if (nTries >= 0 && (nTries & 3) == 3) {

+                        if (cb > 0 && val.GetCount() > 0 && cb == val.GetCount()) {

+                            if (offset >= 0 && S_OK == SetPointer(offset)

+                                    || S_OK == SetPointer(m_llLength + offset)) {

+                                CAutoVectorPtr<BYTE> pData;

+                                if (pData.Allocate(cb)) {

+                                    DWORD BytesRead = 0;

+                                    if (S_OK == Read(pData, cb, 1, &BytesRead) && cb == BytesRead) {

+                                        if (mask.GetCount() < cb) {

+                                            size_t i = mask.GetCount();

+                                            mask.SetCount(cb);

+                                            for (; i < cb; i++) {

+                                                mask[i] = 0xff;

+                                            }

+                                        }

+

+                                        for (unsigned int i = 0; i < cb; i++) {

+                                            pData[i] &= (BYTE)mask[i];

+                                        }

+

+                                        if (memcmp(pData, val.GetData(), cb) == 0) {

+                                            nMatches++;

+                                        }

+                                    }

+                                }

+                            }

+

+                            offset = 0;

+                            cb = 0;

+                            mask.RemoveAll();

+                            val.RemoveAll();

+                        }

+                    }

+                }

+

+                if (nMatches > 0 && nMatches * 4 == nTries) {

+                    m_subtype = GUIDFromCString(subtype);

+                    return S_OK;

+                }

+            }

+        }

+    }

+

+    return false;

 }

diff --git a/src/filters/reader/CDXAReader/CDXAReader.h b/src/filters/reader/CDXAReader/CDXAReader.h
index bd8b22826..01a721c93 100644
--- a/src/filters/reader/CDXAReader/CDXAReader.h
+++ b/src/filters/reader/CDXAReader/CDXAReader.h
@@ -32,59 +32,59 @@
 class CCDXAStream : public CAsyncStream

 {

 private:

-	enum {

-		RIFFCDXA_HEADER_SIZE = 44, // usually...

-		RAW_SYNC_SIZE = 12, // 00 FF .. FF 00

-		RAW_HEADER_SIZE = 4,

-		RAW_SUBHEADER_SIZE = 8,

-		RAW_DATA_SIZE = 2324,

-		RAW_EDC_SIZE = 4,

-		RAW_SECTOR_SIZE = 2352

-	};

+    enum {

+        RIFFCDXA_HEADER_SIZE = 44, // usually...

+        RAW_SYNC_SIZE = 12, // 00 FF .. FF 00

+        RAW_HEADER_SIZE = 4,

+        RAW_SUBHEADER_SIZE = 8,

+        RAW_DATA_SIZE = 2324,

+        RAW_EDC_SIZE = 4,

+        RAW_SECTOR_SIZE = 2352

+    };

 

-	CCritSec m_csLock;

+    CCritSec m_csLock;

 

-	HANDLE m_hFile;

-	LONGLONG m_llPosition, m_llLength;

-	int m_nFirstSector;

+    HANDLE m_hFile;

+    LONGLONG m_llPosition, m_llLength;

+    int m_nFirstSector;

 

-	int m_nBufferedSector;

-	BYTE m_sector[RAW_SECTOR_SIZE];

+    int m_nBufferedSector;

+    BYTE m_sector[RAW_SECTOR_SIZE];

 

-	bool LookForMediaSubType();

+    bool LookForMediaSubType();

 

 public:

-	CCDXAStream();

-	virtual ~CCDXAStream();

+    CCDXAStream();

+    virtual ~CCDXAStream();

 

-	bool Load(const WCHAR* fnw);

+    bool Load(const WCHAR* fnw);

 

-	HRESULT SetPointer(LONGLONG llPos);

-	HRESULT Read(PBYTE pbBuffer, DWORD dwBytesToRead, BOOL bAlign, LPDWORD pdwBytesRead);

-	LONGLONG Size(LONGLONG* pSizeAvailable);

-	DWORD Alignment();

-	void Lock();

-	void Unlock();

+    HRESULT SetPointer(LONGLONG llPos);

+    HRESULT Read(PBYTE pbBuffer, DWORD dwBytesToRead, BOOL bAlign, LPDWORD pdwBytesRead);

+    LONGLONG Size(LONGLONG* pSizeAvailable);

+    DWORD Alignment();

+    void Lock();

+    void Unlock();

 

-	GUID m_subtype;

+    GUID m_subtype;

 };

 

 class __declspec(uuid("D367878E-F3B8-4235-A968-F378EF1B9A44"))

-	CCDXAReader

-	: public CAsyncReader

-	, public IFileSourceFilter

+    CCDXAReader

+    : public CAsyncReader

+    , public IFileSourceFilter

 {

-	CCDXAStream m_stream;

-	CStringW m_fn;

+    CCDXAStream m_stream;

+    CStringW m_fn;

 

 public:

-	CCDXAReader(IUnknown* pUnk, HRESULT* phr);

-	~CCDXAReader();

+    CCDXAReader(IUnknown* pUnk, HRESULT* phr);

+    ~CCDXAReader();

 

-	DECLARE_IUNKNOWN

-	STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv);

+    DECLARE_IUNKNOWN

+    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv);

 

-	// IFileSourceFilter

-	STDMETHODIMP Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt);

-	STDMETHODIMP GetCurFile(LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt);

+    // IFileSourceFilter

+    STDMETHODIMP Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt);

+    STDMETHODIMP GetCurFile(LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt);

 };

diff --git a/src/filters/reader/UDPReader/UDPReader.cpp b/src/filters/reader/UDPReader/UDPReader.cpp
index b8aceda1f..e04e78465 100644
--- a/src/filters/reader/UDPReader/UDPReader.cpp
+++ b/src/filters/reader/UDPReader/UDPReader.cpp
@@ -28,36 +28,36 @@
 #ifdef REGISTER_FILTER

 

 const AMOVIESETUP_MEDIATYPE sudPinTypesOut[] = {

-	{&MEDIATYPE_Stream, &MEDIASUBTYPE_NULL},

+    {&MEDIATYPE_Stream, &MEDIASUBTYPE_NULL},

 };

 

 const AMOVIESETUP_PIN sudOpPin[] = {

-	{L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, _countof(sudPinTypesOut), sudPinTypesOut}

+    {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, _countof(sudPinTypesOut), sudPinTypesOut}

 };

 

 const AMOVIESETUP_FILTER sudFilter[] = {

-	{&__uuidof(CUDPReader), UDPReaderName, MERIT_NORMAL, _countof(sudOpPin), sudOpPin, CLSID_LegacyAmFilterCategory}

+    {&__uuidof(CUDPReader), UDPReaderName, MERIT_NORMAL, _countof(sudOpPin), sudOpPin, CLSID_LegacyAmFilterCategory}

 };

 

 CFactoryTemplate g_Templates[] = {

-	{sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CUDPReader>, NULL, &sudFilter[0]}

+    {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CUDPReader>, NULL, &sudFilter[0]}

 };

 

 int g_cTemplates = _countof(g_Templates);

 

 STDAPI DllRegisterServer()

 {

-	SetRegKeyValue(_T("udp"), 0, _T("Source Filter"), CStringFromGUID(__uuidof(CUDPReader)));

-	SetRegKeyValue(_T("tévé"), 0, _T("Source Filter"), CStringFromGUID(__uuidof(CUDPReader)));

+    SetRegKeyValue(_T("udp"), 0, _T("Source Filter"), CStringFromGUID(__uuidof(CUDPReader)));

+    SetRegKeyValue(_T("tévé"), 0, _T("Source Filter"), CStringFromGUID(__uuidof(CUDPReader)));

 

-	return AMovieDllRegisterServer2(TRUE);

+    return AMovieDllRegisterServer2(TRUE);

 }

 

 STDAPI DllUnregisterServer()

 {

-	// TODO

+    // TODO

 

-	return AMovieDllRegisterServer2(FALSE);

+    return AMovieDllRegisterServer2(FALSE);

 }

 

 #include "../../FilterApp.h"

@@ -74,11 +74,11 @@ CFilterApp theApp;
 //

 

 CUDPReader::CUDPReader(IUnknown* pUnk, HRESULT* phr)

-	: CAsyncReader(NAME("CUDPReader"), pUnk, &m_stream, phr, __uuidof(this))

+    : CAsyncReader(NAME("CUDPReader"), pUnk, &m_stream, phr, __uuidof(this))

 {

-	if (phr) {

-		*phr = S_OK;

-	}

+    if (phr) {

+        *phr = S_OK;

+    }

 }

 

 CUDPReader::~CUDPReader()

@@ -87,374 +87,374 @@ CUDPReader::~CUDPReader()
 

 STDMETHODIMP CUDPReader::NonDelegatingQueryInterface(REFIID riid, void** ppv)

 {

-	CheckPointer(ppv, E_POINTER);

+    CheckPointer(ppv, E_POINTER);

 

-	return

-		QI(IFileSourceFilter)

-		__super::NonDelegatingQueryInterface(riid, ppv);

+    return

+        QI(IFileSourceFilter)

+        __super::NonDelegatingQueryInterface(riid, ppv);

 }

 

 // IFileSourceFilter

 

 STDMETHODIMP CUDPReader::Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt)

 {

-	if (!m_stream.Load(pszFileName)) {

-		return E_FAIL;

-	}

+    if (!m_stream.Load(pszFileName)) {

+        return E_FAIL;

+    }

 

-	m_fn = pszFileName;

+    m_fn = pszFileName;

 

-	CMediaType mt;

-	mt.majortype = MEDIATYPE_Stream;

-	mt.subtype = m_stream.GetSubType();

-	m_mt = mt;

+    CMediaType mt;

+    mt.majortype = MEDIATYPE_Stream;

+    mt.subtype = m_stream.GetSubType();

+    m_mt = mt;

 

-	return S_OK;

+    return S_OK;

 }

 

 STDMETHODIMP CUDPReader::GetCurFile(LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt)

 {

-	if (!ppszFileName) {

-		return E_POINTER;

-	}

+    if (!ppszFileName) {

+        return E_POINTER;

+    }

 

-	*ppszFileName = (LPOLESTR)CoTaskMemAlloc((m_fn.GetLength()+1)*sizeof(WCHAR));

-	if (!(*ppszFileName)) {

-		return E_OUTOFMEMORY;

-	}

+    *ppszFileName = (LPOLESTR)CoTaskMemAlloc((m_fn.GetLength() + 1) * sizeof(WCHAR));

+    if (!(*ppszFileName)) {

+        return E_OUTOFMEMORY;

+    }

 

-	wcscpy_s(*ppszFileName, m_fn.GetLength() + 1, m_fn);

+    wcscpy_s(*ppszFileName, m_fn.GetLength() + 1, m_fn);

 

-	return S_OK;

+    return S_OK;

 }

 

 // CUDPStream

 

 CUDPStream::CUDPStream()

 {

-	m_port = 0;

-	m_socket = INVALID_SOCKET;

-	m_subtype = MEDIASUBTYPE_NULL;

+    m_port = 0;

+    m_socket = INVALID_SOCKET;

+    m_subtype = MEDIASUBTYPE_NULL;

 }

 

 CUDPStream::~CUDPStream()

 {

-	Clear();

+    Clear();

 }

 

 void CUDPStream::Clear()

 {

-	if (m_socket !=INVALID_SOCKET) {

-		closesocket(m_socket);

-		m_socket = INVALID_SOCKET;

-	}

-	if (CAMThread::ThreadExists()) {

-		CAMThread::CallWorker(CMD_EXIT);

-		CAMThread::Close();

-	}

-	while (!m_packets.IsEmpty()) {

-		delete m_packets.RemoveHead();

-	}

-	m_pos = m_len = 0;

-	m_drop = false;

+    if (m_socket != INVALID_SOCKET) {

+        closesocket(m_socket);

+        m_socket = INVALID_SOCKET;

+    }

+    if (CAMThread::ThreadExists()) {

+        CAMThread::CallWorker(CMD_EXIT);

+        CAMThread::Close();

+    }

+    while (!m_packets.IsEmpty()) {

+        delete m_packets.RemoveHead();

+    }

+    m_pos = m_len = 0;

+    m_drop = false;

 }

 

 void CUDPStream::Append(BYTE* buff, int len)

 {

-	CAutoLock cAutoLock(&m_csLock);

-

-	if (m_packets.GetCount() > 1) {

-		__int64 size = m_packets.GetTail()->m_end - m_packets.GetHead()->m_start;

-

-		if (!m_drop && (m_pos >= BUFF_SIZE_FIRST && size >= BUFF_SIZE_FIRST || size >= 2*BUFF_SIZE_FIRST)) {

-			m_drop = true;

-			TRACE(_T("DROP ON\n"));

-		} else if (m_drop && size <= BUFF_SIZE_FIRST) {

-			m_drop = false;

-			TRACE(_T("DROP OFF\n"));

-		}

-

-		if (m_drop) {

-			return;

-		}

-	}

-

-	m_packets.AddTail(DNew packet_t(buff, m_len, m_len + len));

-	m_len += len;

+    CAutoLock cAutoLock(&m_csLock);

+

+    if (m_packets.GetCount() > 1) {

+        __int64 size = m_packets.GetTail()->m_end - m_packets.GetHead()->m_start;

+

+        if (!m_drop && (m_pos >= BUFF_SIZE_FIRST && size >= BUFF_SIZE_FIRST || size >= 2 * BUFF_SIZE_FIRST)) {

+            m_drop = true;

+            TRACE(_T("DROP ON\n"));

+        } else if (m_drop && size <= BUFF_SIZE_FIRST) {

+            m_drop = false;

+            TRACE(_T("DROP OFF\n"));

+        }

+

+        if (m_drop) {

+            return;

+        }

+    }

+

+    m_packets.AddTail(DNew packet_t(buff, m_len, m_len + len));

+    m_len += len;

 }

 

 bool CUDPStream::Load(const WCHAR* fnw)

 {

-	Clear();

+    Clear();

 

-	CStringW url = CStringW(fnw);

+    CStringW url = CStringW(fnw);

 

-	CAtlList<CStringW> sl;

-	Explode(url, sl, ':');

-	if (sl.GetCount() != 3) {

-		return false;

-	}

+    CAtlList<CStringW> sl;

+    Explode(url, sl, ':');

+    if (sl.GetCount() != 3) {

+        return false;

+    }

 

-	CStringW protocol = sl.RemoveHead();

-	// if (protocol != L"udp") return false;

+    CStringW protocol = sl.RemoveHead();

+    // if (protocol != L"udp") return false;

 

-	m_ip = CString(sl.RemoveHead()).TrimLeft('/');

+    m_ip = CString(sl.RemoveHead()).TrimLeft('/');

 

-	int port = _wtoi(Explode(sl.RemoveHead(), sl, '/', 2));

-	if (port < 0 || port > 0xffff) {

-		return false;

-	}

-	m_port = port;

+    int port = _wtoi(Explode(sl.RemoveHead(), sl, '/', 2));

+    if (port < 0 || port > 0xffff) {

+        return false;

+    }

+    m_port = port;

 

-	if (sl.GetCount() != 2 || FAILED(GUIDFromCString(CString(sl.GetTail()), m_subtype))) {

-		m_subtype = MEDIASUBTYPE_NULL;    // TODO: detect subtype

-	}

+    if (sl.GetCount() != 2 || FAILED(GUIDFromCString(CString(sl.GetTail()), m_subtype))) {

+        m_subtype = MEDIASUBTYPE_NULL;    // TODO: detect subtype

+    }

 

-	CAMThread::Create();

-	if (FAILED(CAMThread::CallWorker(CMD_RUN))) {

-		Clear();

-		return false;

-	}

+    CAMThread::Create();

+    if (FAILED(CAMThread::CallWorker(CMD_RUN))) {

+        Clear();

+        return false;

+    }

 

-	clock_t start = clock();

-	while (clock() - start < 3000 && m_len < 1000000) {

-		Sleep(100);

-	}

+    clock_t start = clock();

+    while (clock() - start < 3000 && m_len < 1000000) {

+        Sleep(100);

+    }

 

-	return true;

+    return true;

 }

 

 HRESULT CUDPStream::SetPointer(LONGLONG llPos)

 {

-	CAutoLock cAutoLock(&m_csLock);

+    CAutoLock cAutoLock(&m_csLock);

 

-	if (m_packets.IsEmpty() && llPos != 0

-			|| !m_packets.IsEmpty() && llPos < m_packets.GetHead()->m_start

-			|| !m_packets.IsEmpty() && llPos > m_packets.GetTail()->m_end) {

-		TRACE(_T("CUDPStream: SetPointer error\n"));

-		return E_FAIL;

-	}

+    if (m_packets.IsEmpty() && llPos != 0

+            || !m_packets.IsEmpty() && llPos < m_packets.GetHead()->m_start

+            || !m_packets.IsEmpty() && llPos > m_packets.GetTail()->m_end) {

+        TRACE(_T("CUDPStream: SetPointer error\n"));

+        return E_FAIL;

+    }

 

-	m_pos = llPos;

+    m_pos = llPos;

 

-	return S_OK;

+    return S_OK;

 }

 

 HRESULT CUDPStream::Read(PBYTE pbBuffer, DWORD dwBytesToRead, BOOL bAlign, LPDWORD pdwBytesRead)

 {

-	CAutoLock cAutoLock(&m_csLock);

+    CAutoLock cAutoLock(&m_csLock);

 

-	DWORD len = dwBytesToRead;

-	BYTE* ptr = pbBuffer;

+    DWORD len = dwBytesToRead;

+    BYTE* ptr = pbBuffer;

 

-	while (len > 0 && !m_packets.IsEmpty()) {

-		POSITION pos = m_packets.GetHeadPosition();

-		while (pos && len > 0) {

-			packet_t* p = m_packets.GetNext(pos);

+    while (len > 0 && !m_packets.IsEmpty()) {

+        POSITION pos = m_packets.GetHeadPosition();

+        while (pos && len > 0) {

+            packet_t* p = m_packets.GetNext(pos);

 

-			if (p->m_start <= m_pos && m_pos < p->m_end) {

-				DWORD size;

+            if (p->m_start <= m_pos && m_pos < p->m_end) {

+                DWORD size;

 

-				if (m_pos < p->m_start) {

-					ASSERT(0);

-					size = (DWORD)min(len, p->m_start - m_pos);

-					memset(ptr, 0, size);

-				} else {

-					size = (DWORD)min(len, p->m_end - m_pos);

-					memcpy(ptr, &p->m_buff[m_pos - p->m_start], size);

-				}

+                if (m_pos < p->m_start) {

+                    ASSERT(0);

+                    size = (DWORD)min(len, p->m_start - m_pos);

+                    memset(ptr, 0, size);

+                } else {

+                    size = (DWORD)min(len, p->m_end - m_pos);

+                    memcpy(ptr, &p->m_buff[m_pos - p->m_start], size);

+                }

 

-				m_pos += size;

+                m_pos += size;

 

-				ptr += size;

-				len -= size;

-			}

+                ptr += size;

+                len -= size;

+            }

 

-			if (p->m_end <= m_pos - 2048 && BUFF_SIZE_FIRST <= m_pos) {

-				while (m_packets.GetHeadPosition() != pos) {

-					delete m_packets.RemoveHead();

-				}

-			}

+            if (p->m_end <= m_pos - 2048 && BUFF_SIZE_FIRST <= m_pos) {

+                while (m_packets.GetHeadPosition() != pos) {

+                    delete m_packets.RemoveHead();

+                }

+            }

 

-		}

-	}

+        }

+    }

 

-	if (pdwBytesRead) {

-		*pdwBytesRead = ptr - pbBuffer;

-	}

+    if (pdwBytesRead) {

+        *pdwBytesRead = ptr - pbBuffer;

+    }

 

-	return S_OK;

+    return S_OK;

 }

 

 LONGLONG CUDPStream::Size(LONGLONG* pSizeAvailable)

 {

-	CAutoLock cAutoLock(&m_csLock);

-	if (pSizeAvailable) {

-		*pSizeAvailable = m_len;

-	}

-	return 0;

+    CAutoLock cAutoLock(&m_csLock);

+    if (pSizeAvailable) {

+        *pSizeAvailable = m_len;

+    }

+    return 0;

 }

 

 DWORD CUDPStream::Alignment()

 {

-	return 1;

+    return 1;

 }

 

 void CUDPStream::Lock()

 {

-	m_csLock.Lock();

+    m_csLock.Lock();

 }

 

 void CUDPStream::Unlock()

 {

-	m_csLock.Unlock();

+    m_csLock.Unlock();

 }

 

 DWORD CUDPStream::ThreadProc()

 {

-	WSADATA wsaData;

-	WSAStartup(MAKEWORD(2, 2), &wsaData);

-

-	sockaddr_in addr;

-	memset(&addr, 0, sizeof(addr));

-	addr.sin_family = AF_INET;

-	addr.sin_addr.s_addr = htonl(INADDR_ANY);

-	addr.sin_port = htons((u_short)m_port);

-

-	ip_mreq imr;

-	imr.imr_multiaddr.s_addr = inet_addr(CStringA(m_ip));

-	imr.imr_interface.s_addr = INADDR_ANY;

-

-	if ((m_socket = socket(AF_INET, SOCK_DGRAM, 0))!=INVALID_SOCKET) {

-		/*		u_long argp = 1;

-				ioctlsocket(m_socket, FIONBIO, &argp);

-		*/

-		DWORD dw = TRUE;

-		if (setsockopt(m_socket, SOL_SOCKET, SO_REUSEADDR, (const char*)&dw, sizeof(dw))==SOCKET_ERROR) {

-			closesocket(m_socket);

-			m_socket =  INVALID_SOCKET;

-		}

-

-		if (bind(m_socket, (struct sockaddr*)&addr, sizeof(addr))==SOCKET_ERROR) {

-			closesocket(m_socket);

-			m_socket =  INVALID_SOCKET;

-		}

-

-		if (IN_MULTICAST(htonl(imr.imr_multiaddr.s_addr))) {

-			int ret = setsockopt(m_socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const char*)&imr, sizeof(imr));

-			if (ret < 0) {

-				ret = ::WSAGetLastError();

-			}

-			ret = ret;

-		}

-	}

-

-	SetThreadPriority(m_hThread, THREAD_PRIORITY_TIME_CRITICAL);

+    WSADATA wsaData;

+    WSAStartup(MAKEWORD(2, 2), &wsaData);

+

+    sockaddr_in addr;

+    memset(&addr, 0, sizeof(addr));

+    addr.sin_family = AF_INET;

+    addr.sin_addr.s_addr = htonl(INADDR_ANY);

+    addr.sin_port = htons((u_short)m_port);

+

+    ip_mreq imr;

+    imr.imr_multiaddr.s_addr = inet_addr(CStringA(m_ip));

+    imr.imr_interface.s_addr = INADDR_ANY;

+

+    if ((m_socket = socket(AF_INET, SOCK_DGRAM, 0)) != INVALID_SOCKET) {

+        /*      u_long argp = 1;

+                ioctlsocket(m_socket, FIONBIO, &argp);

+        */

+        DWORD dw = TRUE;

+        if (setsockopt(m_socket, SOL_SOCKET, SO_REUSEADDR, (const char*)&dw, sizeof(dw)) == SOCKET_ERROR) {

+            closesocket(m_socket);

+            m_socket =  INVALID_SOCKET;

+        }

+

+        if (bind(m_socket, (struct sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {

+            closesocket(m_socket);

+            m_socket =  INVALID_SOCKET;

+        }

+

+        if (IN_MULTICAST(htonl(imr.imr_multiaddr.s_addr))) {

+            int ret = setsockopt(m_socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const char*)&imr, sizeof(imr));

+            if (ret < 0) {

+                ret = ::WSAGetLastError();

+            }

+            ret = ret;

+        }

+    }

+

+    SetThreadPriority(m_hThread, THREAD_PRIORITY_TIME_CRITICAL);

 

 #ifdef _DEBUG

-	FILE* dump = NULL;

-	//	dump = _tfopen(_T("c:\\udp.ts"), _T("wb"));

-	FILE* log = NULL;

-	//	log = _tfopen(_T("c:\\udp.txt"), _T("wt"));

+    FILE* dump = NULL;

+    //  dump = _tfopen(_T("c:\\udp.ts"), _T("wb"));

+    FILE* log = NULL;

+    //  log = _tfopen(_T("c:\\udp.txt"), _T("wt"));

 #endif

 

-	for (;;) {

-		DWORD cmd = GetRequest();

-

-		switch (cmd) {

-			default:

-			case CMD_EXIT:

-				if (m_socket!=INVALID_SOCKET) {

-					closesocket(m_socket);

-					m_socket =  INVALID_SOCKET;

-				}

-				WSACleanup();

+    for (;;) {

+        DWORD cmd = GetRequest();

+

+        switch (cmd) {

+            default:

+            case CMD_EXIT:

+                if (m_socket != INVALID_SOCKET) {

+                    closesocket(m_socket);

+                    m_socket =  INVALID_SOCKET;

+                }

+                WSACleanup();

 #ifdef _DEBUG

-				if (dump) {

-					fclose(dump);

-				}

-				if (log) {

-					fclose(log);

-				}

+                if (dump) {

+                    fclose(dump);

+                }

+                if (log) {

+                    fclose(log);

+                }

 #endif

-				Reply(S_OK);

-				return 0;

-			case CMD_RUN:

-				Reply(m_socket!=INVALID_SOCKET ? S_OK : E_FAIL);

-

-				{

-					char buff[65536*2];

-					int buffsize = 0;

-

-					for (unsigned int i = 0; ; i++) {

-						if (!(i&0xff)) {

-							if (CheckRequest(NULL)) {

-								break;

-							}

-						}

-

-						int fromlen = sizeof(addr);

-						int len = recvfrom(m_socket, &buff[buffsize], 65536, 0, (SOCKADDR*)&addr, &fromlen);

-						if (len <= 0) {

-							Sleep(1);

-							continue;

-						}

+                Reply(S_OK);

+                return 0;

+            case CMD_RUN:

+                Reply(m_socket != INVALID_SOCKET ? S_OK : E_FAIL);

+

+                {

+                    char buff[65536 * 2];

+                    int buffsize = 0;

+

+                    for (unsigned int i = 0; ; i++) {

+                        if (!(i & 0xff)) {

+                            if (CheckRequest(NULL)) {

+                                break;

+                            }

+                        }

+

+                        int fromlen = sizeof(addr);

+                        int len = recvfrom(m_socket, &buff[buffsize], 65536, 0, (SOCKADDR*)&addr, &fromlen);

+                        if (len <= 0) {

+                            Sleep(1);

+                            continue;

+                        }

 

 #ifdef _DEBUG

-						if (log) {

-							if (buffsize >= len && !memcmp(&buff[buffsize-len], &buff[buffsize], len)) {

-								DWORD pid = ((buff[buffsize+1]<<8)|buff[buffsize+2])&0x1fff;

-								DWORD counter = buff[buffsize+3]&0xf;

-								_ftprintf_s(log, _T("%04d %2d DUP\n"), pid, counter);

-							}

-						}

+                        if (log) {

+                            if (buffsize >= len && !memcmp(&buff[buffsize - len], &buff[buffsize], len)) {

+                                DWORD pid = ((buff[buffsize + 1] << 8) | buff[buffsize + 2]) & 0x1fff;

+                                DWORD counter = buff[buffsize + 3] & 0xf;

+                                _ftprintf_s(log, _T("%04d %2d DUP\n"), pid, counter);

+                            }

+                        }

 #endif

 

-						buffsize += len;

+                        buffsize += len;

 

-						if (buffsize >= 65536 || m_len == 0) {

+                        if (buffsize >= 65536 || m_len == 0) {

 #ifdef _DEBUG

-							if (dump) {

-								fwrite(buff, buffsize, 1, dump);

-							}

-

-							if (log) {

-								static BYTE pid2counter[0x2000];

-								static bool init = false;

-								if (!init) {

-									memset(pid2counter, 0, sizeof(pid2counter));

-									init = true;

-								}

-

-								for (int i = 0; i < buffsize; i += 188) {

-									DWORD pid = ((buff[i+1]<<8)|buff[i+2])&0x1fff;

-									BYTE counter = buff[i+3]&0xf;

-									if (pid2counter[pid] != ((counter-1+16)&15)) {

-										_ftprintf_s(log, _T("%04x %2d -> %2d\n"), pid, pid2counter[pid], counter);

-									}

-									pid2counter[pid] = counter;

-								}

-							}

+                            if (dump) {

+                                fwrite(buff, buffsize, 1, dump);

+                            }

+

+                            if (log) {

+                                static BYTE pid2counter[0x2000];

+                                static bool init = false;

+                                if (!init) {

+                                    memset(pid2counter, 0, sizeof(pid2counter));

+                                    init = true;

+                                }

+

+                                for (int i = 0; i < buffsize; i += 188) {

+                                    DWORD pid = ((buff[i + 1] << 8) | buff[i + 2]) & 0x1fff;

+                                    BYTE counter = buff[i + 3] & 0xf;

+                                    if (pid2counter[pid] != ((counter - 1 + 16) & 15)) {

+                                        _ftprintf_s(log, _T("%04x %2d -> %2d\n"), pid, pid2counter[pid], counter);

+                                    }

+                                    pid2counter[pid] = counter;

+                                }

+                            }

 #endif

 

-							Append((BYTE*)buff, buffsize);

-							buffsize = 0;

-						}

-					}

-				}

-				break;

-		}

-	}

-

-	ASSERT(0);

-	return (DWORD)-1;

+                            Append((BYTE*)buff, buffsize);

+                            buffsize = 0;

+                        }

+                    }

+                }

+                break;

+        }

+    }

+

+    ASSERT(0);

+    return (DWORD) - 1;

 }

 

 CUDPStream::packet_t::packet_t(BYTE* p, __int64 start, __int64 end)

-	: m_start(start)

-	, m_end(end)

+    : m_start(start)

+    , m_end(end)

 {

-	size_t size = (size_t)(end - start);

-	m_buff = DNew BYTE[size];

-	memcpy(m_buff, p, size);

+    size_t size = (size_t)(end - start);

+    m_buff = DNew BYTE[size];

+    memcpy(m_buff, p, size);

 }

diff --git a/src/filters/reader/UDPReader/UDPReader.h b/src/filters/reader/UDPReader/UDPReader.h
index 1741fd77f..8cce7a74f 100644
--- a/src/filters/reader/UDPReader/UDPReader.h
+++ b/src/filters/reader/UDPReader/UDPReader.h
@@ -32,66 +32,66 @@
 class CUDPStream : public CAsyncStream, public CAMThread

 {

 private:

-	CCritSec m_csLock;

+    CCritSec m_csLock;

 

-	class packet_t

-	{

-	public:

-		BYTE* m_buff;

-		__int64 m_start, m_end;

-		packet_t(BYTE* p, __int64 start, __int64 end);

-		virtual ~packet_t() {

-			delete [] m_buff;

-		}

-	};

+    class packet_t

+    {

+    public:

+        BYTE* m_buff;

+        __int64 m_start, m_end;

+        packet_t(BYTE* p, __int64 start, __int64 end);

+        virtual ~packet_t() {

+            delete [] m_buff;

+        }

+    };

 

-	int m_port;

-	CString m_ip;

-	SOCKET m_socket;

-	GUID m_subtype;

-	__int64 m_pos, m_len;

-	bool m_drop;

-	CAtlList<packet_t*> m_packets;

+    int m_port;

+    CString m_ip;

+    SOCKET m_socket;

+    GUID m_subtype;

+    __int64 m_pos, m_len;

+    bool m_drop;

+    CAtlList<packet_t*> m_packets;

 

-	void Clear();

-	void Append(BYTE* buff, int len);

+    void Clear();

+    void Append(BYTE* buff, int len);

 

-	enum {CMD_EXIT, CMD_RUN};

-	DWORD ThreadProc();

+    enum {CMD_EXIT, CMD_RUN};

+    DWORD ThreadProc();

 

 public:

-	CUDPStream();

-	virtual ~CUDPStream();

+    CUDPStream();

+    virtual ~CUDPStream();

 

-	bool Load(const WCHAR* fnw);

-	const GUID& GetSubType() {

-		return m_subtype;

-	}

+    bool Load(const WCHAR* fnw);

+    const GUID& GetSubType() {

+        return m_subtype;

+    }

 

-	HRESULT SetPointer(LONGLONG llPos);

-	HRESULT Read(PBYTE pbBuffer, DWORD dwBytesToRead, BOOL bAlign, LPDWORD pdwBytesRead);

-	LONGLONG Size(LONGLONG* pSizeAvailable);

-	DWORD Alignment();

-	void Lock();

-	void Unlock();

+    HRESULT SetPointer(LONGLONG llPos);

+    HRESULT Read(PBYTE pbBuffer, DWORD dwBytesToRead, BOOL bAlign, LPDWORD pdwBytesRead);

+    LONGLONG Size(LONGLONG* pSizeAvailable);

+    DWORD Alignment();

+    void Lock();

+    void Unlock();

 };

 

 class __declspec(uuid("0E4221A9-9718-48D5-A5CF-4493DAD4A015"))

-	CUDPReader

-	: public CAsyncReader

-	, public IFileSourceFilter

+    CUDPReader

+    : public CAsyncReader

+    , public IFileSourceFilter

 {

-	CUDPStream m_stream;

-	CStringW m_fn;

+    CUDPStream m_stream;

+    CStringW m_fn;

 

 public:

-	CUDPReader(IUnknown* pUnk, HRESULT* phr);

-	~CUDPReader();

+    CUDPReader(IUnknown* pUnk, HRESULT* phr);

+    ~CUDPReader();

 

-	DECLARE_IUNKNOWN

-	STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv);

+    DECLARE_IUNKNOWN

+    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv);

 

-	// IFileSourceFilter

-	STDMETHODIMP Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt);

-	STDMETHODIMP GetCurFile(LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt);

+    // IFileSourceFilter

+    STDMETHODIMP Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt);

+    STDMETHODIMP GetCurFile(LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt);

 };

diff --git a/src/filters/reader/VTSReader/VTSReader.cpp b/src/filters/reader/VTSReader/VTSReader.cpp
index e6573878c..f88fadb15 100644
--- a/src/filters/reader/VTSReader/VTSReader.cpp
+++ b/src/filters/reader/VTSReader/VTSReader.cpp
@@ -29,41 +29,41 @@
 #ifdef REGISTER_FILTER

 

 const AMOVIESETUP_MEDIATYPE sudPinTypesOut[] = {

-	{&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG2_PROGRAM},

+    {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG2_PROGRAM},

 };

 

 const AMOVIESETUP_PIN sudOpPin[] = {

-	{L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, _countof(sudPinTypesOut), sudPinTypesOut}

+    {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, _countof(sudPinTypesOut), sudPinTypesOut}

 };

 

 const AMOVIESETUP_FILTER sudFilter[] = {

-	{&__uuidof(CVTSReader), VTSReaderName, MERIT_NORMAL, _countof(sudOpPin), sudOpPin, CLSID_LegacyAmFilterCategory}

+    {&__uuidof(CVTSReader), VTSReaderName, MERIT_NORMAL, _countof(sudOpPin), sudOpPin, CLSID_LegacyAmFilterCategory}

 };

 

 CFactoryTemplate g_Templates[] = {

-	{sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CVTSReader>, NULL, &sudFilter[0]}

+    {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CVTSReader>, NULL, &sudFilter[0]}

 };

 

 int g_cTemplates = _countof(g_Templates);

 

 STDAPI DllRegisterServer()

 {

-	SetRegKeyValue(

-		_T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{773EAEDE-D5EE-4fce-9C8F-C4F53D0A2F73}"),

-		_T("0"), _T("0,12,,445644564944454F2D565453")); // "DVDVIDEO-VTS"

+    SetRegKeyValue(

+        _T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{773EAEDE-D5EE-4fce-9C8F-C4F53D0A2F73}"),

+        _T("0"), _T("0,12,,445644564944454F2D565453")); // "DVDVIDEO-VTS"

 

-	SetRegKeyValue(

-		_T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{773EAEDE-D5EE-4fce-9C8F-C4F53D0A2F73}"),

-		_T("Source Filter"), _T("{773EAEDE-D5EE-4fce-9C8F-C4F53D0A2F73}"));

+    SetRegKeyValue(

+        _T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{773EAEDE-D5EE-4fce-9C8F-C4F53D0A2F73}"),

+        _T("Source Filter"), _T("{773EAEDE-D5EE-4fce-9C8F-C4F53D0A2F73}"));

 

-	return AMovieDllRegisterServer2(TRUE);

+    return AMovieDllRegisterServer2(TRUE);

 }

 

 STDAPI DllUnregisterServer()

 {

-	DeleteRegKey(_T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{773EAEDE-D5EE-4fce-9C8F-C4F53D0A2F73}"));

+    DeleteRegKey(_T("Media Type\\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{773EAEDE-D5EE-4fce-9C8F-C4F53D0A2F73}"));

 

-	return AMovieDllRegisterServer2(FALSE);

+    return AMovieDllRegisterServer2(FALSE);

 }

 

 #include "../../FilterApp.h"

@@ -77,11 +77,11 @@ CFilterApp theApp;
 //

 

 CVTSReader::CVTSReader(IUnknown* pUnk, HRESULT* phr)

-	: CAsyncReader(NAME("CVTSReader"), pUnk, &m_stream, phr, __uuidof(this))

+    : CAsyncReader(NAME("CVTSReader"), pUnk, &m_stream, phr, __uuidof(this))

 {

-	if (phr) {

-		*phr = S_OK;

-	}

+    if (phr) {

+        *phr = S_OK;

+    }

 }

 

 CVTSReader::~CVTSReader()

@@ -90,117 +90,117 @@ CVTSReader::~CVTSReader()
 

 STDMETHODIMP CVTSReader::NonDelegatingQueryInterface(REFIID riid, void** ppv)

 {

-	CheckPointer(ppv, E_POINTER);

+    CheckPointer(ppv, E_POINTER);

 

-	return

-		QI(IFileSourceFilter)

-		QI(ITrackInfo)

-		QI(IDSMChapterBag)

-		__super::NonDelegatingQueryInterface(riid, ppv);

+    return

+        QI(IFileSourceFilter)

+        QI(ITrackInfo)

+        QI(IDSMChapterBag)

+        __super::NonDelegatingQueryInterface(riid, ppv);

 }

 

 STDMETHODIMP CVTSReader::QueryFilterInfo(FILTER_INFO* pInfo)

 {

-	CheckPointer(pInfo, E_POINTER);

-	ValidateReadWritePtr(pInfo, sizeof(FILTER_INFO));

+    CheckPointer(pInfo, E_POINTER);

+    ValidateReadWritePtr(pInfo, sizeof(FILTER_INFO));

 

-	wcscpy_s(pInfo->achName, VTSReaderName);

-	pInfo->pGraph = m_pGraph;

-	if (m_pGraph) {

-		m_pGraph->AddRef();

-	}

+    wcscpy_s(pInfo->achName, VTSReaderName);

+    pInfo->pGraph = m_pGraph;

+    if (m_pGraph) {

+        m_pGraph->AddRef();

+    }

 

-	return S_OK;

+    return S_OK;

 }

 

 // IFileSourceFilter

 

 STDMETHODIMP CVTSReader::Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt)

 {

-	if (!m_stream.Load(pszFileName)) {

-		return E_FAIL;

-	}

+    if (!m_stream.Load(pszFileName)) {

+        return E_FAIL;

+    }

 

-	ChapRemoveAll();

-	for (int i=0; i<m_stream.GetChaptersCount(); i++) {

-		CString chap; chap.Format(_T("Chapter %d"), i+1);

-		ChapAppend(m_stream.GetChapterOffset(i), chap);

-	}

+    ChapRemoveAll();

+    for (int i = 0; i < m_stream.GetChaptersCount(); i++) {

+        CString chap; chap.Format(_T("Chapter %d"), i + 1);

+        ChapAppend(m_stream.GetChapterOffset(i), chap);

+    }

 

 

-	m_fn = pszFileName;

+    m_fn = pszFileName;

 

-	CMediaType mt;

-	mt.majortype = MEDIATYPE_Stream;

-	mt.subtype = MEDIASUBTYPE_MPEG2_PROGRAM;

-	m_mt = mt;

+    CMediaType mt;

+    mt.majortype = MEDIATYPE_Stream;

+    mt.subtype = MEDIASUBTYPE_MPEG2_PROGRAM;

+    m_mt = mt;

 

-	return S_OK;

+    return S_OK;

 }

 

 STDMETHODIMP CVTSReader::GetCurFile(LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt)

 {

-	if (!ppszFileName) {

-		return E_POINTER;

-	}

+    if (!ppszFileName) {

+        return E_POINTER;

+    }

 

-	*ppszFileName = (LPOLESTR)CoTaskMemAlloc((m_fn.GetLength()+1)*sizeof(WCHAR));

-	if (!(*ppszFileName)) {

-		return E_OUTOFMEMORY;

-	}

+    *ppszFileName = (LPOLESTR)CoTaskMemAlloc((m_fn.GetLength() + 1) * sizeof(WCHAR));

+    if (!(*ppszFileName)) {

+        return E_OUTOFMEMORY;

+    }

 

-	wcscpy_s(*ppszFileName, m_fn.GetLength() + 1, m_fn);

+    wcscpy_s(*ppszFileName, m_fn.GetLength() + 1, m_fn);

 

-	return S_OK;

+    return S_OK;

 }

 

 // ITrackInfo

 

 STDMETHODIMP_(UINT) CVTSReader::GetTrackCount()

 {

-	return 0; // Not implemented yet

+    return 0; // Not implemented yet

 }

 

 STDMETHODIMP_(BOOL) CVTSReader::GetTrackInfo(UINT aTrackIdx, struct TrackElement* pStructureToFill)

 {

-	return FALSE; // Not implemented yet

+    return FALSE; // Not implemented yet

 }

 

 STDMETHODIMP_(BOOL) CVTSReader::GetTrackExtendedInfo(UINT aTrackIdx, void* pStructureToFill)

 {

-	return FALSE; // Not implemented yet

+    return FALSE; // Not implemented yet

 }

 

 STDMETHODIMP_(BSTR) CVTSReader::GetTrackName(UINT aTrackIdx)

 {

-	return m_stream.GetTrackName(aTrackIdx); // return stream's language

+    return m_stream.GetTrackName(aTrackIdx); // return stream's language

 }

 

 STDMETHODIMP_(BSTR) CVTSReader::GetTrackCodecID(UINT aTrackIdx)

 {

-	return NULL; // Not implemented yet

+    return NULL; // Not implemented yet

 }

 

 STDMETHODIMP_(BSTR) CVTSReader::GetTrackCodecName(UINT aTrackIdx)

 {

-	return NULL; // Not implemented yet

+    return NULL; // Not implemented yet

 }

 

 STDMETHODIMP_(BSTR) CVTSReader::GetTrackCodecInfoURL(UINT aTrackIdx)

 {

-	return NULL; // Not implemented yet

+    return NULL; // Not implemented yet

 }

 

 STDMETHODIMP_(BSTR) CVTSReader::GetTrackCodecDownloadURL(UINT aTrackIdx)

 {

-	return NULL; // Not implemented yet

+    return NULL; // Not implemented yet

 }

 

 // CVTSStream

 

 CVTSStream::CVTSStream() : m_off(0)

 {

-	m_vob.Attach(DNew CVobFile());

+    m_vob.Attach(DNew CVobFile());

 }

 

 CVTSStream::~CVTSStream()

@@ -209,87 +209,87 @@ CVTSStream::~CVTSStream()
 

 bool CVTSStream::Load(const WCHAR* fnw)

 {

-	CAtlList<CString> sl;

-	return (m_vob && m_vob->Open(CString(fnw), sl) /*&& m_vob->IsDVD()*/);

+    CAtlList<CString> sl;

+    return (m_vob && m_vob->Open(CString(fnw), sl) /*&& m_vob->IsDVD()*/);

 }

 

 HRESULT CVTSStream::SetPointer(LONGLONG llPos)

 {

-	m_off = (int)(llPos&2047);

-	int lba = (int)(llPos/2048);

+    m_off = (int)(llPos & 2047);

+    int lba = (int)(llPos / 2048);

 

-	return lba == m_vob->Seek(lba) ? S_OK : S_FALSE;

+    return lba == m_vob->Seek(lba) ? S_OK : S_FALSE;

 }

 

 HRESULT CVTSStream::Read(PBYTE pbBuffer, DWORD dwBytesToRead, BOOL bAlign, LPDWORD pdwBytesRead)

 {

-	CAutoLock lck(&m_csLock);

+    CAutoLock lck(&m_csLock);

 

-	DWORD len = dwBytesToRead;

-	BYTE* ptr = pbBuffer;

+    DWORD len = dwBytesToRead;

+    BYTE* ptr = pbBuffer;

 

-	while (len > 0) {

-		BYTE buff[2048];

-		if (!m_vob->Read(buff)) {

-			break;

-		}

+    while (len > 0) {

+        BYTE buff[2048];

+        if (!m_vob->Read(buff)) {

+            break;

+        }

 

-		int size = min(2048 - m_off, (int)min(len, 2048));

+        int size = min(2048 - m_off, (int)min(len, 2048));

 

-		memcpy(ptr, &buff[m_off], size);

+        memcpy(ptr, &buff[m_off], size);

 

-		m_off = (m_off + size)&2047;

+        m_off = (m_off + size) & 2047;

 

-		if (m_off > 0) {

-			m_vob->Seek(m_vob->GetPosition()-1);

-		}

+        if (m_off > 0) {

+            m_vob->Seek(m_vob->GetPosition() - 1);

+        }

 

-		ptr += size;

-		len -= size;

-	}

+        ptr += size;

+        len -= size;

+    }

 

-	if (pdwBytesRead) {

-		*pdwBytesRead = ptr - pbBuffer;

-	}

+    if (pdwBytesRead) {

+        *pdwBytesRead = ptr - pbBuffer;

+    }

 

-	return S_OK;

+    return S_OK;

 }

 

 LONGLONG CVTSStream::Size(LONGLONG* pSizeAvailable)

 {

-	LONGLONG len = 2048i64*m_vob->GetLength();

-	if (pSizeAvailable) {

-		*pSizeAvailable = len;

-	}

-	return len;

+    LONGLONG len = 2048i64 * m_vob->GetLength();

+    if (pSizeAvailable) {

+        *pSizeAvailable = len;

+    }

+    return len;

 }

 

 DWORD CVTSStream::Alignment()

 {

-	return 1;

+    return 1;

 }

 

 void CVTSStream::Lock()

 {

-	m_csLock.Lock();

+    m_csLock.Lock();

 }

 

 void CVTSStream::Unlock()

 {

-	m_csLock.Unlock();

+    m_csLock.Unlock();

 }

 

 BSTR CVTSStream::GetTrackName(UINT aTrackIdx)

 {

-	return m_vob->GetTrackName(aTrackIdx);

+    return m_vob->GetTrackName(aTrackIdx);

 }

 

 int CVTSStream::GetChaptersCount()

 {

-	return m_vob->GetChaptersCount();

+    return m_vob->GetChaptersCount();

 }

 

 REFERENCE_TIME CVTSStream::GetChapterOffset(UINT ChapterNumber)

 {

-	return m_vob->GetChapterOffset(ChapterNumber);

+    return m_vob->GetChapterOffset(ChapterNumber);

 }
\ No newline at end of file
diff --git a/src/filters/reader/VTSReader/VTSReader.h b/src/filters/reader/VTSReader/VTSReader.h
index 7b26839a8..6eeab899e 100644
--- a/src/filters/reader/VTSReader/VTSReader.h
+++ b/src/filters/reader/VTSReader/VTSReader.h
@@ -37,62 +37,62 @@ class CVobFile;
 class CVTSStream : public CAsyncStream

 {

 private:

-	CCritSec m_csLock;

+    CCritSec m_csLock;

 

-	CAutoPtr<CVobFile> m_vob;

-	int m_off;

+    CAutoPtr<CVobFile> m_vob;

+    int m_off;

 

 public:

-	CVTSStream();

-	virtual ~CVTSStream();

+    CVTSStream();

+    virtual ~CVTSStream();

 

-	bool Load(const WCHAR* fnw);

+    bool Load(const WCHAR* fnw);

 

-	HRESULT SetPointer(LONGLONG llPos);

-	HRESULT Read(PBYTE pbBuffer, DWORD dwBytesToRead, BOOL bAlign, LPDWORD pdwBytesRead);

-	LONGLONG Size(LONGLONG* pSizeAvailable);

-	DWORD Alignment();

-	void Lock();

-	void Unlock();

+    HRESULT SetPointer(LONGLONG llPos);

+    HRESULT Read(PBYTE pbBuffer, DWORD dwBytesToRead, BOOL bAlign, LPDWORD pdwBytesRead);

+    LONGLONG Size(LONGLONG* pSizeAvailable);

+    DWORD Alignment();

+    void Lock();

+    void Unlock();

 

-	BSTR GetTrackName(UINT aTrackIdx);

-	int GetChaptersCount();

-	REFERENCE_TIME GetChapterOffset(UINT ChapterNumber);

+    BSTR GetTrackName(UINT aTrackIdx);

+    int GetChaptersCount();

+    REFERENCE_TIME GetChapterOffset(UINT ChapterNumber);

 };

 

 class __declspec(uuid("773EAEDE-D5EE-4fce-9C8F-C4F53D0A2F73"))

-	CVTSReader

-	: public CAsyncReader

-	, public IFileSourceFilter

-	, public ITrackInfo

-	, public IDSMChapterBagImpl

+    CVTSReader

+    : public CAsyncReader

+    , public IFileSourceFilter

+    , public ITrackInfo

+    , public IDSMChapterBagImpl

 {

-	CVTSStream m_stream;

-	CStringW m_fn;

+    CVTSStream m_stream;

+    CStringW m_fn;

 

 public:

-	CVTSReader(IUnknown* pUnk, HRESULT* phr);

-	~CVTSReader();

+    CVTSReader(IUnknown* pUnk, HRESULT* phr);

+    ~CVTSReader();

 

-	DECLARE_IUNKNOWN

-	STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv);

+    DECLARE_IUNKNOWN

+    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv);

 

-	// CBaseFilter

+    // CBaseFilter

 

-	STDMETHODIMP QueryFilterInfo(FILTER_INFO* pInfo);

+    STDMETHODIMP QueryFilterInfo(FILTER_INFO* pInfo);

 

-	// IFileSourceFilter

-	STDMETHODIMP Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt);

-	STDMETHODIMP GetCurFile(LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt);

+    // IFileSourceFilter

+    STDMETHODIMP Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt);

+    STDMETHODIMP GetCurFile(LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt);

 

-	// ITrackInfo

+    // ITrackInfo

 

-	STDMETHODIMP_(UINT) GetTrackCount();

-	STDMETHODIMP_(BOOL) GetTrackInfo(UINT aTrackIdx, struct TrackElement* pStructureToFill);

-	STDMETHODIMP_(BOOL) GetTrackExtendedInfo(UINT aTrackIdx, void* pStructureToFill);

-	STDMETHODIMP_(BSTR) GetTrackName(UINT aTrackIdx);

-	STDMETHODIMP_(BSTR) GetTrackCodecID(UINT aTrackIdx);

-	STDMETHODIMP_(BSTR) GetTrackCodecName(UINT aTrackIdx);

-	STDMETHODIMP_(BSTR) GetTrackCodecInfoURL(UINT aTrackIdx);

-	STDMETHODIMP_(BSTR) GetTrackCodecDownloadURL(UINT aTrackIdx);

+    STDMETHODIMP_(UINT) GetTrackCount();

+    STDMETHODIMP_(BOOL) GetTrackInfo(UINT aTrackIdx, struct TrackElement* pStructureToFill);

+    STDMETHODIMP_(BOOL) GetTrackExtendedInfo(UINT aTrackIdx, void* pStructureToFill);

+    STDMETHODIMP_(BSTR) GetTrackName(UINT aTrackIdx);

+    STDMETHODIMP_(BSTR) GetTrackCodecID(UINT aTrackIdx);

+    STDMETHODIMP_(BSTR) GetTrackCodecName(UINT aTrackIdx);

+    STDMETHODIMP_(BSTR) GetTrackCodecInfoURL(UINT aTrackIdx);

+    STDMETHODIMP_(BSTR) GetTrackCodecDownloadURL(UINT aTrackIdx);

 };