bool spk2mt(Speakers spk, CMediaType &mt, int i)
{
if (spk.format == FORMAT_SPDIF)
{
// SPDIF media types
if (i < 0 || i >= 2)
return false;
std::auto_ptr<WAVEFORMATEX> wfe(spk2wfe(spk, 0));
if (!wfe.get())
return false;
mt.SetType(&MEDIATYPE_Audio);
mt.SetSubtype(i == 0? &MEDIASUBTYPE_DOLBY_AC3_SPDIF: &MEDIASUBTYPE_PCM);
mt.SetFormatType(&FORMAT_WaveFormatEx);
mt.SetFormat((BYTE*)wfe.get(), sizeof(WAVEFORMATEX) + wfe->cbSize);
return true;
}
else if (FORMAT_MASK(spk.format) & FORMAT_CLASS_PCM)
{
// PCM media types
std::auto_ptr<WAVEFORMATEX> wfe(spk2wfe(spk, i));
if (!wfe.get())
return false;
mt.SetType(&MEDIATYPE_Audio);
mt.SetSubtype(&MEDIASUBTYPE_PCM);
mt.SetFormatType(&FORMAT_WaveFormatEx);
mt.SetFormat((BYTE*)wfe.get(), sizeof(WAVEFORMATEX) + wfe->cbSize);
return true;
}
else
return false;
}
LRESULT Tacm::streamOpen(LPACMDRVSTREAMINSTANCE padsi)
{
LPWAVEFORMATEX pwfxSrc = padsi->pwfxSrc;
if (pwfxSrc->wFormatTag != WAVE_FORMAT_AVIS) {
return ACMERR_NOTPOSSIBLE;
}
LPWAVEFORMATEX pwfxDst = padsi->pwfxDst;
if (!avisIsValidFormat(pwfxSrc) || !pcmIsValidFormat(pwfxDst)) {
return ACMERR_NOTPOSSIBLE;
}
padsi->fdwDriver = 0L;
padsi->dwDriver = (DWORD_PTR)this;
if (ACM_STREAMOPENF_QUERY & padsi->fdwOpen) {
return MMSYSERR_NOERROR; //only querying
}
if (!avisynth) {
CMediaType mt;
mt.formattype = FORMAT_WaveFormatEx;
mt.SetFormat((BYTE*)pwfxSrc, sizeof(*pwfxSrc) + pwfxSrc->cbSize);
TsampleFormat fmt;
avisynth = new TavisynthAudio(mt, fmt, NULL, "ffdshow_acm_avisynth_script");
}
if (avisynth->ok) {
bytesPerSample = avisynth->vi->BytesPerAudioSample();
fps_denominator = avisynth->vi->fps_denominator;
fps_numerator = avisynth->vi->fps_numerator;
return MMSYSERR_NOERROR;
} else {
OutputDebugString(_l("ffacm error"));//ffvfw->dbgError(err.msg);
return ACMERR_NOTPOSSIBLE;
}
}
void CDeMultiplexer::GetAudioStreamPMT(CMediaType& pmt)
{
// Fake audio in use
if (m_AudioStreamType == NO_STREAM)
{
pmt.InitMediaType();
pmt.SetType(&MEDIATYPE_Audio);
pmt.SetSubtype(&MEDIASUBTYPE_DOLBY_AC3);
pmt.SetSampleSize(1);
pmt.SetTemporalCompression(FALSE);
pmt.SetVariableSize();
pmt.SetFormatType(&FORMAT_WaveFormatEx);
pmt.SetFormat(AC3AudioFormat, sizeof(AC3AudioFormat));
}
else
pmt = m_audioParser->pmt;
}
Packet* CClip::GenerateFakeAudio(REFERENCE_TIME rtStart)
{
if (rtStart + FAKE_AUDIO_DURATION - 1 > playlistFirstPacketTime + clipDuration)
superceeded |= SUPERCEEDED_AUDIO_RETURN;
if (superceeded&SUPERCEEDED_AUDIO_RETURN)
return NULL;
if (!FakeAudioAvailable())
return NULL;
Packet* packet = new Packet();
packet->nClipNumber = nClip;
packet->SetCount(AC3_FRAME_LENGTH);
packet->SetData(ac3_sample, AC3_FRAME_LENGTH);
packet->rtStart = rtStart;
packet->rtStop = packet->rtStart + 1;
if (firstAudio)
{
CMediaType pmt;
pmt.InitMediaType();
pmt.SetType(&MEDIATYPE_Audio);
pmt.SetSubtype(&MEDIASUBTYPE_DOLBY_AC3);
pmt.SetSampleSize(1);
pmt.SetTemporalCompression(FALSE);
pmt.SetVariableSize();
pmt.SetFormatType(&FORMAT_WaveFormatEx);
pmt.SetFormat(AC3AudioFormat, sizeof(AC3AudioFormat));
WAVEFORMATEXTENSIBLE* wfe = (WAVEFORMATEXTENSIBLE*)pmt.pbFormat;
wfe->Format.nChannels = 6;
wfe->Format.nSamplesPerSec = 48000;
wfe->Format.wFormatTag = WAVE_FORMAT_DOLBY_AC3;
packet->pmt = CreateMediaType(&pmt);
}
audioPlaybackPosition += FAKE_AUDIO_DURATION;
lastAudioPosition += FAKE_AUDIO_DURATION;
return packet;
}
CMediaType CLAVAudio::CreateBitstreamMediaType(AVCodecID codec, DWORD dwSampleRate, BOOL bDTSHDOverride)
{
CMediaType mt;
mt.majortype = MEDIATYPE_Audio;
mt.subtype = MEDIASUBTYPE_PCM;
mt.formattype = FORMAT_WaveFormatEx;
WAVEFORMATEXTENSIBLE wfex;
memset(&wfex, 0, sizeof(wfex));
WAVEFORMATEX* wfe = &wfex.Format;
wfe->nChannels = 2;
wfe->wBitsPerSample = 16;
GUID subtype = GUID_NULL;
switch(codec) {
case AV_CODEC_ID_AC3:
wfe->wFormatTag = WAVE_FORMAT_DOLBY_AC3_SPDIF;
wfe->nSamplesPerSec = min(dwSampleRate, 48000);
break;
case AV_CODEC_ID_EAC3:
wfe->nSamplesPerSec = 192000;
wfe->nChannels = 2;
subtype = KSDATAFORMAT_SUBTYPE_IEC61937_DOLBY_DIGITAL_PLUS;
break;
case AV_CODEC_ID_TRUEHD:
wfe->nSamplesPerSec = 192000;
wfe->nChannels = 8;
subtype = KSDATAFORMAT_SUBTYPE_IEC61937_DOLBY_MLP;
break;
case AV_CODEC_ID_DTS:
if (m_settings.bBitstream[Bitstream_DTSHD] && m_bDTSHD && !bDTSHDOverride) {
wfe->nSamplesPerSec = 192000;
wfe->nChannels = 8;
subtype = KSDATAFORMAT_SUBTYPE_IEC61937_DTS_HD;
} else {
wfe->wFormatTag = WAVE_FORMAT_DOLBY_AC3_SPDIF; // huh? but it works.
wfe->nSamplesPerSec = min(dwSampleRate, 48000);
}
break;
default:
ASSERT(0);
break;
}
wfe->nBlockAlign = wfe->nChannels * wfe->wBitsPerSample / 8;
wfe->nAvgBytesPerSec = wfe->nSamplesPerSec * wfe->nBlockAlign;
if (subtype != GUID_NULL) {
wfex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
wfex.Format.cbSize = sizeof(wfex) - sizeof(wfex.Format);
wfex.dwChannelMask = get_channel_mask(wfe->nChannels);
wfex.Samples.wValidBitsPerSample = wfex.Format.wBitsPerSample;
wfex.SubFormat = subtype;
}
mt.SetSampleSize(1);
mt.SetFormat((BYTE*)&wfex, sizeof(wfex.Format) + wfex.Format.cbSize);
return mt;
}
static int v4w_open_videodevice(V4wState *s, int format, MSVideoSize *vsize)
{
// Initialize COM
CoInitialize(NULL);
// get a Graph
HRESULT hr=s->m_pGraph.CoCreateInstance(CLSID_FilterGraph);
if(FAILED(hr))
{
return -1;
}
// get a CaptureGraphBuilder2
#if !defined(_WIN32_WCE)
hr=s->m_pBuilder.CoCreateInstance(CLSID_CaptureGraphBuilder2);
#else
hr=s->m_pBuilder.CoCreateInstance(CLSID_CaptureGraphBuilder);
#endif
if(FAILED(hr))
{
return -2;
}
// connect capture graph builder with the graph
s->m_pBuilder->SetFiltergraph(s->m_pGraph);
// get mediacontrol so we can start and stop the filter graph
hr=s->m_pGraph.QueryInterface(&(s->m_pControl));
if(FAILED(hr))
{
return -3;
}
// get DXFilter
s->m_pDXFilter = new CDXFilter(NULL, &hr, FALSE);
if(s->m_pDXFilter==NULL)
{
return -4;
}
s->m_pDXFilter->AddRef();
if(FAILED(hr))
{
return -4;
}
CMediaType mt;
mt.SetType(&MEDIATYPE_Video);
if (format==MS_YUV420P)
{
GUID m = (GUID)FOURCCMap(MAKEFOURCC('I','4','2','0'));
mt.SetSubtype(&m);
mt.SetSubtype(&MEDIASUBTYPE_YV12);
}
else //if (format==MS_RGB24)
{
mt.SetSubtype(&MEDIASUBTYPE_RGB24);
}
//mt.SetSubtype(&MEDIASUBTYPE_IYUV);
//mt.SetSubtype(&MEDIASUBTYPE_YUYV);
//mt.SetSubtype(&MEDIASUBTYPE_RGB24);
//mt.SetSampleSize();
mt.formattype = FORMAT_VideoInfo;
mt.SetTemporalCompression(FALSE);
VIDEOINFO *pvi = (VIDEOINFO *)
mt.AllocFormatBuffer(sizeof(VIDEOINFO));
if (NULL == pvi)
return E_OUTOFMEMORY;
ZeroMemory(pvi, sizeof(VIDEOINFO));
if (format==MS_YUV420P)
{
pvi->bmiHeader.biCompression = MAKEFOURCC('I','4','2','0');
pvi->bmiHeader.biCompression = MAKEFOURCC('Y','V','1','2');
pvi->bmiHeader.biBitCount = 12;
}
else
{
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 24;
}
pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pvi->bmiHeader.biWidth = vsize->width;
pvi->bmiHeader.biHeight = vsize->height;
pvi->bmiHeader.biPlanes = 1;
pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader);
pvi->bmiHeader.biClrImportant = 0;
mt.SetSampleSize(pvi->bmiHeader.biSizeImage);
mt.SetFormat((BYTE*)pvi, sizeof(VIDEOINFO));
hr = s->m_pDXFilter->SetAcceptedMediaType(&mt);
if(FAILED(hr))
{
return -5;
}
hr = s->m_pDXFilter->SetCallback(Callback);
if(FAILED(hr))
{
return -6;
}
hr = s->m_pDXFilter->QueryInterface(IID_IBaseFilter,
(LPVOID *)&s->m_pIDXFilter);
if(FAILED(hr))
{
return -7;
}
hr = s->m_pGraph->AddFilter(s->m_pIDXFilter, L"DXFilter Filter");
if(FAILED(hr))
{
return -8;
}
#ifdef WM6
ICreateDevEnum *pCreateDevEnum = NULL;
IEnumMoniker *pEnumMoniker = NULL;
IMoniker *pMoniker = NULL;
ULONG nFetched = 0;
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum, (PVOID *)&pCreateDevEnum);
if(FAILED(hr))
{
return -9;
}
hr = pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
&pEnumMoniker, 0);
if (FAILED(hr) || pEnumMoniker == NULL) {
//printf("no device\n");
return -10;
}
pEnumMoniker->Reset();
hr = pEnumMoniker->Next(1, &pMoniker, &nFetched);
if(FAILED(hr) || pMoniker==NULL)
{
return -11;
}
hr = pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&s->m_pDeviceFilter );
if(FAILED(hr))
{
return -12;
}
s->m_pGraph->AddFilter(s->m_pDeviceFilter, L"Device Filter");
pMoniker->Release();
pEnumMoniker->Release();
pCreateDevEnum->Release();
#else
WCHAR wzDeviceName[ MAX_PATH + 1 ];
CComVariant varCamName;
CPropertyBag PropBag;
CComPtr<IPersistPropertyBag> pPropertyBag;
GetFirstCameraDriver(wzDeviceName);
hr = s->m_pDeviceFilter.CoCreateInstance( CLSID_VideoCapture );
if (FAILED(hr))
{
return -8;
}
s->m_pDeviceFilter.QueryInterface( &pPropertyBag );
varCamName = wzDeviceName;
if(( varCamName.vt == VT_BSTR ) == NULL ) {
return E_OUTOFMEMORY;
}
PropBag.Write( L"VCapName", &varCamName );
pPropertyBag->Load( &PropBag, NULL );
pPropertyBag.Release();
hr = s->m_pGraph->AddFilter( s->m_pDeviceFilter, L"Video capture source" );
#endif
if (FAILED(hr))
{
return -8;
}
// get null renderer
s->m_pNullRenderer = NULL;
#if 0
hr=s->m_pNullRenderer.CoCreateInstance(CLSID_NullRenderer);
if(FAILED(hr))
{
return -13;
}
#endif
if (s->m_pNullRenderer!=NULL)
{
s->m_pGraph->AddFilter(s->m_pNullRenderer, L"Null Renderer");
}
hr = s->m_pBuilder->RenderStream(&PIN_CATEGORY_PREVIEW,
&MEDIATYPE_Video, s->m_pDeviceFilter, s->m_pIDXFilter, s->m_pNullRenderer);
if (FAILED(hr))
{
//hr = s->m_pBuilder->RenderStream(&PIN_CATEGORY_CAPTURE,
// &MEDIATYPE_Video, s->m_pDeviceFilter, s->m_pIDXFilter, s->m_pNullRenderer);
if (FAILED(hr))
{
return -14;
}
}
//m_pDXFilter->SetBufferSamples(TRUE);
// Create the System Device Enumerator.
IFilterMapper *pMapper = NULL;
//IEnumMoniker *pEnum = NULL;
IEnumRegFilters *pEnum = NULL;
hr = CoCreateInstance(CLSID_FilterMapper,
NULL, CLSCTX_INPROC, IID_IFilterMapper,
(void **) &pMapper);
if (FAILED(hr))
{
// Error handling omitted for clarity.
}
GUID arrayInTypes[2];
arrayInTypes[0] = MEDIATYPE_Video;
arrayInTypes[1] = MEDIASUBTYPE_dvsd;
hr = pMapper->EnumMatchingFilters(
&pEnum,
MERIT_HW_COMPRESSOR, // Minimum merit.
FALSE, // At least one input pin?
MEDIATYPE_NULL,
MEDIASUBTYPE_NULL,
FALSE, // Must be a renderer?
FALSE, // At least one output pin?
MEDIATYPE_NULL,
MEDIASUBTYPE_NULL);
// Enumerate the monikers.
//IMoniker *pMoniker;
REGFILTER *pMoniker;
ULONG cFetched;
while (pEnum->Next(1, &pMoniker, &cFetched) == S_OK)
{
IPropertyBag *pPropBag = NULL;
#if 0
hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag,
(void **)&pPropBag);
if (SUCCEEDED(hr))
{
// To retrieve the friendly name of the filter, do the following:
VARIANT varName;
VariantInit(&varName);
hr = pPropBag->Read(L"FriendlyName", &varName, 0);
if (SUCCEEDED(hr))
{
// Display the name in your UI somehow.
}
VariantClear(&varName);
// To create an instance of the filter, do the following:
IBaseFilter *pFilter;
hr = pMoniker->BindToObject(NULL, NULL, IID_IBaseFilter, (void**)&pFilter);
// Now add the filter to the graph. Remember to release pFilter later.
// Clean up.
pPropBag->Release();
}
pMoniker->Release();
#endif
}
// Clean up.
pMapper->Release();
pEnum->Release();
s_callback = s;
hr = s->m_pControl->Run();
if(FAILED(hr))
{
return -15;
}
s->rotregvalue=1;
s->pix_fmt = format;
s->vsize.height = vsize->height;
s->vsize.width = vsize->width;
return 0;
}
static int v4w_open_videodevice(V4wState *s)
{
// Initialize COM
CoInitialize(NULL);
// get a Graph
HRESULT hr= CoCreateInstance (CLSID_FilterGraph,
NULL,
CLSCTX_INPROC_SERVER,
IID_IGraphBuilder, //IID_IBaseFilter,
(void **)&s->m_pGraph);
if(FAILED(hr))
{
return -1;
}
// get a CaptureGraphBuilder2
hr= CoCreateInstance (CLSID_CaptureGraphBuilder2,
NULL,
CLSCTX_INPROC_SERVER,
IID_ICaptureGraphBuilder2, //IID_IBaseFilter,
(void **)&s->m_pBuilder);
if(FAILED(hr))
{
return -2;
}
// connect capture graph builder with the graph
s->m_pBuilder->SetFiltergraph(s->m_pGraph);
// get mediacontrol so we can start and stop the filter graph
hr=s->m_pGraph->QueryInterface (IID_IMediaControl, (void **)&s->m_pControl);
if(FAILED(hr))
{
return -3;
}
ICreateDevEnum *pCreateDevEnum = NULL;
IEnumMoniker *pEnumMoniker = NULL;
IMoniker *pMoniker = NULL;
ULONG nFetched = 0;
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum, (PVOID *)&pCreateDevEnum);
if(FAILED(hr))
{
return -4;
}
hr = pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
&pEnumMoniker, 0);
if (FAILED(hr) || pEnumMoniker == NULL) {
//printf("no device\n");
return -5;
}
pEnumMoniker->Reset();
int pos=0;
while(S_OK == pEnumMoniker->Next(1, &pMoniker, &nFetched) )
{
IPropertyBag *pBag;
hr = pMoniker->BindToStorage( 0, 0, IID_IPropertyBag, (void**) &pBag );
if( hr != S_OK )
continue;
if (s->dev[0]=='\0')
break;
VARIANT var;
VariantInit(&var);
hr = pBag->Read( L"FriendlyName", &var, NULL );
if( hr != S_OK )
{
pMoniker->Release();
continue;
}
//USES_CONVERSION;
char szName[256];
WideCharToMultiByte(CP_UTF8,0,var.bstrVal,-1,szName,256,0,0);
VariantClear(&var);
if (strcmp(szName, s->dev)==0)
break;
pMoniker->Release();
pBag->Release();
pMoniker=NULL;
pBag=NULL;
}
if(pMoniker==NULL)
{
return -6;
}
hr = pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&s->m_pDeviceFilter );
if(FAILED(hr))
{
return -7;
}
s->m_pGraph->AddFilter(s->m_pDeviceFilter, L"Device Filter");
pMoniker->Release();
pEnumMoniker->Release();
pCreateDevEnum->Release();
GUID pPinCategory;
if (try_format(s->m_pDeviceFilter, s->pix_fmt, &pPinCategory)==0)
s->pix_fmt = s->pix_fmt;
else if (try_format(s->m_pDeviceFilter,MS_YUV420P, &pPinCategory)==0)
s->pix_fmt = MS_YUV420P;
else if (try_format(s->m_pDeviceFilter,MS_YUY2, &pPinCategory)==0)
s->pix_fmt = MS_YUY2;
else if (try_format(s->m_pDeviceFilter,MS_YUYV, &pPinCategory)==0)
s->pix_fmt = MS_YUYV;
else if (try_format(s->m_pDeviceFilter,MS_UYVY, &pPinCategory)==0)
s->pix_fmt = MS_UYVY;
else if (try_format(s->m_pDeviceFilter,MS_RGB24, &pPinCategory)==0)
s->pix_fmt = MS_RGB24;
else
{
ms_error("Unsupported video pixel format.");
return -8;
}
if (s->pix_fmt == MS_YUV420P)
ms_message("Driver supports YUV420P, using that format.");
else if (s->pix_fmt == MS_YUY2)
ms_message("Driver supports YUY2 (YUYV), using that format.");
else if (s->pix_fmt == MS_YUYV)
ms_message("Driver supports YUV422, using that format.");
else if (s->pix_fmt == MS_UYVY)
ms_message("Driver supports UYVY, using that format.");
else if (s->pix_fmt == MS_RGB24)
ms_message("Driver supports RGB24, using that format.");
if (try_format_size(s, s->pix_fmt, s->vsize.width, s->vsize.height, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", s->vsize.width, s->vsize.height);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_QCIF_W, MS_VIDEO_SIZE_QCIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_QCIF_W, MS_VIDEO_SIZE_QCIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_CIF_W, MS_VIDEO_SIZE_CIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_CIF_W, MS_VIDEO_SIZE_CIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_4CIF_W, MS_VIDEO_SIZE_4CIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_4CIF_W, MS_VIDEO_SIZE_4CIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_QVGA_W, MS_VIDEO_SIZE_QVGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_QVGA_W, MS_VIDEO_SIZE_QVGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_QQVGA_W, MS_VIDEO_SIZE_QQVGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_QQVGA_W, MS_VIDEO_SIZE_QQVGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_NS1_W, MS_VIDEO_SIZE_NS1_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_NS1_W, MS_VIDEO_SIZE_NS1_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_QSIF_W, MS_VIDEO_SIZE_QSIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_QSIF_W, MS_VIDEO_SIZE_QSIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_SIF_W, MS_VIDEO_SIZE_SIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_SIF_W, MS_VIDEO_SIZE_SIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_VGA_W, MS_VIDEO_SIZE_VGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_VGA_W, MS_VIDEO_SIZE_VGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_SDTV_W, MS_VIDEO_SIZE_SDTV_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_SDTV_W, MS_VIDEO_SIZE_SDTV_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_288P_W, MS_VIDEO_SIZE_288P_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_288P_W, MS_VIDEO_SIZE_288P_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_448P_W, MS_VIDEO_SIZE_448P_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_448P_W, MS_VIDEO_SIZE_448P_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_576P_W, MS_VIDEO_SIZE_576P_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_576P_W, MS_VIDEO_SIZE_576P_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_720P_W, MS_VIDEO_SIZE_720P_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_720P_W, MS_VIDEO_SIZE_720P_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_1080P_W, MS_VIDEO_SIZE_1080P_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_1080P_W, MS_VIDEO_SIZE_1080P_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_4SIF_W, MS_VIDEO_SIZE_4SIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_4SIF_W, MS_VIDEO_SIZE_4SIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_SVGA_W, MS_VIDEO_SIZE_SVGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_SVGA_W, MS_VIDEO_SIZE_SVGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_XGA_W, MS_VIDEO_SIZE_XGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_XGA_W, MS_VIDEO_SIZE_XGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_WXGA_W, MS_VIDEO_SIZE_WXGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_WXGA_W, MS_VIDEO_SIZE_WXGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_HDTVP_W, MS_VIDEO_SIZE_HDTVP_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_HDTVP_W, MS_VIDEO_SIZE_HDTVP_H);
else
{
ms_error("No supported size found for format.");
/* size not supported? */
return -9;
}
// get DXFilter
s->m_pDXFilter = new CDXFilter(NULL, &hr, FALSE);
if(s->m_pDXFilter==NULL)
{
return -10;
}
s->m_pDXFilter->AddRef();
CMediaType mt;
mt.SetType(&MEDIATYPE_Video);
GUID m = MEDIASUBTYPE_RGB24;
if (s->pix_fmt == MS_YUV420P)
m = (GUID)FOURCCMap(MAKEFOURCC('I','4','2','0'));
else if (s->pix_fmt == MS_YUY2)
m = MEDIASUBTYPE_YUY2;
else if (s->pix_fmt == MS_YUYV)
m = MEDIASUBTYPE_YUYV;
else if (s->pix_fmt == MS_UYVY)
m = MEDIASUBTYPE_UYVY;
else if (s->pix_fmt == MS_RGB24)
m = MEDIASUBTYPE_RGB24;
mt.SetSubtype(&m);
mt.formattype = FORMAT_VideoInfo;
mt.SetTemporalCompression(FALSE);
VIDEOINFO *pvi = (VIDEOINFO *)
mt.AllocFormatBuffer(sizeof(VIDEOINFO));
if (NULL == pvi)
return -11;
ZeroMemory(pvi, sizeof(VIDEOINFO));
if (s->pix_fmt == MS_YUV420P)
pvi->bmiHeader.biCompression = MAKEFOURCC('I','4','2','0');
else if (s->pix_fmt == MS_YUY2)
pvi->bmiHeader.biCompression = MAKEFOURCC('Y','U','Y','2');
else if (s->pix_fmt == MS_YUYV)
pvi->bmiHeader.biCompression = MAKEFOURCC('Y','U','Y','V');
else if (s->pix_fmt == MS_UYVY)
pvi->bmiHeader.biCompression = MAKEFOURCC('U','Y','V','Y');
else if (s->pix_fmt == MS_RGB24)
pvi->bmiHeader.biCompression = BI_RGB;
if (s->pix_fmt == MS_YUV420P)
pvi->bmiHeader.biBitCount = 12;
else if (s->pix_fmt == MS_YUY2)
pvi->bmiHeader.biBitCount = 16;
else if (s->pix_fmt == MS_YUYV)
pvi->bmiHeader.biBitCount = 16;
else if (s->pix_fmt == MS_UYVY)
pvi->bmiHeader.biBitCount = 16;
else if (s->pix_fmt == MS_RGB24)
pvi->bmiHeader.biBitCount = 24;
pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pvi->bmiHeader.biWidth = s->vsize.width;
pvi->bmiHeader.biHeight = s->vsize.height;
pvi->bmiHeader.biPlanes = 1;
pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader);
pvi->bmiHeader.biClrImportant = 0;
mt.SetSampleSize(pvi->bmiHeader.biSizeImage);
mt.SetFormat((BYTE*)pvi, sizeof(VIDEOINFO));
hr = s->m_pDXFilter->SetAcceptedMediaType(&mt);
if(FAILED(hr))
{
return -12;
}
hr = s->m_pDXFilter->SetCallback(Callback);
if(FAILED(hr))
{
return -13;
}
hr = s->m_pDXFilter->QueryInterface(IID_IBaseFilter,
(LPVOID *)&s->m_pIDXFilter);
if(FAILED(hr))
{
return -14;
}
hr = s->m_pGraph->AddFilter(s->m_pIDXFilter, L"DXFilter Filter");
if(FAILED(hr))
{
return -15;
}
// get null renderer
hr=CoCreateInstance (CLSID_NullRenderer,
NULL,
CLSCTX_INPROC_SERVER,
IID_IBaseFilter,
(void **)&s->m_pNullRenderer);
if(FAILED(hr))
{
return -16;
}
if (s->m_pNullRenderer!=NULL)
{
s->m_pGraph->AddFilter(s->m_pNullRenderer, L"Null Renderer");
}
hr = s->m_pBuilder->RenderStream(&pPinCategory,
&MEDIATYPE_Video, s->m_pDeviceFilter, s->m_pIDXFilter, s->m_pNullRenderer);
if (FAILED(hr))
{
return -17;
}
IAMStreamConfig *pConfig = NULL;
hr = s->m_pBuilder->FindInterface(
&pPinCategory, // Preview pin.
&MEDIATYPE_Video, // Any media type.
s->m_pDeviceFilter, // Pointer to the capture filter.
IID_IAMStreamConfig, (void**)&pConfig);
if (pConfig!=NULL)
{
AM_MEDIA_TYPE *pType = NULL;
int iCount, iSize;
pConfig->GetNumberOfCapabilities(&iCount, &iSize);
for (int i = 0; i < iCount; i++) {
VIDEO_STREAM_CONFIG_CAPS scc;
pType = NULL;
pConfig->GetStreamCaps(i, &pType, (BYTE *)&scc);
if (!((pType->formattype == FORMAT_VideoInfo) &&
(pType->cbFormat >= sizeof(VIDEOINFOHEADER)) &&
(pType->pbFormat != NULL)))
continue;
VIDEOINFOHEADER & videoInfo = *(VIDEOINFOHEADER *)pType->pbFormat;
if (m != pType->subtype)
continue;
if (videoInfo.bmiHeader.biWidth != s->vsize.width)
continue;
if (videoInfo.bmiHeader.biHeight != s->vsize.height)
continue;
if (videoInfo.bmiHeader.biBitCount != pvi->bmiHeader.biBitCount)
continue;
if (videoInfo.bmiHeader.biCompression != pvi->bmiHeader.biCompression)
continue;
videoInfo.AvgTimePerFrame = UNITS / (LONGLONG)s->fps;
pConfig->SetFormat(pType);
}
pConfig->GetFormat(&pType);
if (pType!=NULL)
{
VIDEOINFO *pvi;
pvi = (VIDEOINFO *)pType->pbFormat;
ms_message("v4w: camera asked fps=%.2f // real fps=%.2f", s->fps, ((float)UNITS / (float)pvi->AvgTimePerFrame));
}
pConfig->Release();
}
//m_pDXFilter->SetBufferSamples(TRUE);
s_callback = s;
hr = s->m_pControl->Run();
if(FAILED(hr))
{
return -18;
}
s->rotregvalue=1;
return 0;
}
HRESULT CFSTSplitterFilter::Initialize(IPin *pPin, IAsyncReader *pReader)
{
// Check and validate the pointer
CheckPointer(pReader, E_POINTER);
ValidateReadPtr(pReader, sizeof(IAsyncReader));
// Read file header
FST_HEADER header;
HRESULT hr = pReader->SyncRead(0, sizeof(header), (BYTE*)&header);
if (hr != S_OK)
return hr;
// Verify file header
if (header.dwID != FST_ID_2TSF)
return VFW_E_INVALID_FILE_FORMAT;
// Protect the filter data
CAutoLock datalock(&m_csData);
// Set video stream info
m_nVideoFrames = header.nVideoFrames;
m_nFramesPerSecond = header.nFramesPerSecond;
// Allocate frame table
m_pFrameTable = (FST_FRAME_ENTRY*)CoTaskMemAlloc(m_nVideoFrames * sizeof(FST_FRAME_ENTRY));
if (m_pFrameTable == NULL) {
Shutdown();
return E_OUTOFMEMORY;
}
// Read in the frame table
hr = pReader->SyncRead(sizeof(header), m_nVideoFrames * sizeof(FST_FRAME_ENTRY), (BYTE*)m_pFrameTable);
if (hr != S_OK) {
Shutdown();
return hr;
}
// Walk the frame table and determine the maximum frame data sizes
DWORD cbMaxImage = 0, cbMaxSound = 0;
for (DWORD iFrame = 0; iFrame < m_nVideoFrames; iFrame++) {
if (m_pFrameTable[iFrame].cbImage > cbMaxImage)
cbMaxImage = m_pFrameTable[iFrame].cbImage;
if (m_pFrameTable[iFrame].cbSound > cbMaxSound)
cbMaxSound = m_pFrameTable[iFrame].cbSound;
}
// Set file positions
m_llDefaultStart = (LONGLONG)sizeof(FST_HEADER) + m_nVideoFrames * sizeof(FST_FRAME_ENTRY); // Right after the header and frame table
m_llDefaultStop = MAXLONGLONG; // Defaults to file end
// Decide on the input pin properties
m_cbInputAlign = 1;
m_cbInputBuffer = cbMaxImage + cbMaxSound;
// Protect the output pins state
CAutoLock pinlock(&m_csPins);
// Decide on the output pins count
m_nOutputPins = 1; // Video is always present
// Check if we have soundtrack
if (
(header.dwAudioSampleRate != 0) &&
(header.nAudioBits != 0) &&
(m_pFrameTable[0].cbSound != 0)
)
m_nOutputPins++;
// Create output pins array
ASSERT(m_ppOutputPin == NULL);
m_ppOutputPin = new CParserOutputPin*[m_nOutputPins];
if (m_ppOutputPin == NULL) {
m_nOutputPins = 0;
Shutdown();
return E_OUTOFMEMORY;
}
// Reset the output pin array elements to NULLs
for (int i = 0; i < m_nOutputPins; i++)
m_ppOutputPin[i] = NULL;
// Allocate video media type
CMediaType *pmtVideo = new CMediaType();
if (pmtVideo == NULL) {
Shutdown();
return E_OUTOFMEMORY;
}
// Initialize the video media type
pmtVideo->InitMediaType();
pmtVideo->SetType(&MEDIATYPE_Video);
pmtVideo->SetSubtype(&MEDIASUBTYPE_FSTVideo);
pmtVideo->SetSampleSize(0);
pmtVideo->SetTemporalCompression(TRUE);
pmtVideo->SetFormatType(&FORMAT_FSTVideo);
if (!pmtVideo->SetFormat((BYTE*)&header, sizeof(header))) {
delete pmtVideo;
Shutdown();
return E_FAIL;
}
// Allocate the video allocator properties
ALLOCATOR_PROPERTIES *papVideo = (ALLOCATOR_PROPERTIES*)CoTaskMemAlloc(sizeof(ALLOCATOR_PROPERTIES));
if (papVideo == NULL) {
delete pmtVideo;
Shutdown();
return E_OUTOFMEMORY;
}
// Set the video allocator properties
papVideo->cbAlign = 0; // No matter
papVideo->cbPrefix = 0; // No matter
papVideo->cBuffers = 4; // TEMP: No need to set larger value?
papVideo->cbBuffer = cbMaxImage;
// Allocate time formats array. If we fail here, it's not an error,
// we'll just set zero seeker parameters and may proceed
DWORD dwVideoCapabilities = 0;
int nVideoTimeFormats = 0;
GUID *pVideoTimeFormats = (GUID*)CoTaskMemAlloc(3 * sizeof(GUID));
if (pVideoTimeFormats) {
nVideoTimeFormats = 3;
// Fill in the time formats array
pVideoTimeFormats[0] = TIME_FORMAT_MEDIA_TIME;
pVideoTimeFormats[1] = TIME_FORMAT_FRAME;
pVideoTimeFormats[2] = TIME_FORMAT_SAMPLE;
dwVideoCapabilities = AM_SEEKING_CanGetCurrentPos |
AM_SEEKING_CanGetStopPos |
AM_SEEKING_CanGetDuration;
}
// Create video output pin (always the first one!)
hr = NOERROR;
m_ppOutputPin[0] = new CParserOutputPin(
NAME("FST Splitter Video Output Pin"),
this,
&m_csFilter,
pmtVideo,
papVideo,
dwVideoCapabilities,
nVideoTimeFormats,
pVideoTimeFormats,
&hr,
wszFSTVideoOutputName
);
if (
(FAILED(hr)) ||
(m_ppOutputPin[0] == NULL)
) {
if (m_ppOutputPin[0]) {
delete m_ppOutputPin[0];
m_ppOutputPin[0] = NULL;
} else {
delete pmtVideo;
CoTaskMemFree(papVideo);
if (pVideoTimeFormats)
CoTaskMemFree(pVideoTimeFormats);
}
Shutdown();
if (FAILED(hr))
return hr;
else
return E_OUTOFMEMORY;
}
// Hold a reference on the video output pin
m_ppOutputPin[0]->AddRef();
// We've created a new pin -- so increment pin version
IncrementPinVersion();
if (m_nOutputPins > 1) {
// Allocate audio media type
CMediaType *pmtAudio = new CMediaType();
if (pmtAudio == NULL) {
Shutdown();
return E_OUTOFMEMORY;
}
// Initialize the audio media type
pmtAudio->InitMediaType();
pmtAudio->SetType(&MEDIATYPE_Audio);
pmtAudio->SetSubtype(&MEDIASUBTYPE_PCM);
pmtAudio->SetSampleSize(header.nAudioBits * (header.wAudioChannels + 1) / 8);
pmtAudio->SetTemporalCompression(FALSE);
pmtAudio->SetFormatType(&FORMAT_WaveFormatEx);
WAVEFORMATEX *pFormat = (WAVEFORMATEX*)pmtAudio->AllocFormatBuffer(sizeof(WAVEFORMATEX));
if (pFormat == NULL) {
delete pmtAudio;
Shutdown();
return E_OUTOFMEMORY;
}
// Fill in the audio format block
pFormat->wFormatTag = WAVE_FORMAT_PCM;
pFormat->nChannels = header.wAudioChannels + 1; // TEMP: Is it really so?
pFormat->nSamplesPerSec = header.dwAudioSampleRate;
pFormat->nAvgBytesPerSec = pFormat->nChannels * header.nAudioBits * header.dwAudioSampleRate / 8;
pFormat->nBlockAlign = pFormat->nChannels * header.nAudioBits / 8;
pFormat->wBitsPerSample = header.nAudioBits;
pFormat->cbSize = 0;
// Allocate the audio allocator properties
ALLOCATOR_PROPERTIES *papAudio = (ALLOCATOR_PROPERTIES*)CoTaskMemAlloc(sizeof(ALLOCATOR_PROPERTIES));
if (papAudio == NULL) {
delete pmtAudio;
Shutdown();
return E_OUTOFMEMORY;
}
// Set the audio allocator properties
papAudio->cbAlign = 0; // No matter
papAudio->cbPrefix = 0; // No matter
papAudio->cBuffers = 4; // No use to set different from video value
papAudio->cbBuffer = cbMaxSound;
// Set the wave format parameters needed for the calculation
// of sample stream and media duration
m_nSampleSize = pFormat->nBlockAlign;
m_nAvgBytesPerSec = pFormat->nAvgBytesPerSec;
// Allocate time formats array. If we fail here, it's not an error,
// we'll just set zero seeker parameters and may proceed
DWORD dwAudioCapabilities = 0;
int nAudioTimeFormats = 0;
GUID *pAudioTimeFormats = (GUID*)CoTaskMemAlloc(3 * sizeof(GUID));
if (pAudioTimeFormats) {
nAudioTimeFormats = 3;
// Fill in the time formats array
pAudioTimeFormats[0] = TIME_FORMAT_MEDIA_TIME;
pAudioTimeFormats[1] = TIME_FORMAT_SAMPLE;
pAudioTimeFormats[2] = TIME_FORMAT_BYTE;
dwAudioCapabilities = AM_SEEKING_CanGetCurrentPos |
AM_SEEKING_CanGetStopPos |
AM_SEEKING_CanGetDuration;
}
// Create audio output pin
hr = NOERROR;
m_ppOutputPin[1] = new CParserOutputPin(
NAME("FST Splitter Audio Output Pin"),
this,
&m_csFilter,
pmtAudio,
papAudio,
dwAudioCapabilities,
nAudioTimeFormats,
pAudioTimeFormats,
&hr,
wszFSTAudioOutputName
);
if (
(FAILED(hr)) ||
(m_ppOutputPin[1] == NULL)
) {
if (m_ppOutputPin[1]) {
delete m_ppOutputPin[1];
m_ppOutputPin[1] = NULL;
} else {
delete pmtAudio;
CoTaskMemFree(papAudio);
if (pAudioTimeFormats)
CoTaskMemFree(pAudioTimeFormats);
}
Shutdown();
if (FAILED(hr))
return hr;
else
return E_OUTOFMEMORY;
}
// Hold a reference on the audio output pin
m_ppOutputPin[1]->AddRef();
// We've created a new pin -- so increment pin version
IncrementPinVersion();
}
// Scope for the locking
{
// Protect media content information
CAutoLock infolock(&m_csInfo);
// Set the media content strings
m_wszAuthorName = (OLECHAR*)CoTaskMemAlloc(sizeof(OLECHAR) * (lstrlenW(wszFSTAuthorName) + 1));
if (m_wszAuthorName)
lstrcpyW(m_wszAuthorName, wszFSTAuthorName);
m_wszDescription = (OLECHAR*)CoTaskMemAlloc(sizeof(OLECHAR) * (lstrlenW(wszFSTDescription) + 1));
if (m_wszDescription)
lstrcpyW(m_wszDescription, wszFSTDescription);
}
return NOERROR;
}
static int v4w_open_videodevice(V4wState *s)
{
// Initialize COM
CoInitialize(NULL);
// get a Graph
HRESULT hr=s->m_pGraph.CoCreateInstance(CLSID_FilterGraph);
if(FAILED(hr))
{
return -1;
}
// get a CaptureGraphBuilder2
hr=s->m_pBuilder.CoCreateInstance(CLSID_CaptureGraphBuilder2);
if(FAILED(hr))
{
return -2;
}
// connect capture graph builder with the graph
s->m_pBuilder->SetFiltergraph(s->m_pGraph);
// get mediacontrol so we can start and stop the filter graph
hr=s->m_pGraph.QueryInterface(&(s->m_pControl));
if(FAILED(hr))
{
return -3;
}
#ifdef _DEBUG
HANDLE m_hLogFile=CreateFile(L"DShowGraphLog.txt",GENERIC_READ|GENERIC_WRITE,FILE_SHARE_READ,NULL,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
if(m_hLogFile!=INVALID_HANDLE_VALUE)
{
hr=s->m_pGraph->SetLogFile((DWORD_PTR)m_hLogFile);
/* ASSERT(SUCCEEDED(hr)); */
}
//AddGraphToRot(s->m_pGraph, &s->rotregvalue);
#endif
ICreateDevEnum *pCreateDevEnum = NULL;
IEnumMoniker *pEnumMoniker = NULL;
IMoniker *pMoniker = NULL;
ULONG nFetched = 0;
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum, (PVOID *)&pCreateDevEnum);
if(FAILED(hr))
{
return -4;
}
hr = pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
&pEnumMoniker, 0);
if (FAILED(hr) || pEnumMoniker == NULL) {
//printf("no device\n");
return -5;
}
pEnumMoniker->Reset();
int pos=0;
while(S_OK == pEnumMoniker->Next(1, &pMoniker, &nFetched) )
{
if (pos>=s->devidx)
break;
pos++;
pMoniker->Release();
pMoniker=NULL;
}
if(pMoniker==NULL)
{
return -6;
}
hr = pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&s->m_pDeviceFilter );
if(FAILED(hr))
{
return -7;
}
s->m_pGraph->AddFilter(s->m_pDeviceFilter, L"Device Filter");
pMoniker->Release();
pEnumMoniker->Release();
pCreateDevEnum->Release();
if (try_format(s, s->pix_fmt)==0)
s->pix_fmt = s->pix_fmt;
else if (try_format(s,MS_YUV420P)==0)
s->pix_fmt = MS_YUV420P;
else if (try_format(s,MS_YUY2)==0)
s->pix_fmt = MS_YUY2;
else if (try_format(s,MS_YUYV)==0)
s->pix_fmt = MS_YUYV;
else if (try_format(s,MS_UYVY)==0)
s->pix_fmt = MS_UYVY;
else if (try_format(s,MS_RGB24)==0)
s->pix_fmt = MS_RGB24;
else
{
ms_error("Unsupported video pixel format.");
return -8;
}
if (s->pix_fmt == MS_YUV420P)
ms_message("Driver supports YUV420P, using that format.");
else if (s->pix_fmt == MS_YUY2)
ms_message("Driver supports YUY2 (UYVY), using that format.");
else if (s->pix_fmt == MS_YUYV)
ms_message("Driver supports YUV422, using that format.");
else if (s->pix_fmt == MS_UYVY)
ms_message("Driver supports UYVY, using that format.");
else if (s->pix_fmt == MS_RGB24)
ms_message("Driver supports RGB24, using that format.");
if (try_format_size(s, s->pix_fmt, s->vsize.width, s->vsize.height)==0)
ms_message("Selected Size: %ix%i.", s->vsize.width, s->vsize.height);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_QCIF_W, MS_VIDEO_SIZE_QCIF_H)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_QCIF_W, MS_VIDEO_SIZE_QCIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_CIF_W, MS_VIDEO_SIZE_CIF_H)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_CIF_W, MS_VIDEO_SIZE_CIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_4CIF_W, MS_VIDEO_SIZE_4CIF_H)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_4CIF_W, MS_VIDEO_SIZE_4CIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_VGA_W, MS_VIDEO_SIZE_VGA_H)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_VGA_W, MS_VIDEO_SIZE_VGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_QVGA_W, MS_VIDEO_SIZE_QVGA_H)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_QVGA_W, MS_VIDEO_SIZE_QVGA_H);
else
{
ms_error("No supported size found for format.");
/* size not supported? */
return -9;
}
// get DXFilter
s->m_pDXFilter = new CDXFilter(NULL, &hr, FALSE);
if(s->m_pDXFilter==NULL)
{
return -10;
}
s->m_pDXFilter->AddRef();
CMediaType mt;
mt.SetType(&MEDIATYPE_Video);
GUID m = MEDIASUBTYPE_RGB24;
if (s->pix_fmt == MS_YUV420P)
m = (GUID)FOURCCMap(MAKEFOURCC('I','4','2','0'));
else if (s->pix_fmt == MS_YUY2)
m = MEDIASUBTYPE_YUY2;
else if (s->pix_fmt == MS_YUYV)
m = MEDIASUBTYPE_YUYV;
else if (s->pix_fmt == MS_UYVY)
m = MEDIASUBTYPE_UYVY;
else if (s->pix_fmt == MS_RGB24)
m = MEDIASUBTYPE_RGB24;
mt.SetSubtype(&m);
mt.formattype = FORMAT_VideoInfo;
mt.SetTemporalCompression(FALSE);
VIDEOINFO *pvi = (VIDEOINFO *)
mt.AllocFormatBuffer(sizeof(VIDEOINFO));
if (NULL == pvi)
return -11;
ZeroMemory(pvi, sizeof(VIDEOINFO));
if (s->pix_fmt == MS_YUV420P)
pvi->bmiHeader.biCompression = MAKEFOURCC('I','4','2','0');
else if (s->pix_fmt == MS_YUY2)
pvi->bmiHeader.biCompression = MAKEFOURCC('Y','U','Y','2');
else if (s->pix_fmt == MS_YUYV)
pvi->bmiHeader.biCompression = MAKEFOURCC('Y','U','Y','V');
else if (s->pix_fmt == MS_UYVY)
pvi->bmiHeader.biCompression = MAKEFOURCC('U','Y','V','Y');
else if (s->pix_fmt == MS_RGB24)
pvi->bmiHeader.biCompression = BI_RGB;
if (s->pix_fmt == MS_YUV420P)
pvi->bmiHeader.biBitCount = 12;
else if (s->pix_fmt == MS_YUY2)
pvi->bmiHeader.biBitCount = 16;
else if (s->pix_fmt == MS_YUYV)
pvi->bmiHeader.biBitCount = 16;
else if (s->pix_fmt == MS_UYVY)
pvi->bmiHeader.biBitCount = 16;
else if (s->pix_fmt == MS_RGB24)
pvi->bmiHeader.biBitCount = 24;
pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pvi->bmiHeader.biWidth = s->vsize.width;
pvi->bmiHeader.biHeight = s->vsize.height;
pvi->bmiHeader.biPlanes = 1;
pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader);
pvi->bmiHeader.biClrImportant = 0;
mt.SetSampleSize(pvi->bmiHeader.biSizeImage);
mt.SetFormat((BYTE*)pvi, sizeof(VIDEOINFO));
hr = s->m_pDXFilter->SetAcceptedMediaType(&mt);
if(FAILED(hr))
{
return -12;
}
hr = s->m_pDXFilter->SetCallback(Callback);
if(FAILED(hr))
{
return -13;
}
hr = s->m_pDXFilter->QueryInterface(IID_IBaseFilter,
(LPVOID *)&s->m_pIDXFilter);
if(FAILED(hr))
{
return -14;
}
hr = s->m_pGraph->AddFilter(s->m_pIDXFilter, L"DXFilter Filter");
if(FAILED(hr))
{
return -15;
}
// get null renderer
hr=s->m_pNullRenderer.CoCreateInstance(CLSID_NullRenderer);
if(FAILED(hr))
{
return -16;
}
if (s->m_pNullRenderer!=NULL)
{
s->m_pGraph->AddFilter(s->m_pNullRenderer, L"Null Renderer");
}
hr = s->m_pBuilder->RenderStream(&PIN_CATEGORY_PREVIEW,
&MEDIATYPE_Video, s->m_pDeviceFilter, s->m_pIDXFilter, s->m_pNullRenderer);
if (FAILED(hr))
{
//hr = s->m_pBuilder->RenderStream(&PIN_CATEGORY_CAPTURE,
// &MEDIATYPE_Video, s->m_pDeviceFilter, s->m_pIDXFilter, s->m_pNullRenderer);
if (FAILED(hr))
{
return -17;
}
}
//m_pDXFilter->SetBufferSamples(TRUE);
s_callback = s;
hr = s->m_pControl->Run();
if(FAILED(hr))
{
return -18;
}
s->rotregvalue=1;
return 0;
}
HRESULT CNutSplitterFilter::CreateOutputs(IAsyncReader* pAsyncReader)
{
CheckPointer(pAsyncReader, E_POINTER);
HRESULT hr = E_FAIL;
m_pFile.Free();
m_pFile.Attach(new CNutFile(pAsyncReader, hr));
if(!m_pFile) return E_OUTOFMEMORY;
if(FAILED(hr)) {m_pFile.Free(); return hr;}
m_rtNewStart = m_rtCurrent = 0;
m_rtNewStop = m_rtStop = m_rtDuration = 0;
// pins
POSITION pos = m_pFile->m_streams.GetHeadPosition();
while(pos)
{
CNutFile::stream_header* sh = m_pFile->m_streams.GetNext(pos);
CAtlArray<CMediaType> mts;
CMediaType mt;
if(sh->stream_class == CNutFile::SC_VIDEO)
{
CNutFile::video_stream_header& vsh = sh->vsh;
mt.majortype = MEDIATYPE_Video;
mt.subtype = FOURCCMap(*(DWORD*)sh->fourcc.GetData());
mt.formattype = FORMAT_VideoInfo;
VIDEOINFOHEADER vih;
memset(&vih, 0, sizeof(vih));
vih.dwBitRate = (DWORD)sh->average_bitrate;
vih.AvgTimePerFrame = 10000000i64 * sh->time_base_nom / sh->time_base_denom;
vih.bmiHeader.biSize = sizeof(vih.bmiHeader);
vih.bmiHeader.biCompression = mt.subtype.Data1;
vih.bmiHeader.biWidth = (LONG)vsh.width;
vih.bmiHeader.biHeight = (LONG)vsh.height;
mt.SetFormat((BYTE*)&vih, sizeof(vih));
mts.Add(mt);
if(vsh.sample_width && vsh.sample_height)
{
VIDEOINFOHEADER2 vih2;
memset(&vih2, 0, sizeof(vih2));
vih2.dwBitRate = vih.dwBitRate;
vih2.AvgTimePerFrame = vih.AvgTimePerFrame;
vih2.dwPictAspectRatioX = (DWORD)vsh.sample_width;
vih2.dwPictAspectRatioY = (DWORD)vsh.sample_height;
vih2.bmiHeader = vih.bmiHeader;
mt.SetFormat((BYTE*)&vih2, sizeof(vih2));
mts.InsertAt(0, mt);
}
}
else if(sh->stream_class == CNutFile::SC_AUDIO)
{
CNutFile::audio_stream_header& ash = sh->ash;
// TODO
}
else if(sh->stream_class == CNutFile::SC_SUBTITLE)
{
// TODO
}
if(mts.GetCount() > 0)
{
CAutoPtr<CBaseSplitterOutputPin> pPinOut(new CBaseSplitterOutputPin(mts, L"Video", this, this, &hr));
AddOutputPin((DWORD)sh->stream_id, pPinOut);
}
}
// TODO
m_rtNewStop = m_rtStop = m_rtDuration = 0;
return m_pOutputs.GetCount() > 0 ? S_OK : E_FAIL;
}
