myvtm/Other/unix/libvideoframework/videocap.c

#include "precompile.h"
#include "videocap.h"
#include "ListEntry.h"
#include "qedit.h"
#include <dshow.h> // need directshow sdk
//#include "SpBase.h"

#include "../libvideohorflip/videohorflip.h"

#define av_always_inline __inline
#define inline __inline

#include <libswscale\swscale.h>
#include <libavcodec\avcodec.h>
#include "libavutil/imgutils.h"
#include "video_common/ffmpeg_api_adapter.h"


////////////////////////////////////////////////////////////////////////////////////////
// helper 
#define swap(t, x, y)	\
{	\
	t v; \
	v = x; \
	x = y; \
	y = v; \
}

int g_width= 640;
int g_height= 360;

static void i420_flip_vertical(video_frame *frame)
{
	if (frame->format == VIDEO_FORMAT_I420) {
		frame->data[0] = frame->data[0] + frame->linesize[0]*(frame->height-1);
		frame->data[1] = frame->data[1] + frame->linesize[1]*((frame->height>>1)-1);
		frame->data[2] = frame->data[2] + frame->linesize[2]*((frame->height>>1)-1);
		frame->linesize[0] = -frame->linesize[0];
		frame->linesize[1] = -frame->linesize[1];
		frame->linesize[2] = -frame->linesize[2];
		swap(unsigned char*, frame->data[1], frame->data[2]);
		swap(int, frame->linesize[1], frame->linesize[2]);
	}
}

static HRESULT AddToRot(IUnknown *pUnkGraph, DWORD *pdwRegister)
{
    IMoniker * pMoniker;
    IRunningObjectTable *pROT;
    WCHAR wsz[256];
    HRESULT hr;
    if (FAILED(GetRunningObjectTable(0, &pROT))) {
        return E_FAIL;
    }
    wsprintfW(wsz, L"FilterGraph %08x pid %08x", (DWORD_PTR)pUnkGraph, GetCurrentProcessId());
    hr = CreateItemMoniker(L"!", wsz, &pMoniker);
    if (SUCCEEDED(hr)) {
        pROT->lpVtbl->Register(pROT, ROTFLAGS_REGISTRATIONKEEPSALIVE, pUnkGraph,
            pMoniker, pdwRegister);
        pMoniker->lpVtbl->Release(pMoniker);
    }
    pROT->lpVtbl->Release(pROT);
    return hr;
}

static void RemoveFromRot(DWORD pdwRegister)
{
    IRunningObjectTable *pROT;
    if (SUCCEEDED(GetRunningObjectTable(0, &pROT))) {
        pROT->lpVtbl->Revoke(pROT, pdwRegister);
        pROT->lpVtbl->Release(pROT);
    }
}

static char* GuidToString(const GUID guid)
{
	int buf_len=64;
	char *buf =(char *)malloc(buf_len);
	_snprintf(
		buf,
		buf_len,
		"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
		guid.Data1, guid.Data2, guid.Data3,
		guid.Data4[0], guid.Data4[1],
		guid.Data4[2], guid.Data4[3],
		guid.Data4[4], guid.Data4[5],
		guid.Data4[6], guid.Data4[7]);
	//printf("%s\n",buf);
	return buf;
}

static void FreeMediaTypeEx(AM_MEDIA_TYPE *pmt)
{
    if (pmt) {
        if (pmt->cbFormat) {
            CoTaskMemFree((PVOID)pmt->pbFormat);
            pmt->cbFormat = 0;
            pmt->pbFormat = NULL;
        }
        if (pmt->pUnk) {
            pmt->pUnk->lpVtbl->Release(pmt->pUnk);
            pmt->pUnk = NULL;
        }
        CoTaskMemFree(pmt);
    }
}

static HRESULT GetUnconnectedPin(IBaseFilter *pFilter,PIN_DIRECTION PinDir,IPin **ppPin)
{
    IEnumPins *pEnum = 0;
    IPin *pPin = 0;
    HRESULT hr = pFilter->lpVtbl->EnumPins(pFilter, &pEnum);
    *ppPin = 0;

    if (FAILED(hr))
        return hr;
    while (pEnum->lpVtbl->Next(pEnum, 1, &pPin, NULL) == S_OK) {
        PIN_DIRECTION ThisPinDir;
        pPin->lpVtbl->QueryDirection(pPin, &ThisPinDir);
        if (ThisPinDir == PinDir) {
            IPin *pTmp = 0;
            hr = pPin->lpVtbl->ConnectedTo(pPin, &pTmp);
            if (SUCCEEDED(hr))  // Already connected, not the pin we want.
                pTmp->lpVtbl->Release(pTmp);
            else  // Unconnected, this is the pin we want.
            {
                pEnum->lpVtbl->Release(pEnum);
                *ppPin = pPin;
                return S_OK;
            }
        }
        pPin->lpVtbl->Release(pPin);
    }
    pEnum->lpVtbl->Release(pEnum);
    // Did not find a matching pin.
    return E_FAIL;
}

static HRESULT ConnectFilters1(IGraphBuilder *pGraph, // Filter Graph Manager.
                               IPin *pOut,            // Output pin on the upstream filter.
                               IBaseFilter *pDest)    // Downstream filter.
{
    IPin *pIn;
    HRESULT hr;

    if ((pGraph == NULL) || (pOut == NULL) || (pDest == NULL))
    {
        return E_POINTER;
    }

    // Find an input pin on the downstream filter.
    pIn = 0;
    hr = GetUnconnectedPin(pDest, PINDIR_INPUT, &pIn);
    if (FAILED(hr))
    {
        return hr;
    }
    // Try to connect them.
    hr = pGraph->lpVtbl->ConnectDirect(pGraph, pOut, pIn, NULL);
	if (FAILED(hr)){
        hr = pGraph->lpVtbl->Connect(pGraph, pOut, pIn);
	}
    pIn->lpVtbl->Release(pIn);
    return hr;
}

static HRESULT ConnectFilters2(IGraphBuilder *pGraph, IBaseFilter *pSrc, IBaseFilter *pDest)
{
    IPin *pOut;
    HRESULT hr;

    if ((pGraph == NULL) || (pSrc == NULL) || (pDest == NULL))
        return E_POINTER;
    // Find an output pin on the first filter.
    pOut = 0;
    hr = GetUnconnectedPin(pSrc, PINDIR_OUTPUT, &pOut);
    if (FAILED(hr)) 
        return hr;
    hr = ConnectFilters1(pGraph, pOut, pDest);
    pOut->lpVtbl->Release(pOut);
    return hr;
}

static HRESULT WalkFilterCategory(REFCLSID category, 
                                  HRESULT (*OnDeviceCB)(int index,IMoniker *pMoniker,VOID *pUserData1,VOID *pUserData2),
                                  VOID * pUserData1, 
                                  VOID* pUserData2)
{
    HRESULT hr;
    ICreateDevEnum *pDevEnum = NULL;
    IEnumMoniker *pEnumMoniker = NULL;
    IMoniker *pMoniker = NULL;
    BOOL quit;
    int i = 0;

    if (!OnDeviceCB)
        return E_INVALIDARG;

    hr = CoCreateInstance(&CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, 
        &IID_ICreateDevEnum, (void**)&pDevEnum);
    if (FAILED(hr)) 
        return hr;
    hr = pDevEnum->lpVtbl->CreateClassEnumerator(pDevEnum, category, 
        &pEnumMoniker, 0);
    if (FAILED(hr)) {
        pDevEnum->lpVtbl->Release(pDevEnum);
        return hr;
    } else if (hr == S_OK) {
		pEnumMoniker->lpVtbl->Reset(pEnumMoniker);
		quit = FALSE;
		while (pEnumMoniker->lpVtbl->Next(pEnumMoniker, 1, &pMoniker, NULL) == S_OK && !quit) {
			hr = OnDeviceCB(i++, pMoniker, pUserData1, pUserData2);
			quit = FAILED(hr) || (hr == S_OK);
			pMoniker->lpVtbl->Release(pMoniker);
		}
		pEnumMoniker->lpVtbl->Release(pEnumMoniker);
		pDevEnum->lpVtbl->Release(pDevEnum);
	} else {
		if (pEnumMoniker)
			pEnumMoniker->lpVtbl->Release(pEnumMoniker);
		pDevEnum->lpVtbl->Release(pDevEnum);
	}
    return hr;
}

static HRESULT CreateFilterByFriendlyNameCB(int index, IMoniker *pMoniker, void *pUserData1, void *pUserData2)
{
    HRESULT hr;
    IBaseFilter *pBaseFilter = NULL;
    WCHAR *szName = (WCHAR*)pUserData2;
    if (pMoniker) {
		IPropertyBag *pPropBag;
		VARIANT name;
		hr = pMoniker->lpVtbl->BindToStorage(pMoniker, NULL, NULL, 
			&IID_IPropertyBag, (void**)&pPropBag);
		if (FAILED(hr))
			return S_FALSE;
		VariantInit(&name);
		name.vt = VT_BSTR;
		hr = pPropBag->lpVtbl->Read(pPropBag, L"FriendlyName", &name, NULL);
		if (FAILED(hr)) {
			pPropBag->lpVtbl->Release(pPropBag);
			VariantClear(&name);
			return S_FALSE;
		}
		if (SysStringByteLen(name.bstrVal) && wcscmp(name.bstrVal, szName)==0) {
			hr = pMoniker->lpVtbl->BindToObject(pMoniker, NULL, NULL, 
				&IID_IBaseFilter, (void**)&pBaseFilter);
			if (SUCCEEDED(hr)) {
				*(IBaseFilter**)pUserData1 = pBaseFilter;
				hr = S_OK;
			}
		}
        pPropBag->lpVtbl->Release(pPropBag);
        VariantClear(&name);
    } else {
        hr = E_POINTER;
    }
    return hr;
}

static HRESULT CreateFilterByFriendlyName(REFCLSID category, void **ppBaseFilter, WCHAR* szName)
{
    HRESULT hr = WalkFilterCategory(category, 
        &CreateFilterByFriendlyNameCB, ppBaseFilter, szName);
    return hr == S_FALSE ? E_NOINTERFACE : hr;
}

static HRESULT CreateFilterByIndexCB(int index, IMoniker *pMoniker, void *pUserData1, void *pUserData2)
{
    HRESULT hr;
    IBaseFilter *pBaseFilter = NULL;
    int *pidx = (int*)pUserData2;
    if (pMoniker && index == *pidx) {
        hr = pMoniker->lpVtbl->BindToObject(pMoniker, NULL, NULL, 
            &IID_IBaseFilter, (void**)&pBaseFilter);
        if (FAILED(hr))
            return hr;
        *(IBaseFilter**)pUserData1 = pBaseFilter;
        return S_OK;
    }
    return S_FALSE;
}

static HRESULT CreateFilterByIndex(REFCLSID category,
                                   void **ppBaseFilter,
                                   int idx)
{
    HRESULT hr = WalkFilterCategory(category, &CreateFilterByIndexCB,
        ppBaseFilter, &idx);
    return hr == S_FALSE ? E_NOINTERFACE : hr;
}

static HRESULT RemoveGraphAllFilters(IGraphBuilder *pGraphBuilder)
{
    HRESULT hr;
    IEnumFilters *pEnumFilters;
    if (!pGraphBuilder)
        return E_POINTER;
    hr = pGraphBuilder->lpVtbl->EnumFilters(pGraphBuilder, &pEnumFilters);
    if (SUCCEEDED(hr)) {
        IBaseFilter *pFilter;
        pEnumFilters->lpVtbl->Reset(pEnumFilters);
        while (pEnumFilters->lpVtbl->Next(pEnumFilters, 1, &pFilter, NULL) == S_OK) {
            pGraphBuilder->lpVtbl->RemoveFilter(pGraphBuilder, pFilter);
            pFilter->lpVtbl->Release(pFilter);
            pEnumFilters->lpVtbl->Reset(pEnumFilters);
        }
        pEnumFilters->lpVtbl->Release(pEnumFilters);
    }
    return hr;
}

////////////////////////////////////////////////////////////////////////////////////////////////

static const int mode_width[VIDEOCAP_MAX_MODE] = {
    VIDEOCAP_SQCIF_WIDTH,VIDEOCAP_QQVGA_WIDTH, 
    VIDEOCAP_QCIF_WIDTH,VIDEOCAP_QVGA_WIDTH,
    VIDEOCAP_CIF_WIDTH,VIDEOCAP_VGA_WIDTH,
    VIDEOCAP_4CIF_WIDTH,VIDEOCAP_SVGA_WIDTH,
	VIDEOCAP_NHD_WIDTH,VIDEOCAP_SXGA_WIDTH,
	VIDEOCAP_720P_WIDTH,VIDEOCAP_1080P_WIDTH,
};

static const int mode_height[VIDEOCAP_MAX_MODE] = {
    VIDEOCAP_SQCIF_HEIGHT,VIDEOCAP_QQVGA_HEIGHT, 
    VIDEOCAP_QCIF_HEIGHT,VIDEOCAP_QVGA_HEIGHT,
    VIDEOCAP_CIF_HEIGHT,VIDEOCAP_VGA_HEIGHT,
    VIDEOCAP_4CIF_HEIGHT,VIDEOCAP_SVGA_HEIGHT,
	VIDEOCAP_NHD_HEIGHT,VIDEOCAP_SXGA_HEIGHT,
	VIDEOCAP_720P_HEIGHT,VIDEOCAP_1080P_HEIGHT,
};

typedef struct async_cap_t
{
	LIST_ENTRY entry;
	HANDLE evt;
	int result;
	video_frame *ref_cap_frame;
}async_cap_t;

/**
 * we use DirectShow to capture video frames
 */
typedef struct videocap
{
    IBaseFilter *sourcefilter;
	IBaseFilter *cpcfilter; // color space converter if necessary
	IBaseFilter *avidecfilter;
    IBaseFilter *grabberfilter;
	IBaseFilter *horflipfilter;
    IBaseFilter *renderfilter;
    ISampleGrabber *grabber;
    IGraphBuilder *graphbuilder;
    IMediaControl *mc;
    IMediaEvent *me;
    IVideoWindow *videowindow;

#ifdef _DEBUG
    DWORD dwROTRegister; // register RunningObjectTable
#endif

    videocap_param param;

    int running;

    HANDLE thread_background;
    HANDLE evt_thread_exit;

    int cap_index;
    CRITICAL_SECTION cap_cs;
    video_frame cap_frame;

	CRITICAL_SECTION async_cap_cs;
	LIST_ENTRY async_cap_list;

	LONG grab_cb_count;

    CRITICAL_SECTION res_cs;
    video_frame res_frame;
    struct SwsContext *sws_context; /* for image scaling and format converting */
} videocap;

HRESULT set_video_source_format(videocap *);
void release_all_interfaces(videocap *);

typedef struct ISampleGrabberCBImpl
{
    struct ISampleGrabberCBVtbl *lpVtbl;
    struct videocap* vcap;
    struct ISampleGrabberCBVtbl vtbl;
}ISampleGrabberCBImpl;
static HRESULT STDMETHODCALLTYPE QueryInterface(ISampleGrabberCB * This, 
                                                REFIID riid, 
                                                void** ppvObject)
{
    if (This == NULL || riid == NULL || ppvObject == NULL || *ppvObject == NULL)
        return E_POINTER;
    if (IsEqualIID(riid, &IID_IUnknown)) {
        *ppvObject = (void*)This;
        return S_OK;
    } else if (IsEqualIID(riid, &IID_ISampleGrabberCB)) {
        *ppvObject = (void*)This;
        return S_OK;
    }
    return E_NOTIMPL;
}
static ULONG STDMETHODCALLTYPE AddRef(ISampleGrabberCB * This)
{
    return 1;
}
static ULONG STDMETHODCALLTYPE Release(ISampleGrabberCB * This)
{
    free(This);
    return 0;
}
static HRESULT STDMETHODCALLTYPE SampleCB(ISampleGrabberCB * This, double SampleTime,IMediaSample *pSample)
{
    return E_NOTIMPL;
}
static HRESULT STDMETHODCALLTYPE BufferCB(ISampleGrabberCB * This, double SampleTime,BYTE *pBuffer,long BufferLen)
{
	ISampleGrabberCBImpl *pImpl = (ISampleGrabberCBImpl *)This;
	videocap *vcap = pImpl->vcap;
	int linesize = BufferLen / mode_height[vcap->param.cap_mode];
	struct SwsContext *sws;
	char*Buffertmp=(char*)malloc(mode_width[vcap->param.cap_mode]*mode_height[vcap->param.cap_mode]*3);
	uint8_t *src_data[4];
	int src_linesize[4];
	unsigned char *dst[4] = {(unsigned char*)Buffertmp,NULL,NULL,NULL};
	int dst_linesize[4] = {mode_width[vcap->param.cap_mode]*3,0,0,0};
	char*buffer;
	int oriLen = mode_height[vcap->param.cap_mode]*mode_width[vcap->param.cap_mode]*3;
	get_output_mediatype(vcap);
	//MFLog(LM_SYSTEM,(LB,"BufferLen=%d,w=%d,h=%d, g_width=%d,g_height=%d",BufferLen,mode_width[vcap->param.cap_mode], mode_height[vcap->param.cap_mode],g_width,g_height));
	if (BufferLen != oriLen)
	{
		//计算目标图像比例
		int srcH;
		//float fDstScale = (float)(mode_width[vcap->param.cap_mode]/mode_height[vcap->param.cap_mode]);
		float fDstScale = (float)mode_width[vcap->param.cap_mode]/(float)mode_height[vcap->param.cap_mode];
		float fSrcScale = (float)g_width/(float)g_height;
		//MFLog(LM_SYSTEM,(LB,"fDstScale=%f, fSrcScale=%f", fDstScale, fSrcScale));
		if (fSrcScale!=fDstScale)
		{
			//计算偏移量
			int nWidth,nHeight,nOffset=0;
			if (fSrcScale > fDstScale)
			{  
				//宽度过大
				//nHeight = g_height;
				//nWidth = g_height*fDstScale;
				//nOffset = (g_height-nHeight)/2*nWidth*3;
				//MFLog(LM_SYSTEM,(LB,"too width"));
				return 0;
			}
			else if (fSrcScale < fDstScale)
			{
				//高度过长
				nWidth = g_width;
				nHeight = (int)ceil(g_width/fDstScale);
				nOffset = (g_height-nHeight)/2*nWidth*3;
				//MFLog(LM_SYSTEM,(LB,"too height,nWidth=%d,nHeight=%d,nOffset=%d",nWidth,nHeight,nOffset));
			}
			//计算等比例变换需要的SWS
			sws=sws_getContext(nWidth,nHeight,PIX_FMT_BGR24, mode_width[vcap->param.cap_mode], mode_height[vcap->param.cap_mode], PIX_FMT_BGR24, SWS_BICUBIC, NULL, NULL, NULL);
			av_image_alloc(src_data, src_linesize,g_width,g_height, PIX_FMT_BGR24, 1);
			memcpy(src_data[0],pBuffer+nOffset,nWidth*nHeight*3);                    //Y
			srcH = nHeight;
		}
		else
		{
			//MFLog(LM_SYSTEM,(LB,"need scale"));
			//计算等比例变换需要的SWS
			sws=sws_getContext(g_width,g_height,PIX_FMT_BGR24, mode_width[vcap->param.cap_mode], mode_height[vcap->param.cap_mode], PIX_FMT_BGR24, SWS_BICUBIC, NULL, NULL, NULL);
			av_image_alloc(src_data, src_linesize,g_width,g_height, PIX_FMT_BGR24, 1);
			memcpy(src_data[0],pBuffer,BufferLen);                    //Y
			srcH = g_height;
		}

		//分辨率转换
		sws_scale(sws, src_data, src_linesize, 0, srcH, dst, dst_linesize);
		sws_freeContext(sws);
		av_freep(&src_data[0]); 
		buffer = Buffertmp;
		BufferLen = mode_width[vcap->param.cap_mode]*mode_height[vcap->param.cap_mode]*3;
	}
	else
	{
		//MFLog(LM_SYSTEM,(LB,"normal"));
		buffer = (char*)pBuffer;
	}

	linesize = BufferLen / mode_height[vcap->param.cap_mode];
	if (vcap->param.option & VIDEOCAP_OPT_ENABLE_GRAB) 
	{
		if (vcap->cap_index++%3 == 0) 
		{ /* 3 is grabbing interval */
			EnterCriticalSection(&vcap->cap_cs);
			//memcpy(vcap->cap_frame.data[0], pBuffer, BufferLen);
			memcpy(vcap->cap_frame.data[0], buffer, BufferLen);
			LeaveCriticalSection(&vcap->cap_cs);
		}
	}

	if (vcap->grab_cb_count) 
	{
		if (vcap->param.on_grab) 
		{
			video_frame frm = {0};
			frm.data[0] = buffer;
			frm.linesize[0] = linesize;
			frm.width = mode_width[vcap->param.cap_mode];
			frm.height = mode_height[vcap->param.cap_mode];
			frm.format = VIDEO_FORMAT_RGB24;
			vcap->param.on_grab(vcap->param.user_data, &frm);
		}
		InterlockedDecrement(&vcap->grab_cb_count);
	}
	if (vcap->param.option & VIDEOCAP_OPT_ENABLE_ASYNC_GRAB) 
	{
		async_cap_t *pos, *n;
		EnterCriticalSection(&vcap->async_cap_cs);
		ListEntry_ForEachSafe(pos, n, &vcap->async_cap_list, async_cap_t, entry) 
		{
			ListEntry_DeleteNode(&pos->entry);
			pos->result = 0;
			memcpy(pos->ref_cap_frame->data[0], buffer, BufferLen);
			SetEvent(pos->evt);
		}
		LeaveCriticalSection(&vcap->async_cap_cs);
	}
	if (vcap->param.on_frame_raw) 
	{
		video_frame frm = {0};
		frm.data[0] = buffer;
		frm.linesize[0] = linesize;
		frm.width = mode_width[vcap->param.cap_mode];
		frm.height = mode_height[vcap->param.cap_mode];
		frm.format = VIDEO_FORMAT_RGB24;
		vcap->param.on_frame_raw(vcap->param.user_data, &frm);
	}
	if (vcap->param.option & VIDEOCAP_OPT_EANBLE_RESIZE) 
	{ /* user enable resizing */
		unsigned char *src_data[4];
		int src_linesize[4] = {linesize, 0, 0, 0};

			src_data[0] = (unsigned char*)buffer; 
			src_data[1] = NULL; 
			src_data[2] = NULL; 
			src_data[3] = NULL; 

		EnterCriticalSection(&vcap->res_cs);
		if (vcap->param.option & VIDEOCAP_OPT_ENABLE_FLIP) 
		{
			src_data[0] += (mode_height[vcap->param.cap_mode]-1)*src_linesize[0];
			src_linesize[0] = -src_linesize[0];
			sws_scale(vcap->sws_context, src_data, src_linesize, 0, mode_height[vcap->param.cap_mode], vcap->res_frame.data, vcap->res_frame.linesize);
		} 
		else 
		{
			sws_scale(vcap->sws_context, src_data, src_linesize, 
				0, mode_height[vcap->param.cap_mode], vcap->res_frame.data, vcap->res_frame.linesize);
		}
		if (vcap->param.on_frame) 
		{
			vcap->param.on_frame(vcap->param.user_data, &vcap->res_frame);
		}
		LeaveCriticalSection(&vcap->res_cs);
	} 
	else 
	{
		if (vcap->param.on_frame) 
		{
			video_frame frame;
			memset(&frame, 0, sizeof(video_frame));
			frame.width = mode_width[vcap->param.cap_mode];
			frame.height = mode_height[vcap->param.cap_mode];
			frame.data[0] = buffer;
			frame.linesize[0] = linesize;
			frame.format = VIDEO_FORMAT_RGB24;
			vcap->param.on_frame(vcap->param.user_data, &frame);
			//MFLog(LM_SYSTEM,(LB,"normal"));
		}
	}

	free(Buffertmp);
	return S_OK;
}
static ISampleGrabberCB* CreateISampleGrabberCBImpl(videocap *vcap)
{
    ISampleGrabberCBImpl *pImpl = 
        (ISampleGrabberCBImpl*)malloc(sizeof(ISampleGrabberCBImpl));
    if (pImpl) {
        pImpl->lpVtbl = &pImpl->vtbl;
        pImpl->lpVtbl->QueryInterface = &QueryInterface;
        pImpl->lpVtbl->AddRef = &AddRef;
        pImpl->lpVtbl->Release = &Release;
        pImpl->lpVtbl->BufferCB = &BufferCB;
        pImpl->lpVtbl->SampleCB = &SampleCB;
        pImpl->vcap = vcap;
    }
    return (ISampleGrabberCB*)pImpl;
}

static HRESULT TryConnectFilters(IGraphBuilder *pGraphBuilder, int cnt, IBaseFilter *pFilters[])
{
	HRESULT hr = S_OK;
	int i;

	if (!pGraphBuilder)
		return E_POINTER;
	if (cnt == 0)
		return S_OK;
	if (!pFilters)
		return E_POINTER;

	for (i = 1; i < cnt; ++i) 
	{
		IBaseFilter *src = pFilters[i-1];
		IBaseFilter *dst = pFilters[i];
		if (!src || !dst)
			return E_POINTER;
		hr = ConnectFilters2(pGraphBuilder, src, dst);
		
		if (FAILED(hr)) 
		{
			return hr;
		}
	}

	return hr;
}


////////////////////////////////////////////////////////////////////////////////////////////////

/* used for device lost event listenning */
static DWORD WINAPI BackgroundThread(LPVOID *param)
{
    struct videocap *vcap = (struct videocap *)param;
    int quit = 0;
    HANDLE t;
    HANDLE evts[2] = {0};
    HANDLE hProcess = GetCurrentProcess();
    HRESULT hr;

    hr = vcap->me->lpVtbl->GetEventHandle(vcap->me, (OAEVENT*)&t);
    if (FAILED(hr))
        return 0;
    if (DuplicateHandle(hProcess, t, hProcess, &evts[0], DUPLICATE_SAME_ACCESS, FALSE, DUPLICATE_SAME_ACCESS) == FALSE)
        return 0;
    evts[1] = vcap->evt_thread_exit;

    while (!quit) 
	{
        DWORD dwResult = WaitForMultipleObjects(2, evts, FALSE, INFINITE) - WAIT_OBJECT_0;
        if (0 == dwResult) 
		{
            long lEventCode;
            LONG_PTR lParam1;
            LONG_PTR lParam2;
            vcap->me->lpVtbl->GetEvent(vcap->me, &lEventCode, &lParam1, &lParam2, INFINITE);
            if (lEventCode == EC_DEVICE_LOST || lEventCode == EC_ERRORABORT) 
			{
                if (vcap->param.on_device_lost)
                    (*vcap->param.on_device_lost)(vcap->param.user_data);
                quit = 1;
            }
            vcap->me->lpVtbl->FreeEventParams(vcap->me, lEventCode, lParam1, lParam2);
        } 
		else 
		{
            quit = 1;
        }
    }

    CloseHandle(evts[0]);

    return 0;
}

////////////////////////////////////////////////////////////////////////////////////////////////

int videocap_create(videocap_t *h ,videocap_param *param)
{
    videocap *vcap;
	    //RvcLog_init("./videoframework",1);
    /* check param */
    if (!param)
        return -1;
    if (param->cap_mode < 0 || param->cap_mode >= VIDEOCAP_MAX_MODE)
        return -1;
    if (param->frame_fmt != VIDEO_FORMAT_I420 && param->frame_fmt != VIDEO_FORMAT_RGB24)
        return -1;
    if (param->fps < 1.0 ||
        param->fps > 100.0)
        return -1;
    if (param->pre_hwnd) 
	{
        if (!IsWindow(param->pre_hwnd))
            return -1;
        if (param->pre_width < 0)
            return -1;
        if (param->pre_height < 0)
            return -1;
    }
    if (param->dev_id < 0)
        return -1;
    if (param->frame_fmt == VIDEO_FORMAT_I420 && !(param->option&VIDEOCAP_OPT_EANBLE_RESIZE)) {
        param->res_mode = param->cap_mode;
        param->option |= VIDEOCAP_OPT_EANBLE_RESIZE;
    }
    if (param->option & VIDEOCAP_OPT_EANBLE_RESIZE) { 
        if (param->res_mode < VIDEOCAP_FRAME_SQCIF || param->res_mode > VIDEOCAP_FRAME_SVGA)
            return -1;
    }

    vcap = (videocap*)malloc(sizeof(videocap));
    if (!vcap)
        return -1;
    ZeroMemory((void*)vcap, sizeof(videocap));
    memcpy(&vcap->param, param, sizeof(videocap_param));
    if (param->option & VIDEOCAP_OPT_ENABLE_GRAB) {
        int width = mode_width[param->cap_mode];
        int height = mode_height[param->cap_mode];
        if (video_frame_alloc(width, height, VIDEO_FORMAT_RGB24, &vcap->cap_frame) != 0) {
            free(vcap);
            return -1;
        }
		video_frame_fill_black(&vcap->cap_frame);
        InitializeCriticalSection(&vcap->cap_cs);
    }
	if (param->option & VIDEOCAP_OPT_ENABLE_ASYNC_GRAB) {
		InitializeCriticalSection(&vcap->async_cap_cs);
	}
    if (param->option & VIDEOCAP_OPT_EANBLE_RESIZE) {
        int width = mode_width[param->res_mode];
        int height = mode_height[param->res_mode];
        if (video_frame_alloc(width, height, param->frame_fmt, &vcap->res_frame) != 0) {
            if (param->option & VIDEOCAP_OPT_ENABLE_GRAB) {
                DeleteCriticalSection(&vcap->cap_cs);
                video_frame_free(&vcap->cap_frame);
            }
            free(vcap);
            return -1;
        }
		video_frame_fill_black(&vcap->res_frame);
        vcap->sws_context = sws_getContext(mode_width[param->cap_mode], 
            mode_height[param->cap_mode], 
            PIX_FMT_BGR24,
            mode_width[param->res_mode],
            mode_height[param->res_mode], 
            vcap->param.frame_fmt==VIDEO_FORMAT_RGB24 ? PIX_FMT_BGR24 : PIX_FMT_YUV420P,
            SWS_FAST_BILINEAR,
            NULL,
            NULL,
            NULL);
        if (!vcap->sws_context) {
            video_frame_free(&vcap->res_frame);
            if (param->option & VIDEOCAP_OPT_ENABLE_GRAB) {
                DeleteCriticalSection(&vcap->cap_cs);
                video_frame_free(&vcap->cap_frame);
            }
            free(vcap);
            return -1;
        }
        InitializeCriticalSection(&vcap->res_cs);
    }
    *h = vcap;
    return 0;
}



void videocap_destroy(videocap_t h)
{
    if (h->param.option & VIDEOCAP_OPT_ENABLE_GRAB) {
        DeleteCriticalSection(&h->cap_cs);
        video_frame_free(&h->cap_frame);
    }
	if (h->param.option & VIDEOCAP_OPT_ENABLE_ASYNC_GRAB) {
		DeleteCriticalSection(&h->async_cap_cs);
	}
    if (h->param.option & VIDEOCAP_OPT_EANBLE_RESIZE) {
        sws_freeContext(h->sws_context);
        DeleteCriticalSection(&h->res_cs);
        video_frame_free(&h->res_frame);
    }
    free(h);
}

int videocap_adj_brightness(videocap_t h, int nValue)
{
	IAMVideoProcAmp *pProcAmp = 0;
	HRESULT hr = h->sourcefilter->lpVtbl->QueryInterface(h->sourcefilter, &IID_IAMVideoProcAmp, (void**)&pProcAmp);
	if(SUCCEEDED(hr))
	{
		long Min, Max, Step, Default, Flags, Val;
		// 亮度. 
		if(( nValue > 0 )&&(nValue < 100 ))
		{
			hr = pProcAmp->lpVtbl->GetRange(pProcAmp, VideoProcAmp_Brightness, &Min, &Max, &Step,
				&Default, &Flags);
			if(SUCCEEDED(hr))
			{
				Flags = VideoProcAmp_Flags_Manual;
				hr = pProcAmp->lpVtbl->Get(pProcAmp,VideoProcAmp_Brightness, &Val, &Flags);
				Val = ((Max-Min)*nValue/100)+Min;
				if (Val>Max)
				{
					Val = Max;
				}
				else if (Val<Min)
				{
					Val = Min;
				}
				hr = pProcAmp->lpVtbl->Set(pProcAmp,VideoProcAmp_Brightness, Val, Flags);
			}
		}
	}
	return hr;
}

int videocap_set_autobrightness(videocap_t h)
{
	IAMVideoProcAmp *pProcAmp = 0;
	HRESULT hr = h->sourcefilter->lpVtbl->QueryInterface(h->sourcefilter, &IID_IAMVideoProcAmp, (void**)&pProcAmp);
	if(SUCCEEDED(hr))
	{
		long Min, Max, Step, Default, Flags, Val;
		// 亮度. 
		hr = pProcAmp->lpVtbl->GetRange(pProcAmp, VideoProcAmp_Brightness, &Min, &Max, &Step,
			&Default, &Flags);
		if(SUCCEEDED(hr))
		{
			Flags = VideoProcAmp_Flags_Auto;
			Val = Min + (Max-Min)/2;
			hr = pProcAmp->lpVtbl->Set(pProcAmp,VideoProcAmp_Brightness, Val, Flags);
		}
	}
	return hr;
}

int videocap_get_brightness(videocap_t h,int*nValue)
{
	IAMVideoProcAmp *pProcAmp = 0;
	HRESULT hr = h->sourcefilter->lpVtbl->QueryInterface(h->sourcefilter, &IID_IAMVideoProcAmp, (void**)&pProcAmp);
	if(SUCCEEDED(hr))
	{
		long Min, Max, Step, Default, Flags, Val;
		// 亮度. 
		hr = pProcAmp->lpVtbl->GetRange(pProcAmp, VideoProcAmp_Brightness, &Min, &Max, &Step,
			&Default, &Flags);
		if(SUCCEEDED(hr))
		{
			hr = pProcAmp->lpVtbl->Get(pProcAmp,VideoProcAmp_Brightness, &Val, &Flags);
			*nValue = (Val-Min)*100/(Max-Min);
		}
	}
	return hr;
}

int videocap_start(videocap_t h)
{
    HRESULT hr;

    if (!h)
        return VIDEOCAP_ERROR;

	h->grab_cb_count = 0;

	ListEntry_InitHead(&h->async_cap_list);

    // create filter graph
    hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
        &IID_IGraphBuilder, (void**)&h->graphbuilder);
    if (FAILED(hr))
	{
		//Dbg("CoCreateInstance failed.");
        goto on_error;
	}
    hr = h->graphbuilder->lpVtbl->QueryInterface(h->graphbuilder, 
        &IID_IMediaControl, (void**)&h->mc);
    if (FAILED(hr))
	{
		//Dbg("QueryInterface failed.");
        goto on_error;
	}
    hr = h->graphbuilder->lpVtbl->QueryInterface(h->graphbuilder, 
        &IID_IMediaEvent, (void**)&h->me);
    if (FAILED(hr))
	{
		//Dbg("QueryInterface IID_IMediaEvent failed.");
		goto on_error;
	}

#ifdef _DEBUG
    {
        IUnknown *pUnk;
        hr = h->graphbuilder->lpVtbl->QueryInterface(h->graphbuilder, 
            &IID_IUnknown, (void**)&pUnk);
        if (FAILED(hr))
            goto on_error;
        hr = AddToRot(pUnk, &h->dwROTRegister);
        pUnk->lpVtbl->Release(pUnk);
        if (FAILED(hr))
            goto on_error;
    }
#endif

    /* create video source filter and add to graph */
	hr = CreateFilterByIndex(&CLSID_VideoInputDeviceCategory, 
		(void**)&h->sourcefilter, h->param.dev_id);
	if (FAILED(hr))
	{
		goto on_error;
	}
	hr = h->graphbuilder->lpVtbl->AddFilter(h->graphbuilder, h->sourcefilter, L"videosource");
	if (FAILED(hr))
		goto on_error;
	hr = set_video_source_format((videocap*)h);
	if (FAILED(hr))
	{
		goto on_error;
	}
	hr = CoCreateInstance(&CLSID_Colour, NULL, CLSCTX_INPROC_SERVER,
		&IID_IBaseFilter, (void**) &h->cpcfilter);
	if (FAILED(hr))
	{
		goto on_error;
	}
	hr = h->graphbuilder->lpVtbl->AddFilter(h->graphbuilder, h->cpcfilter, L"cpcfilter");
	if (FAILED(hr))
	{
		goto on_error;
	}
	hr = CoCreateInstance(&CLSID_AVIDec, NULL, CLSCTX_INPROC_SERVER,
		&IID_IBaseFilter, (void**) &h->avidecfilter);
	if (FAILED(hr))
	{
		goto on_error;
	}
	hr = h->graphbuilder->lpVtbl->AddFilter(h->graphbuilder, h->avidecfilter, L"avidecfilter");
	if (FAILED(hr))
	{
		goto on_error;
	}
    // create grabber filter and add to graph
    hr = CoCreateInstance(&CLSID_SampleGrabber, NULL, CLSCTX_INPROC_SERVER,
			&IID_IBaseFilter, (void**) &h->grabberfilter);
    if (FAILED(hr))
	{
		goto on_error;
	}
    hr = h->graphbuilder->lpVtbl->AddFilter(h->graphbuilder, h->grabberfilter, L"grabber");
    if (FAILED(hr))
	{
		goto on_error;
	}
    hr = h->grabberfilter->lpVtbl->QueryInterface(h->grabberfilter, 
        &IID_ISampleGrabber, (void**)&h->grabber);
    if (FAILED(hr))
	{
		goto on_error;
	}

	if (1)
	{
		int width = mode_width[h->param.cap_mode];
		int height = mode_height[h->param.cap_mode];
		AM_MEDIA_TYPE *mt = (AM_MEDIA_TYPE*)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
		VIDEOINFOHEADER *pvi = (VIDEOINFOHEADER*)CoTaskMemAlloc(sizeof(VIDEOINFOHEADER));
		memset(mt, 0, sizeof(AM_MEDIA_TYPE));
		memset(pvi, 0, sizeof(VIDEOINFOHEADER));
		mt->lSampleSize = width * height * 3;
		mt->majortype = MEDIATYPE_Video;
		mt->subtype = MEDIASUBTYPE_RGB24;
		mt->formattype = FORMAT_VideoInfo;
		mt->bFixedSizeSamples = TRUE;
		mt->bTemporalCompression = FALSE;
		mt->cbFormat = sizeof(VIDEOINFOHEADER);
		mt->pbFormat = (BYTE*)pvi;
		pvi->bmiHeader.biWidth = width;
		pvi->bmiHeader.biHeight = height;
		pvi->bmiHeader.biSizeImage = width * height * 3;
		pvi->bmiHeader.biBitCount = 24;
		pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
		pvi->AvgTimePerFrame = (REFERENCE_TIME)(10000000 / h->param.fps);
		pvi->dwBitRate = (DWORD)(width*height*24*h->param.fps);
		hr = h->grabber->lpVtbl->SetMediaType(h->grabber, mt);
		FreeMediaTypeEx(mt);
		if (FAILED(hr))
		{
			//Dbg("SetMediaType error, err=%08xd", hr);
			goto on_error;
		}
	}
	
    h->grabber->lpVtbl->SetOneShot(h->grabber, FALSE);
    {
        ISampleGrabberCB *pImpl = CreateISampleGrabberCBImpl(h);
        if (!pImpl)
            goto on_error;
		// 0: SampleCB
		// 1: BufferCB
        h->grabber->lpVtbl->SetCallback(h->grabber, pImpl, 1);////////////////////////
    }
	if (h->param.option & VIDEOCAP_OPT_HOZFLIP) {
		h->horflipfilter = (IBaseFilter*)videohorflip_create_filter();
		if (!h->horflipfilter)
			goto on_error;
		hr = h->graphbuilder->lpVtbl->AddFilter(h->graphbuilder, h->horflipfilter, L"horflip");
		if (FAILED(hr))
		{	
			goto on_error;
		}
	}
    // create render filter and add to graph
    {
        hr = CoCreateInstance(h->param.pre_hwnd ? &CLSID_VideoRendererDefault : &CLSID_NullRenderer, 
            NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (void**) &h->renderfilter);
        if (FAILED(hr))
            goto on_error;
    }
    hr = h->graphbuilder->lpVtbl->AddFilter(h->graphbuilder, h->renderfilter, L"renderfilter");
    if (FAILED(hr))
	{  
		goto on_error;
	}

	// try connect filters
	if (!(h->param.option & VIDEOCAP_OPT_HOZFLIP)) {
		IBaseFilter *Filter1[] = {h->sourcefilter, h->grabberfilter, h->renderfilter};
		IBaseFilter *Filter2[] = {h->sourcefilter, h->cpcfilter, h->grabberfilter, h->renderfilter};
		IBaseFilter *Filter3[] = {h->sourcefilter, h->avidecfilter, h->grabberfilter, h->renderfilter};
		IBaseFilter *Filter4[] = {h->sourcefilter, h->avidecfilter, h->cpcfilter, h->grabberfilter, h->renderfilter};
		struct {
			int cnt;
			IBaseFilter **Filters;
		} tpl[] = {
			{ARRAYSIZE(Filter1), Filter1},
			{ARRAYSIZE(Filter2), Filter2},
			{ARRAYSIZE(Filter3), Filter3},
			{ARRAYSIZE(Filter4), Filter4},
		};
		int i;
		for (i = 0; i < ARRAYSIZE(tpl); ++i) {
			Sleep(50);
			hr = TryConnectFilters(h->graphbuilder, tpl[i].cnt, tpl[i].Filters);
			if (SUCCEEDED(hr)) {
				break;
			}
		}
		if (i == ARRAYSIZE(tpl)) {
			goto on_error;
		}
	} else {
		IBaseFilter *Filter1[] = {h->sourcefilter, h->grabberfilter, h->horflipfilter, h->renderfilter};
		IBaseFilter *Filter2[] = {h->sourcefilter, h->cpcfilter, h->grabberfilter, h->horflipfilter, h->renderfilter};
		IBaseFilter *Filter3[] = {h->sourcefilter, h->avidecfilter, h->grabberfilter, h->horflipfilter, h->renderfilter};
		IBaseFilter *Filter4[] = {h->sourcefilter, h->avidecfilter, h->cpcfilter, h->grabberfilter, h->horflipfilter, h->renderfilter};
		struct {
			int cnt;
			IBaseFilter **Filters;
		} tpl[] = {
			{ARRAYSIZE(Filter1), Filter1},
			{ARRAYSIZE(Filter2), Filter2},
			{ARRAYSIZE(Filter3), Filter3},
			{ARRAYSIZE(Filter4), Filter4},
		};
		int i;
		for (i = 0; i < ARRAYSIZE(tpl); ++i) {
			Sleep(50);
			hr = TryConnectFilters(h->graphbuilder, tpl[i].cnt, tpl[i].Filters);
			if (SUCCEEDED(hr)) {
				break;
			}
		}
		if (i == ARRAYSIZE(tpl)) {
			goto on_error;
		}
	}

	if (h->param.pre_hwnd) {
        RECT rc;
        hr = h->renderfilter->lpVtbl->QueryInterface(h->renderfilter, 
            &IID_IVideoWindow, (void**)&h->videowindow);
        if (FAILED(hr))
		{  
			goto on_error;
		}
        GetClientRect(h->param.pre_hwnd, &rc);
        h->videowindow->lpVtbl->put_Owner(h->videowindow, (OAHWND)h->param.pre_hwnd);
        h->videowindow->lpVtbl->put_Visible(h->videowindow, OAFALSE);
        h->videowindow->lpVtbl->put_Left(h->videowindow, 0);
        h->videowindow->lpVtbl->put_Top(h->videowindow, 0);
        h->videowindow->lpVtbl->put_Height(h->videowindow, min(h->param.pre_height, rc.bottom-rc.top));
        h->videowindow->lpVtbl->put_Width(h->videowindow, min(h->param.pre_width, rc.right - rc.left));
        h->videowindow->lpVtbl->put_WindowStyle(h->videowindow,
            WS_CHILD|WS_VISIBLE|WS_CLIPCHILDREN|WS_CLIPSIBLINGS);
        h->videowindow->lpVtbl->put_MessageDrain(h->videowindow, (OAHWND)h->param.pre_hwnd);
        h->videowindow->lpVtbl->put_Visible(h->videowindow, OATRUE);
    }

    if (h->param.on_device_lost) {
        h->thread_background = CreateThread(NULL, 0, &BackgroundThread, h, 0, 0);
        h->evt_thread_exit = CreateEvent(NULL, FALSE, FALSE, NULL);
    }

    hr = h->mc->lpVtbl->Run(h->mc);
    if (FAILED(hr))
	{  
		goto on_error;
	}

    h->running = TRUE;

    return VIDEOCAP_OK;

on_error:
    release_all_interfaces(h);
    return VIDEOCAP_ERROR;
}

int videocap_stop(videocap_t h)
{
    long code;
    
    if (!h->running)
        return -1;

    if (h->param.on_device_lost) {
        SetEvent(h->evt_thread_exit);
        WaitForSingleObject(h->thread_background, INFINITE);
        CloseHandle(h->thread_background);
        h->thread_background = NULL;
        CloseHandle(h->evt_thread_exit);
        h->evt_thread_exit = NULL;
    }

    h->mc->lpVtbl->Stop(h->mc);
    h->me->lpVtbl->WaitForCompletion(h->me, INFINITE, &code);

    h->running = 0;

	if (h->param.option & VIDEOCAP_OPT_ENABLE_ASYNC_GRAB) {
		EnterCriticalSection(&h->async_cap_cs);
		{
			async_cap_t *pos, *n;
			ListEntry_ForEachSafe(pos, n, &h->async_cap_list, async_cap_t, entry) {
				ListEntry_DeleteNode(&pos->entry);
				pos->result = -1; // cancel
				SetEvent(pos->evt);
			}
		}
		LeaveCriticalSection(&h->async_cap_cs);
	}

#ifdef _DEBUG
    RemoveFromRot(h->dwROTRegister);
    h->dwROTRegister = 0;
#endif

    release_all_interfaces(h);

    return VIDEOCAP_OK;
}

int videocap_grab(videocap_t h, video_frame *frame)
{
    int ret;

    if (!h)
        return -1;
    if (!h->running)
        return -1;
    if (!(h->param.option & VIDEOCAP_OPT_ENABLE_GRAB)) /* initialize without grabbing option */
        return -1;

    EnterCriticalSection(&h->cap_cs);
    ret = video_frame_copy(frame, &h->cap_frame);
    LeaveCriticalSection(&h->cap_cs);

    return ret;
}

int videocap_async_grab(videocap_t h, video_frame *frame)
{
	async_cap_t *ac;

	if (!h)
		return -1;
	if (!h->running)
		return -1;
	if (!(h->param.option & VIDEOCAP_OPT_ENABLE_ASYNC_GRAB)) /* initialize without grabbing option */
		return -1;

	ac = (async_cap_t*)malloc(sizeof(async_cap_t));
	ac->evt = CreateEvent(NULL, FALSE, FALSE, NULL);
	ac->ref_cap_frame = frame;
	EnterCriticalSection(&h->async_cap_cs);
	ListEntry_AddTail(&h->async_cap_list, &ac->entry);
	LeaveCriticalSection(&h->async_cap_cs);

	WaitForSingleObject(ac->evt, INFINITE);

	CloseHandle(ac->evt);
	free(ac);

	return 0;
}

int videocap_incrment_grab_cb(videocap_t h)
{
	if (!h)
		return -1;
	if (!h->running)
		return -1;

	InterlockedIncrement(&h->grab_cb_count);

	return 0;
}

int videocap_get_frame(videocap_t h, video_frame *frame)
{
    int ret;

    if (!h)
        return -1;
    if (!(h->param.option & VIDEOCAP_OPT_EANBLE_RESIZE))
        return -1;
    if (!h->running)
        return -1;

    EnterCriticalSection(&h->res_cs);
    ret = video_frame_copy(frame, &h->res_frame);
    LeaveCriticalSection(&h->res_cs);

    return ret;
}

int videocap_is_running(videocap_t h, BOOL *state)
{
    if (!h)
        return VIDEOCAP_ERROR;
    return h->running;
}

int videocap_set_preview_wnd_visible(videocap_t h, BOOL visible)
{
    if (!h || !h->videowindow)
        return VIDEOCAP_ERROR;
    h->videowindow->lpVtbl->put_Visible(h->videowindow, 
        visible ? OATRUE : OAFALSE);
    return VIDEOCAP_OK;
}

int videocap_get_preview_wnd_visible(videocap_t h, BOOL *visible)
{
    long l = OAFALSE;
    if (!h || !h->videowindow)
        return VIDEOCAP_ERROR;
    h->videowindow->lpVtbl->get_Visible(h->videowindow, &l);
    *visible = l ? TRUE : FALSE;
    return VIDEOCAP_OK;
}

int videocap_set_preview_wnd_width(videocap_t h, int width)
{
    if (!h)
        return -1;
    if (!h->param.pre_hwnd)
        return -1;
    h->videowindow->lpVtbl->put_Width(h->videowindow, width);
    return 0;
}

int videocap_set_preview_wnd_height(videocap_t h, int height)
{
    if (!h)
        return -1;
    if (!h->param.pre_hwnd)
        return -1;
    h->videowindow->lpVtbl->put_Height(h->videowindow, height);
    return 0;
}

static HRESULT set_video_source_format(videocap *vcap)
{
    HRESULT hr;
    IAMStreamConfig *config;
    ICaptureGraphBuilder2 *capturebuilder;
    VIDEOINFOHEADER *pvi;
    int i, count, size = 0;
    BOOL alreadyset = FALSE;

    // create capture builder
    hr = CoCreateInstance(&CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER,
        &IID_ICaptureGraphBuilder2, (void**)&capturebuilder);
    if (FAILED(hr))
        return hr;
    hr = capturebuilder->lpVtbl->FindInterface(capturebuilder,
        &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, vcap->sourcefilter,
        &IID_IAMStreamConfig, (void**)&config);
    if (FAILED(hr))
        return hr;
    config->lpVtbl->GetNumberOfCapabilities(config, &count, &size);
    if (size == sizeof(VIDEO_STREAM_CONFIG_CAPS)) {
		int width = mode_width[vcap->param.cap_mode];
		int height = mode_height[vcap->param.cap_mode];
        for (i = 0; i < count && !alreadyset; ++i)
		{
            VIDEO_STREAM_CONFIG_CAPS scc;
			AM_MEDIA_TYPE *pmtConfig;
			hr = config->lpVtbl->GetStreamCaps(config, i, &pmtConfig, (BYTE*)&scc);
			if (FAILED(hr))
				continue;
			if (IsEqualIID(&pmtConfig->majortype, &MEDIATYPE_Video) &&
				IsEqualIID(&pmtConfig->formattype, &FORMAT_VideoInfo) &&
				(pmtConfig->cbFormat >= sizeof(VIDEOINFOHEADER)) &&
				pmtConfig->pbFormat != NULL) 
			{
				pvi = (VIDEOINFOHEADER*)pmtConfig->pbFormat;
				if (pvi->bmiHeader.biWidth == width && pvi->bmiHeader.biHeight == height) 
				{
					pvi->AvgTimePerFrame = (REFERENCE_TIME)(10000000 / vcap->param.fps);
					hr = config->lpVtbl->SetFormat(config, pmtConfig);
					if (SUCCEEDED(hr))
					{
						char *subtype_str=GuidToString(pmtConfig->subtype);
						alreadyset = TRUE;
					}
					else
					{
						alreadyset = FALSE;
					}
				}
			}
            FreeMediaTypeEx(pmtConfig);
        }
    }
    config->lpVtbl->Release(config);
    capturebuilder->lpVtbl->Release(capturebuilder);
    return hr;
}

static HRESULT get_output_mediatype(videocap *vcap)
{
	AM_MEDIA_TYPE   mt;
	HRESULT hr;
	VIDEOINFOHEADER *videoHeader = NULL;
	char *subtype_str = NULL;

	ZeroMemory(&mt, sizeof(AM_MEDIA_TYPE));
	hr = vcap->grabber->lpVtbl->GetConnectedMediaType(vcap->grabber, &mt);
	if(FAILED(hr))
	{
		printf("GetConnectedMediaType Failed, hr=%08X! \n",hr);
		return hr;
	}
	
	videoHeader = (VIDEOINFOHEADER*)(mt.pbFormat);
	g_width = videoHeader->bmiHeader.biWidth;
	g_height = videoHeader->bmiHeader.biHeight;

	subtype_str=GuidToString(mt.subtype);
	printf("grabber Format Width=%d, Height=%d, biBitCount=%d, biSizeImage=%d, biCompression=%d, biPlanes=%d,biSize=%d,subtype=%s\n,newPmt->lSampleSize=%d, newPmt->bFixedSizeSamples=%d, newPmt->bTemporalCompression=%d\n",
		videoHeader->bmiHeader.biWidth,
		videoHeader->bmiHeader.biHeight,
		videoHeader->bmiHeader.biBitCount,
		videoHeader->bmiHeader.biSizeImage,
		videoHeader->bmiHeader.biCompression,
		videoHeader->bmiHeader.biPlanes,
		videoHeader->bmiHeader.biSize,
		subtype_str,
		mt.lSampleSize,
		mt.bFixedSizeSamples,
		mt.bTemporalCompression);

	return S_OK;
}

static void release_all_interfaces(videocap *h)
{
    if (h->mc) {
        h->mc->lpVtbl->Release(h->mc);
        h->mc = NULL;
    }
    if (h->me) {
        h->me->lpVtbl->Release(h->me);
        h->me = NULL;
    }
    if (h->videowindow) {
        h->videowindow->lpVtbl->put_Owner(h->videowindow, (OAHWND)NULL);
        h->videowindow->lpVtbl->Release(h->videowindow);
        h->videowindow = NULL;
    }
    if (h->graphbuilder) {
        RemoveGraphAllFilters(h->graphbuilder);
        h->graphbuilder->lpVtbl->Release(h->graphbuilder);
        h->graphbuilder = NULL;
    }
    if (h->sourcefilter) {
        h->sourcefilter->lpVtbl->Release(h->sourcefilter);
        h->sourcefilter = NULL;
    }
	if (h->avidecfilter) {
		h->avidecfilter->lpVtbl->Release(h->avidecfilter);
		h->avidecfilter = NULL;
	}
	if (h->cpcfilter) {
		h->cpcfilter->lpVtbl->Release(h->cpcfilter);
		h->cpcfilter = NULL;
	}
    if (h->grabber) {
        h->grabber->lpVtbl->Release(h->grabber);
        h->grabber = NULL;
    }
    if (h->grabberfilter) {
        h->grabberfilter->lpVtbl->Release(h->grabberfilter);
        h->grabberfilter = NULL;
    }
	if (h->horflipfilter) {
		h->horflipfilter->lpVtbl->Release(h->horflipfilter);
		h->horflipfilter = NULL;
	}
    if (h->renderfilter) {
        h->renderfilter->lpVtbl->Release(h->renderfilter);
        h->renderfilter = NULL;
    }
}

////////////////////////////////////////////////////////////

static HRESULT get_device_count_cb(int index, IMoniker *pMoniker, void *pUserData1, void *pUserData2)
{
    if (pMoniker)
        ++*(int*)pUserData1;
    return S_FALSE;
}

int videocap_get_device_count()
{
    int count = 0;
    HRESULT hr = WalkFilterCategory(&CLSID_VideoInputDeviceCategory, 
        &get_device_count_cb, &count, NULL);
    return SUCCEEDED(hr) ? count : 0;
}

struct _buf {
    WCHAR *buf;
    int len;
};

static HRESULT get_device_name_cb(int index, IMoniker *pMoniker, void *pUserData1, void *pUserData2)
{
    if (pMoniker) {
        int *p_id = (int*)pUserData1;
        struct _buf *buf = (struct _buf*)pUserData2;
        HRESULT hr;
        if (index == *p_id) {
            IPropertyBag *pPropBag;
            VARIANT name;
            hr = pMoniker->lpVtbl->BindToStorage(pMoniker, NULL, NULL, 
                &IID_IPropertyBag, (void**)&pPropBag);
            if (FAILED(hr)) {
                buf->len = -1; /* failed */
                return hr;
            }
            VariantInit(&name);
            name.vt = VT_BSTR;
            hr = pPropBag->lpVtbl->Read(pPropBag, L"FriendlyName", &name, NULL);
            if (FAILED(hr)) {
                pPropBag->lpVtbl->Release(pPropBag);
                VariantClear(&name);
                buf->len = -1;
                return hr;
            }
            buf->len = SysStringByteLen(name.bstrVal) + 2;
            if (buf)
                memcpy(buf->buf, name.bstrVal, buf->len);
            pPropBag->lpVtbl->Release(pPropBag);
            VariantClear(&name);
            return S_OK;
        }
    }
    return S_FALSE;
}

int videocap_get_device_name(int device_id, WCHAR *buf, int len)
{
    struct _buf x = {buf, len};
    int dev_id = device_id;
    HRESULT hr = WalkFilterCategory(&CLSID_VideoInputDeviceCategory, 
        &get_device_name_cb, &dev_id, &x);
    if (hr == S_OK)
        return x.len;
    return -1;
}

static HRESULT get_device_path_cb(int index, IMoniker *pMoniker, void *pUserData1, void *pUserData2)
{
	if (pMoniker) {
		int *p_id = (int*)pUserData1;
		struct _buf *buf = (struct _buf*)pUserData2;
		HRESULT hr;
		if (index == *p_id) {
			IPropertyBag *pPropBag;
			VARIANT path;
			hr = pMoniker->lpVtbl->BindToStorage(pMoniker, NULL, NULL, 
				&IID_IPropertyBag, (void**)&pPropBag);
			if (FAILED(hr)) {
				buf->len = -1; /* failed */
				return hr;
			}
			VariantInit(&path);
			path.vt = VT_BSTR;
			hr = pPropBag->lpVtbl->Read(pPropBag, L"DevicePath", &path, NULL);
			if (FAILED(hr)) {
				pPropBag->lpVtbl->Release(pPropBag);
				VariantClear(&path);
				buf->len = -1;
				return hr;
			}
			buf->len = SysStringByteLen(path.bstrVal) + 2;
			if (buf)
				memcpy(buf->buf, path.bstrVal, buf->len);
			pPropBag->lpVtbl->Release(pPropBag);
			VariantClear(&path);
			return S_OK;
		}
	}
	return S_FALSE;
}

int videocap_get_device_path(int device_id, WCHAR *buf, int len)
{
	struct _buf x = {buf, len};
	int dev_id = device_id;
	HRESULT hr = WalkFilterCategory(&CLSID_VideoInputDeviceCategory, 
		&get_device_path_cb, &dev_id, &x);
	if (hr == S_OK)
		return x.len;
	return -1;
}

static int is_support(int min, int max, int granularity, int x)
{
    if (x < min || x > max)
        return 0;
    if (x == min || x == max)
        return 1;
    if (granularity == 0)
        return 0;
    if ((x-min)/granularity*granularity != (x-min))
        return 0;
    if ((max-x)/granularity*granularity != (max-x))
        return 0;
    return 1;
}

static int is_support_size(VIDEO_STREAM_CONFIG_CAPS *pscc, int width, int height)
{
    return is_support(pscc->MinOutputSize.cx, pscc->MaxOutputSize.cx, pscc->OutputGranularityX, width) &&
        is_support(pscc->MinOutputSize.cy, pscc->MaxOutputSize.cy, pscc->OutputGranularityY, height);
}

int videocap_get_device_cap(int device_id, videocap_device_cap *cap)
{
    int error = -1, i, count, size = 0, j;
    HRESULT hr;
    ICaptureGraphBuilder2 *pBuilder = NULL;
    IBaseFilter *pSourceFilter = NULL;
    IAMStreamConfig *config = NULL;
	videocap_device_cap tmp_cap = {0};

	if (!cap)
		return error;
	hr = CreateFilterByIndex(&CLSID_VideoInputDeviceCategory, (void**)&pSourceFilter, device_id);
	if (FAILED(hr))
		return error;
	hr = CoCreateInstance(&CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER,
		&IID_ICaptureGraphBuilder2, (void**)&pBuilder);
	if (FAILED(hr))
		return error;
	ZeroMemory(cap, sizeof(videocap_device_cap));
	hr = pBuilder->lpVtbl->FindInterface(pBuilder, &PIN_CATEGORY_CAPTURE,
		&MEDIATYPE_Video, pSourceFilter, &IID_IAMStreamConfig, (void**)&config);
	if (FAILED(hr))
		goto on_error;
    config->lpVtbl->GetNumberOfCapabilities(config, &count, &size);
    if (size == sizeof(VIDEO_STREAM_CONFIG_CAPS)) {
        for (i = 0; i < count; ++i) {
            VIDEO_STREAM_CONFIG_CAPS scc;
            AM_MEDIA_TYPE *pmtConfig;
            VIDEOINFOHEADER *pvi = NULL;
            hr = config->lpVtbl->GetStreamCaps(config, i, &pmtConfig, (BYTE*)&scc);
            if (FAILED(hr))
                continue;
            if (IsEqualIID(&pmtConfig->majortype, &MEDIATYPE_Video) &&
                IsEqualIID(&pmtConfig->formattype, &FORMAT_VideoInfo) &&
                (pmtConfig->cbFormat >= sizeof(VIDEOINFOHEADER)) &&
                pmtConfig->pbFormat != NULL) {
                    if (IsEqualIID(&pmtConfig->subtype, &MEDIASUBTYPE_RGB24)) {
                        for (j = 0; j < VIDEOCAP_MAX_MODE; ++j) {
                            if (is_support_size(&scc, mode_width[j], mode_height[j])) {
                                tmp_cap.mode[j] = 1;
                                tmp_cap.min_frame_interval[j] = (int)scc.MinFrameInterval;
                                tmp_cap.max_frame_interval[j] = (int)scc.MaxFrameInterval;
                            }
                        }
                    }
            }
            FreeMediaTypeEx(pmtConfig);
        }
    }
    config->lpVtbl->Release(config);
    for (i = 0, j = 0; i < VIDEOCAP_MAX_MODE; ++i) {
        if (tmp_cap.mode[i]) {
            cap->mode[j] = i;
            cap->min_frame_interval[j] = cap->min_frame_interval[i];
            cap->max_frame_interval[j] = cap->max_frame_interval[i];
            j++;
        }
    }
    cap->mode_cnt = j;
    error = 0;
on_error:
    if (pBuilder)
        pBuilder->lpVtbl->Release(pBuilder);
    if (pSourceFilter)
        pSourceFilter->lpVtbl->Release(pSourceFilter);
    return error;
}

int videocap_get_mode_width(int mode)
{
    return mode_width[mode];
}

int videocap_get_mode_height(int mode)
{
    return mode_height[mode];
}

void YUV2RGB(byte *pYUV, byte *pRGB)
{
	byte y, u, v;
	y = *pYUV;
	pYUV++;
	u = *pYUV;
	pYUV++;
	v = *pYUV; 
	//r
	*pRGB = 1.0*y+1.772*(u-128); 
	if (*pRGB<0) *pRGB = 0;
	if(*pRGB>255) *pRGB = 255;
	//G
	pRGB++;   
	*pRGB =1.0*y - 0.34413*(u-128) - 0.71414*(v-128);
	if (*pRGB<0) *pRGB = 0;
	if(*pRGB>255) *pRGB = 255;	
	//b
	pRGB++;   
	*pRGB = 1.0*y+1.402*(v-128);
	if (*pRGB<0) *pRGB = 0;
	if(*pRGB>255) *pRGB = 255;

	pYUV++;
	y = *pYUV;
	pYUV++;
	u = *pYUV;
	pYUV++;
	v = *pYUV; 
	//r
	pRGB++; 
	*pRGB = 1.0*y+1.772*(u-128); 
	if (*pRGB<0) *pRGB = 0;
	if(*pRGB>255) *pRGB = 255;
	//G
	pRGB++;   
	*pRGB =1.0*y - 0.34413*(u-128) - 0.71414*(v-128);
	if (*pRGB<0) *pRGB = 0;
	if(*pRGB>255) *pRGB = 255;	
	//b
	pRGB++;   
	*pRGB = 1.0*y+1.402*(v-128);
	if (*pRGB<0) 
		*pRGB = 0;
	if(*pRGB>255) 
		*pRGB = 255;
}


int  Yuv2RgbFrame(BYTE* pYUVBuf,  BYTE* pRGBBuf, int cx, int cy) 
{ 
	int i = 0;
	int j=0;
	BYTE* pYUV = pYUVBuf;
	BYTE* pRGB = pRGBBuf;
	BYTE YUV[6];
	BYTE RGB[6];
	memset(YUV,0,6);
	memset(RGB,0,6);
	for ( i = 0;i<cy;i++)
	{
		for ( j=0; j<cx;j+=2)
		{
			//yuy2(yuyv)-->yuv444(yuvyuv)-->rgb24
			YUV[0] = *pYUV; 
			pYUV++;
			YUV[1] = *pYUV; 
			pYUV+=2;
			YUV[2] = *pYUV; 
			pYUV--;
			YUV[3] = *pYUV; 
			pYUV--;
			YUV[4] = *pYUV; 
			pYUV+=2;
			YUV[5] = *pYUV; 
			pYUV++;
			YUV2RGB(YUV,RGB);
			memcpy(pRGB + ((cy-i-1)*cx + j)*3 ,RGB,6);
		}
	}
	return 0;
}

int  yuv422_to_rgb24(unsigned char*yuv422,unsigned char*rgb24,int width,int height) 
{ 
	int x,y;  
	uint8_t*yuv444;  
	yuv444 = (uint8_t*) malloc(sizeof(uint8_t) * width * height * 3); 
	for(x = 0,y = 0;x < width*height*2,y < width*height*3;x+=4,y+=6) 
	{ 
		yuv444[y] = yuv422[x]; 
		yuv444[y+1] = yuv422[x+1]; 
		yuv444[y+2] = yuv422[x+3]; 
		yuv444[y+3] = yuv422[x+2]; 
		yuv444[y+4] = yuv422[x+1]; 
		yuv444[y+5] = yuv422[x+3];  
	}  
	for(x = 0;x < width*height*3;x+=3) 
	{ 
		rgb24[x+2] = yuv444[x] + 1.402*(yuv444[x+2] - 128);  
		rgb24[x+1] = yuv444[x]-0.34414*(yuv444[x+1]-128)-0.71414*(yuv444[x+2]-128); 
		rgb24[x] = yuv444[x] + 1.772*(yuv444[x+1] - 128); 
		if(rgb24[x]>255)
			rgb24[x]=255; 
		if(rgb24[x]<0)
			rgb24[x]=0;  
		if(rgb24[x+1]>255)
			rgb24[x+1]=255; 
		if(rgb24[x+1]<0)
			rgb24[x+1]=0; 
		if(rgb24[x+2]>255)
			rgb24[x+2]=255; 
		if(rgb24[x+2]<0)
			rgb24[x+2]=0;
	}  
	free(yuv444); 
	return 0;
}  
////////////////////////////////////////////////////////////