camera.h

Window Mobile Capture with DirectDraw

#ifndef	 _CAMERA_H_

#include <dshow.h> // DirectShow
#include <Dmodshow.h>
#include <dmo.h>
#include "CameraImageRenderer.h"
#include "wmcodecs.h"      // Window Media Player

#define WM_GRAPHNOTIFY						(WM_USER+2111)

class CCamera : public CMediaSampleCallback
{
	CComBSTR							m_bstrCameraName;
	CComPtr<IBaseFilter>				m_pVideoCapture;
	CComPtr<IGraphBuilder>				m_pGraph;
	CComPtr<ICaptureGraphBuilder2>		m_pGraphBuilder2;
	CComPtr<IImageSinkFilter>			m_pImageSinkFilter;

public:
	CCamera()
	{
		wchar_t szCameraName[MAX_PATH] = {0};
		HRESULT hr = GetFirstCameraDriver(szCameraName);
		ATLASSERT(hr == S_OK);
		m_bstrCameraName = szCameraName;
		InitCaptureGraph();
	}

	CCamera(wchar_t *szCameraName)
	{
		m_bstrCameraName = szCameraName;
		InitCaptureGraph();
	}

	~CCamera(){}

	CComBSTR GetCameraName() { return m_bstrCameraName; }

	HRESULT DefaultPreview()
	{
		HRESULT hr = E_FAIL;
		ATLASSERT(m_pVideoCapture != NULL);
		hr = m_pGraphBuilder2->RenderStream(&PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, m_pVideoCapture, NULL, NULL);
		return hr;
	}

	HRESULT RenderImageFile()
	{
		HRESULT hr = E_FAIL;

		//////////////////////////////////////////////////////////////////////////
		// render still image
		CComPtr<IBaseFilter>			pImageSinkFilter;
		hr = pImageSinkFilter.CoCreateInstance( CLSID_IMGSinkFilter );
		ATLASSERT(SUCCEEDED(hr));
		hr = m_pGraph->AddFilter( pImageSinkFilter, L"Still image filter" );
		ATLASSERT(SUCCEEDED(hr));
		hr = m_pGraphBuilder2->RenderStream( &PIN_CATEGORY_STILL, &MEDIATYPE_Video, m_pVideoCapture, NULL, pImageSinkFilter );
		ATLASSERT(SUCCEEDED(hr));		
		hr = pImageSinkFilter.QueryInterface( &m_pImageSinkFilter );
		ATLASSERT(SUCCEEDED(hr));
		return hr;
	}

	HRESULT RenderAsFile(LPCWSTR pwsFileName)
	{
		HRESULT hr = E_FAIL;

		//////////////////////////////////////////////////////////////////////////
		// render file
		CComPtr<IBaseFilter> pVideoEncoder;
		CComPtr<IDMOWrapperFilter> pWrapperFilter;

		hr = pVideoEncoder.CoCreateInstance(CLSID_DMOWrapperFilter);
		ATLASSERT(hr == S_OK);

		hr = pVideoEncoder->QueryInterface( &pWrapperFilter );
		hr = pWrapperFilter->Init( CLSID_CWMV9EncMediaObject, DMOCATEGORY_VIDEO_ENCODER );
		ATLASSERT(hr == S_OK);
		hr = m_pGraph->AddFilter( pVideoEncoder, L"WMV9DMO Encoder");
		ATLASSERT(hr == S_OK);

		CComPtr<IBaseFilter> pASFMultiplexer;
		CComPtr<IFileSinkFilter> pFileSinkFilter;
		hr = m_pGraphBuilder2->SetOutputFileName(&MEDIASUBTYPE_Asf, CComBSTR(pwsFileName), &pASFMultiplexer, &pFileSinkFilter);
		ATLASSERT(hr == S_OK);

		hr = m_pGraphBuilder2->RenderStream( &PIN_CATEGORY_CAPTURE,	&MEDIATYPE_Video, m_pVideoCapture, pVideoEncoder,	pASFMultiplexer );
		ATLASSERT(SUCCEEDED(hr));
		return hr;
	}

	HRESULT Render()
	{
		HRESULT hr = E_FAIL;
		ATLASSERT(m_pVideoCapture != NULL);

		//////////////////////////////////////////////////////////////////////////
		// preview	
		// Add My Camera Image Renderer filter to the graph.
		CComPtr<IBaseFilter> pImageRenderer;
		CCameraImageRenderer *pRenderer2 = new CCameraImageRenderer(NULL, &hr, this);
		pRenderer2->AddRef();
		pRenderer2->QueryInterface(__uuidof(IBaseFilter), (void**)&pImageRenderer);
		ATLASSERT(pImageRenderer != NULL);
		hr = m_pGraph->AddFilter(pImageRenderer, L"Camera Preview Renderer");
		ATLASSERT(SUCCEEDED(hr));
		hr = m_pGraphBuilder2->RenderStream( &PIN_CATEGORY_PREVIEW, &MEDIATYPE_Video, m_pVideoCapture, NULL, pImageRenderer );
		ATLASSERT(SUCCEEDED(hr));

		//////////////////////////////////////////////////////////////////////////
		// Add the Still Image Renderer filter to the graph.
		CComPtr<IBaseFilter> pNullRenderer;
		CCameraImageRenderer *pStillImageRenderer = new CCameraImageRenderer(NULL, &hr, this);
		pStillImageRenderer->AddRef();
		pStillImageRenderer->QueryInterface(__uuidof(IBaseFilter), (void**)&pNullRenderer);
		ATLASSERT(pNullRenderer != NULL);
		hr = m_pGraph->AddFilter(pNullRenderer, L"Null Renderer");
		ATLASSERT(SUCCEEDED(hr));
		hr = m_pGraphBuilder2->RenderStream( &PIN_CATEGORY_STILL, &MEDIATYPE_Video, m_pVideoCapture, NULL, pNullRenderer);
		ATLASSERT(SUCCEEDED(hr));

		return hr;
	}

	HRESULT Configure()
	{
		HRESULT hr = S_OK;

		//////////////////////////////////////////////////////////////////////////
		CComPtr<IAMCameraControl> pCameraControl;
		hr = m_pVideoCapture->QueryInterface( &pCameraControl );
		ATLASSERT(pCameraControl != NULL);

		hr = pCameraControl->Set(CameraControl_Roll, 180, CameraControl_Flags_Auto);
		ATLASSERT(hr == S_OK);

		//////////////////////////////////////////////////////////////////////////
		CComPtr<IAMStreamConfig> pConfig;
		hr = m_pGraphBuilder2->FindInterface(
			&PIN_CATEGORY_CAPTURE, // Preview pin. PIN_CATEGORY_PREVIEW, PIN_CATEGORY_CAPTURE
			0,    // Any media type.
			m_pVideoCapture, // Pointer to the capture filter.
			IID_IAMStreamConfig, (void**)&pConfig);
		
		ATLASSERT(pConfig != NULL);

		int iCount = 0, iSize = 0;
		hr = pConfig->GetNumberOfCapabilities(&iCount, &iSize);

		// Check the size to make sure we pass in the correct structure.
		if (iSize == sizeof(VIDEO_STREAM_CONFIG_CAPS))
		{
			// Use the video capabilities structure.

			for (int iFormat = 0; iFormat < iCount; iFormat++)
			{
				VIDEO_STREAM_CONFIG_CAPS scc;
				AM_MEDIA_TYPE *pmtConfig;
				hr = pConfig->GetStreamCaps(iFormat, &pmtConfig, (BYTE*)&scc);
				if (SUCCEEDED(hr))
				{
					/* Examine the format, and possibly use it. */

					VIDEOINFOHEADER *pVih = (VIDEOINFOHEADER*)pmtConfig->pbFormat;
					// pVih contains the detailed format information.
					LONG lWidth = pVih->bmiHeader.biWidth;
					LONG lHeight = pVih->bmiHeader.biHeight;
				}
			}
		}

		AM_MEDIA_TYPE *pmtConfig = NULL;
		hr = pConfig->GetFormat(&pmtConfig);
		if(pmtConfig == NULL)
			return E_FAIL;
		return hr;
	}

	HRESULT Run(HWND hWnd)
	{
		CComPtr<IMediaEventEx> pMediaEvent;
		CComPtr<IMediaControl> pMediaControl;

		// handle media event
		HRESULT hr = m_pGraph->QueryInterface( &pMediaEvent );
		hr = pMediaEvent->SetNotifyWindow((OAHWND)hWnd,	WM_GRAPHNOTIFY,0);

		hr = m_pGraph->QueryInterface(&pMediaControl);
		hr = Configure();
		ATLASSERT(SUCCEEDED(hr));

		hr =pMediaControl->Run();
		ATLASSERT(SUCCEEDED(hr));
		if(FAILED(hr))
			return hr;

		LONGLONG dwStart  = 0, dwEnd      = 0;
		WORD wStartCookie = 1, wEndCookie = 2;

		dwEnd=MAXLONGLONG;

		//start capturing
		hr= m_pGraphBuilder2->ControlStream(&PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, m_pVideoCapture, &dwStart, &dwEnd,wStartCookie, wEndCookie );
		ATLASSERT(SUCCEEDED(hr));
		if(FAILED(hr))
			return hr;

		return S_OK;
	}

	HRESULT Stop()
	{
		CComPtr<IMediaControl> pMediaControl;
		HRESULT hr = m_pGraph->QueryInterface(&pMediaControl);
		hr = pMediaControl->Stop();
		return hr;
	}

	HRESULT ShotStillImage(LPCWSTR szFileName)
	{
		HRESULT hr = S_OK;
		CComPtr<IPin>			 pStillPin;
		CComPtr<IAMVideoControl> pVideoControl;

		if( m_pGraphBuilder2 == NULL || m_pVideoCapture == NULL)
			return E_FAIL;

		hr = m_pGraphBuilder2->FindPin( m_pVideoCapture, PINDIR_OUTPUT, &PIN_CATEGORY_STILL, &MEDIATYPE_Video, FALSE, 0, &pStillPin );
		ATLASSERT(SUCCEEDED(hr));
		hr = m_pVideoCapture.QueryInterface( &pVideoControl );
		ATLASSERT(SUCCEEDED(hr));
		hr = pVideoControl->SetMode( pStillPin, VideoControlFlag_Trigger );
		ATLASSERT(SUCCEEDED(hr));
		return hr;
	}

	HRESULT ShotImageFile(LPCWSTR szFileName)
	{
		HRESULT hr = S_OK;
		CComPtr<IFileSinkFilter> pFileSink;
		CComPtr<IPin>			 pStillPin;
		CComPtr<IAMVideoControl> pVideoControl;

		if( m_pGraphBuilder2 == NULL || m_pVideoCapture == NULL)
			return E_FAIL;

		hr = m_pImageSinkFilter.QueryInterface( &pFileSink );
		ATLASSERT(SUCCEEDED(hr));
		hr = pFileSink->SetFileName( CComBSTR(szFileName), NULL );
		ATLASSERT(SUCCEEDED(hr));

		hr = m_pGraphBuilder2->FindPin( m_pVideoCapture, PINDIR_OUTPUT, &PIN_CATEGORY_STILL, &MEDIATYPE_Video, FALSE, 0, &pStillPin );
		ATLASSERT(SUCCEEDED(hr));
		hr = m_pVideoCapture.QueryInterface( &pVideoControl );
		ATLASSERT(SUCCEEDED(hr));
		hr = pVideoControl->SetMode( pStillPin, VideoControlFlag_Trigger );
		ATLASSERT(SUCCEEDED(hr));
		return hr;
	}

	HRESULT GetSourcePosition(long* pLeft,long* pTop,long* pWidth,long* pHeight)
	{
		CComQIPtr<IVideoWindow> pBasicVideo = m_pGraph;
		ATLASSERT(pBasicVideo != NULL);
		return pBasicVideo->GetWindowPosition(pLeft, pTop, pWidth, pHeight);
	}

	HRESULT SetOwner(OAHWND hwnd)
	{
		CComQIPtr<IVideoWindow> pBasicVideo = m_pGraph;
		ATLASSERT(pBasicVideo != NULL);
		pBasicVideo->put_Owner(hwnd);
		pBasicVideo->put_Left(50);
		pBasicVideo->put_Caption(CComBSTR(L"VCAM"));
		return NOERROR;
	}

	static HRESULT GetFirstCameraDriver( WCHAR *pwzName );

protected:
	HRESULT InitCaptureGraph();
	HRESULT GetCameraCaptureFilter(IBaseFilter **ppCaptureFilter, WCHAR *pwzName);		

	IPin * GetInPin( IBaseFilter * pFilter, int nPin )
	{
		CComPtr<IPin> pComPin=0;
		GetPin(pFilter, PINDIR_INPUT, nPin, &pComPin);
		return pComPin;
	}


	IPin * GetOutPin( IBaseFilter * pFilter, int nPin )
	{
		CComPtr<IPin> pComPin=0;
		GetPin(pFilter, PINDIR_OUTPUT, nPin, &pComPin);
		return pComPin;
	}

	HRESULT GetPin( IBaseFilter * pFilter, PIN_DIRECTION dirrequired, int iNum, IPin **ppPin)
	{
		CComPtr< IEnumPins > pEnum;
		*ppPin = NULL;

		HRESULT hr = pFilter->EnumPins(&pEnum);
		if(FAILED(hr)) 
			return hr;

		ULONG ulFound;
		IPin *pPin;
		hr = E_FAIL;

		while(S_OK == pEnum->Next(1, &pPin, &ulFound))
		{
			PIN_DIRECTION pindir = (PIN_DIRECTION)3;

			pPin->QueryDirection(&pindir);
			if(pindir == dirrequired)
			{
				if(iNum == 0)
				{
					*ppPin = pPin;  // Return the pin's interface
					hr = S_OK;      // Found requested pin, so clear error
					break;
				}
				iNum--;
			} 

			pPin->Release();
		} 

		return hr;
	}
};

#endif