camengine.cpp

摄像头控制引擎（内含畸变矫正算法） 本程序是在VC++6.0环境下开发的

        }
        return E_NOTIMPL;
    }

    STDMETHODIMP SampleCB(double Time, IMediaSample *pSample)
    {
        return E_NOTIMPL;
    }


    STDMETHODIMP BufferCB(double Time, BYTE *pBuffer, long BufferLen)
    {
		int i, j;
		BYTE *lpSrc;
		double  value;

        if( !g_bOneShot )
            return 0;

        if ((g_StillMediaType.majortype != MEDIATYPE_Video) ||
            (g_StillMediaType.formattype != FORMAT_VideoInfo) ||
            (g_StillMediaType.cbFormat < sizeof(VIDEOINFOHEADER)) ||
            (g_StillMediaType.pbFormat == NULL))
        {
            return VFW_E_INVALIDMEDIATYPE;
        }

		
		// 每行
		for(i = 0; i < SRCIMGH; i++)
		{
			// 每列
			for(j = 0; j < SRCIMGW; j++)
			{
				// 指向DIB第i行，第j个象素的指针
				lpSrc = (BYTE *)pBuffer + (SRCIMGW*3) * i + j*3;
				value = *lpSrc * 0.114;
				value += *(BYTE *)(lpSrc + 1) * 0.587;
				value += *(BYTE *)(lpSrc + 2) * 0.299;
				g_Buffer[i*SRCIMGW+j] = (BYTE)(value + 0.5);
			}
		}

		Rectify();

		g_bOneShot = FALSE;	


        return S_OK;

    }
};


SampleGrabberCallback g_StillCapCB;

BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
    switch (ul_reason_for_call)
	{
		case DLL_PROCESS_ATTACH:
		case DLL_THREAD_ATTACH:
		case DLL_THREAD_DETACH:
		case DLL_PROCESS_DETACH:
			break;
    }
    return TRUE;
}


// This is an example of an exported variable
CAMENGINE_API int nCamEngine=0;

// This is an example of an exported function.
CAMENGINE_API int fnCamEngine(void)
{
	return 42;
}

// This is the constructor of a class that has been exported.
// see CamEngine.h for the class definition
CCamEngine::CCamEngine()
{ 
	return; 
}



CAMENGINE_API int Camera_GetDevice()
{
	
    HRESULT hr;
	
	hr = FindCaptureDevice(&g_pCap, g_pGraph);
    if (FAILED(hr))
    {
        return -1000;
    }

    return 0;
}


CAMENGINE_API int Camera_Activate(void)
{
    HRESULT hr;
	int iCount = 0, iSize = 0;
	VIDEO_STREAM_CONFIG_CAPS scc;
	AM_MEDIA_TYPE *pmtConfig;
	VIDEOINFOHEADER *pVih; 

 	hr = g_pCapture->FindInterface(&PIN_CATEGORY_CAPTURE, 
							0, 
							g_pCap,
							IID_IAMStreamConfig, (void **)&g_pConfig);
    if (FAILED(hr))
    {
        return hr;
    }

	hr = g_pConfig->GetNumberOfCapabilities(&iCount, &iSize);
	if(iSize == sizeof(VIDEO_STREAM_CONFIG_CAPS))
	{
		for(int iFormat = 0; iFormat < iCount; iFormat++)
		{
			hr = g_pConfig->GetStreamCaps(iFormat, &pmtConfig, (BYTE *)&scc);
			if(SUCCEEDED(hr))
			{
				if(pmtConfig->majortype == MEDIATYPE_Video &&
					pmtConfig->subtype == MEDIASUBTYPE_RGB24 &&
					pmtConfig->formattype == FORMAT_VideoInfo &&
					pmtConfig->cbFormat >= sizeof(VIDEOINFOHEADER) &&
					pmtConfig->pbFormat != NULL)
				{
					pVih = (VIDEOINFOHEADER *)pmtConfig->pbFormat;
					
					if(pVih->bmiHeader.biWidth == SRCIMGW && pVih->bmiHeader.biHeight == SRCIMGH)
					{
						g_pConfig->SetFormat(pmtConfig);
						g_StillMediaType = *pmtConfig;
						DeleteMediaType(pmtConfig);
						break;
					}
				
				}
				DeleteMediaType(pmtConfig);
			}
		}
	}


	IBaseFilter *pSG_Filter;
	hr = CoCreateInstance(CLSID_SampleGrabber, NULL, CLSCTX_INPROC_SERVER,
		IID_IBaseFilter, (void**)&pSG_Filter);
    if( FAILED( hr ) )
    {
        return hr;

    }

	hr = g_pGraph->AddFilter(pSG_Filter, L"SampleGrab");
    if( FAILED( hr ) )
    {
        return hr;
    }

	pSG_Filter->Release();

	hr = pSG_Filter->QueryInterface(IID_ISampleGrabber, (void**)&g_pGrabber);
    if( FAILED( hr ) )
    {
        return hr;
    }

    CComQIPtr< IBaseFilter, &IID_IBaseFilter > pGrabBase( g_pGrabber );

    hr = g_pGrabber->SetMediaType( &g_StillMediaType ); // shouldn't fail
    if( FAILED( hr ) )
    {
        return hr;
    }

    // add the grabber to the graph
    //
    hr = g_pGraph->AddFilter( pGrabBase, L"Grabber" );
    if( FAILED( hr ) )
    {
        return hr;
    }

	hr = g_pCapture->RenderStream(&PIN_CATEGORY_PREVIEW, &MEDIATYPE_Video, 
    g_pCap, pGrabBase, NULL);
    if (FAILED(hr))
    {
        return hr;
    }


    hr = g_pGrabber->GetConnectedMediaType( &g_StillMediaType );
    if ( FAILED( hr) )
    {
        return hr;
    }

    hr = g_pGrabber->SetBufferSamples( FALSE );

    hr = g_pGrabber->SetOneShot( FALSE );

	hr = g_pGrabber->SetCallback(&g_StillCapCB, 1); // 0 = Use the SampleCB callback method.


	g_pMC->Run();

	g_pVW->put_Visible(OAFALSE);

	return 0;
}

CAMENGINE_API int Camera_Init(void)
{
    HRESULT hr;
	int re;

    if(FAILED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED)))
    {
        exit(1);
    } 

	hr = InitCaptureGraphBuilder(&g_pGraph, &g_pCapture);

    if (FAILED(hr))
    {
        return hr;
    }

    // Obtain interfaces for media control and Video Window
    hr = g_pGraph->QueryInterface(IID_IMediaControl,(LPVOID *) &g_pMC);
    if (FAILED(hr))
        return hr;

    hr = g_pGraph->QueryInterface(IID_IVideoWindow, (LPVOID *) &g_pVW);
    if (FAILED(hr))
        return hr;

    hr = g_pGraph->QueryInterface(IID_IMediaEvent, (LPVOID *) &g_pME);
    if (FAILED(hr))
        return hr;

	g_StillMediaType.majortype = MEDIATYPE_Video;
	g_StillMediaType.subtype = MEDIASUBTYPE_RGB24;

	re = Camera_GetDevice();
	if(re != 0)
		return re;
	re = Camera_Activate();
	if(re != 0)
		return re;
	return 0;
}



CAMENGINE_API int Camera_Exit(void)
{
    if (g_pMC)
        g_pMC->StopWhenReady();

    if(g_pVW)
    {
        g_pVW->put_Visible(OAFALSE);
        g_pVW->put_Owner(NULL);
    }
    // Release DirectShow interfaces

    SAFE_RELEASE(g_pMC);
    SAFE_RELEASE(g_pME);
    SAFE_RELEASE(g_pVW);
    SAFE_RELEASE(g_pCap);
    SAFE_RELEASE(g_pGrabber);
    SAFE_RELEASE(g_pConfig);
    SAFE_RELEASE(g_pCapture);
    SAFE_RELEASE(g_pGraph);

	CoUninitialize();

	return 0;
}

CAMENGINE_API int Camera_CaptureToFile(LPCSTR lpszFileName, BYTE *lpImage, BYTE sensorID)
{
	g_SensorID = sensorID;
	
	g_pMC->Run();
	g_pVW->put_Visible(OAFALSE);
	while(g_bOneShot)
	{
		Sleep(20);
	}
	g_bOneShot = TRUE;
	while(g_bOneShot)
	{
		Sleep(5);
	}

	SaveBitmap(&g_Result[0], RSTIMGW, RSTIMGH, lpszFileName);

	if(lpImage != NULL)
		memcpy(lpImage, &g_Result[0], RSTIMGW*RSTIMGH);
//	SaveBitmap(&g_Buffer[0], SRCIMGW, SRCIMGH, lpszFileName);

	return 0;
}

CAMENGINE_API int Camera_Capture(BYTE *lpImage, BYTE sensorID)
{
	g_SensorID = sensorID;

	g_pMC->Run();
	g_pVW->put_Visible(OAFALSE);

	while(g_bOneShot)
	{
		Sleep(20);
	}
	g_bOneShot = TRUE;
	while(g_bOneShot)
	{
		Sleep(5);
	}

	if(lpImage != NULL)
		memcpy(lpImage, &g_Result[0], RSTIMGW*RSTIMGH);
	
	return 0;
}



CAMENGINE_API void Camera_Pause()
{
	g_pMC->Pause();
	g_pVW->put_Visible(OAFALSE);

}

CAMENGINE_API void Camera_Run()
{
	g_pMC->Run();
	g_pVW->put_Visible(OAFALSE);

}