|
Posted by Michton on October 24, 2007, 10:12 am
Please log in for more thread options
Hi Everybody.
I try to make an application that grab some frame from the Preview
Camera and also draw some overlay on them back.
All the nice guys here explained me that I need to NullRenderer and
CSampleGrabber
1) I succeeded to Compile AND Register the NullRederer and the
CSampleGrabber.
2 )I succeded to instatiate the NulllRender
3) The instantiation of the CSampleGrabber falls.
(CLSID_CSampleGrabber)
Can someone helps?
Need any more code to test this?
Here is the code (improved from the basic CameraCapture of SDK)
RESULT
CGraphManager::CreateCaptureGraphInternal()
{
HRESULT hr = S_OK;
CComVariant varCamName;
CPropertyBag PropBag;
OAEVENT oaEvent;
WCHAR wzDeviceName[ MAX_PATH + 1 ];
CComPtr<IMediaEvent> pMediaEvent;
CComPtr<IGraphBuilder> pFilterGraph;
CComPtr<IBaseFilter> pVideoEncoder;
CComPtr<IBaseFilter> pASFMultiplexer;
CComPtr<IFileSinkFilter> pFileSinkFilter;
CComPtr<IPersistPropertyBag> pPropertyBag;
CComPtr<IDMOWrapperFilter> pWrapperFilter;
CComPtr<IBaseFilter> pImageSinkFilter;
CComPtr<IAMVideoControl> pVideoControl;
CComPtr<IPin> pStillPin;
CComPtr<IUnknown> pUnkCaptureFilter;
CComPtr<IVideoWindow> pVideoWindow;
IMediaControl *pControl = NULL;
CComPtr<IBaseFilter> nullRenderer;
CComPtr<IFilterGraph> pGrabber;
CComPtr<IUnknown> pUnk1;
CComPtr<IPin> pCaptPin;
RECT rect;
//
// Create the capture graph builder and register the filtergraph
manager.
//
CHK( m_pCaptureGraphBuilder.CoCreateInstance( CLSID_CaptureGraphBuilder ));
CHK( pFilterGraph.CoCreateInstance( CLSID_FilterGraph ));
CHK( m_pCaptureGraphBuilder->SetFiltergraph( pFilterGraph ));
//
// Create and initialize the video capture filter
//
CHK( m_pVideoCaptureFilter.CoCreateInstance( CLSID_VideoCapture ));
CHK( m_pVideoCaptureFilter.QueryInterface( &pPropertyBag ));
// We are loading the driver CAM1 in the video capture filter.
CHK( GetFirstCameraDriver( wzDeviceName ));
varCamName = wzDeviceName;
if( varCamName.vt != VT_BSTR )
{
ERR( E_OUTOFMEMORY );
}
CHK( PropBag.Write( L"VCapName", &varCamName ));
CHK( pPropertyBag->Load( &PropBag, NULL ));
// Everything succeeded, the video capture filter is added to the
filtergraph
CHK( pFilterGraph->AddFilter( m_pVideoCaptureFilter, L"Video
Capture Filter Source" ));
//
// Third step: Create the video encoder DMO, load the WMV9
encoder, and
// add it to the graph
//
// Create the video encoder
CHK( pVideoEncoder.CoCreateInstance( CLSID_DMOWrapperFilter ));
CHK( pVideoEncoder.QueryInterface( &pWrapperFilter ));
// Load the WMV9 DMO
CHK( pWrapperFilter->Init( CLSID_CWMV9EncMediaObject,
DMOCATEGORY_VIDEO_ENCODER ));
// Everything succeeded, let's add the encoder to the graph
CHK( pFilterGraph->AddFilter( pVideoEncoder, L"WMV9 DMO
Encoder" ));
//
// Create the ASF multiplexer and add it to the graph
//
CHK( m_pCaptureGraphBuilder->SetOutputFileName( &MEDIASUBTYPE_Asf,
L"\video1.asf", &pASFMultiplexer, &pFileSinkFilter ));
//
// Connect the video capture filter, the encoder and the
multiplexer together
//
CHK( m_pCaptureGraphBuilder->RenderStream( &PIN_CATEGORY_CAPTURE,
&MEDIATYPE_Video, m_pVideoCaptureFilter, pVideoEncoder,
pASFMultiplexer ));
CHK(pFilterGraph->QueryInterface(IID_IVideoWindow, (void
**)&pVideoWindow));
CHK(m_pCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_PREVIEW,
&MEDIATYPE_Video, m_pVideoCaptureFilter, NULL, NULL ));
CHK(pVideoWindow->put_Owner((OAHWND)g_h1));
hr = pVideoWindow->put_WindowStyle(WS_CHILD | WS_VISIBLE |
WS_CLIPSIBLINGS);
GetClientRect(g_h1, &rect);
CHK(pVideoWindow->SetWindowPosition(rect.left,rect.top,rect.right -
rect.left, rect.bottom - rect.top));
CHK(pVideoWindow->put_AutoShow(OATRUE));
CHK(pVideoWindow->put_Visible(OATRUE));
CHK(pVideoWindow->put_WindowState(SW_SHOW));
// CHK(pVideoWindow->put_FullScreenMode(OATRUE));
// CHK(pVideoWindow->SetWindowForeground(OATRUE));
// CHK(m_pCaptureGraphBuilder->QueryInterface(IID_IMediaControl,
(void **) &pControl));
// CHK(pControl->Run());
//
// Create the still image filter, and connect it to the video capture
filter
//
CHK( pImageSinkFilter.CoCreateInstance( CLSID_IMGSinkFilter ));
CHK( pFilterGraph->AddFilter( pImageSinkFilter, L"Still image
filter" ));
CHK( m_pCaptureGraphBuilder->RenderStream( &PIN_CATEGORY_STILL,
&MEDIATYPE_Video, m_pVideoCaptureFilter, NULL, pImageSinkFilter ));
CHK( pImageSinkFilter.QueryInterface( &m_pImageSinkFilter ));
//
// Prevent the data from flowing into the capture stream
//
CHK( m_pCaptureGraphBuilder->ControlStream( &PIN_CATEGORY_CAPTURE,
&MEDIATYPE_Video, m_pVideoCaptureFilter, 0, 0 ,0,0 ));
IAMStreamConfig *pStillStreamConfig;
// IBaseFilter *pCap;
// GetDefaultCapDevice( &pCap );
CHK(m_pCaptureGraphBuilder->FindInterface(&PIN_CATEGORY_STILL,
&MEDIATYPE_Video,m_pVideoCaptureFilter, IID_IAMStreamConfig,
(void**)&pStillStreamConfig));
AM_MEDIA_TYPE *pType = NULL , pType1;
int iCount=0, iSize=0;
/* // Does not work for Mio
VIDEO_STREAM_CONFIG_CAPS caps;
pStillStreamConfig->GetNumberOfCapabilities(&iCount, &iSize);
pStillStreamConfig->GetFormat(&pType);
// pType->majortype = MEDIATYPE_Video;
// pType->subtype = MEDIASUBTYPE_RGB555;
int i;
for(i=0;i<iCount;i++)
{
// GetStreamCaps allocates the AM_MEDIA_TYPE, which must be deleted
by using DeleteMediaType
if(pStillStreamConfig->GetStreamCaps(i, &pType, (BYTE*)&caps) ==
S_OK )
{
VIDEOINFOHEADER* m_fVideoHeader = (VIDEOINFOHEADER*)pType-
>pbFormat;
int t=0;
t++; // Just use to debug and test the best mode.
}
}
pStillStreamConfig->GetStreamCaps(2, &pType, (BYTE*)&caps) ; // That
means 320X240
VIDEOINFOHEADER* wert = (VIDEOINFOHEADER*)pType->pbFormat; // Take it
into VIDEOINFOHEADER.
CHK(pStillStreamConfig->SetFormat(pType));
pStillStreamConfig->GetFormat(&pType); // HERE I CHECK the connected
STREAM FORMAT !!
wert = (VIDEOINFOHEADER*)pType->pbFormat; // Take it into
VIDEOINFOHEADER.
//
// Let's get the handle for DShow events. The main loop will
listen to both notifications from
// the UI thread and for DShow notifications
//
*/
CHK( pFilterGraph->QueryInterface( IID_IMediaEvent, (void**)
&pMediaEvent ));
CHK( pMediaEvent->GetEventHandle( &oaEvent ));
m_handle[1] = (HANDLE) oaEvent;
m_fGraphBuilt = TRUE;
CHK(nullRenderer.CoCreateInstance(CLSID_NullRend));
CHK(pFilterGraph->AddFilter(nullRenderer,L"NullRenderer")); // This
Works
//////////////
---------------------------------------------------------------------------////////////////////////////////////////
////////////// -------------------This line make the CHK to
FAIL-----------////////////////////////////////////////
//////////////
---------------------------------------------------------------------------////////////////////////////////////////
//////////////
---------------------------------------------------------------------------////////////////////////////////////////
//////////////
---------------------------------------------------------------------------////////////////////////////////////////
CHK(pGrabber.CoCreateInstance(CLSID_CSampleGrabber));
//////////////
---------------------------------------------------------------------------////////////////////////////////////////
//////////////
---------------------------------------------------------------------------////////////////////////////////////////
//////////////
---------------------------------------------------------------------------////////////////////////////////////////
//////////////
---------------------------------------------------------------------------////////////////////////////////////////
//////////////
---------------------------------------------------------------------------////////////////////////////////////////
//////////////
---------------------------------------------------------------------------////////////////////////////////////////
CHK( m_pVideoCaptureFilter.QueryInterface( &pVideoControl ));
CHK( m_pVideoCaptureFilter.QueryInterface( &pUnk1 ));
CHK( m_pCaptureGraphBuilder->FindPin( pUnk1, PINDIR_INPUT,
&PIN_CATEGORY_PREVIEW, &MEDIATYPE_Video, FALSE, 0, &pCaptPin ));
// CHK( pVideoControl->SetMode( pStillPin,
VideoControlFlag_FlipHorizontal ));
//////////////////////////////////////////////
// pCaptPin->Release();
CHK( m_pVideoCaptureFilter.QueryInterface( &pUnkCaptureFilter ));
// CHK(pFilterGraph->AddFilter(pGrabber,L"SamGrabber"));
// IPin *pGrabOut = GetOutPin(pGrab, 0);
// IPin *pNullIn = GetInPin(nullRenderer, 0);
// NotifyMessage( MESSAGE_ERROR, L"Building the graph failed" );
IBaseFilter* pSourceFilter=NULL;
hr=S_FALSE;
IOverlay *pOverlay;
if(m_pCaptureGraphBuilder){
if(SUCCEEDED(pFilterGraph->FindFilterByName(L"Video Capture Filter
Source",&pSourceFilter ))){
IAMCameraControl *pControl=NULL;
if(SUCCEEDED(pSourceFilter->QueryInterface(IID_IAMCameraControl,
(void**)&pControl) )){
//CHK(pControl->Set(CameraControl_Zoom,
150,CameraControl_Flags_Manual));
//CHK(pControl-
>Set(CameraControl_Macro,CameraControl_Macro_On,CameraControl_Flags_Manual));
// CHK(pControl-
>Set(CameraControl_SetMode,CameraControl_Mode_Camera ,CameraControl_Flags_Manual));
// CHK(pControl-
>Set(CameraControl_MeteringMode,CameraControl_MeteringMode_Normal,CameraControl_Flags_Manual));
// CHK(pControl-
>Set(CameraControl_Effect,CameraControl_Effect_Normal,CameraControl_Flags_Manual));
}
IAMVideoProcAmp *pVideoControl=NULL;
if(SUCCEEDED(pSourceFilter->QueryInterface(IID_IAMVideoProcAmp,
(void**)&pVideoControl) )){
long nMin,nMax,nDefault,nStep,nCaps;
// hr = pVideoControl-
>GetRange(VideoProcAmp_Gain,&nMin,&nMax,&nStep,&nDefault,&nCaps);
// CHK(pVideoControl->Set(VideoProcAmp_Scene,
1,CameraControl_Flags_Auto));
}
// ConnectPins(nullRenderer, 0, pSourceFilter,0);
// SafeRelease(pControl);
}
// SafeRelease(pSourceFilter);
/*
IBaseFilter *pFilter= NULL;
IPin *pin = NULL;
if(SUCCEEDED(pFilterGraph->FindFilterByName(L"Video
Renderer",&pFilter ))){
if (SUCCEEDED(pFilter->FindPin(L"VMR Input0", &pin))) {
if (SUCCEEDED(pin->QueryInterface(IID_IOverlay,
(void **)&pOverlay))){
pin->Release();
pFilter->Release();
}
// SafeRelease(pControl);
}
// SafeRelease(pSourceFilter);
} */
}
Cleanup:
if( FAILED( hr ))
{
TCHAR s[40];
_stprintf(s,_T("Message=%x\n"),hr);
OutputDebugString(s);
NotifyMessage( MESSAGE_ERROR, L"Building the graph failed" );
}
return hr;
}
HRESULT
CGraphManager::RunCaptureGraphInternal()
{
HRESULT hr = S_OK;
CComPtr<IGraphBuilder> pGraphBuilder;
CComPtr<IMediaControl> pMediaControl;
// Let's make sure that the graph has been initialized
if(( m_pCaptureGraphBuilder == NULL ) || ( m_fGraphBuilt ==
FALSE ))
{
ERR( E_FAIL );
}
// Retrieve the filtergraph off the capture graph builder
CHK( m_pCaptureGraphBuilder->GetFiltergraph( &pGraphBuilder ));
// Get the media control interface, and run the graph
CHK( pGraphBuilder->QueryInterface( &pMediaControl ));
CHK( pMediaControl->Run());
CHK( NotifyMessage( MESSAGE_INFO, L"The Graph is running" ));
Cleanup:
if( FAILED( hr ))
{
NotifyMessage( MESSAGE_ERROR, L"Runing the capture graph failed" );
}
return hr;
}
|
XML Sitemap