iqbalrifai
/
Aegisub
mirror of https://github.com/odrling/Aegisub
1
0
Fork 0
Code Issues Releases Wiki Activity
Aegisub/devel/vsfilter/dsutil/DSUtil.cpp

2219 lines
55 KiB
C++
Raw Blame History

/*
* Copyright (C) 2003-2006 Gabest
* http://www.gabest.org
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This Program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
#include "stdafx.h"
#include <Vfw.h>
#include "../include/winddk/devioctl.h"
#include "../include/winddk/ntddcdrm.h"
#include "DSUtil.h"
#include "../include/moreuuids.h"
void DumpStreamConfig(TCHAR* fn, IAMStreamConfig* pAMVSCCap)
{
CString s, ss;
CStdioFile f;
if(!f.Open(fn, CFile::modeCreate|CFile::modeWrite|CFile::typeText))
return;
int cnt = 0, size = 0;
if(FAILED(pAMVSCCap->GetNumberOfCapabilities(&cnt, &size)))
return;
s.Empty();
s.Format(_T("cnt %d, size %d\n"), cnt, size);
f.WriteString(s);
if(size == sizeof(VIDEO_STREAM_CONFIG_CAPS))
{
for(int i = 0; i < cnt; i++)
{
AM_MEDIA_TYPE* pmt = NULL;
VIDEO_STREAM_CONFIG_CAPS caps;
memset(&caps, 0, sizeof(caps));
s.Empty();
ss.Format(_T("%d\n"), i); s += ss;
f.WriteString(s);
if(FAILED(pAMVSCCap->GetStreamCaps(i, &pmt, (BYTE*)&caps)))
continue;
{
s.Empty();
ss.Format(_T("VIDEO_STREAM_CONFIG_CAPS\n")); s += ss;
ss.Format(_T("\tVideoStandard 0x%08x\n"), caps.VideoStandard); s += ss;
ss.Format(_T("\tInputSize %dx%d\n"), caps.InputSize); s += ss;
ss.Format(_T("\tCroppingSize %dx%d - %dx%d\n"), caps.MinCroppingSize, caps.MaxCroppingSize); s += ss;
ss.Format(_T("\tCropGranularity %d, %d\n"), caps.CropGranularityX, caps.CropGranularityY); s += ss;
ss.Format(_T("\tCropAlign %d, %d\n"), caps.CropAlignX, caps.CropAlignY); s += ss;
ss.Format(_T("\tOutputSize %dx%d - %dx%d\n"), caps.MinOutputSize, caps.MaxOutputSize); s += ss;
ss.Format(_T("\tOutputGranularity %d, %d\n"), caps.OutputGranularityX, caps.OutputGranularityY); s += ss;
ss.Format(_T("\tStretchTaps %d, %d\n"), caps.StretchTapsX, caps.StretchTapsY); s += ss;
ss.Format(_T("\tShrinkTaps %d, %d\n"), caps.ShrinkTapsX, caps.ShrinkTapsY); s += ss;
ss.Format(_T("\tFrameInterval %I64d, %I64d (%.4f, %.4f)\n"),
caps.MinFrameInterval, caps.MaxFrameInterval,
(float)10000000/caps.MinFrameInterval, (float)10000000/caps.MaxFrameInterval); s += ss;
ss.Format(_T("\tBitsPerSecond %d - %d\n"), caps.MinBitsPerSecond, caps.MaxBitsPerSecond); s += ss;
f.WriteString(s);
}
BITMAPINFOHEADER* pbh;
if(pmt->formattype == FORMAT_VideoInfo)
{
VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)pmt->pbFormat;
pbh = &vih->bmiHeader;
s.Empty();
ss.Format(_T("FORMAT_VideoInfo\n")); s += ss;
ss.Format(_T("\tAvgTimePerFrame %I64d, %.4f\n"), vih->AvgTimePerFrame, (float)10000000/vih->AvgTimePerFrame); s += ss;
ss.Format(_T("\trcSource %d,%d,%d,%d\n"), vih->rcSource); s += ss;
ss.Format(_T("\trcTarget %d,%d,%d,%d\n"), vih->rcTarget); s += ss;
f.WriteString(s);
}
else if(pmt->formattype == FORMAT_VideoInfo2)
{
VIDEOINFOHEADER2* vih = (VIDEOINFOHEADER2*)pmt->pbFormat;
pbh = &vih->bmiHeader;
s.Empty();
ss.Format(_T("FORMAT_VideoInfo2\n")); s += ss;
ss.Format(_T("\tAvgTimePerFrame %I64d, %.4f\n"), vih->AvgTimePerFrame, (float)10000000/vih->AvgTimePerFrame); s += ss;
ss.Format(_T("\trcSource %d,%d,%d,%d\n"), vih->rcSource); s += ss;
ss.Format(_T("\trcTarget %d,%d,%d,%d\n"), vih->rcTarget); s += ss;
ss.Format(_T("\tdwInterlaceFlags 0x%x\n"), vih->dwInterlaceFlags); s += ss;
ss.Format(_T("\tdwPictAspectRatio %d:%d\n"), vih->dwPictAspectRatioX, vih->dwPictAspectRatioY); s += ss;
f.WriteString(s);
}
else
{
DeleteMediaType(pmt);
continue;
}
s.Empty();
ss.Format(_T("BITMAPINFOHEADER\n")); s += ss;
ss.Format(_T("\tbiCompression %x\n"), pbh->biCompression); s += ss;
ss.Format(_T("\tbiWidth %d\n"), pbh->biWidth); s += ss;
ss.Format(_T("\tbiHeight %d\n"), pbh->biHeight); s += ss;
ss.Format(_T("\tbiBitCount %d\n"), pbh->biBitCount); s += ss;
ss.Format(_T("\tbiPlanes %d\n"), pbh->biPlanes); s += ss;
ss.Format(_T("\tbiSizeImage %d\n"), pbh->biSizeImage); s += ss;
f.WriteString(s);
DeleteMediaType(pmt);
}
}
else if(size == sizeof(AUDIO_STREAM_CONFIG_CAPS))
{
// TODO
}
}
int CountPins(IBaseFilter* pBF, int& nIn, int& nOut, int& nInC, int& nOutC)
{
nIn = nOut = 0;
nInC = nOutC = 0;
BeginEnumPins(pBF, pEP, pPin)
{
PIN_DIRECTION dir;
if(SUCCEEDED(pPin->QueryDirection(&dir)))
{
CComPtr<IPin> pPinConnectedTo;
pPin->ConnectedTo(&pPinConnectedTo);
if(dir == PINDIR_INPUT) {nIn++; if(pPinConnectedTo) nInC++;}
else if(dir == PINDIR_OUTPUT) {nOut++; if(pPinConnectedTo) nOutC++;}
}
}
EndEnumPins
return(nIn+nOut);
}
bool IsSplitter(IBaseFilter* pBF, bool fCountConnectedOnly)
{
int nIn, nOut, nInC, nOutC;
CountPins(pBF, nIn, nOut, nInC, nOutC);
return(fCountConnectedOnly ? nOutC > 1 : nOut > 1);
}
bool IsMultiplexer(IBaseFilter* pBF, bool fCountConnectedOnly)
{
int nIn, nOut, nInC, nOutC;
CountPins(pBF, nIn, nOut, nInC, nOutC);
return(fCountConnectedOnly ? nInC > 1 : nIn > 1);
}
bool IsStreamStart(IBaseFilter* pBF)
{
CComQIPtr<IAMFilterMiscFlags> pAMMF(pBF);
if(pAMMF && pAMMF->GetMiscFlags()&AM_FILTER_MISC_FLAGS_IS_SOURCE)
return(true);
int nIn, nOut, nInC, nOutC;
CountPins(pBF, nIn, nOut, nInC, nOutC);
AM_MEDIA_TYPE mt;
CComPtr<IPin> pIn = GetFirstPin(pBF);
return((nOut > 1)
|| (nOut > 0 && nIn == 1 && pIn && SUCCEEDED(pIn->ConnectionMediaType(&mt)) && mt.majortype == MEDIATYPE_Stream));
}
bool IsStreamEnd(IBaseFilter* pBF)
{
int nIn, nOut, nInC, nOutC;
CountPins(pBF, nIn, nOut, nInC, nOutC);
return(nOut == 0);
}
bool IsVideoRenderer(IBaseFilter* pBF)
{
int nIn, nOut, nInC, nOutC;
CountPins(pBF, nIn, nOut, nInC, nOutC);
if(nInC > 0 && nOut == 0)
{
BeginEnumPins(pBF, pEP, pPin)
{
AM_MEDIA_TYPE mt;
if(S_OK != pPin->ConnectionMediaType(&mt))
continue;
FreeMediaType(mt);
return(!!(mt.majortype == MEDIATYPE_Video));
/*&& (mt.formattype == FORMAT_VideoInfo || mt.formattype == FORMAT_VideoInfo2));*/
}
EndEnumPins
}
CLSID clsid;
memcpy(&clsid, &GUID_NULL, sizeof(clsid));
pBF->GetClassID(&clsid);
return(clsid == CLSID_VideoRenderer || clsid == CLSID_VideoRendererDefault);
}
#include <initguid.h>
DEFINE_GUID(CLSID_ReClock,
0x9dc15360, 0x914c, 0x46b8, 0xb9, 0xdf, 0xbf, 0xe6, 0x7f, 0xd3, 0x6c, 0x6a);
bool IsAudioWaveRenderer(IBaseFilter* pBF)
{
int nIn, nOut, nInC, nOutC;
CountPins(pBF, nIn, nOut, nInC, nOutC);
if(nInC > 0 && nOut == 0 && CComQIPtr<IBasicAudio>(pBF))
{
BeginEnumPins(pBF, pEP, pPin)
{
AM_MEDIA_TYPE mt;
if(S_OK != pPin->ConnectionMediaType(&mt))
continue;
FreeMediaType(mt);
return(!!(mt.majortype == MEDIATYPE_Audio)
/*&& mt.formattype == FORMAT_WaveFormatEx*/);
}
EndEnumPins
}
CLSID clsid;
memcpy(&clsid, &GUID_NULL, sizeof(clsid));
pBF->GetClassID(&clsid);
return(clsid == CLSID_DSoundRender || clsid == CLSID_AudioRender || clsid == CLSID_ReClock
|| clsid == __uuidof(CNullAudioRenderer) || clsid == __uuidof(CNullUAudioRenderer));
}
IBaseFilter* GetUpStreamFilter(IBaseFilter* pBF, IPin* pInputPin)
{
return GetFilterFromPin(GetUpStreamPin(pBF, pInputPin));
}
IPin* GetUpStreamPin(IBaseFilter* pBF, IPin* pInputPin)
{
BeginEnumPins(pBF, pEP, pPin)
{
if(pInputPin && pInputPin != pPin) continue;
PIN_DIRECTION dir;
CComPtr<IPin> pPinConnectedTo;
if(SUCCEEDED(pPin->QueryDirection(&dir)) && dir == PINDIR_INPUT
&& SUCCEEDED(pPin->ConnectedTo(&pPinConnectedTo)))
{
IPin* pRet = pPinConnectedTo.Detach();
pRet->Release();
return(pRet);
}
}
EndEnumPins
return(NULL);
}
IPin* GetFirstPin(IBaseFilter* pBF, PIN_DIRECTION dir)
{
if(!pBF) return(NULL);
BeginEnumPins(pBF, pEP, pPin)
{
PIN_DIRECTION dir2;
pPin->QueryDirection(&dir2);
if(dir == dir2)
{
IPin* pRet = pPin.Detach();
pRet->Release();
return(pRet);
}
}
EndEnumPins
return(NULL);
}
IPin* GetFirstDisconnectedPin(IBaseFilter* pBF, PIN_DIRECTION dir)
{
if(!pBF) return(NULL);
BeginEnumPins(pBF, pEP, pPin)
{
PIN_DIRECTION dir2;
pPin->QueryDirection(&dir2);
CComPtr<IPin> pPinTo;
if(dir == dir2 && (S_OK != pPin->ConnectedTo(&pPinTo)))
{
IPin* pRet = pPin.Detach();
pRet->Release();
return(pRet);
}
}
EndEnumPins
return(NULL);
}
IBaseFilter* FindFilter(LPCWSTR clsid, IFilterGraph* pFG)
{
CLSID clsid2;
CLSIDFromString(CComBSTR(clsid), &clsid2);
return(FindFilter(clsid2, pFG));
}
IBaseFilter* FindFilter(const CLSID& clsid, IFilterGraph* pFG)
{
BeginEnumFilters(pFG, pEF, pBF)
{
CLSID clsid2;
if(SUCCEEDED(pBF->GetClassID(&clsid2)) && clsid == clsid2)
return(pBF);
}
EndEnumFilters
return NULL;
}
CStringW GetFilterName(IBaseFilter* pBF)
{
CStringW name;
CFilterInfo fi;
if(pBF && SUCCEEDED(pBF->QueryFilterInfo(&fi)))
name = fi.achName;
return(name);
}
CStringW GetPinName(IPin* pPin)
{
CStringW name;
CPinInfo pi;
if(pPin && SUCCEEDED(pPin->QueryPinInfo(&pi)))
name = pi.achName;
return(name);
}
IFilterGraph* GetGraphFromFilter(IBaseFilter* pBF)
{
if(!pBF) return NULL;
IFilterGraph* pGraph = NULL;
CFilterInfo fi;
if(pBF && SUCCEEDED(pBF->QueryFilterInfo(&fi)))
pGraph = fi.pGraph;
return(pGraph);
}
IBaseFilter* GetFilterFromPin(IPin* pPin)
{
if(!pPin) return NULL;
IBaseFilter* pBF = NULL;
CPinInfo pi;
if(pPin && SUCCEEDED(pPin->QueryPinInfo(&pi)))
pBF = pi.pFilter;
return(pBF);
}
IPin* AppendFilter(IPin* pPin, CString DisplayName, IGraphBuilder* pGB)
{
IPin* pRet = pPin;
CInterfaceList<IBaseFilter> pFilters;
do
{
if(!pPin || DisplayName.IsEmpty() || !pGB)
break;
CComPtr<IPin> pPinTo;
PIN_DIRECTION dir;
if(FAILED(pPin->QueryDirection(&dir)) || dir != PINDIR_OUTPUT || SUCCEEDED(pPin->ConnectedTo(&pPinTo)))
break;
CComPtr<IBindCtx> pBindCtx;
CreateBindCtx(0, &pBindCtx);
CComPtr<IMoniker> pMoniker;
ULONG chEaten;
if(S_OK != MkParseDisplayName(pBindCtx, CComBSTR(DisplayName), &chEaten, &pMoniker))
break;
CComPtr<IBaseFilter> pBF;
if(FAILED(pMoniker->BindToObject(pBindCtx, 0, IID_IBaseFilter, (void**)&pBF)) || !pBF)
break;
CComPtr<IPropertyBag> pPB;
if(FAILED(pMoniker->BindToStorage(pBindCtx, 0, IID_IPropertyBag, (void**)&pPB)))
break;
CComVariant var;
if(FAILED(pPB->Read(CComBSTR(_T("FriendlyName")), &var, NULL)))
break;
pFilters.AddTail(pBF);
BeginEnumFilters(pGB, pEnum, pBF2)
pFilters.AddTail(pBF2);
EndEnumFilters
if(FAILED(pGB->AddFilter(pBF, CStringW(var.bstrVal))))
break;
BeginEnumFilters(pGB, pEnum, pBF2)
if(!pFilters.Find(pBF2) && SUCCEEDED(pGB->RemoveFilter(pBF2)))
pEnum->Reset();
EndEnumFilters
pPinTo = GetFirstPin(pBF, PINDIR_INPUT);
if(!pPinTo)
{
pGB->RemoveFilter(pBF);
break;
}
HRESULT hr;
if(FAILED(hr = pGB->ConnectDirect(pPin, pPinTo, NULL)))
{
hr = pGB->Connect(pPin, pPinTo);
pGB->RemoveFilter(pBF);
break;
}
BeginEnumFilters(pGB, pEnum, pBF2)
if(!pFilters.Find(pBF2) && SUCCEEDED(pGB->RemoveFilter(pBF2)))
pEnum->Reset();
EndEnumFilters
pRet = GetFirstPin(pBF, PINDIR_OUTPUT);
if(!pRet)
{
pRet = pPin;
pGB->RemoveFilter(pBF);
break;
}
}
while(false);
return(pRet);
}
IPin* InsertFilter(IPin* pPin, CString DisplayName, IGraphBuilder* pGB)
{
do
{
if(!pPin || DisplayName.IsEmpty() || !pGB)
break;
PIN_DIRECTION dir;
if(FAILED(pPin->QueryDirection(&dir)))
break;
CComPtr<IPin> pFrom, pTo;
if(dir == PINDIR_INPUT)
{
pPin->ConnectedTo(&pFrom);
pTo = pPin;
}
else if(dir == PINDIR_OUTPUT)
{
pFrom = pPin;
pPin->ConnectedTo(&pTo);
}
if(!pFrom || !pTo)
break;
CComPtr<IBindCtx> pBindCtx;
CreateBindCtx(0, &pBindCtx);
CComPtr<IMoniker> pMoniker;
ULONG chEaten;
if(S_OK != MkParseDisplayName(pBindCtx, CComBSTR(DisplayName), &chEaten, &pMoniker))
break;
CComPtr<IBaseFilter> pBF;
if(FAILED(pMoniker->BindToObject(pBindCtx, 0, IID_IBaseFilter, (void**)&pBF)) || !pBF)
break;
CComPtr<IPropertyBag> pPB;
if(FAILED(pMoniker->BindToStorage(pBindCtx, 0, IID_IPropertyBag, (void**)&pPB)))
break;
CComVariant var;
if(FAILED(pPB->Read(CComBSTR(_T("FriendlyName")), &var, NULL)))
break;
if(FAILED(pGB->AddFilter(pBF, CStringW(var.bstrVal))))
break;
CComPtr<IPin> pFromTo = GetFirstPin(pBF, PINDIR_INPUT);
if(!pFromTo)
{
pGB->RemoveFilter(pBF);
break;
}
if(FAILED(pGB->Disconnect(pFrom)) || FAILED(pGB->Disconnect(pTo)))
{
pGB->RemoveFilter(pBF);
pGB->ConnectDirect(pFrom, pTo, NULL);
break;
}
HRESULT hr;
if(FAILED(hr = pGB->ConnectDirect(pFrom, pFromTo, NULL)))
{
pGB->RemoveFilter(pBF);
pGB->ConnectDirect(pFrom, pTo, NULL);
break;
}
CComPtr<IPin> pToFrom = GetFirstPin(pBF, PINDIR_OUTPUT);
if(!pToFrom)
{
pGB->RemoveFilter(pBF);
pGB->ConnectDirect(pFrom, pTo, NULL);
break;
}
if(FAILED(pGB->ConnectDirect(pToFrom, pTo, NULL)))
{
pGB->RemoveFilter(pBF);
pGB->ConnectDirect(pFrom, pTo, NULL);
break;
}
pPin = pToFrom;
}
while(false);
return(pPin);
}
void ExtractMediaTypes(IPin* pPin, CAtlArray<GUID>& types)
{
types.RemoveAll();
BeginEnumMediaTypes(pPin, pEM, pmt)
{
bool fFound = false;
for(int i = 0; !fFound && i < types.GetCount(); i += 2)
{
if(types[i] == pmt->majortype && types[i+1] == pmt->subtype)
fFound = true;
}
if(!fFound)
{
types.Add(pmt->majortype);
types.Add(pmt->subtype);
}
}
EndEnumMediaTypes(pmt)
}
void ExtractMediaTypes(IPin* pPin, CAtlList<CMediaType>& mts)
{
mts.RemoveAll();
BeginEnumMediaTypes(pPin, pEM, pmt)
{
bool fFound = false;
POSITION pos = mts.GetHeadPosition();
while(!fFound && pos)
{
CMediaType& mt = mts.GetNext(pos);
if(mt.majortype == pmt->majortype && mt.subtype == pmt->subtype)
fFound = true;
}
if(!fFound)
{
mts.AddTail(CMediaType(*pmt));
}
}
EndEnumMediaTypes(pmt)
}
int Eval_Exception(int n_except)
{
if(n_except == STATUS_ACCESS_VIOLATION)
{
AfxMessageBox(_T("The property page of this filter has just caused a\nmemory access violation. The application will gently die now :)"));
}
return EXCEPTION_CONTINUE_SEARCH;
}
void MyOleCreatePropertyFrame(HWND hwndOwner, UINT x, UINT y, LPCOLESTR lpszCaption, ULONG cObjects, LPUNKNOWN FAR* lplpUnk, ULONG cPages, LPCLSID lpPageClsID, LCID lcid, DWORD dwReserved, LPVOID lpvReserved)
{
__try
{
OleCreatePropertyFrame(hwndOwner, x, y, lpszCaption, cObjects, lplpUnk, cPages, lpPageClsID, lcid, dwReserved, lpvReserved);
}
__except(Eval_Exception(GetExceptionCode()))
{
// No code; this block never executed.
}
}
void ShowPPage(CString DisplayName, HWND hParentWnd)
{
CComPtr<IBindCtx> pBindCtx;
CreateBindCtx(0, &pBindCtx);
CComPtr<IMoniker> pMoniker;
ULONG chEaten;
if(S_OK != MkParseDisplayName(pBindCtx, CStringW(DisplayName), &chEaten, &pMoniker))
return;
CComPtr<IBaseFilter> pBF;
if(FAILED(pMoniker->BindToObject(pBindCtx, 0, IID_IBaseFilter, (void**)&pBF)) || !pBF)
return;
ShowPPage(pBF, hParentWnd);
}
void ShowPPage(IUnknown* pUnk, HWND hParentWnd)
{
CComQIPtr<ISpecifyPropertyPages> pSPP = pUnk;
if(!pSPP) return;
CString str;
CComQIPtr<IBaseFilter> pBF = pSPP;
CFilterInfo fi;
CComQIPtr<IPin> pPin = pSPP;
CPinInfo pi;
if(pBF && SUCCEEDED(pBF->QueryFilterInfo(&fi)))
str = fi.achName;
else if(pPin && SUCCEEDED(pPin->QueryPinInfo(&pi)))
str = pi.achName;
CAUUID caGUID;
caGUID.pElems = NULL;
if(SUCCEEDED(pSPP->GetPages(&caGUID)))
{
IUnknown* lpUnk = NULL;
pSPP.QueryInterface(&lpUnk);
MyOleCreatePropertyFrame(
hParentWnd, 0, 0, CStringW(str),
1, (IUnknown**)&lpUnk,
caGUID.cElems, caGUID.pElems,
0, 0, NULL);
lpUnk->Release();
if(caGUID.pElems) CoTaskMemFree(caGUID.pElems);
}
}
CLSID GetCLSID(IBaseFilter* pBF)
{
CLSID clsid = GUID_NULL;
if(pBF) pBF->GetClassID(&clsid);
return(clsid);
}
CLSID GetCLSID(IPin* pPin)
{
return(GetCLSID(GetFilterFromPin(pPin)));
}
bool IsCLSIDRegistered(LPCTSTR clsid)
{
CString rootkey1(_T("CLSID\\"));
CString rootkey2(_T("CLSID\\{083863F1-70DE-11d0-BD40-00A0C911CE86}\\Instance\\"));
return ERROR_SUCCESS == CRegKey().Open(HKEY_CLASSES_ROOT, rootkey1 + clsid, KEY_READ)
|| ERROR_SUCCESS == CRegKey().Open(HKEY_CLASSES_ROOT, rootkey2 + clsid, KEY_READ);
}
bool IsCLSIDRegistered(const CLSID& clsid)
{
bool fRet = false;
LPOLESTR pStr = NULL;
if(S_OK == StringFromCLSID(clsid, &pStr) && pStr)
{
fRet = IsCLSIDRegistered(CString(pStr));
CoTaskMemFree(pStr);
}
return(fRet);
}
void CStringToBin(CString str, CAtlArray<BYTE>& data)
{
str.Trim();
ASSERT((str.GetLength()&1) == 0);
data.SetCount(str.GetLength()/2);
BYTE b = 0;
str.MakeUpper();
for(int i = 0, j = str.GetLength(); i < j; i++)
{
TCHAR c = str[i];
if(c >= '0' && c <= '9')
{
if(!(i&1)) b = ((char(c-'0')<<4)&0xf0)|(b&0x0f);
else b = (char(c-'0')&0x0f)|(b&0xf0);
}
else if(c >= 'A' && c <= 'F')
{
if(!(i&1)) b = ((char(c-'A'+10)<<4)&0xf0)|(b&0x0f);
else b = (char(c-'A'+10)&0x0f)|(b&0xf0);
}
else break;
if(i&1)
{
data[i>>1] = b;
b = 0;
}
}
}
CString BinToCString(BYTE* ptr, int len)
{
CString ret;
while(len-- > 0)
{
TCHAR high, low;
high = (*ptr>>4) >= 10 ? (*ptr>>4)-10 + 'A' : (*ptr>>4) + '0';
low = (*ptr&0xf) >= 10 ? (*ptr&0xf)-10 + 'A' : (*ptr&0xf) + '0';
CString str;
str.Format(_T("%c%c"), high, low);
ret += str;
ptr++;
}
return(ret);
}
static void FindFiles(CString fn, CAtlList<CString>& files)
{
CString path = fn;
path.Replace('/', '\\');
path = path.Left(path.ReverseFind('\\')+1);
WIN32_FIND_DATA findData;
HANDLE h = FindFirstFile(fn, &findData);
if(h != INVALID_HANDLE_VALUE)
{
do {files.AddTail(path + findData.cFileName);}
while(FindNextFile(h, &findData));
FindClose(h);
}
}
cdrom_t GetCDROMType(TCHAR drive, CAtlList<CString>& files)
{
files.RemoveAll();
CString path;
path.Format(_T("%c:"), drive);
if(GetDriveType(path + _T("\\")) == DRIVE_CDROM)
{
// CDROM_VideoCD
FindFiles(path + _T("\\mpegav\\avseq??.dat"), files);
FindFiles(path + _T("\\mpegav\\avseq??.mpg"), files);
FindFiles(path + _T("\\mpeg2\\avseq??.dat"), files);
FindFiles(path + _T("\\mpeg2\\avseq??.mpg"), files);
FindFiles(path + _T("\\mpegav\\music??.dat"), files);
FindFiles(path + _T("\\mpegav\\music??.mpg"), files);
FindFiles(path + _T("\\mpeg2\\music??.dat"), files);
FindFiles(path + _T("\\mpeg2\\music??.mpg"), files);
if(files.GetCount() > 0) return CDROM_VideoCD;
// CDROM_DVDVideo
FindFiles(path + _T("\\VIDEO_TS\\video_ts.ifo"), files);
if(files.GetCount() > 0) return CDROM_DVDVideo;
// CDROM_Audio
if(!(GetVersion()&0x80000000))
{
HANDLE hDrive = CreateFile(CString(_T("\\\\.\\")) + path, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, (HANDLE)NULL);
if(hDrive != INVALID_HANDLE_VALUE)
{
DWORD BytesReturned;
CDROM_TOC TOC;
if(DeviceIoControl(hDrive, IOCTL_CDROM_READ_TOC, NULL, 0, &TOC, sizeof(TOC), &BytesReturned, 0))
{
for(int i = TOC.FirstTrack; i <= TOC.LastTrack; i++)
{
// MMC-3 Draft Revision 10g: Table 222 <20> Q Sub-channel control field
TOC.TrackData[i-1].Control &= 5;
if(TOC.TrackData[i-1].Control == 0 || TOC.TrackData[i-1].Control == 1)
{
CString fn;
fn.Format(_T("%s\\track%02d.cda"), path, i);
files.AddTail(fn);
}
}
}
CloseHandle(hDrive);
}
}
if(files.GetCount() > 0) return CDROM_Audio;
// it is a cdrom but nothing special
return CDROM_Unknown;
}
return CDROM_NotFound;
}
CString GetDriveLabel(TCHAR drive)
{
CString label;
CString path;
path.Format(_T("%c:\\"), drive);
TCHAR VolumeNameBuffer[MAX_PATH], FileSystemNameBuffer[MAX_PATH];
DWORD VolumeSerialNumber, MaximumComponentLength, FileSystemFlags;
if(GetVolumeInformation(path,
VolumeNameBuffer, MAX_PATH, &VolumeSerialNumber, &MaximumComponentLength,
&FileSystemFlags, FileSystemNameBuffer, MAX_PATH))
{
label = VolumeNameBuffer;
}
return(label);
}
bool GetKeyFrames(CString fn, CUIntArray& kfs)
{
kfs.RemoveAll();
CString fn2 = CString(fn).MakeLower();
if(fn2.Mid(fn2.ReverseFind('.')+1) == _T("avi"))
{
AVIFileInit();
PAVIFILE pfile;
if(AVIFileOpen(&pfile, fn, OF_SHARE_DENY_WRITE, 0L) == 0)
{
AVIFILEINFO afi;
memset(&afi, 0, sizeof(afi));
AVIFileInfo(pfile, &afi, sizeof(AVIFILEINFO));
CComPtr<IAVIStream> pavi;
if(AVIFileGetStream(pfile, &pavi, streamtypeVIDEO, 0) == AVIERR_OK)
{
AVISTREAMINFO si;
AVIStreamInfo(pavi, &si, sizeof(si));
if(afi.dwCaps&AVIFILECAPS_ALLKEYFRAMES)
{
kfs.SetSize(si.dwLength);
for(int kf = 0; kf < si.dwLength; kf++) kfs[kf] = kf;
}
else
{
for(int kf = 0; ; kf++)
{
kf = pavi->FindSample(kf, FIND_KEY|FIND_NEXT);
if(kf < 0 || kfs.GetCount() > 0 && kfs[kfs.GetCount()-1] >= kf) break;
kfs.Add(kf);
}
if(kfs.GetCount() > 0 && kfs[kfs.GetCount()-1] < si.dwLength-1)
{
kfs.Add(si.dwLength-1);
}
}
}
AVIFileRelease(pfile);
}
AVIFileExit();
}
return(kfs.GetCount() > 0);
}
DVD_HMSF_TIMECODE RT2HMSF(REFERENCE_TIME rt, double fps)
{
DVD_HMSF_TIMECODE hmsf =
{
(BYTE)((rt/10000000/60/60)),
(BYTE)((rt/10000000/60)%60),
(BYTE)((rt/10000000)%60),
(BYTE)(1.0*((rt/10000)%1000) * fps / 1000)
};
return hmsf;
}
REFERENCE_TIME HMSF2RT(DVD_HMSF_TIMECODE hmsf, double fps)
{
if(fps == 0) {hmsf.bFrames = 0; fps = 1;}
return (REFERENCE_TIME)((((REFERENCE_TIME)hmsf.bHours*60+hmsf.bMinutes)*60+hmsf.bSeconds)*1000+1.0*hmsf.bFrames*1000/fps)*10000;
}
void memsetd(void* dst, unsigned int c, int nbytes)
{
__asm
{
mov eax, c
mov ecx, nbytes
shr ecx, 2
mov edi, dst
cld
rep stosd
}
}
bool ExtractBIH(const AM_MEDIA_TYPE* pmt, BITMAPINFOHEADER* bih)
{
if(pmt && bih)
{
memset(bih, 0, sizeof(*bih));
if(pmt->formattype == FORMAT_VideoInfo)
{
VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)pmt->pbFormat;
memcpy(bih, &vih->bmiHeader, sizeof(BITMAPINFOHEADER));
return true;
}
else if(pmt->formattype == FORMAT_VideoInfo2)
{
VIDEOINFOHEADER2* vih = (VIDEOINFOHEADER2*)pmt->pbFormat;
memcpy(bih, &vih->bmiHeader, sizeof(BITMAPINFOHEADER));
return true;
}
else if(pmt->formattype == FORMAT_MPEGVideo)
{
VIDEOINFOHEADER* vih = &((MPEG1VIDEOINFO*)pmt->pbFormat)->hdr;
memcpy(bih, &vih->bmiHeader, sizeof(BITMAPINFOHEADER));
return true;
}
else if(pmt->formattype == FORMAT_MPEG2_VIDEO)
{
VIDEOINFOHEADER2* vih = &((MPEG2VIDEOINFO*)pmt->pbFormat)->hdr;
memcpy(bih, &vih->bmiHeader, sizeof(BITMAPINFOHEADER));
return true;
}
else if(pmt->formattype == FORMAT_DiracVideoInfo)
{
VIDEOINFOHEADER2* vih = &((DIRACINFOHEADER*)pmt->pbFormat)->hdr;
memcpy(bih, &vih->bmiHeader, sizeof(BITMAPINFOHEADER));
return true;
}
}
return false;
}
bool ExtractBIH(IMediaSample* pMS, BITMAPINFOHEADER* bih)
{
AM_MEDIA_TYPE* pmt = NULL;
pMS->GetMediaType(&pmt);
if(pmt)
{
bool fRet = ExtractBIH(pmt, bih);
DeleteMediaType(pmt);
return(fRet);
}
return(false);
}
bool ExtractDim(const AM_MEDIA_TYPE* pmt, int& w, int& h, int& arx, int& ary)
{
w = h = arx = ary = 0;
if(pmt->formattype == FORMAT_VideoInfo || pmt->formattype == FORMAT_MPEGVideo)
{
VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)pmt->pbFormat;
w = vih->bmiHeader.biWidth;
h = abs(vih->bmiHeader.biHeight);
arx = w * vih->bmiHeader.biYPelsPerMeter;
ary = h * vih->bmiHeader.biXPelsPerMeter;
}
else if(pmt->formattype == FORMAT_VideoInfo2 || pmt->formattype == FORMAT_MPEG2_VIDEO || pmt->formattype == FORMAT_DiracVideoInfo)
{
VIDEOINFOHEADER2* vih = (VIDEOINFOHEADER2*)pmt->pbFormat;
w = vih->bmiHeader.biWidth;
h = abs(vih->bmiHeader.biHeight);
arx = vih->dwPictAspectRatioX;
ary = vih->dwPictAspectRatioY;
}
else
{
return(false);
}
if(!arx || !ary)
{
arx = w;
ary = h;
}
BYTE* ptr = NULL;
DWORD len = 0;
if(pmt->formattype == FORMAT_MPEGVideo)
{
ptr = ((MPEG1VIDEOINFO*)pmt->pbFormat)->bSequenceHeader;
len = ((MPEG1VIDEOINFO*)pmt->pbFormat)->cbSequenceHeader;
if(ptr && len >= 8 && *(DWORD*)ptr == 0xb3010000)
{
w = (ptr[4]<<4)|(ptr[5]>>4);
h = ((ptr[5]&0xf)<<8)|ptr[6];
float ar[] =
{
1.0000f,1.0000f,0.6735f,0.7031f,
0.7615f,0.8055f,0.8437f,0.8935f,
0.9157f,0.9815f,1.0255f,1.0695f,
1.0950f,1.1575f,1.2015f,1.0000f,
};
arx = (int)((float)w / ar[ptr[7]>>4] + 0.5);
ary = h;
}
}
else if(pmt->formattype == FORMAT_MPEG2_VIDEO)
{
ptr = (BYTE*)((MPEG2VIDEOINFO*)pmt->pbFormat)->dwSequenceHeader;
len = ((MPEG2VIDEOINFO*)pmt->pbFormat)->cbSequenceHeader;
if(ptr && len >= 8 && *(DWORD*)ptr == 0xb3010000)
{
w = (ptr[4]<<4)|(ptr[5]>>4);
h = ((ptr[5]&0xf)<<8)|ptr[6];
struct {int x, y;} ar[] = {{w,h},{4,3},{16,9},{221,100},{w,h}};
int i = min(max(ptr[7]>>4, 1), 5)-1;
arx = ar[i].x;
ary = ar[i].y;
}
}
if(ptr && len >= 8)
{
}
DWORD a = arx, b = ary;
while(a) {int tmp = a; a = b % tmp; b = tmp;}
if(b) arx /= b, ary /= b;
return(true);
}
bool MakeMPEG2MediaType(CMediaType& mt, BYTE* seqhdr, DWORD len, int w, int h)
{
if(len < 4 || *(DWORD*)seqhdr != 0xb3010000) return false;
BYTE* seqhdr_ext = NULL;
BYTE* seqhdr_end = seqhdr + 11;
if(seqhdr_end - seqhdr > len) return false;
if(*seqhdr_end & 0x02) seqhdr_end += 64;
if(seqhdr_end - seqhdr > len) return false;
if(*seqhdr_end & 0x01) seqhdr_end += 64;
if(seqhdr_end - seqhdr > len) return false;
seqhdr_end++;
if(seqhdr_end - seqhdr > len) return false;
if(len - (seqhdr_end - seqhdr) > 4 && *(DWORD*)seqhdr_end == 0xb5010000) {seqhdr_ext = seqhdr_end; seqhdr_end += 10;}
if(seqhdr_end - seqhdr > len) return false;
len = seqhdr_end - seqhdr;
mt = CMediaType();
mt.majortype = MEDIATYPE_Video;
mt.subtype = MEDIASUBTYPE_MPEG2_VIDEO;
mt.formattype = FORMAT_MPEG2Video;
MPEG2VIDEOINFO* vih = (MPEG2VIDEOINFO*)mt.AllocFormatBuffer(FIELD_OFFSET(MPEG2VIDEOINFO, dwSequenceHeader) + len);
memset(mt.Format(), 0, mt.FormatLength());
vih->hdr.bmiHeader.biSize = sizeof(vih->hdr.bmiHeader);
vih->hdr.bmiHeader.biWidth = w;
vih->hdr.bmiHeader.biHeight = h;
BYTE* pSequenceHeader = (BYTE*)vih->dwSequenceHeader;
memcpy(pSequenceHeader, seqhdr, len);
vih->cbSequenceHeader = len;
static char profile[8] =
{
0, AM_MPEG2Profile_High, AM_MPEG2Profile_SpatiallyScalable, AM_MPEG2Profile_SNRScalable,
AM_MPEG2Profile_Main, AM_MPEG2Profile_Simple, 0, 0
};
static char level[16] =
{
0, 0, 0, 0,
AM_MPEG2Level_High, 0, AM_MPEG2Level_High1440, 0,
AM_MPEG2Level_Main, 0, AM_MPEG2Level_Low, 0,
0, 0, 0, 0
};
if(seqhdr_ext && (seqhdr_ext[4] & 0xf0) == 0x10)
{
vih->dwProfile = profile[seqhdr_ext[4] & 0x07];
vih->dwLevel = level[seqhdr_ext[5] >> 4];
}
return true;
}
unsigned __int64 GetFileVersion(LPCTSTR fn)
{
unsigned __int64 ret = 0;
DWORD buff[4];
VS_FIXEDFILEINFO* pvsf = (VS_FIXEDFILEINFO*)buff;
DWORD d; // a variable that GetFileVersionInfoSize sets to zero (but why is it needed ?????????????????????????????? :)
DWORD len = GetFileVersionInfoSize((TCHAR*)fn, &d);
if(len)
{
TCHAR* b1 = new TCHAR[len];
if(b1)
{
UINT uLen;
if(GetFileVersionInfo((TCHAR*)fn, 0, len, b1) && VerQueryValue(b1, _T("\\"), (void**)&pvsf, &uLen))
{
ret = ((unsigned __int64)pvsf->dwFileVersionMS<<32) | pvsf->dwFileVersionLS;
}
delete [] b1;
}
}
return ret;
}
bool CreateFilter(CStringW DisplayName, IBaseFilter** ppBF, CStringW& FriendlyName)
{
if(!ppBF) return(false);
*ppBF = NULL;
FriendlyName.Empty();
CComPtr<IBindCtx> pBindCtx;
CreateBindCtx(0, &pBindCtx);
CComPtr<IMoniker> pMoniker;
ULONG chEaten;
if(S_OK != MkParseDisplayName(pBindCtx, CComBSTR(DisplayName), &chEaten, &pMoniker))
return(false);
if(FAILED(pMoniker->BindToObject(pBindCtx, 0, IID_IBaseFilter, (void**)ppBF)) || !*ppBF)
return(false);
CComPtr<IPropertyBag> pPB;
CComVariant var;
if(SUCCEEDED(pMoniker->BindToStorage(pBindCtx, 0, IID_IPropertyBag, (void**)&pPB))
&& SUCCEEDED(pPB->Read(CComBSTR(_T("FriendlyName")), &var, NULL)))
FriendlyName = var.bstrVal;
return(true);
}
IBaseFilter* AppendFilter(IPin* pPin, IMoniker* pMoniker, IGraphBuilder* pGB)
{
do
{
if(!pPin || !pMoniker || !pGB)
break;
CComPtr<IPin> pPinTo;
PIN_DIRECTION dir;
if(FAILED(pPin->QueryDirection(&dir)) || dir != PINDIR_OUTPUT || SUCCEEDED(pPin->ConnectedTo(&pPinTo)))
break;
CComPtr<IBindCtx> pBindCtx;
CreateBindCtx(0, &pBindCtx);
CComPtr<IPropertyBag> pPB;
if(FAILED(pMoniker->BindToStorage(pBindCtx, 0, IID_IPropertyBag, (void**)&pPB)))
break;
CComVariant var;
if(FAILED(pPB->Read(CComBSTR(_T("FriendlyName")), &var, NULL)))
break;
CComPtr<IBaseFilter> pBF;
if(FAILED(pMoniker->BindToObject(pBindCtx, 0, IID_IBaseFilter, (void**)&pBF)) || !pBF)
break;
if(FAILED(pGB->AddFilter(pBF, CStringW(var.bstrVal))))
break;
BeginEnumPins(pBF, pEP, pPinTo)
{
PIN_DIRECTION dir;
if(FAILED(pPinTo->QueryDirection(&dir)) || dir != PINDIR_INPUT)
continue;
if(SUCCEEDED(pGB->ConnectDirect(pPin, pPinTo, NULL)))
return(pBF);
}
EndEnumFilters
pGB->RemoveFilter(pBF);
}
while(false);
return(NULL);
}
CStringW GetFriendlyName(CStringW DisplayName)
{
CStringW FriendlyName;
CComPtr<IBindCtx> pBindCtx;
CreateBindCtx(0, &pBindCtx);
CComPtr<IMoniker> pMoniker;
ULONG chEaten;
if(S_OK != MkParseDisplayName(pBindCtx, CComBSTR(DisplayName), &chEaten, &pMoniker))
return(false);
CComPtr<IPropertyBag> pPB;
CComVariant var;
if(SUCCEEDED(pMoniker->BindToStorage(pBindCtx, 0, IID_IPropertyBag, (void**)&pPB))
&& SUCCEEDED(pPB->Read(CComBSTR(_T("FriendlyName")), &var, NULL)))
FriendlyName = var.bstrVal;
return FriendlyName;
}
typedef struct
{
CString path;
HINSTANCE hInst;
CLSID clsid;
} ExternalObject;
static CAtlList<ExternalObject> s_extobjs;
HRESULT LoadExternalObject(LPCTSTR path, REFCLSID clsid, REFIID iid, void** ppv)
{
CheckPointer(ppv, E_POINTER);
CString fullpath = MakeFullPath(path);
HINSTANCE hInst = NULL;
bool fFound = false;
POSITION pos = s_extobjs.GetHeadPosition();
while(pos)
{
ExternalObject& eo = s_extobjs.GetNext(pos);
if(!eo.path.CompareNoCase(fullpath))
{
hInst = eo.hInst;
fFound = true;
break;
}
}
HRESULT hr = E_FAIL;
if(hInst || (hInst = CoLoadLibrary(CComBSTR(fullpath), TRUE)))
{
typedef HRESULT (__stdcall * PDllGetClassObject)(REFCLSID rclsid, REFIID riid, LPVOID* ppv);
PDllGetClassObject p = (PDllGetClassObject)GetProcAddress(hInst, "DllGetClassObject");
if(p && FAILED(hr = p(clsid, iid, ppv)))
{
CComPtr<IClassFactory> pCF;
if(SUCCEEDED(hr = p(clsid, __uuidof(IClassFactory), (void**)&pCF)))
{
hr = pCF->CreateInstance(NULL, iid, ppv);
}
}
}
if(FAILED(hr) && hInst && !fFound)
{
CoFreeLibrary(hInst);
return hr;
}
if(hInst && !fFound)
{
ExternalObject eo;
eo.path = fullpath;
eo.hInst = hInst;
eo.clsid = clsid;
s_extobjs.AddTail(eo);
}
return hr;
}
HRESULT LoadExternalFilter(LPCTSTR path, REFCLSID clsid, IBaseFilter** ppBF)
{
return LoadExternalObject(path, clsid, __uuidof(IBaseFilter), (void**)ppBF);
}
HRESULT LoadExternalPropertyPage(IPersist* pP, REFCLSID clsid, IPropertyPage** ppPP)
{
CLSID clsid2 = GUID_NULL;
if(FAILED(pP->GetClassID(&clsid2))) return E_FAIL;
POSITION pos = s_extobjs.GetHeadPosition();
while(pos)
{
ExternalObject& eo = s_extobjs.GetNext(pos);
if(eo.clsid == clsid2)
{
return LoadExternalObject(eo.path, clsid, __uuidof(IPropertyPage), (void**)ppPP);
}
}
return E_FAIL;
}
void UnloadExternalObjects()
{
POSITION pos = s_extobjs.GetHeadPosition();
while(pos)
{
ExternalObject& eo = s_extobjs.GetNext(pos);
CoFreeLibrary(eo.hInst);
}
s_extobjs.RemoveAll();
}
CString MakeFullPath(LPCTSTR path)
{
CString full(path);
full.Replace('/', '\\');
CString fn;
fn.ReleaseBuffer(GetModuleFileName(AfxGetInstanceHandle(), fn.GetBuffer(MAX_PATH), MAX_PATH));
CPath p(fn);
if(full.GetLength() >= 2 && full[0] == '\\' && full[1] != '\\')
{
p.StripToRoot();
full = CString(p) + full.Mid(1);
}
else if(full.Find(_T(":\\")) < 0)
{
p.RemoveFileSpec();
p.AddBackslash();
full = CString(p) + full;
}
CPath c(full);
c.Canonicalize();
return CString(c);
}
//
CString GetMediaTypeName(const GUID& guid)
{
CString ret = guid == GUID_NULL
? _T("Any type")
: CString(GuidNames[guid]);
if(ret == _T("FOURCC GUID"))
{
CString str;
if(guid.Data1 >= 0x10000)
str.Format(_T("Video: %c%c%c%c"), (guid.Data1>>0)&0xff, (guid.Data1>>8)&0xff, (guid.Data1>>16)&0xff, (guid.Data1>>24)&0xff);
else
str.Format(_T("Audio: 0x%08x"), guid.Data1);
ret = str;
}
else if(ret == _T("Unknown GUID Name"))
{
WCHAR null[128] = {0}, buff[128];
StringFromGUID2(GUID_NULL, null, 127);
ret = CString(CStringW(StringFromGUID2(guid, buff, 127) ? buff : null));
}
return ret;
}
GUID GUIDFromCString(CString str)
{
GUID guid = GUID_NULL;
HRESULT hr = CLSIDFromString(CComBSTR(str), &guid);
ASSERT(SUCCEEDED(hr));
return guid;
}
HRESULT GUIDFromCString(CString str, GUID& guid)
{
guid = GUID_NULL;
return CLSIDFromString(CComBSTR(str), &guid);
}
CString CStringFromGUID(const GUID& guid)
{
WCHAR null[128] = {0}, buff[128];
StringFromGUID2(GUID_NULL, null, 127);
return CString(StringFromGUID2(guid, buff, 127) > 0 ? buff : null);
}
CStringW UTF8To16(LPCSTR utf8)
{
CStringW str;
int n = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0)-1;
if(n < 0) return str;
str.ReleaseBuffer(MultiByteToWideChar(CP_UTF8, 0, utf8, -1, str.GetBuffer(n), n+1)-1);
return str;
}
CStringA UTF16To8(LPCWSTR utf16)
{
CStringA str;
int n = WideCharToMultiByte(CP_UTF8, 0, utf16, -1, NULL, 0, NULL, NULL)-1;
if(n < 0) return str;
str.ReleaseBuffer(WideCharToMultiByte(CP_UTF8, 0, utf16, -1, str.GetBuffer(n), n+1, NULL, NULL)-1);
return str;
}
static struct {LPCSTR name, iso6392, iso6391;} s_isolangs[] =
{
{"Abkhazian", "abk", "ab"},
{"Achinese", "ace", ""},
{"Acoli", "ach", ""},
{"Adangme", "ada", ""},
{"Afar", "aar", "aa"},
{"Afrihili", "afh", ""},
{"Afrikaans", "afr", "af"},
{"Afro-Asiatic (Other)", "afa", ""},
{"Akan", "aka", "ak"},
{"Akkadian", "akk", ""},
{"Albanian", "alb", "sq"},
{"Albanian", "sqi", "sq"},
{"Aleut", "ale", ""},
{"Algonquian languages", "alg", ""},
{"Altaic (Other)", "tut", ""},
{"Amharic", "amh", "am"},
{"Apache languages", "apa", ""},
{"Arabic", "ara", "ar"},
{"Aragonese", "arg", "an"},
{"Aramaic", "arc", ""},
{"Arapaho", "arp", ""},
{"Araucanian", "arn", ""},
{"Arawak", "arw", ""},
{"Armenian", "arm", "hy"},
{"Armenian", "hye", "hy"},
{"Artificial (Other)", "art", ""},
{"Assamese", "asm", "as"},
{"Asturian; Bable", "ast", ""},
{"Athapascan languages", "ath", ""},
{"Australian languages", "aus", ""},
{"Austronesian (Other)", "map", ""},
{"Avaric", "ava", "av"},
{"Avestan", "ave", "ae"},
{"Awadhi", "awa", ""},
{"Aymara", "aym", "ay"},
{"Azerbaijani", "aze", "az"},
{"Bable; Asturian", "ast", ""},
{"Balinese", "ban", ""},
{"Baltic (Other)", "bat", ""},
{"Baluchi", "bal", ""},
{"Bambara", "bam", "bm"},
{"Bamileke languages", "bai", ""},
{"Banda", "bad", ""},
{"Bantu (Other)", "bnt", ""},
{"Basa", "bas", ""},
{"Bashkir", "bak", "ba"},
{"Basque", "baq", "eu"},
{"Basque", "eus", "eu"},
{"Batak (Indonesia)", "btk", ""},
{"Beja", "bej", ""},
{"Belarusian", "bel", "be"},
{"Bemba", "bem", ""},
{"Bengali", "ben", "bn"},
{"Berber (Other)", "ber", ""},
{"Bhojpuri", "bho", ""},
{"Bihari", "bih", "bh"},
{"Bikol", "bik", ""},
{"Bini", "bin", ""},
{"Bislama", "bis", "bi"},
{"Bokm<EFBFBD>l, Norwegian; Norwegian Bokm<6B>l", "nob", "nb"},
{"Bosnian", "bos", "bs"},
{"Braj", "bra", ""},
{"Breton", "bre", "br"},
{"Buginese", "bug", ""},
{"Bulgarian", "bul", "bg"},
{"Buriat", "bua", ""},
{"Burmese", "bur", "my"},
{"Burmese", "mya", "my"},
{"Caddo", "cad", ""},
{"Carib", "car", ""},
{"Spanish; Castilian", "spa", "es"},
{"Catalan", "cat", "ca"},
{"Caucasian (Other)", "cau", ""},
{"Cebuano", "ceb", ""},
{"Celtic (Other)", "cel", ""},
{"Central American Indian (Other)", "cai", ""},
{"Chagatai", "chg", ""},
{"Chamic languages", "cmc", ""},
{"Chamorro", "cha", "ch"},
{"Chechen", "che", "ce"},
{"Cherokee", "chr", ""},
{"Chewa; Chichewa; Nyanja", "nya", "ny"},
{"Cheyenne", "chy", ""},
{"Chibcha", "chb", ""},
{"Chichewa; Chewa; Nyanja", "nya", "ny"},
{"Chinese", "chi", "zh"},
{"Chinese", "zho", "zh"},
{"Chinook jargon", "chn", ""},
{"Chipewyan", "chp", ""},
{"Choctaw", "cho", ""},
{"Chuang; Zhuang", "zha", "za"},
{"Church Slavic; Old Church Slavonic", "chu", "cu"},
{"Old Church Slavonic; Old Slavonic; ", "chu", "cu"},
{"Church Slavonic; Old Bulgarian; Church Slavic;", "chu", "cu"},
{"Old Slavonic; Church Slavonic; Old Bulgarian;", "chu", "cu"},
{"Church Slavic; Old Church Slavonic", "chu", "cu"},
{"Chuukese", "chk", ""},
{"Chuvash", "chv", "cv"},
{"Coptic", "cop", ""},
{"Cornish", "cor", "kw"},
{"Corsican", "cos", "co"},
{"Cree", "cre", "cr"},
{"Creek", "mus", ""},
{"Creoles and pidgins (Other)", "crp", ""},
{"Creoles and pidgins,", "cpe", ""},
// {"English-based (Other)", "", ""},
{"Creoles and pidgins,", "cpf", ""},
// {"French-based (Other)", "", ""},
{"Creoles and pidgins,", "cpp", ""},
// {"Portuguese-based (Other)", "", ""},
{"Croatian", "scr", "hr"},
{"Croatian", "hrv", "hr"},
{"Cushitic (Other)", "cus", ""},
{"Czech", "cze", "cs"},
{"Czech", "ces", "cs"},
{"Dakota", "dak", ""},
{"Danish", "dan", "da"},
{"Dargwa", "dar", ""},
{"Dayak", "day", ""},
{"Delaware", "del", ""},
{"Dinka", "din", ""},
{"Divehi", "div", "dv"},
{"Dogri", "doi", ""},
{"Dogrib", "dgr", ""},
{"Dravidian (Other)", "dra", ""},
{"Duala", "dua", ""},
{"Dutch; Flemish", "dut", "nl"},
{"Dutch; Flemish", "nld", "nl"},
{"Dutch, Middle (ca. 1050-1350)", "dum", ""},
{"Dyula", "dyu", ""},
{"Dzongkha", "dzo", "dz"},
{"Efik", "efi", ""},
{"Egyptian (Ancient)", "egy", ""},
{"Ekajuk", "eka", ""},
{"Elamite", "elx", ""},
{"English", "eng", "en"},
{"English, Middle (1100-1500)", "enm", ""},
{"English, Old (ca.450-1100)", "ang", ""},
{"Esperanto", "epo", "eo"},
{"Estonian", "est", "et"},
{"Ewe", "ewe", "ee"},
{"Ewondo", "ewo", ""},
{"Fang", "fan", ""},
{"Fanti", "fat", ""},
{"Faroese", "fao", "fo"},
{"Fijian", "fij", "fj"},
{"Finnish", "fin", "fi"},
{"Finno-Ugrian (Other)", "fiu", ""},
{"Flemish; Dutch", "dut", "nl"},
{"Flemish; Dutch", "nld", "nl"},
{"Fon", "fon", ""},
{"French", "fre", "fr"},
{"French", "fra*", "fr"},
{"French, Middle (ca.1400-1600)", "frm", ""},
{"French, Old (842-ca.1400)", "fro", ""},
{"Frisian", "fry", "fy"},
{"Friulian", "fur", ""},
{"Fulah", "ful", "ff"},
{"Ga", "gaa", ""},
{"Gaelic; Scottish Gaelic", "gla", "gd"},
{"Gallegan", "glg", "gl"},
{"Ganda", "lug", "lg"},
{"Gayo", "gay", ""},
{"Gbaya", "gba", ""},
{"Geez", "gez", ""},
{"Georgian", "geo", "ka"},
{"Georgian", "kat", "ka"},
{"German", "ger", "de"},
{"German", "deu", "de"},
{"German, Low; Saxon, Low; Low German; Low Saxon", "nds", ""},
{"German, Middle High (ca.1050-1500)", "gmh", ""},
{"German, Old High (ca.750-1050)", "goh", ""},
{"Germanic (Other)", "gem", ""},
{"Gikuyu; Kikuyu", "kik", "ki"},
{"Gilbertese", "gil", ""},
{"Gondi", "gon", ""},
{"Gorontalo", "gor", ""},
{"Gothic", "got", ""},
{"Grebo", "grb", ""},
{"Greek, Ancient (to 1453)", "grc", ""},
{"Greek, Modern (1453-)", "gre", "el"},
{"Greek, Modern (1453-)", "ell", "el"},
{"Greenlandic; Kalaallisut", "kal", "kl"},
{"Guarani", "grn", "gn"},
{"Gujarati", "guj", "gu"},
{"Gwich<EFBFBD>in", "gwi", ""},
{"Haida", "hai", ""},
{"Hausa", "hau", "ha"},
{"Hawaiian", "haw", ""},
{"Hebrew", "heb", "he"},
{"Herero", "her", "hz"},
{"Hiligaynon", "hil", ""},
{"Himachali", "him", ""},
{"Hindi", "hin", "hi"},
{"Hiri Motu", "hmo", "ho"},
{"Hittite", "hit", ""},
{"Hmong", "hmn", ""},
{"Hungarian", "hun", "hu"},
{"Hupa", "hup", ""},
{"Iban", "iba", ""},
{"Icelandic", "ice", "is"},
{"Icelandic", "isl", "is"},
{"Ido", "ido", "io"},
{"Igbo", "ibo", "ig"},
{"Ijo", "ijo", ""},
{"Iloko", "ilo", ""},
{"Inari Sami", "smn", ""},
{"Indic (Other)", "inc", ""},
{"Indo-European (Other)", "ine", ""},
{"Indonesian", "ind", "id"},
{"Ingush", "inh", ""},
{"Interlingua (International", "ina", "ia"},
// {"Auxiliary Language Association)", "", ""},
{"Interlingue", "ile", "ie"},
{"Inuktitut", "iku", "iu"},
{"Inupiaq", "ipk", "ik"},
{"Iranian (Other)", "ira", ""},
{"Irish", "gle", "ga"},
{"Irish, Middle (900-1200)", "mga", ""},
{"Irish, Old (to 900)", "sga", ""},
{"Iroquoian languages", "iro", ""},
{"Italian", "ita", "it"},
{"Japanese", "jpn", "ja"},
{"Javanese", "jav", "jv"},
{"Judeo-Arabic", "jrb", ""},
{"Judeo-Persian", "jpr", ""},
{"Kabardian", "kbd", ""},
{"Kabyle", "kab", ""},
{"Kachin", "kac", ""},
{"Kalaallisut; Greenlandic", "kal", "kl"},
{"Kamba", "kam", ""},
{"Kannada", "kan", "kn"},
{"Kanuri", "kau", "kr"},
{"Kara-Kalpak", "kaa", ""},
{"Karen", "kar", ""},
{"Kashmiri", "kas", "ks"},
{"Kawi", "kaw", ""},
{"Kazakh", "kaz", "kk"},
{"Khasi", "kha", ""},
{"Khmer", "khm", "km"},
{"Khoisan (Other)", "khi", ""},
{"Khotanese", "kho", ""},
{"Kikuyu; Gikuyu", "kik", "ki"},
{"Kimbundu", "kmb", ""},
{"Kinyarwanda", "kin", "rw"},
{"Kirghiz", "kir", "ky"},
{"Komi", "kom", "kv"},
{"Kongo", "kon", "kg"},
{"Konkani", "kok", ""},
{"Korean", "kor", "ko"},
{"Kosraean", "kos", ""},
{"Kpelle", "kpe", ""},
{"Kru", "kro", ""},
{"Kuanyama; Kwanyama", "kua", "kj"},
{"Kumyk", "kum", ""},
{"Kurdish", "kur", "ku"},
{"Kurukh", "kru", ""},
{"Kutenai", "kut", ""},
{"Kwanyama, Kuanyama", "kua", "kj"},
{"Ladino", "lad", ""},
{"Lahnda", "lah", ""},
{"Lamba", "lam", ""},
{"Lao", "lao", "lo"},
{"Latin", "lat", "la"},
{"Latvian", "lav", "lv"},
{"Letzeburgesch; Luxembourgish", "ltz", "lb"},
{"Lezghian", "lez", ""},
{"Limburgan; Limburger; Limburgish", "lim", "li"},
{"Limburger; Limburgan; Limburgish;", "lim", "li"},
{"Limburgish; Limburger; Limburgan", "lim", "li"},
{"Lingala", "lin", "ln"},
{"Lithuanian", "lit", "lt"},
{"Low German; Low Saxon; German, Low; Saxon, Low", "nds", ""},
{"Low Saxon; Low German; Saxon, Low; German, Low", "nds", ""},
{"Lozi", "loz", ""},
{"Luba-Katanga", "lub", "lu"},
{"Luba-Lulua", "lua", ""},
{"Luiseno", "lui", ""},
{"Lule Sami", "smj", ""},
{"Lunda", "lun", ""},
{"Luo (Kenya and Tanzania)", "luo", ""},
{"Lushai", "lus", ""},
{"Luxembourgish; Letzeburgesch", "ltz", "lb"},
{"Macedonian", "mac", "mk"},
{"Macedonian", "mkd", "mk"},
{"Madurese", "mad", ""},
{"Magahi", "mag", ""},
{"Maithili", "mai", ""},
{"Makasar", "mak", ""},
{"Malagasy", "mlg", "mg"},
{"Malay", "may", "ms"},
{"Malay", "msa", "ms"},
{"Malayalam", "mal", "ml"},
{"Maltese", "mlt", "mt"},
{"Manchu", "mnc", ""},
{"Mandar", "mdr", ""},
{"Mandingo", "man", ""},
{"Manipuri", "mni", ""},
{"Manobo languages", "mno", ""},
{"Manx", "glv", "gv"},
{"Maori", "mao", "mi"},
{"Maori", "mri", "mi"},
{"Marathi", "mar", "mr"},
{"Mari", "chm", ""},
{"Marshallese", "mah", "mh"},
{"Marwari", "mwr", ""},
{"Masai", "mas", ""},
{"Mayan languages", "myn", ""},
{"Mende", "men", ""},
{"Micmac", "mic", ""},
{"Minangkabau", "min", ""},
{"Miscellaneous languages", "mis", ""},
{"Mohawk", "moh", ""},
{"Moldavian", "mol", "mo"},
{"Mon-Khmer (Other)", "mkh", ""},
{"Mongo", "lol", ""},
{"Mongolian", "mon", "mn"},
{"Mossi", "mos", ""},
{"Multiple languages", "mul", ""},
{"Munda languages", "mun", ""},
{"Nahuatl", "nah", ""},
{"Nauru", "nau", "na"},
{"Navaho, Navajo", "nav", "nv"},
{"Navajo; Navaho", "nav", "nv"},
{"Ndebele, North", "nde", "nd"},
{"Ndebele, South", "nbl", "nr"},
{"Ndonga", "ndo", "ng"},
{"Neapolitan", "nap", ""},
{"Nepali", "nep", "ne"},
{"Newari", "new", ""},
{"Nias", "nia", ""},
{"Niger-Kordofanian (Other)", "nic", ""},
{"Nilo-Saharan (Other)", "ssa", ""},
{"Niuean", "niu", ""},
{"Norse, Old", "non", ""},
{"North American Indian (Other)", "nai", ""},
{"Northern Sami", "sme", "se"},
{"North Ndebele", "nde", "nd"},
{"Norwegian", "nor", "no"},
{"Norwegian Bokm<6B>l; Bokm<6B>l, Norwegian", "nob", "nb"},
{"Norwegian Nynorsk; Nynorsk, Norwegian", "nno", "nn"},
{"Nubian languages", "nub", ""},
{"Nyamwezi", "nym", ""},
{"Nyanja; Chichewa; Chewa", "nya", "ny"},
{"Nyankole", "nyn", ""},
{"Nynorsk, Norwegian; Norwegian Nynorsk", "nno", "nn"},
{"Nyoro", "nyo", ""},
{"Nzima", "nzi", ""},
{"Occitan (post 1500},; Proven<65>al", "oci", "oc"},
{"Ojibwa", "oji", "oj"},
{"Old Bulgarian; Old Slavonic; Church Slavonic;", "chu", "cu"},
{"Oriya", "ori", "or"},
{"Oromo", "orm", "om"},
{"Osage", "osa", ""},
{"Ossetian; Ossetic", "oss", "os"},
{"Ossetic; Ossetian", "oss", "os"},
{"Otomian languages", "oto", ""},
{"Pahlavi", "pal", ""},
{"Palauan", "pau", ""},
{"Pali", "pli", "pi"},
{"Pampanga", "pam", ""},
{"Pangasinan", "pag", ""},
{"Panjabi", "pan", "pa"},
{"Papiamento", "pap", ""},
{"Papuan (Other)", "paa", ""},
{"Persian", "per", "fa"},
{"Persian", "fas", "fa"},
{"Persian, Old (ca.600-400 B.C.)", "peo", ""},
{"Philippine (Other)", "phi", ""},
{"Phoenician", "phn", ""},
{"Pohnpeian", "pon", ""},
{"Polish", "pol", "pl"},
{"Portuguese", "por", "pt"},
{"Prakrit languages", "pra", ""},
{"Proven<EFBFBD>al; Occitan (post 1500)", "oci", "oc"},
{"Proven<EFBFBD>al, Old (to 1500)", "pro", ""},
{"Pushto", "pus", "ps"},
{"Quechua", "que", "qu"},
{"Raeto-Romance", "roh", "rm"},
{"Rajasthani", "raj", ""},
{"Rapanui", "rap", ""},
{"Rarotongan", "rar", ""},
{"Reserved for local use", "qaa-qtz", ""},
{"Romance (Other)", "roa", ""},
{"Romanian", "rum", "ro"},
{"Romanian", "ron", "ro"},
{"Romany", "rom", ""},
{"Rundi", "run", "rn"},
{"Russian", "rus", "ru"},
{"Salishan languages", "sal", ""},
{"Samaritan Aramaic", "sam", ""},
{"Sami languages (Other)", "smi", ""},
{"Samoan", "smo", "sm"},
{"Sandawe", "sad", ""},
{"Sango", "sag", "sg"},
{"Sanskrit", "san", "sa"},
{"Santali", "sat", ""},
{"Sardinian", "srd", "sc"},
{"Sasak", "sas", ""},
{"Saxon, Low; German, Low; Low Saxon; Low German", "nds", ""},
{"Scots", "sco", ""},
{"Scottish Gaelic; Gaelic", "gla", "gd"},
{"Selkup", "sel", ""},
{"Semitic (Other)", "sem", ""},
{"Serbian", "scc", "sr"},
{"Serbian", "srp", "sr"},
{"Serer", "srr", ""},
{"Shan", "shn", ""},
{"Shona", "sna", "sn"},
{"Sichuan Yi", "iii", "ii"},
{"Sidamo", "sid", ""},
{"Sign languages", "sgn", ""},
{"Siksika", "bla", ""},
{"Sindhi", "snd", "sd"},
{"Sinhalese", "sin", "si"},
{"Sino-Tibetan (Other)", "sit", ""},
{"Siouan languages", "sio", ""},
{"Skolt Sami", "sms", ""},
{"Slave (Athapascan)", "den", ""},
{"Slavic (Other)", "sla", ""},
{"Slovak", "slo", "sk"},
{"Slovak", "slk", "sk"},
{"Slovenian", "slv", "sl"},
{"Sogdian", "sog", ""},
{"Somali", "som", "so"},
{"Songhai", "son", ""},
{"Soninke", "snk", ""},
{"Sorbian languages", "wen", ""},
{"Sotho, Northern", "nso", ""},
{"Sotho, Southern", "sot", "st"},
{"South American Indian (Other)", "sai", ""},
{"Southern Sami", "sma", ""},
{"South Ndebele", "nbl", "nr"},
{"Spanish; Castilian", "spa", "es"},
{"Sukuma", "suk", ""},
{"Sumerian", "sux", ""},
{"Sundanese", "sun", "su"},
{"Susu", "sus", ""},
{"Swahili", "swa", "sw"},
{"Swati", "ssw", "ss"},
{"Swedish", "swe", "sv"},
{"Syriac", "syr", ""},
{"Tagalog", "tgl", "tl"},
{"Tahitian", "tah", "ty"},
{"Tai (Other)", "tai", ""},
{"Tajik", "tgk", "tg"},
{"Tamashek", "tmh", ""},
{"Tamil", "tam", "ta"},
{"Tatar", "tat", "tt"},
{"Telugu", "tel", "te"},
{"Tereno", "ter", ""},
{"Tetum", "tet", ""},
{"Thai", "tha", "th"},
{"Tibetan", "tib", "bo"},
{"Tibetan", "bod", "bo"},
{"Tigre", "tig", ""},
{"Tigrinya", "tir", "ti"},
{"Timne", "tem", ""},
{"Tiv", "tiv", ""},
{"Tlingit", "tli", ""},
{"Tok Pisin", "tpi", ""},
{"Tokelau", "tkl", ""},
{"Tonga (Nyasa)", "tog", ""},
{"Tonga (Tonga Islands)", "ton", "to"},
{"Tsimshian", "tsi", ""},
{"Tsonga", "tso", "ts"},
{"Tswana", "tsn", "tn"},
{"Tumbuka", "tum", ""},
{"Tupi languages", "tup", ""},
{"Turkish", "tur", "tr"},
{"Turkish, Ottoman (1500-1928)", "ota", ""},
{"Turkmen", "tuk", "tk"},
{"Tuvalu", "tvl", ""},
{"Tuvinian", "tyv", ""},
{"Twi", "twi", "tw"},
{"Ugaritic", "uga", ""},
{"Uighur", "uig", "ug"},
{"Ukrainian", "ukr", "uk"},
{"Umbundu", "umb", ""},
{"Undetermined", "und", ""},
{"Urdu", "urd", "ur"},
{"Uzbek", "uzb", "uz"},
{"Vai", "vai", ""},
{"Venda", "ven", "ve"},
{"Vietnamese", "vie", "vi"},
{"Volap<EFBFBD>k", "vol", "vo"},
{"Votic", "vot", ""},
{"Wakashan languages", "wak", ""},
{"Walamo", "wal", ""},
{"Walloon", "wln", "wa"},
{"Waray", "war", ""},
{"Washo", "was", ""},
{"Welsh", "wel", "cy"},
{"Welsh", "cym", "cy"},
{"Wolof", "wol", "wo"},
{"Xhosa", "xho", "xh"},
{"Yakut", "sah", ""},
{"Yao", "yao", ""},
{"Yapese", "yap", ""},
{"Yiddish", "yid", "yi"},
{"Yoruba", "yor", "yo"},
{"Yupik languages", "ypk", ""},
{"Zande", "znd", ""},
{"Zapotec", "zap", ""},
{"Zenaga", "zen", ""},
{"Zhuang; Chuang", "zha", "za"},
{"Zulu", "zul", "zu"},
{"Zuni", "zun", ""},
{"Classical Newari", "nwc", ""},
{"Klingon", "tlh", ""},
{"Blin", "byn", ""},
{"Lojban", "jbo", ""},
{"Lower Sorbian", "dsb", ""},
{"Upper Sorbian", "hsb", ""},
{"Kashubian", "csb", ""},
{"Crimean Turkish", "crh", ""},
{"Erzya", "myv", ""},
{"Moksha", "mdf", ""},
{"Karachay-Balkar", "krc", ""},
{"Adyghe", "ady", ""},
{"Udmurt", "udm", ""},
{"Dargwa", "dar", ""},
{"Ingush", "inh", ""},
{"Nogai", "nog", ""},
{"Haitian", "hat", "ht"},
{"Kalmyk", "xal", ""},
{"", "", ""},
};
CString ISO6391ToLanguage(LPCSTR code)
{
CHAR tmp[2+1];
strncpy(tmp, code, 2);
tmp[2] = 0;
_strlwr(tmp);
for(int i = 0, j = countof(s_isolangs); i < j; i++)
if(!strcmp(s_isolangs[i].iso6391, tmp))
{
CString ret = CString(CStringA(s_isolangs[i].name));
int i = ret.Find(';');
if(i > 0) ret = ret.Left(i);
return ret;
}
return(_T(""));
}
CString ISO6392ToLanguage(LPCSTR code)
{
CHAR tmp[3+1];
strncpy(tmp, code, 3);
tmp[3] = 0;
_strlwr(tmp);
for(int i = 0, j = countof(s_isolangs); i < j; i++)
{
if(!strcmp(s_isolangs[i].iso6392, tmp))
{
CString ret = CString(CStringA(s_isolangs[i].name));
int i = ret.Find(';');
if(i > 0) ret = ret.Left(i);
return ret;
}
}
return _T("");
}
CString ISO6391To6392(LPCSTR code)
{
CHAR tmp[2+1];
strncpy(tmp, code, 2);
tmp[2] = 0;
_strlwr(tmp);
for(int i = 0, j = countof(s_isolangs); i < j; i++)
if(!strcmp(s_isolangs[i].iso6391, tmp))
return CString(CStringA(s_isolangs[i].iso6392));
return _T("");
}
CString ISO6392To6391(LPCSTR code)
{
CHAR tmp[3+1];
strncpy(tmp, code, 3);
tmp[3] = 0;
_strlwr(tmp);
for(int i = 0, j = countof(s_isolangs); i < j; i++)
if(!strcmp(s_isolangs[i].iso6392, tmp))
return CString(CStringA(s_isolangs[i].iso6391));
return _T("");
}
CString LanguageToISO6392(LPCTSTR lang)
{
CString str = lang;
str.MakeLower();
for(int i = 0, j = countof(s_isolangs); i < j; i++)
{
CAtlList<CString> sl;
Explode(CString(s_isolangs[i].name), sl, ';');
POSITION pos = sl.GetHeadPosition();
while(pos)
{
if(!str.CompareNoCase(sl.GetNext(pos)))
return CString(s_isolangs[i].iso6392);
}
}
return _T("");
}
int MakeAACInitData(BYTE* pData, int profile, int freq, int channels)
{
int srate_idx;
if(92017 <= freq) srate_idx = 0;
else if(75132 <= freq) srate_idx = 1;
else if(55426 <= freq) srate_idx = 2;
else if(46009 <= freq) srate_idx = 3;
else if(37566 <= freq) srate_idx = 4;
else if(27713 <= freq) srate_idx = 5;
else if(23004 <= freq) srate_idx = 6;
else if(18783 <= freq) srate_idx = 7;
else if(13856 <= freq) srate_idx = 8;
else if(11502 <= freq) srate_idx = 9;
else if(9391 <= freq) srate_idx = 10;
else srate_idx = 11;
pData[0] = ((abs(profile) + 1) << 3) | ((srate_idx & 0xe) >> 1);
pData[1] = ((srate_idx & 0x1) << 7) | (channels << 3);
int ret = 2;
if(profile < 0)
{
freq *= 2;
if(92017 <= freq) srate_idx = 0;
else if(75132 <= freq) srate_idx = 1;
else if(55426 <= freq) srate_idx = 2;
else if(46009 <= freq) srate_idx = 3;
else if(37566 <= freq) srate_idx = 4;
else if(27713 <= freq) srate_idx = 5;
else if(23004 <= freq) srate_idx = 6;
else if(18783 <= freq) srate_idx = 7;
else if(13856 <= freq) srate_idx = 8;
else if(11502 <= freq) srate_idx = 9;
else if(9391 <= freq) srate_idx = 10;
else srate_idx = 11;
pData[2] = 0x2B7>>3;
pData[3] = (BYTE)((0x2B7<<5) | 5);
pData[4] = (1<<7) | (srate_idx<<3);
ret = 5;
}
return(ret);
}
BOOL CFileGetStatus(LPCTSTR lpszFileName, CFileStatus& status)
{
try
{
return CFile::GetStatus(lpszFileName, status);
}
catch(CException* e)
{
// MFCBUG: E_INVALIDARG / "Parameter is incorrect" is thrown for certain cds (vs2003)
// http://groups.google.co.uk/groups?hl=en&lr=&ie=UTF-8&threadm=OZuXYRzWDHA.536%40TK2MSFTNGP10.phx.gbl&rnum=1&prev=/groups%3Fhl%3Den%26lr%3D%26ie%3DISO-8859-1
TRACE(_T("CFile::GetStatus has thrown an exception\n"));
e->Delete();
return false;
}
}
// filter registration helpers
bool DeleteRegKey(LPCTSTR pszKey, LPCTSTR pszSubkey)
{
bool bOK = false;
HKEY hKey;
LONG ec = ::RegOpenKeyEx(HKEY_CLASSES_ROOT, pszKey, 0, KEY_ALL_ACCESS, &hKey);
if(ec == ERROR_SUCCESS)
{
if(pszSubkey != 0)
ec = ::RegDeleteKey(hKey, pszSubkey);
bOK = (ec == ERROR_SUCCESS);
::RegCloseKey(hKey);
}
return bOK;
}
bool SetRegKeyValue(LPCTSTR pszKey, LPCTSTR pszSubkey, LPCTSTR pszValueName, LPCTSTR pszValue)
{
bool bOK = false;
CString szKey(pszKey);
if(pszSubkey != 0)
szKey += CString(_T("\\")) + pszSubkey;
HKEY hKey;
LONG ec = ::RegCreateKeyEx(HKEY_CLASSES_ROOT, szKey, 0, 0, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, 0, &hKey, 0);
if(ec == ERROR_SUCCESS)
{
if(pszValue != 0)
{
ec = ::RegSetValueEx(hKey, pszValueName, 0, REG_SZ,
reinterpret_cast<BYTE*>(const_cast<LPTSTR>(pszValue)),
(_tcslen(pszValue) + 1) * sizeof(TCHAR));
}
bOK = (ec == ERROR_SUCCESS);
::RegCloseKey(hKey);
}
return bOK;
}
bool SetRegKeyValue(LPCTSTR pszKey, LPCTSTR pszSubkey, LPCTSTR pszValue)
{
return SetRegKeyValue(pszKey, pszSubkey, 0, pszValue);
}
void RegisterSourceFilter(const CLSID& clsid, const GUID& subtype2, LPCTSTR chkbytes, LPCTSTR ext, ...)
{
CString null = CStringFromGUID(GUID_NULL);
CString majortype = CStringFromGUID(MEDIATYPE_Stream);
CString subtype = CStringFromGUID(subtype2);
SetRegKeyValue(_T("Media Type\\") + majortype, subtype, _T("0"), chkbytes);
SetRegKeyValue(_T("Media Type\\") + majortype, subtype, _T("Source Filter"), CStringFromGUID(clsid));
DeleteRegKey(_T("Media Type\\") + null, subtype);
va_list marker;
va_start(marker, ext);
for(; ext; ext = va_arg(marker, LPCTSTR))
DeleteRegKey(_T("Media Type\\Extensions"), ext);
va_end(marker);
}
void RegisterSourceFilter(const CLSID& clsid, const GUID& subtype2, const CAtlList<CString>& chkbytes, LPCTSTR ext, ...)
{
CString null = CStringFromGUID(GUID_NULL);
CString majortype = CStringFromGUID(MEDIATYPE_Stream);
CString subtype = CStringFromGUID(subtype2);
POSITION pos = chkbytes.GetHeadPosition();
for(int i = 0; pos; i++)
{
CString idx;
idx.Format(_T("%d"), i);
SetRegKeyValue(_T("Media Type\\") + majortype, subtype, idx, chkbytes.GetNext(pos));
}
SetRegKeyValue(_T("Media Type\\") + majortype, subtype, _T("Source Filter"), CStringFromGUID(clsid));
DeleteRegKey(_T("Media Type\\") + null, subtype);
va_list marker;
va_start(marker, ext);
for(; ext; ext = va_arg(marker, LPCTSTR))
DeleteRegKey(_T("Media Type\\Extensions"), ext);
va_end(marker);
}
void UnRegisterSourceFilter(const GUID& subtype)
{
DeleteRegKey(_T("Media Type\\") + CStringFromGUID(MEDIATYPE_Stream), CStringFromGUID(subtype));
}
Reference in New Issue View Git Blame Copy Permalink