940 lines
40 KiB
C++
940 lines
40 KiB
C++
#include <dvcap/CaptureDeviceGraph.hpp>
|
|
#include <com/variant.hpp>
|
|
#include <com/bstring.hpp>
|
|
#include <dvcap/dvcap.hpp>
|
|
|
|
CaptureDeviceGraph::CaptureDeviceGraph()
|
|
: mVideoFormat(DVENCODERVIDEOFORMAT_NTSC),
|
|
mDVResolution(DVRESOLUTION_HALF),
|
|
mSubunitMode(VCRMode), mLogFile("dvcap.log","wb")
|
|
{
|
|
SystemTime systemTime;
|
|
mLogFile.writeLine("*********************************************************************");
|
|
mLogFile.writeLine(String(" DVCAPTURE LOG FILE STARTED AT:")+systemTime.toString());
|
|
mLogFile.writeLine("*********************************************************************");
|
|
}
|
|
|
|
CaptureDeviceGraph::~CaptureDeviceGraph()
|
|
{
|
|
if(mVideoWindow.isOkay())
|
|
{
|
|
mVideoWindow->put_Visible(OAFALSE);
|
|
mVideoWindow->put_Owner(0);
|
|
}
|
|
freeFilters();
|
|
}
|
|
|
|
void CaptureDeviceGraph::freeFilters()
|
|
{
|
|
mGraph.Release();
|
|
mCaptureGraphBuilder.Release();
|
|
mMediaEvent.Release();
|
|
mInputFileFilter.Release();
|
|
mDeviceFilter.Release();
|
|
mExtDevice.Release();
|
|
mExtTransport.Release();
|
|
mTimecodeReader.Release();
|
|
mVideoWindow.Release();
|
|
mDroppedFrames.Release();
|
|
}
|
|
|
|
bool CaptureDeviceGraph::buildBasicGraph()
|
|
{
|
|
ComResult comResult;
|
|
|
|
if(!initializeGraph())
|
|
{
|
|
error("[CaptureDeviceGraph::buildBasicGraph] Failed to create filter graph.");
|
|
return false;
|
|
}
|
|
if(!addDeviceFilter())
|
|
{
|
|
error("[CaptureDeviceGraph::buildBasicGraph] Failed to add device filter.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::buildBasicGraph] mDeviceFilter->QueryInterface(IID_IAMExtTransport,(void**)(IAMExtTransport**)mExtTransport)");
|
|
comResult=mDeviceFilter->QueryInterface(IID_IAMExtTransport,(void**)(IAMExtTransport**)mExtTransport);
|
|
if(!comResult.success())
|
|
{
|
|
error("[CaptureDeviceGraph::buildBasicGraph] Failed to QueryInterface IID_IAMExtTransport.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::buildBasicGraph] mDeviceFilter->QueryInterface(IID_IAMExtDevice,(void**)(IAMExtDevice**)mExtDevice)");
|
|
comResult=mDeviceFilter->QueryInterface(IID_IAMExtDevice,(void**)(IAMExtDevice**)mExtDevice);
|
|
if(!comResult.success())
|
|
{
|
|
error("[CaptureDeviceGraph::buildBasicGraph] Failed to QueryInterface IID_IAMExtDevice.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::buildBasicGraph] mDeviceFilter->QueryInterface(IID_IAMTimecodeReader,(void**)(IAMTimecodeReader**)mTimecodeReader)");
|
|
comResult=mDeviceFilter->QueryInterface(IID_IAMTimecodeReader,(void**)(IAMTimecodeReader**)mTimecodeReader);
|
|
if(!comResult.success())
|
|
{
|
|
error("[CaptureDeviceGraph::buildBasicGraph] Failed to QueryInterface IID_IAMTimecodeReader.");
|
|
return false;
|
|
}
|
|
mSubunitMode=getDVMode();
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::initializeGraph()
|
|
{
|
|
ComResult comResult;
|
|
|
|
mGraph.Release();
|
|
mCaptureGraphBuilder.Release();
|
|
mMediaEvent.Release();
|
|
mMediaControl.Release();
|
|
mVideoWindow.Release();
|
|
LOG("[CaptureDeviceGraph::initializeGraph] mGraph.createInstance(CLSID_FilterGraph,IID_IGraphBuilder)");
|
|
comResult=mGraph.createInstance(CLSID_FilterGraph,IID_IGraphBuilder);
|
|
if(!comResult.success())
|
|
{
|
|
error("[CaptureDeviceGraph::initializeGraph] Failed to create CLSID_FilterGraph.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::initializeGraph] mCaptureGraphBuilder.createInstance(CLSID_CaptureGraphBuilder2,IID_ICaptureGraphBuilder2)");
|
|
comResult=mCaptureGraphBuilder.createInstance(CLSID_CaptureGraphBuilder2,IID_ICaptureGraphBuilder2);
|
|
if(!comResult.success())
|
|
{
|
|
error("[CaptureDeviceGraph::initializeGraph] Failed to create CLSID_CaptureGraphBuilder2.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::initializeGraph] mCaptureGraphBuilder->SetFiltergraph(mGraph)");
|
|
comResult=mCaptureGraphBuilder->SetFiltergraph(mGraph);
|
|
if(!comResult.success())
|
|
{
|
|
error("[CaptureDeviceGraph::initializeGraph] Failed to SetFiltergraph.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::initializeGraph] mGraph->QueryInterface(IID_IMediaEventEx,(void**)(IMediaEventEx**)mMediaEvent)");
|
|
comResult=mGraph->QueryInterface(IID_IMediaEventEx,(void**)(IMediaEventEx**)mMediaEvent);
|
|
if(!comResult.success())
|
|
{
|
|
error("[CaptureDeviceGraph::initializeGraph] Failed to QueryInterface IMediaEventEx.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::initializeGraph] mGraph->QueryInterface(IID_IMediaControl,(void**)(IMediaControl**)mMediaControl)");
|
|
comResult=mGraph->QueryInterface(IID_IMediaControl,(void**)(IMediaControl**)mMediaControl);
|
|
if(!comResult.success())
|
|
{
|
|
error("[CaptureDeviceGraph::initializeGraph] Failed to QueryInterface IMediaControl.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::initializeGraph] mGraph->QueryInterface(IID_IVideoWindow,(void**)(IVideoWindow**)mVideoWindow)");
|
|
comResult=mGraph->QueryInterface(IID_IVideoWindow,(void**)(IVideoWindow**)mVideoWindow);
|
|
if(!comResult.success())
|
|
{
|
|
error("[CaptureDeviceGraph::initializeGraph] Failed to QueryInterface IVideoWindow.");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::addDeviceFilter()
|
|
{
|
|
ComResult comResult;
|
|
ComPointer<ICreateDevEnum> createDevEnum;
|
|
ComPointer<IEnumMoniker> enumMoniker;
|
|
ComPointer<IMoniker> moniker;
|
|
ULONG nFetched=0;
|
|
|
|
LOG("[CaptureDeviceGraph::addDeviceFilter] createDevEnum.createInstance(CLSID_SystemDeviceEnum,IID_ICreateDevEnum)");
|
|
comResult=createDevEnum.createInstance(CLSID_SystemDeviceEnum,IID_ICreateDevEnum);
|
|
if(!comResult.success())
|
|
{
|
|
error("[CaptureDeviceGraph::addDeviceFilter] Failed to create CLSID_SystemDeviceEnum");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::addDeviceFilter] createDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,(IEnumMoniker**)enumMoniker,0)");
|
|
if(!ComResult(createDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,(IEnumMoniker**)enumMoniker,0)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::addDeviceFilter] createDevEnum->CreateClassEnumerator() Failed.");
|
|
return false;
|
|
}
|
|
if(!enumMoniker.isOkay())
|
|
{
|
|
error("[CaptureDeviceGraph::addDeviceFilter] createDevEnum->CreateClassEnumerator() Failed.");
|
|
return false;
|
|
}
|
|
enumMoniker->Reset();
|
|
while(ComResult(enumMoniker->Next(1,(IMoniker**)moniker,&nFetched)).success())
|
|
{
|
|
ComPointer<IPropertyBag> propertyBag;
|
|
Variant vName;
|
|
LOG("[CaptureDeviceGraph::addDeviceFilter] moniker->BindToStorage(0,0,IID_IPropertyBag,(void**)(IPropertyBag**)propertyBag)");
|
|
comResult=moniker->BindToStorage(0,0,IID_IPropertyBag,(void**)(IPropertyBag**)propertyBag);
|
|
if(!comResult.success())
|
|
{
|
|
error("[CaptureDeviceGraph::addDeviceFilter] Failed to BindToStorage on moniker");
|
|
continue;
|
|
}
|
|
LOG("[CaptureDeviceGraph::addDeviceFilter] propertyBag->Read(L\"FriendlyName\",&vName.getVARIANT(),0)");
|
|
comResult=propertyBag->Read(L"FriendlyName",&vName.getVARIANT(),0);
|
|
if(!comResult.success())
|
|
{
|
|
error("[CaptureDeviceGraph::addDeviceFilter] Failed to Read FriendlyName");
|
|
continue;
|
|
}
|
|
vName.getData(mDeviceName);
|
|
if(mDeviceName=="Microsoft DV Camera and VCR")
|
|
{
|
|
LOG("[CaptureDeviceGraph::addDeviceFilter] moniker->BindToObject(0,0,IID_IBaseFilter,(void**)(IBaseFilter**)mDeviceFilter)");
|
|
comResult=moniker->BindToObject(0,0,IID_IBaseFilter,(void**)(IBaseFilter**)mDeviceFilter);
|
|
if(!comResult.success())
|
|
{
|
|
error("[CaptureDeviceGraph::addDeviceFilter] Failed to Bind DeviceFilter");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::addDeviceFilter] mGraph->AddFilter(mDeviceFilter,L\"Filter\")");
|
|
comResult=mGraph->AddFilter(mDeviceFilter,L"Filter");
|
|
if(!comResult.success())
|
|
{
|
|
error("[CaptureDeviceGraph::addDeviceFilter] Failed to AddFilter");
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return mDeviceFilter.isOkay();
|
|
}
|
|
|
|
CaptureDeviceGraph::DVMode CaptureDeviceGraph::getDVMode(void)
|
|
{
|
|
ComResult comResult;
|
|
LONG deviceType;
|
|
|
|
LOG("[CaptureDeviceGraph::getDVMode] mExtDevice->GetCapability(ED_DEVCAP_DEVICE_TYPE,&deviceType,0)");
|
|
comResult=mExtDevice->GetCapability(ED_DEVCAP_DEVICE_TYPE,&deviceType,0);
|
|
if(!comResult.success())
|
|
{
|
|
error("[CaptureDeviceGraph::getDVMode] mExtDevice->GetCapability(ED_DEVCAP_DEVICE_TYPE,&deviceType,0) Failed.(Non-Fatal)");
|
|
return UnknownMode;
|
|
}
|
|
switch(deviceType)
|
|
{
|
|
case ED_DEVTYPE_VCR :
|
|
return VCRMode;
|
|
case ED_DEVTYPE_CAMERA :
|
|
return CameraMode;
|
|
case 0 :
|
|
default :
|
|
return UnknownMode;
|
|
}
|
|
}
|
|
|
|
bool CaptureDeviceGraph::getTapeInfo(void)
|
|
{
|
|
ComResult comResult;
|
|
LONG mediaType;
|
|
LONG inSignalMode;
|
|
|
|
LOG("[CaptureDeviceGraph::getTapeInfo] mExtTransport->GetStatus(ED_MEDIA_TYPE,&mediaType)");
|
|
comResult=mExtTransport->GetStatus(ED_MEDIA_TYPE,&mediaType);
|
|
if(!comResult.success())return false;
|
|
if(ED_MEDIA_NOT_PRESENT==mediaType)return false; // fail if no tape installed
|
|
else
|
|
{
|
|
if(ED_MEDIA_DVC!=mediaType)return false; // tape type should be DVC
|
|
LOG("[CaptureDeviceGraph::getTapeInfo] mExtTransport->GetTransportBasicParameters(ED_TRANSBASIC_INPUT_SIGNAL,&inSignalMode,0)");
|
|
comResult=mExtTransport->GetTransportBasicParameters(ED_TRANSBASIC_INPUT_SIGNAL,&inSignalMode,0);
|
|
if(!comResult.success())return false;
|
|
switch(inSignalMode)
|
|
{
|
|
case ED_TRANSBASIC_SIGNAL_525_60_SD :
|
|
mAverageTimePerFrame=33; // 33 ms(29.97 FPS)
|
|
mVideoFormat=DVENCODERVIDEOFORMAT_NTSC;
|
|
break;
|
|
case ED_TRANSBASIC_SIGNAL_525_60_SDL :
|
|
mAverageTimePerFrame=33; // 33 ms(29.97 FPS)
|
|
mVideoFormat=DVENCODERVIDEOFORMAT_NTSC;
|
|
break;
|
|
case ED_TRANSBASIC_SIGNAL_625_50_SD :
|
|
mAverageTimePerFrame=40; // 40 ms (25 FPS)
|
|
mVideoFormat=DVENCODERVIDEOFORMAT_PAL;
|
|
break;
|
|
case ED_TRANSBASIC_SIGNAL_625_50_SDL :
|
|
mAverageTimePerFrame=40; // 40 ms (25 FPS)
|
|
mVideoFormat=DVENCODERVIDEOFORMAT_PAL;
|
|
break;
|
|
default :
|
|
error("[CaptureDeviceGraph::getTapeInfo] unsupported or unrecognized tape format type");
|
|
mAverageTimePerFrame=33;
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// DV_Cam(AV Out)->DVSplitter(vid)->DVCodec->VideoWindow
|
|
// DVSplitter(aud)->Default DirectSound device
|
|
bool CaptureDeviceGraph::makePreviewGraph(void)
|
|
{
|
|
ComResult comResult;
|
|
|
|
mGraphType=GraphPreview;
|
|
LOG("[CaptureDeviceGraph::makePreviewGraph] mExtTransport->GetTransportBasicParameters(ED_TRANSBASIC_INPUT_SIGNAL,&inSignalMode,0)");
|
|
comResult=mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_PREVIEW,&MEDIATYPE_Interleaved,mDeviceFilter,0,0);
|
|
if(!comResult.success())return false;
|
|
return true;
|
|
}
|
|
|
|
// DV_Cam(AV Out)->SmartTee(capture)->AviMux->FileWriter
|
|
// SmartTee(preview)->DVSplitter(vid)->DVCodec->VideoWindow
|
|
// DVSplitter(aud)->Default DirectSound device
|
|
|
|
bool CaptureDeviceGraph::makeDVToFileGraphType1(const BString &pathOutputFileName)
|
|
{
|
|
ComPointer<IBaseFilter> ppf;
|
|
ComPointer<IFileSinkFilter> pSink;
|
|
USES_CONVERSION;
|
|
|
|
if(!pathOutputFileName.isOkay())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphType1] pathOutputFileName is null.");
|
|
return false;
|
|
}
|
|
mGraphType=GraphDVToFile;
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphType1] mCaptureGraphBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi,pathOutputFileName.str(),(IBaseFilter**)ppf,(IFileSinkFilter**)pSink)");
|
|
if(!ComResult(mCaptureGraphBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi,pathOutputFileName.str(),(IBaseFilter**)ppf,(IFileSinkFilter**)pSink)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphType1] SetOutputFileName failed.");
|
|
return false;
|
|
}
|
|
if(!setAviOptions(ppf,INTERLEAVE_NONE))return false;
|
|
// Connect interleaved stream of MSDV to the AVI Mux/FW
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphType1] mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_CAPTURE,&MEDIATYPE_Interleaved,mDeviceFilter,0,ppf)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_CAPTURE,&MEDIATYPE_Interleaved,mDeviceFilter,0,ppf)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphType1] mCaptureGraphBuilder->RenderStream() failed.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphType1] mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_PREVIEW,&MEDIATYPE_Interleaved,mDeviceFilter,0,0)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_PREVIEW,&MEDIATYPE_Interleaved,mDeviceFilter,0,0)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphType1] mCaptureGraphBuilder->RenderStream() failed.");
|
|
return true; // smk test
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::makeDVToFileGraphNoPreType1(const BString &pathOutputFileName)
|
|
{
|
|
ComPointer<IBaseFilter> ppf;
|
|
ComPointer<IFileSinkFilter> sink;
|
|
mGraphType=GraphDVToFileNoPre;
|
|
USES_CONVERSION;
|
|
|
|
// if(!ComResult(mCaptureGraphBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi,pathOutputFileName.str(),ppf,sink)).success())
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphNoPreType1] mCaptureGraphBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi,pathOutputFileName.str(),(IBaseFilter**)ppf,(IFileSinkFilter**)sink)");
|
|
if(!ComResult(mCaptureGraphBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi,pathOutputFileName.str(),(IBaseFilter**)ppf,(IFileSinkFilter**)sink)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphNoPreType1] mCaptureGraphBuilder->SetOutputFileName() failed.");
|
|
return false;
|
|
}
|
|
if(!setAviOptions(ppf,INTERLEAVE_NONE))return false;
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphNoPreType1] mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_CAPTURE,&MEDIATYPE_Interleaved,mDeviceFilter,0,ppf)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_CAPTURE,&MEDIATYPE_Interleaved,mDeviceFilter,0,ppf)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphNoPreType1] mCaptureGraphBuilder->RenderStream() failed.");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// FileSource->AVI_Splitter->InfPinTee->DV_Camera
|
|
// InfPinTee->DVSplitter(vid)->DVDecoder->VideoWIndow
|
|
// DVSplitter(aud)->Default DirectSound device
|
|
// the graph we're making is: Async Reader --> AVI SPlitter --> Tee --> MSDV
|
|
// --> DV Splitter --> DV Decoder --> VidRend
|
|
// --> AudRend
|
|
|
|
bool CaptureDeviceGraph::makeFileToDVGraphType1(const BString &pathInputFileName)
|
|
{
|
|
mGraphType=GraphFileToDV;
|
|
ComPointer<IBaseFilter> aviSplitter;
|
|
ComPointer<IBaseFilter> inFTee;
|
|
USES_CONVERSION;
|
|
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType1] mGraph->AddSourceFilter(pathInputFileName.str(),pathInputFileName.str(),(IBaseFilter**)mInputFileFilter)");
|
|
if(!ComResult(mGraph->AddSourceFilter(pathInputFileName.str(),pathInputFileName.str(),(IBaseFilter**)mInputFileFilter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType1] mGraph->AddSourceFilter() Failed.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType1] aviSplitter.createInstance(CLSID_AviSplitter,IID_IBaseFilter)");
|
|
if(!ComResult(aviSplitter.createInstance(CLSID_AviSplitter,IID_IBaseFilter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType1] aviSplitter->createInstance(CLSID_AviSplitter,IID_IBaseFilter) Failed.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType1] inFTee.createInstance(CLSID_InfTee,IID_IBaseFilter)");
|
|
if(!ComResult(inFTee.createInstance(CLSID_InfTee,IID_IBaseFilter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType1] inFTee->createInstance(CLSID_InfTee,IID_BaseFilter) Failed.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType1] mGraph->AddFilter(aviSplitter,L\"AVI Splitter\")");
|
|
if(!ComResult(mGraph->AddFilter(aviSplitter,L"AVI Splitter")).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType1] mGraph->AddFilter(aviSplitter) Failed.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType1] mCaptureGraphBuilder->RenderStream(0,0,mInputFileFilter,0,aviSplitter)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(0,0,mInputFileFilter,0,aviSplitter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType1] mCaptureGraphBuilder->RenderStream(..,aviSplitter) Failed.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType1] mGraph->AddFilter(inFTee,L\"Infinite Tee\")");
|
|
if(!ComResult(mGraph->AddFilter(inFTee,L"Infinite Tee")).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType1] mGraph->AddFilter(inFTee) Failed.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType1] mCaptureGraphBuilder->RenderStream(0,&MEDIATYPE_Interleaved,aviSplitter,0,inFTee)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(0,&MEDIATYPE_Interleaved,aviSplitter,0,inFTee)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType1] mCaptureGraphBuilder->RenderStream(..,inFTee) Failed.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType1] mCaptureGraphBuilder->RenderStream(0,0,inFTee,0,mDeviceFilter)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(0,0,inFTee,0,mDeviceFilter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType1] mCaptureGraphBuilder->RenderStream(..,mDeviceFilter) Failed.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType1] mCaptureGraphBuilder->RenderStream(0,0,inFTee,0,0)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(0,0,inFTee,0,0)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType1] mCaptureGraphBuilder->RenderStream(..,inFTee,0,0) Failed.");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//FileSource->AVI_Splitter->DV_Camera
|
|
// Graph : Async Reader --> AVI Splitter --> MSDV
|
|
|
|
bool CaptureDeviceGraph::makeFileToDVGraphNoPreType1(const BString &pathInputFileName)
|
|
{
|
|
mGraphType=GraphFileToDVNoPre;
|
|
USES_CONVERSION;
|
|
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphNoPreType1] mGraph->AddSourceFilter(pathInputFileName.str(),pathInputFileName.str(),(IBaseFilter**)mInputFileFilter)");
|
|
if(!ComResult(mGraph->AddSourceFilter(pathInputFileName.str(),pathInputFileName.str(),(IBaseFilter**)mInputFileFilter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphNoPreType1] mGraph->AddSourceFilter() Failed.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphNoPreType1] mCaptureGraphBuilder->RenderStream(0,0,mInputFileFilter,0,mDeviceFilter)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(0,0,mInputFileFilter,0,mDeviceFilter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphNoPreType1] mCaptureGraphBuilder->RenderStream(0,0,mInputFileFilter,0,mDeviceFilter) Failed.");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// the graph we're making is: MSDV --> Smart Tee --> DV SPLITTER --> AVI MUX --> File Writer
|
|
// -->
|
|
//
|
|
// --> DV SPLITTER --> DV DEC --> Video Renderer
|
|
// --> Audio Renderer
|
|
|
|
bool CaptureDeviceGraph::makeDVToFileGraphType2(const BString &pathOutputFileName)
|
|
{
|
|
mGraphType=GraphDVToFileType2;
|
|
ComPointer<IBaseFilter> dvSplitter;
|
|
ComPointer<IBaseFilter> ppf;
|
|
ComPointer<IFileSinkFilter> sink;
|
|
USES_CONVERSION;
|
|
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphType2] dvSplitter.createInstance(CLSID_DVSplitter,IID_IBaseFilter)");
|
|
if(!ComResult(dvSplitter.createInstance(CLSID_DVSplitter,IID_IBaseFilter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphType2] createInstance(CLSID_DVSplitter,IID_IBaseFilter) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphType2] mGraph->AddFilter(dvSplitter,L\"DV Splitter\")");
|
|
if(!ComResult(mGraph->AddFilter(dvSplitter,L"DV Splitter")).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphType2] mGraph->AddFilter(dvSplitter,L\"DV Splitter\") Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphType2] mCaptureGraphBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi,pathOutputFileName.str(),(IBaseFilter**)ppf,(IFileSinkFilter**)sink)");
|
|
if(!ComResult(mCaptureGraphBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi,pathOutputFileName.str(),(IBaseFilter**)ppf,(IFileSinkFilter**)sink)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphType2] mCaptureGraphBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi,pathOutputFileName.str(),(IBaseFilter**)ppf,(IFileSinkFilter**)sink) Failed");
|
|
return false;
|
|
}
|
|
if(!setAviOptions(ppf,INTERLEAVE_NONE))return false;
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphType2] mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_CAPTURE,&MEDIATYPE_Interleaved,mDeviceFilter,dvSplitter,ppf)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_CAPTURE,&MEDIATYPE_Interleaved,mDeviceFilter,dvSplitter,ppf)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphType2] mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_CAPTURE,&MEDIATYPE_Interleaved,mDeviceFilter,dvSplitter,ppf) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphType2] mCaptureGraphBuilder->RenderStream(0,0,dvSplitter,0,ppf)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(0,0,dvSplitter,0,ppf)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphType2] mCaptureGraphBuilder->RenderStream(0,0,dvSplitter,0,ppf) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphType2] mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_PREVIEW,&MEDIATYPE_Interleaved,mDeviceFilter,0,0)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_PREVIEW,&MEDIATYPE_Interleaved,mDeviceFilter,0,0)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphType2] mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_PREVIEW,&MEDIATYPE_Interleaved,mDeviceFilter,0,0) Failed");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// the graph we're making is: MSDV --> Smart Tee --> DV SPLITTER --> AVI MUX --> File Writer
|
|
// -->
|
|
|
|
bool CaptureDeviceGraph::makeDVToFileGraphNoPreType2(const BString &pathOutputFileName)
|
|
{
|
|
mGraphType=GraphDVToFileNoPreType2;
|
|
ComPointer<IBaseFilter> dvSplitter;
|
|
ComPointer<IBaseFilter> ppf;
|
|
ComPointer<IFileSinkFilter> sink;
|
|
USES_CONVERSION;
|
|
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphNoPreType2] dvSplitter.createInstance(CLSID_DVSplitter,IID_IBaseFilter)");
|
|
if(!ComResult(dvSplitter.createInstance(CLSID_DVSplitter,IID_IBaseFilter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphNoPreType2] dvSplitter.createInstance(CLSID_DVSplitter,IID_IBaseFilter) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphNoPreType2] mGraph->AddFilter(dvSplitter,L\"DV Splitter\")");
|
|
if(!ComResult(mGraph->AddFilter(dvSplitter,L"DV Splitter")).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphNoPreType2] mGraph->AddFilter(dvSplitter,L\"DV Splitter\") Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphNoPreType2] mCaptureGraphBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi,pathOutputFileName.str(),(IBaseFilter**)ppf,(IFileSinkFilter**)sink)");
|
|
if(!ComResult(mCaptureGraphBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi,pathOutputFileName.str(),(IBaseFilter**)ppf,(IFileSinkFilter**)sink)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphNoPreType2] mCaptureGraphBuilder->SetOutputFileName(&MEDIASUBSTYPE_Avi,pathOutputFileName.str(),(IBaseFilter**)ppf,(IFileSinkFilter**)sink) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphNoPreType2] mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_CAPTURE,&MEDIATYPE_Interleaved,mDeviceFilter,dvSplitter,ppf)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_CAPTURE,&MEDIATYPE_Interleaved,mDeviceFilter,dvSplitter,ppf)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphNoPreType2] mCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_CAPTURE,&MEDIATYPE_Interleaved,mDeviceFilter,dvSplitter,ppf) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeDVToFileGraphNoPreType2] mCaptureGraphBuilder->RenderStream(0,0,dvSplitter,0,ppf)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(0,0,dvSplitter,0,ppf)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeDVToFileGraphNoPreType2] mCaptureGraphBuilder->RenderStream(0,0,dvSplitter,0,ppf) Failed");
|
|
return false;
|
|
}
|
|
if(!setAviOptions(ppf,INTERLEAVE_NONE))return false;
|
|
return true;
|
|
}
|
|
|
|
// the graph we need to build is: ASYNC reader --> AVI SPLITTER --> DV MUX --> TEE --> MSDV
|
|
// --> --> DVSP --> DV DEC --> VR
|
|
// --> AR
|
|
|
|
bool CaptureDeviceGraph::makeFileToDVGraphType2(const BString &pathInputFileName)
|
|
{
|
|
ComPointer<IBaseFilter> dvMux;
|
|
ComPointer<IBaseFilter> inFTee;
|
|
ComPointer<IPin> out;
|
|
|
|
mGraphType=GraphFileToDVType2;
|
|
USES_CONVERSION;
|
|
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType2] dvMux.createInstance(CLSID_DVMux,IID_IBaseFilter)");
|
|
if(!ComResult(dvMux.createInstance(CLSID_DVMux,IID_IBaseFilter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType2] dvMux.createInstance(CLSID_DVMux,IID_IBaseFiler) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType2] inFTee.createInstance(CLSID_InfTee,IID_IBaseFilter)");
|
|
if(!ComResult(inFTee.createInstance(CLSID_InfTee,IID_IBaseFilter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType2] inFTee.createInstance(CLSID_InfTee,IID_IBaseFilter) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType2] mGraph->AddSourceFilter(pathInputFileName.str(),pathInputFileName.str(),(IBaseFilter**)mInputFileFilter)");
|
|
if(!ComResult(mGraph->AddSourceFilter(pathInputFileName.str(),pathInputFileName.str(),(IBaseFilter**)mInputFileFilter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType2] mGraph->AddSourceFilter(pathInputFileName.str(),pathInputFileName.str(),(IBaseFilter**)mInputFileFilter) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType2] mGraph->AddFilter(dvMux,L\"DV Muxer\")");
|
|
if(!ComResult(mGraph->AddFilter(dvMux,L"DV Muxer")).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType2] mGraph->AddFilter(dvMux,L\"DV Muxer\") Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType2] mGraph->AddFilter(inFTee,L\"Infinite Tee\")");
|
|
if(!ComResult(mGraph->AddFilter(inFTee,L"Infinite Tee")).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType2] mGraph->AddFilter(inFTee,L\"Infinite Tee\") Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType2] mCaptureGraphBuilder->RenderStream(0,0,mInputFileFilter,0,dvMux)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(0,0,mInputFileFilter,0,dvMux)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType2] mCaptureGraphBuilder->RenderStream(0,0,mInputFileFilter,0,dvMux) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType2] mCaptureGraphBuilder->RenderStream(0,0,dvMux,0,inFTee)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(0,0,dvMux,0,inFTee)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType2] mCaptureGraphBuilder->RenderStream(0,0,dvMux,0,inFTee) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType2] mCaptureGraphBuilder->RenderStream(0,0,inFTee,0,mDeviceFilter)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(0,0,inFTee,0,mDeviceFilter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType2] mCaptureGraphBuilder->RenderStream(0,0,inFTee,0,mDeviceFilter) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType2] mCaptureGraphBuilder->FindPin(inFTee,PINDIR_OUTPUT,0,0,true,0,(IPin**)out)");
|
|
if(!ComResult(mCaptureGraphBuilder->FindPin(inFTee,PINDIR_OUTPUT,0,0,true,0,(IPin**)out)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType2] mCaptureGraphBuilder->FindPin(inFTee,PINDIR_OUTPUT,0,0,true,0,(IPin**)out) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphType2] mGraph->Render(out)");
|
|
if(!ComResult(mGraph->Render(out)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphType2] mGraph->Render(out) Failed");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// the graph we need to build is: ASYNC reader --> AVI SPLITTER --> DV MUX --> MSDV
|
|
// -->
|
|
// connect file video stream to DV MUX
|
|
bool CaptureDeviceGraph::makeFileToDVGraphNoPreType2(const BString &pathInputFileName)
|
|
{
|
|
ComPointer<IBaseFilter> dvMux;
|
|
mGraphType=GraphFileToDVNoPreType2;
|
|
USES_CONVERSION;
|
|
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphNoPreType2] dvMux.createInstance(CLSID_DVMux,IID_IBaseFilter)");
|
|
if(!ComResult(dvMux.createInstance(CLSID_DVMux,IID_IBaseFilter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphNoPreType2] dvMux.createInstance(CLSID_DVMux,IID_IBaseFilter) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphNoPreType2] mGraph->AddSourceFilter(pathInputFileName.str(),pathInputFileName.str(),(IBaseFilter**)mInputFileFilter)");
|
|
if(!ComResult(mGraph->AddSourceFilter(pathInputFileName.str(),pathInputFileName.str(),(IBaseFilter**)mInputFileFilter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphNoPreType2] mGraph->AddSourceFilter(pathInputFileName.str(),pathInputFileName.str(),(IBaseFilter**)mInputFileFilter) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphNoPreType2] mGraph->AddFilter(dvMux,L\"DV Muxer\")");
|
|
if(!ComResult(mGraph->AddFilter(dvMux,L"DV Muxer")).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphNoPreType2] mGraph->AddFilter(dvMux,L\"DV Muxer\") Failed");
|
|
return false;
|
|
}
|
|
// connect video
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphNoPreType2] mCaptureGraphBuilder->RenderStream(0,0,mInputFileFilter,0,dvMux)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(0,0,mInputFileFilter,0,dvMux)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphNoPreType2] mCaptureGraphBuilder->RenderStream(0,0,mInputFileFilter,0,dvMux) Failed");
|
|
return false;
|
|
}
|
|
// connect audio - looks suspicious because this line same as previous
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphNoPreType2] mCaptureGraphBuilder->RenderStream(0,0,mInputFileFilter,0,dvMux)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(0,0,mInputFileFilter,0,dvMux)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphNoPreType2] mCaptureGraphBuilder->RenderStream(0,0,mInputFileFilter,0,dvMux) Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::makeFileToDVGraphNoPreType2] mCaptureGraphBuilder->RenderStream(0,0,dvMux,0,mDeviceFilter)");
|
|
if(!ComResult(mCaptureGraphBuilder->RenderStream(0,0,dvMux,0,mDeviceFilter)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::makeFileToDVGraphNoPreType2] mCaptureGraphBuilder->RenderStream(0,0,dvMux,0,mDeviceFilter) Failed");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::setAviOptions(ComPointer<IBaseFilter> &ppf,InterleavingMode interleavingMode)
|
|
{
|
|
ComPointer<IConfigAviMux> mux;
|
|
ComPointer<IConfigInterleaving> interleaving;
|
|
|
|
LOG("[CaptureDeviceGraph::setAviOptions] ppf->QueryInterface(IID_IConfigAviMux,(void**)(IConfigAviMux**)mux)");
|
|
if(!ComResult(ppf->QueryInterface(IID_IConfigAviMux,(void**)(IConfigAviMux**)mux)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::setAviOptions] Failed to QueryInterface on IID_IConfigAviMux");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::setAviOptions] mux->SetOutputCompatibilityIndex(true)");
|
|
if(!ComResult(mux->SetOutputCompatibilityIndex(true)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::setAviOptions] mux->SetOutputCompatibilityIndex failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::setAviOptions] ppf->QueryInterface(IID_IConfigInterleaving,(void**)(IConfigInterleaving**)interleaving)");
|
|
if(!ComResult(ppf->QueryInterface(IID_IConfigInterleaving,(void**)(IConfigInterleaving**)interleaving)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::setAviOptions] QueryInterface IConfigInterleaving failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::setAviOptions] interleaving->put_Mode(interleavingMode)");
|
|
if(!ComResult(interleaving->put_Mode(interleavingMode)).success()) // full,none,half
|
|
{
|
|
error("[CaptureDeviceGraph::setAviOptions] interleaving->put_Mode failed");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::getVideoWindowDimensions(int &width,int &height,bool changeResolution,GUIWindow &window)
|
|
{
|
|
if(window.isValid())
|
|
{
|
|
if(!getResolutionFromDVDecoderPropertyPage(window,changeResolution))return false;
|
|
}
|
|
switch(mDVResolution)
|
|
{
|
|
case DVRESOLUTION_FULL:
|
|
width=DVEncoderWidth;
|
|
if(DVENCODERVIDEOFORMAT_PAL==mVideoFormat)height=PALDVEncoderHeight;
|
|
else if(DVENCODERVIDEOFORMAT_NTSC==mVideoFormat)height=NTSCDVEncoderHeight;
|
|
break;
|
|
case DVRESOLUTION_HALF:
|
|
width=DVEncoderWidth/2;
|
|
if(DVENCODERVIDEOFORMAT_PAL==mVideoFormat)height=PALDVEncoderHeight/2;
|
|
else if(DVENCODERVIDEOFORMAT_NTSC==mVideoFormat)height=NTSCDVEncoderHeight/2;
|
|
break;
|
|
case DVRESOLUTION_QUARTER:
|
|
width=DVEncoderWidth/4;
|
|
if(DVENCODERVIDEOFORMAT_PAL==mVideoFormat)height=PALDVEncoderHeight/4;
|
|
else if(DVENCODERVIDEOFORMAT_NTSC==mVideoFormat)height=NTSCDVEncoderHeight/4;
|
|
break;
|
|
case DVRESOLUTION_DC:
|
|
width = 88;
|
|
if(DVENCODERVIDEOFORMAT_PAL==mVideoFormat)height=PALDVEncoderHeight/8;
|
|
else if(DVENCODERVIDEOFORMAT_NTSC==mVideoFormat)height=NTSCDVEncoderHeight/8;
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::getResolutionFromDVDecoderPropertyPage(GUIWindow &window,bool changeResolution)
|
|
{
|
|
ComPointer<IBaseFilter> dvDecoder;
|
|
ComPointer<IIPDVDec> ipDVDec;
|
|
ComPointer<ISpecifyPropertyPages> propertyPages;
|
|
FILTER_INFO filterInfo;
|
|
|
|
LOG("[CaptureDeviceGraph::getResolutionFromDVDecoderPropertyPage] mGraph->FindFilterByName(L\"DV Video Decoder\",(IBaseFilter**)dvDecoder)");
|
|
if(!ComResult(mGraph->FindFilterByName(L"DV Video Decoder",(IBaseFilter**)dvDecoder)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::getResolutionFromDVPropertyPage] mGraph->FindFilterByName() Failed.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::getResolutionFromDVDecoderPropertyPage] dvDecoder->QueryInterface(IID_ISpecifyPropertyPages,(void**)(ISpecifyPropertyPages**)propertyPages)");
|
|
if(!ComResult(dvDecoder->QueryInterface(IID_ISpecifyPropertyPages,(void**)(ISpecifyPropertyPages**)propertyPages)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::getResolutionFromDVPropertyPage] QueryInterface ISpecifyPropertyPages Failed.");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::getResolutionFromDVDecoderPropertyPage] dvDecoder->QueryFilterInfo(&filterInfo)");
|
|
if(!ComResult(dvDecoder->QueryFilterInfo(&filterInfo)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::getResolutionFromDVPropertyPage] dvDecoder->QueryFilterInfo() Failed.");
|
|
return false;
|
|
}
|
|
if(changeResolution)
|
|
{
|
|
CAUUID caGUID;
|
|
propertyPages->GetPages(&caGUID);
|
|
::OleCreatePropertyFrame(window, // parent window
|
|
0,0, // reserved
|
|
filterInfo.achName, // caption for dialog box
|
|
1, // number of objects
|
|
(IUnknown**)(IBaseFilter**)dvDecoder, // array of object pointers
|
|
caGUID.cElems, // number of property pages
|
|
caGUID.pElems, // array of property page CLSID's
|
|
0, // locale identifier
|
|
0,0); // reserved
|
|
::CoTaskMemFree(caGUID.pElems);
|
|
}
|
|
filterInfo.pGraph->Release();
|
|
LOG("[CaptureDeviceGraph::getResolutionFromDVDecoderPropertyPage] dvDecoder->QueryInterface(IID_IIPDVDec,(void**)(IIPDVDec**)ipDVDec)");
|
|
if(!ComResult(dvDecoder->QueryInterface(IID_IIPDVDec,(void**)(IIPDVDec**)ipDVDec)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::getResolutionFromDVPropertyPage] QueryInterface IIPDVDec Failed");
|
|
return false;
|
|
}
|
|
LOG("[CaptureDeviceGraph::getResolutionFromDVDecoderPropertyPage] ipDVDec->get_IPDisplay((int*)&mDVResolution)");
|
|
if(!ComResult(ipDVDec->get_IPDisplay((int*)&mDVResolution)).success())
|
|
{
|
|
error("[CaptureDeviceGraph::getResolutionFromDVPropertyPage] ipDVDec->get_IPDisplay() Failed.");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::startGraph(void)
|
|
{
|
|
LOG("[CaptureDeviceGraph::startGraph] mMediaControl->Run()");
|
|
if(!ComResult(mMediaControl->Run()).success())
|
|
{
|
|
stopGraph();
|
|
error("[CaptureDeviceGraph::startGraph] mMediaControl->Run() Failed.");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::stopGraph(void)
|
|
{
|
|
LOG("[CaptureDeviceGraph::stopGraph] mMediaControl->Stop()");
|
|
if(!ComResult(mMediaControl->Stop()).success())
|
|
{
|
|
error("[CaptureDeviceGraph::stopGraph] mMediaControl->Stop() Failed.");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::pauseGraph(void)
|
|
{
|
|
LOG("[CaptureDeviceGraph::pauseGraph] mMediaControl->Pause()");
|
|
if(!ComResult(mMediaControl->Pause()).success())
|
|
{
|
|
stopGraph();
|
|
error("[CaptureDeviceGraph::pauseGraph] mMediaControl->Stop() Failed.");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::getTimecode(TIMECODE_SAMPLE &tcSample)
|
|
{
|
|
LOG("[CaptureDeviceGraph::getTimecode] mTimecodeReader->GetTimecode(&tcSample)");
|
|
if(!ComResult(mTimecodeReader->GetTimecode(&tcSample)).success())return false;
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::setNotifyWindow(GUIWindow &window,int command)
|
|
{
|
|
LOG("[CaptureDeviceGraph::setNotifyWindow] mMediaEvent->SetNotifyWindow((LONG_PTR)window.getHandle(),command,0)");
|
|
if(!ComResult(mMediaEvent->SetNotifyWindow((LONG_PTR)window.getHandle(),command,0)).success())return false;
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::putOwner(GUIWindow &window)
|
|
{
|
|
LOG("[CaptureDeviceGraph::putOwner] mVideoWindow->put_Owner((OAHWND)window.getHandle())");
|
|
if(!ComResult(mVideoWindow->put_Owner((OAHWND)window.getHandle())).success())return false;
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::putWindowStyle(int style)
|
|
{
|
|
LOG("[CaptureDeviceGraph::putWindowStyle] mVideoWindow->put_WindowStyle(style)");
|
|
if(!ComResult(mVideoWindow->put_WindowStyle(style)).success())return false;
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::setVideoWindowPosition(int left,int top,int width,int height)
|
|
{
|
|
LOG("[CaptureDeviceGraph::setVideoWindowPosition] mVideoWindow->SetWindowPosition(left,top,width,height)");
|
|
if(!ComResult(mVideoWindow->SetWindowPosition(left,top,width,height)).success())return false;
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::setVideoWindowVisible(bool visible)
|
|
{
|
|
LOG("[CaptureDeviceGraph::setVideoWindowVisible] mVideoWindow->put_Visible(visible?OATRUE:OAFALSE)");
|
|
if(!ComResult(mVideoWindow->put_Visible(visible?OATRUE:OAFALSE)).success())return false;
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::putIAMExtTransportMode(int mode)
|
|
{
|
|
if(!mExtTransport.isOkay())return false;
|
|
LOG("[CaptureDeviceGraph::putIAMExtTransportMode] mExtTransport->put_Mode(mode)");
|
|
return mExtTransport->put_Mode(mode);
|
|
}
|
|
|
|
bool CaptureDeviceGraph::seekAtn(int hour,int minute,int second,int frame)
|
|
{
|
|
BYTE rawAVCPkt[8]={0x00,0x20,0x52,0x20,0xff,0xff,0xff,0xff}; // raw AVC for seek atn
|
|
ULONG searchTrackNumber;
|
|
ComResult comResult;
|
|
long iCnt=sizeof(rawAVCPkt);
|
|
bool returnCode=false;
|
|
|
|
if(DVENCODERVIDEOFORMAT_PAL==mVideoFormat && (frame>25))
|
|
{
|
|
error("[CaptureDeviceGraph::seekAtn] Frame should be less than 25 for PAL");
|
|
return false;
|
|
}
|
|
if(DVENCODERVIDEOFORMAT_NTSC==mVideoFormat && (frame>30))
|
|
{
|
|
error("[CaptureDeviceGraph::seekAtn] Frame should be less than 30 for NTSC");
|
|
return false;
|
|
}
|
|
if((hour<26)&&(hour>=0)&&(minute<60)&&(minute>=0)&&(second<60))
|
|
{
|
|
if(40==mAverageTimePerFrame)
|
|
{
|
|
searchTrackNumber=((minute*60+second)*25+frame)*12*2;
|
|
}
|
|
else // drop two frame every minutes
|
|
{
|
|
searchTrackNumber=((minute*60+second)*30+frame-((minute-(minute/10))*2))*10*2;
|
|
}
|
|
rawAVCPkt[4]=(BYTE)(searchTrackNumber&0x000000ff);
|
|
rawAVCPkt[5]=(BYTE)((searchTrackNumber&0x0000ff00) >> 8);
|
|
rawAVCPkt[6]=(BYTE)((searchTrackNumber&0x00ff0000) >> 16);
|
|
LOG("[CaptureDeviceGraph::seekAtn] mExtTransport->GetTransportBasicParameters(ED_RAW_EXT_DEV_CMD,&iCnt,(LPOLESTR *)rawAVCPkt)");
|
|
comResult=mExtTransport->GetTransportBasicParameters(ED_RAW_EXT_DEV_CMD,&iCnt,(LPOLESTR *)rawAVCPkt);
|
|
if(!comResult.success())
|
|
{
|
|
if(ERROR_TIMEOUT==comResult.result())::OutputDebugString("ATN Seek returns ERROR_TIMEOUT\n");
|
|
else if(ERROR_REQ_NOT_ACCEP==comResult.result())::OutputDebugString(" ATN Seek returns ERROR_REQ_NOT_ACCEP\n");
|
|
else if(ERROR_NOT_SUPPORTED==comResult.result())::OutputDebugString(" ATN Seek returns ERROR_NOT_SUPPORTED\n");
|
|
else if(ERROR_REQUEST_ABORTED==comResult.result())::OutputDebugString(" ATN Seek returns ERROR_REQUEST_ABORTED\n");
|
|
}
|
|
returnCode=true;
|
|
}
|
|
else
|
|
{
|
|
error("Invalid Parameter - Time entered should be:\nHour:Minute:Second:Frame");
|
|
}
|
|
return returnCode;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::nukeInputFileFilter()
|
|
{
|
|
Nuker nuker(mGraph);
|
|
if(!nuker.nukeFilter(mInputFileFilter,true,false))
|
|
{
|
|
LOG("[CaptureDeviceGraph::nukeInputFileFilter] Failed.");
|
|
return false;
|
|
}
|
|
mGraph->RemoveFilter(mInputFileFilter);
|
|
mInputFileFilter.Release();
|
|
return true;
|
|
}
|
|
|
|
bool CaptureDeviceGraph::nukeDeviceFilter()
|
|
{
|
|
Nuker nuker(mGraph);
|
|
if(!nuker.nukeFilter(mDeviceFilter,true,true))
|
|
{
|
|
LOG("[CaptureDeviceGraph::nukeDeviceFilter] Failed.");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|