* IMFSourceReaderCallback implementation.
 */

typedef struct {
    interface IMFSourceReaderCallback isrcb;	/* Interface, methods. */
    CRITICAL_SECTION lock;			/* Mutex. */
    int refCount;				/* Reference count. */
    int closing;				/* True during close. */
    struct WMFC *wmfc;				/* Pointer to WMF struct. */
} SourceReaderCB;

/*
 * Frame buffer.
 */

    IMFMediaSource *mediaSrc;	/* Handle for device. */
    IMFSourceReader *srcReader;	/* Handle for capture. */
    Tcl_Interp *interp;		/* Interpreter for this object. */
    char devId[32];		/* Device id. */
    Tcl_DString devName;	/* Device name. */
    int cbCmdLen;               /* Initial length of callback command. */
    Tcl_DString cbCmd;          /* Callback command prefix. */
    Tcl_TimerToken cbPending;	/* Set when callback dispatched. */
    int fourcc;			/* Media format code. */
    int stride, width, height;	/* Image dimensions. */
    int mirror;			/* Image mirror flags. */
    int rotate;			/* Image rotation in degrees. */
    Tcl_WideInt counters[4];	/* Statistic counters. */
    int useFmt;			/* MediaFmt index to use. */
    int numFmts;		/* Number formats in fmts. */

 */

#ifdef USE_ASYNC_HANDLER
static int SignalBuffer(ClientData clientData, Tcl_Interp *interp, int code);
#else
static int SignalBuffer(Tcl_Event *evPtr, int flags);
#endif
static int StopCapture(WMFC *wmfc, int closing);


/*
 *-------------------------------------------------------------------------
 *
 * EnumDevices --
 *

    LeaveCriticalSection(&srcb->lock);
    return hr;
}

static HRESULT STDMETHODCALLTYPE
SR_OnFlush(IMFSourceReaderCallback *This, DWORD streamIndex)
{
    SourceReaderCB *srcb = (SourceReaderCB *) This;

    srcb->closing = 0;
    return S_OK;
}

static HRESULT STDMETHODCALLTYPE
SR_OnEvent(IMFSourceReaderCallback *This, DWORD streamIndex,
	   IMFMediaEvent *pEvent)
{

};

/*
 *-------------------------------------------------------------------------
 *
 * ImageCallback --
 *
 *	Called as timer handler from the (async) event handler
 *	when a new image is available or image capture was stopped
 *	due to an error.
 *
 *-------------------------------------------------------------------------
 */

static void
ImageCallback(ClientData clientData)
{
    WMFC *wmfc = (WMFC *) clientData;
    Tcl_Interp *interp = wmfc->interp;
    int ret;
#ifdef USE_ASYNC_HANDLER
    int capture = (wmfc->async != NULL);
#else
    int capture = (wmfc->tid != NULL);
#endif

    wmfc->cbPending = NULL;
    Tcl_DStringSetLength(&wmfc->cbCmd, wmfc->cbCmdLen);
    Tcl_DStringAppendElement(&wmfc->cbCmd, wmfc->devId);
    if (wmfc->streamEnd) {
	Tcl_DStringAppendElement(&wmfc->cbCmd, (wmfc->streamEnd < 0) ?
				 "error" : "eof");
    } else {
	Tcl_DStringAppendElement(&wmfc->cbCmd, capture ? "capture" : "stop");
    }
    Tcl_Preserve((ClientData) interp);
    ret = Tcl_EvalEx(interp, Tcl_DStringValue(&wmfc->cbCmd),
		     Tcl_DStringLength(&wmfc->cbCmd), TCL_EVAL_GLOBAL);
    if (ret != TCL_OK) {
	StopCapture(wmfc, 0);
	Tcl_AddErrorInfo(interp, "\n    (wmf event handler)");
 	Tcl_BackgroundError(interp);
    }
    Tcl_Release((ClientData) interp);
}

/*
 *-------------------------------------------------------------------------
 *
 * SignalBuffer --
 *
 *	(Async) event handler called when an image became ready.
 *	Requests next frame and schedules timer handler
 *	for performing the Tcl callback established on open.
 *
 *-------------------------------------------------------------------------
 */

static int
#ifdef USE_ASYNC_HANDLER

	Tcl_AsyncDelete(wmfc->async);
	wmfc->async = NULL;
#else
	wmfc->tid = NULL;
#endif
    }
    if (bufok || dostop) {
	if (wmfc->cbPending == NULL) {
	    wmfc->cbPending =
		Tcl_CreateTimerHandler(0, ImageCallback, (ClientData) wmfc);
	}
    }
    return code;
}

/*
 *-------------------------------------------------------------------------
 *

	wmfc->counters[0] = wmfc->counters[1] = 0;
	wmfc->counters[2] = wmfc->counters[3] = 0;
	wmfc->frame[0].ready = wmfc->frame[1].ready = 0;
	wmfc->streamEnd = 0;
	wmfc->frameReady = wmfc->frameQueued = -1;
	wmfc->srcb.isrcb.lpVtbl = &SourceReaderVtbl;
	wmfc->srcb.refCount = 1;
	wmfc->srcb.closing = 0;
	wmfc->srcb.wmfc = wmfc;
	hr = attr->lpVtbl->SetUnknown(attr,
				      &MF_SOURCE_READER_ASYNC_CALLBACK,
				      (struct IUnknown *) &wmfc->srcb);
	hr = MFCreateSourceReaderFromMediaSource(wmfc->mediaSrc, attr,
						 &wmfc->srcReader);
	if (attr != NULL) {

	    return TCL_ERROR;
	}
	if (GetFormat(wmfc) != TCL_OK) {
 	    wmfc->srcReader->lpVtbl->Release(wmfc->srcReader);
	    wmfc->srcReader = NULL;
	    return TCL_ERROR;
	}
	wmfc->cbPending = NULL;
    }
    EnterCriticalSection(&wmfc->srcb.lock);
#ifdef USE_ASYNC_HANDLER
    if (wmfc->async == NULL) {
	wmfc->async = Tcl_AsyncCreate(SignalBuffer, (ClientData) wmfc);
	doread = 1;
    }


/*
 *-------------------------------------------------------------------------
 *
 * StopCapture --
 *
 *      Stop capture if running. The (async) event handler is removed and
 *	a pending call to ImageCallback is cancelled, too.
 *
 *-------------------------------------------------------------------------
 */

static int
StopCapture(WMFC *wmfc, int closing)
{

    EnterCriticalSection(&wmfc->srcb.lock);
#ifdef USE_ASYNC_HANDLER
    if (wmfc->async != NULL) {
        Tcl_AsyncDelete(wmfc->async);
        wmfc->async = NULL;
    }






#else

    wmfc->tid = NULL;
#endif
    if (wmfc->streamEnd < 0) {
	wmfc->streamEnd = 0;
    }
    wmfc->frameQueued = -1;
    if (wmfc->srcReader != NULL) {
	wmfc->srcb.closing = closing;
	wmfc->srcReader->lpVtbl->Flush(wmfc->srcReader,
				       MF_SOURCE_READER_ALL_STREAMS);
    } else {
	closing = 0;
    }
    LeaveCriticalSection(&wmfc->srcb.lock);
    Tcl_DeleteTimerHandler(wmfc->cbPending);
    wmfc->cbPending = NULL;
    if (closing) {
	int i;

	for (i = 0; i < 5; i++) {
	    if (!wmfc->srcb.closing) {
		break;
	    }
	    Sleep(20);
	}
    }
    return TCL_OK;
}

/*
 *-------------------------------------------------------------------------
 *
 * GetImage --

    Tcl_HashEntry *hPtr;
    Tcl_HashSearch search;
    WMFC *wmfc;

    hPtr = Tcl_FirstHashEntry(&wmfi->wmfc, &search);
    while (hPtr != NULL) {
	wmfc = (WMFC *) Tcl_GetHashValue(hPtr);
	StopCapture(wmfc, 1);
	if (wmfc->srcReader != NULL) {
	    wmfc->srcReader->lpVtbl->Release(wmfc->srcReader);
	}
	if (wmfc->mediaSrc != NULL) {
	    wmfc->mediaSrc->lpVtbl->Release(wmfc->mediaSrc);
	}
	if (wmfc->frame[0].data != NULL) {

devNotFound:
	    Tcl_SetObjResult(interp, Tcl_ObjPrintf("device \"%s\" not found",
			Tcl_GetString(objv[2])));
	    ret = TCL_ERROR;
	}
	wmfc = (WMFC *) Tcl_GetHashValue(hPtr);
	Tcl_DeleteHashEntry(hPtr);
	StopCapture(wmfc, 1);
	if (wmfc->srcReader != NULL) {
	    wmfc->srcReader->lpVtbl->Release(wmfc->srcReader);
	}
	if (wmfc->mediaSrc != NULL) {
	    wmfc->mediaSrc->lpVtbl->Release(wmfc->mediaSrc);
	}
	if (wmfc->frame[0].data != NULL) {

	wmfc->mediaSrc = mediaSrc;
	wmfc->srcReader = NULL;
	wmfc->streamEnd = 0;
	wmfc->frameReady = wmfc->frameQueued = -1;
        wmfc->mirror = 0;
        wmfc->rotate = 0;
        wmfc->interp = interp;
	wmfc->cbPending = NULL;
	InitializeCriticalSection(&wmfc->srcb.lock);
 	Tcl_DStringInit(&wmfc->devName);
	Tcl_DStringAppend(&wmfc->devName, devName, -1);
	Tcl_DStringInit(&wmfc->cbCmd);
	Tcl_DStringAppend(&wmfc->cbCmd, Tcl_GetString(objv[3]), -1);
	wmfc->useFmt = -1;
	wmfc->numFmts = numFmts;

	    return TCL_ERROR;
	}
	hPtr = Tcl_FindHashEntry(&wmfi->wmfc, Tcl_GetString(objv[2]));
	if (hPtr == NULL) {
	    goto devNotFound;
	}
	wmfc = (WMFC *) Tcl_GetHashValue(hPtr);
	StopCapture(wmfc, 0);
	break;
    }

    }

    return ret;
}