#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;
}