HRESULT STDMETHODCALLTYPE XnVideoSource::GetMode( IPin *pPin, __out long *Mode ) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pPin); XN_METHOD_CHECK_POINTER(Mode); HRESULT hr = S_OK; // we have only 1 pin, make sure this is it XnVideoStream* pVideoStream = dynamic_cast<XnVideoStream*>(GetPin(0)); if (pPin != static_cast<IPin*>(pVideoStream)) { XN_METHOD_RETURN(E_FAIL); } *Mode = 0; if (pVideoStream->GetMirror()) *Mode |= VideoControlFlag_FlipHorizontal; if (pVideoStream->GetVerticalFlip()) *Mode |= VideoControlFlag_FlipVertical; XN_METHOD_RETURN(S_OK); }
HRESULT XnVideoSource::GetCapRange(const XnChar* strCap, long *pMin, long *pMax, long *pSteppingDelta, long *pDefault, long *pCapsFlags) { XN_METHOD_START; if (strCap == NULL || !m_image.IsCapabilitySupported(strCap)) { XN_METHOD_RETURN(E_PROP_ID_UNSUPPORTED); } XN_METHOD_CHECK_POINTER(pMin); XN_METHOD_CHECK_POINTER(pMax); XN_METHOD_CHECK_POINTER(pSteppingDelta); XN_METHOD_CHECK_POINTER(pDefault); XN_METHOD_CHECK_POINTER(pCapsFlags); xn::GeneralIntCapability cap = m_image.GetGeneralIntCap(strCap); XnInt32 nMin, nMax, nStep, nDefault; XnBool bIsAutoSupported; cap.GetRange(nMin, nMax, nStep, nDefault, bIsAutoSupported); *pMin = nMin; *pMax = nMax; *pSteppingDelta = nStep; *pDefault = nDefault; *pCapsFlags = bIsAutoSupported ? 0x01 : 0x02; XN_METHOD_RETURN(S_OK); }
HRESULT STDMETHODCALLTYPE XnVideoSource::GetMaxAvailableFrameRate( IPin *pPin, long iIndex, SIZE Dimensions, __out LONGLONG *MaxAvailableFrameRate ) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pPin); XN_METHOD_CHECK_POINTER(MaxAvailableFrameRate); HRESULT hr = S_OK; // we have only 1 pin, make sure this is it XnVideoStream* pVideoStream = dynamic_cast<XnVideoStream*>(GetPin(0)); if (pPin != static_cast<IPin*>(pVideoStream)) { XN_METHOD_RETURN(E_FAIL); } AM_MEDIA_TYPE* pMediaType; VIDEO_STREAM_CONFIG_CAPS vscc; hr = pVideoStream->GetStreamCaps(iIndex, &pMediaType, (BYTE*)&vscc); if (FAILED(hr)) XN_METHOD_RETURN(hr); CoTaskMemFree(pMediaType); if (Dimensions.cx != vscc.MaxOutputSize.cx || Dimensions.cy != vscc.MaxOutputSize.cy) XN_METHOD_RETURN(E_FAIL); *MaxAvailableFrameRate = vscc.MaxFrameInterval; XN_METHOD_RETURN(S_OK); }
HRESULT STDMETHODCALLTYPE XnVideoSource::SetMode( IPin *pPin, long Mode ) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pPin); HRESULT hr = S_OK; // we have only 1 pin, make sure this is it XnVideoStream* pVideoStream = dynamic_cast<XnVideoStream*>(GetPin(0)); if (pPin != static_cast<IPin*>(pVideoStream)) { XN_METHOD_RETURN(E_FAIL); } xnLogVerbose(XN_MASK_FILTER, "Setting flip mode to %d", Mode); hr = pVideoStream->SetMirror(Mode & VideoControlFlag_FlipHorizontal); if (FAILED(hr)) XN_METHOD_RETURN(hr); hr = pVideoStream->SetVerticalFlip(Mode & VideoControlFlag_FlipVertical); if (FAILED(hr)) XN_METHOD_RETURN(hr); XN_METHOD_RETURN(S_OK); }
HRESULT XnVideoSource::GetCap(const XnChar* strCap, long *lValue, long *Flags) { XN_METHOD_START; if (strCap == NULL || !m_image.IsCapabilitySupported(strCap)) { XN_METHOD_RETURN(E_PROP_ID_UNSUPPORTED); } XN_METHOD_CHECK_POINTER(lValue); XN_METHOD_CHECK_POINTER(Flags); xn::GeneralIntCapability cap = m_image.GetGeneralIntCap(strCap); XnInt32 nVal = cap.Get(); if (nVal == XN_AUTO_CONTROL) { XnInt32 nMin, nMax, nStep, nDefault; XnBool bIsAutoSupported; cap.GetRange(nMin, nMax, nStep, nDefault, bIsAutoSupported); *Flags = 0x01; *lValue = nDefault; } else { *Flags = 0x02; *lValue = nVal; } XN_METHOD_RETURN(S_OK); }
HRESULT XnVideoStream::SetMirror(BOOL bMirror) { XN_METHOD_START; XnStatus nRetVal = m_imageGen.GetMirrorCap().SetMirror(bMirror); if (nRetVal != XN_STATUS_OK) { XN_METHOD_RETURN(E_FAIL); } XN_METHOD_RETURN(S_OK); }
// QuerySupported: Query whether the pin supports the specified property. HRESULT XnVideoStream::QuerySupported(REFGUID guidPropSet, DWORD dwPropID, DWORD *pTypeSupport) { XN_METHOD_START; // Taken from MSDN if (guidPropSet != AMPROPSETID_Pin) XN_METHOD_RETURN(E_PROP_SET_UNSUPPORTED); if (dwPropID != AMPROPERTY_PIN_CATEGORY) XN_METHOD_RETURN(E_PROP_ID_UNSUPPORTED); if (pTypeSupport) // We support getting this property, but not setting it. *pTypeSupport = KSPROPERTY_SUPPORT_GET; XN_METHOD_RETURN(S_OK); }
STDMETHODIMP XnVideoSource::GetPowerLineFrequency(XnPowerLineFrequency *pnValue) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pnValue); if (!m_image.IsCapabilitySupported(XN_CAPABILITY_ANTI_FLICKER)) { XN_METHOD_RETURN(E_PROP_ID_UNSUPPORTED); } *pnValue = m_image.GetAntiFlickerCap().GetPowerLineFrequency(); XN_METHOD_RETURN(S_OK); }
HRESULT XnVideoStream::Inactive( void ) { XN_METHOD_START; XnStatus nRetVal = m_imageGen.StopGenerating(); if (nRetVal != XN_STATUS_OK) { XN_METHOD_RETURN(E_UNEXPECTED); } HRESULT hr = CSourceStream::Inactive(); XN_METHOD_RETURN(hr); }
STDMETHODIMP XnVideoSource::SetPowerLineFrequency(XnPowerLineFrequency nValue) { XN_METHOD_START; if (!m_image.IsCapabilitySupported(XN_CAPABILITY_ANTI_FLICKER)) { XN_METHOD_RETURN(E_PROP_ID_UNSUPPORTED); } XnStatus nRetVal = m_image.GetAntiFlickerCap().SetPowerLineFrequency(nValue); if (nRetVal != XN_STATUS_OK) { XN_METHOD_RETURN(E_FAIL); } XN_METHOD_RETURN(S_OK); }
STDMETHODIMP XnVideoStream::GetPages(CAUUID *pPages) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pPages); pPages->cElems = 1; pPages->pElems = reinterpret_cast<GUID*>(CoTaskMemAlloc(sizeof(GUID)*pPages->cElems)); if (pPages->pElems == NULL) { XN_METHOD_RETURN(E_OUTOFMEMORY); } pPages->pElems[0] = CLSID_VideoStreamConfigPropertyPage; XN_METHOD_RETURN(S_OK); }
HRESULT XnVideoStream::Active( void ) { XN_METHOD_START; XnStatus nRetVal = m_imageGen.StartGenerating(); if (nRetVal != XN_STATUS_OK) { xnLogWarning(XN_MASK_FILTER, "Can't start ImageGenerator: %s", xnGetStatusString(nRetVal)); XN_METHOD_RETURN(E_UNEXPECTED); } HRESULT hr = CSourceStream::Active(); XN_METHOD_RETURN(hr); }
// // CheckMediaType // // Returns E_INVALIDARG if the mediatype is not acceptable // HRESULT XnVideoStream::CheckMediaType(const CMediaType *pMediaType) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pMediaType); int index = FindCapability(*pMediaType); if (index == -1 || // not found m_nPreferredMode >= 0 && index != m_nPreferredMode) { XN_METHOD_RETURN(E_INVALIDARG); } XN_METHOD_RETURN(S_OK); }
//IUnknown STDMETHODIMP XnVideoStream::NonDelegatingQueryInterface(REFIID riid, void **ppv) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(ppv); HRESULT hr = S_OK; // Standard OLE stuff if(riid == IID_IAMStreamConfig) { xnDumpFileWriteString(m_Dump, "\tPin query interface to IAMStreamConfig\n"); hr = GetInterface(static_cast<IAMStreamConfig*>(this), ppv); } else if(riid == IID_IKsPropertySet) { xnDumpFileWriteString(m_Dump, "\tPin query interface to IKsPropertySet\n"); hr = GetInterface(static_cast<IKsPropertySet*>(this), ppv); } else if(riid == IID_ISpecifyPropertyPages) { xnDumpFileWriteString(m_Dump, "\tPin query interface to ISpecifyPropertyPages\n"); hr = GetInterface(static_cast<ISpecifyPropertyPages*>(this), ppv); } else { OLECHAR strGuid[40]; StringFromGUID2(riid, strGuid, 40); xnDumpFileWriteString(m_Dump, "\tPin query interface to %S\n", strGuid); hr = CSourceStream::NonDelegatingQueryInterface(riid, ppv); } XN_METHOD_RETURN(hr); }
HRESULT STDMETHODCALLTYPE XnVideoSource::GetCaps(IPin *pPin, long *pCapsFlags) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pPin); XN_METHOD_CHECK_POINTER(pCapsFlags); // we have only 1 pin, make sure this is it if (pPin != static_cast<IPin*>(GetPin(0))) { XN_METHOD_RETURN(E_FAIL); } *pCapsFlags = VideoControlFlag_FlipHorizontal | VideoControlFlag_FlipVertical; XN_METHOD_RETURN(S_OK); }
STDMETHODIMP XnVideoSource::GetLowLightCompensation(XnBool *pbValue) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pbValue); if (!m_image.IsCapabilitySupported(XN_CAPABILITY_LOW_LIGHT_COMPENSATION)) { XN_METHOD_RETURN(E_PROP_ID_UNSUPPORTED); } xn::GeneralIntCapability cap = m_image.GetLowLightCompensationCap(); *pbValue = (XnBool)cap.Get(); XN_METHOD_RETURN(S_OK); }
STDMETHODIMP XnVideoSource::GetGain(XnInt32 *pnValue) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pnValue); if (!m_image.IsCapabilitySupported(XN_CAPABILITY_GAIN)) { XN_METHOD_RETURN(E_PROP_ID_UNSUPPORTED); } xn::GeneralIntCapability cap = m_image.GetGainCap(); *pnValue = cap.Get(); XN_METHOD_RETURN(S_OK); }
HRESULT XnVideoStream::Set(REFGUID guidPropSet, DWORD dwID, void *pInstanceData, DWORD cbInstanceData, void *pPropData, DWORD cbPropData) { XN_METHOD_START; // Taken from MSDN XN_METHOD_RETURN(E_NOTIMPL); }
STDMETHODIMP XnVideoSource::SetLowLightCompensation(XnBool bValue) { XN_METHOD_START; if (!m_image.IsCapabilitySupported(XN_CAPABILITY_LOW_LIGHT_COMPENSATION)) { XN_METHOD_RETURN(E_PROP_ID_UNSUPPORTED); } xn::GeneralIntCapability cap = m_image.GetLowLightCompensationCap(); XnStatus nRetVal = cap.Set(bValue); if (nRetVal != XN_STATUS_OK) { XN_METHOD_RETURN(E_FAIL); } XN_METHOD_RETURN(S_OK); }
STDMETHODIMP XnVideoSource::SetGain(XnInt32 nValue) { XN_METHOD_START; if (!m_image.IsCapabilitySupported(XN_CAPABILITY_GAIN)) { XN_METHOD_RETURN(E_PROP_ID_UNSUPPORTED); } xn::GeneralIntCapability cap = m_image.GetGainCap(); XnStatus nRetVal = cap.Set(nValue); if (nRetVal != XN_STATUS_OK) { XN_METHOD_RETURN(E_FAIL); } XN_METHOD_RETURN(S_OK); }
STDMETHODIMP XnVideoSource::GetPages(CAUUID *pPages) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pPages); pPages->cElems = 3; pPages->pElems = reinterpret_cast<GUID*>(CoTaskMemAlloc(sizeof(GUID)*pPages->cElems)); if (pPages->pElems == NULL) { XN_METHOD_RETURN(E_OUTOFMEMORY); } pPages->pElems[0] = CLSID_VideoProcAmpPropertyPage; pPages->pElems[1] = CLSID_CameraControlPropertyPage; pPages->pElems[2] = CLSID_AdditionalOpenNIControlsPropertyPage; XN_METHOD_RETURN(S_OK); }
STDMETHODIMP XnVideoSource::GetLowLightCompensationDefault(XnBool* pbValue) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pbValue); if (!m_image.IsCapabilitySupported(XN_CAPABILITY_LOW_LIGHT_COMPENSATION)) { XN_METHOD_RETURN(E_PROP_ID_UNSUPPORTED); } XnInt32 nMin, nMax, nStep, nDefault; XnBool bAutoSupported; m_image.GetLowLightCompensationCap().GetRange(nMin, nMax, nStep, nDefault, bAutoSupported); *pbValue = nDefault; XN_METHOD_RETURN(S_OK); }
HRESULT STDMETHODCALLTYPE XnVideoStream::GetStreamCaps(int iIndex, AM_MEDIA_TYPE **pmt, BYTE *pSCC) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pmt); XN_METHOD_CHECK_POINTER(pSCC); xnDumpFileWriteString(m_Dump, "\tCalling %s for %d\n", __FUNCTION__, iIndex); CMediaType mediaType; VIDEO_STREAM_CONFIG_CAPS* pvscc = (VIDEO_STREAM_CONFIG_CAPS*)pSCC; HRESULT hr = GetStreamCapability(iIndex, mediaType, *pvscc); if (FAILED(hr)) XN_METHOD_RETURN(hr); xnDumpFileWriteString(m_Dump, "\tReturning %dx%d@%d using %s\n", m_aSupportedModes[iIndex].OutputMode.nXRes, m_aSupportedModes[iIndex].OutputMode.nYRes, m_aSupportedModes[iIndex].OutputMode.nFPS, xnPixelFormatToString(m_aSupportedModes[iIndex].Format)); *pmt = CreateMediaType(&mediaType); XN_METHOD_RETURN(S_OK); }
HRESULT STDMETHODCALLTYPE XnVideoStream::SetFormat(AM_MEDIA_TYPE *pmt) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pmt); if (pmt == NULL) { XN_METHOD_RETURN(E_INVALIDARG); } xnLogVerbose(XN_MASK_FILTER, "SetFormat was called"); // check if this format is supported CMediaType mediaType(*pmt); int index = FindCapability(mediaType); if (index == -1) { XN_METHOD_RETURN(VFW_E_INVALIDMEDIATYPE); } // keep previous one (so we can rollback) int prevPreferred = m_nPreferredMode; // set the preferred mode m_nPreferredMode = index; // try to reconnect (if needed) IPin* pin; ConnectedTo(&pin); if (pin) { IFilterGraph *pGraph = ((XnVideoSource*)m_pFilter)->GetGraph(); HRESULT hr = pGraph->Reconnect(this); if (FAILED(hr)) { // rollback m_nPreferredMode = prevPreferred; XN_METHOD_RETURN(hr); } } XN_METHOD_RETURN(S_OK); }
HRESULT STDMETHODCALLTYPE XnVideoSource::GetCurrentActualFrameRate( IPin *pPin, __out LONGLONG *ActualFrameRate ) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pPin); XN_METHOD_CHECK_POINTER(ActualFrameRate); HRESULT hr = S_OK; // we have only 1 pin, make sure this is it XnVideoStream* pVideoStream = dynamic_cast<XnVideoStream*>(GetPin(0)); if (pPin != static_cast<IPin*>(pVideoStream)) { XN_METHOD_RETURN(E_FAIL); } *ActualFrameRate = (LONGLONG)(10000000.0 / pVideoStream->GetCurrentFPS() + 0.5); XN_METHOD_RETURN(S_OK); }
HRESULT STDMETHODCALLTYPE XnVideoStream::GetNumberOfCapabilities(int *piCount, int *piSize) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(piCount); XN_METHOD_CHECK_POINTER(piSize); *piCount = m_aSupportedModes.GetSize(); *piSize = sizeof(VIDEO_STREAM_CONFIG_CAPS); XN_METHOD_RETURN(S_OK); }
STDMETHODIMP XnVideoSource::GetGainRange(XnInt32 *pnMin, XnInt32* pnMax, XnInt32* pnStep, XnInt32* pnDefault, XnBool* pbAutoSupported) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pnMin); XN_METHOD_CHECK_POINTER(pnMax); XN_METHOD_CHECK_POINTER(pnStep); XN_METHOD_CHECK_POINTER(pnDefault); XN_METHOD_CHECK_POINTER(pbAutoSupported); if (!m_image.IsCapabilitySupported(XN_CAPABILITY_GAIN)) { XN_METHOD_RETURN(E_PROP_ID_UNSUPPORTED); } xn::GeneralIntCapability cap = m_image.GetGainCap(); cap.GetRange(*pnMin, *pnMax, *pnStep, *pnDefault, *pbAutoSupported); XN_METHOD_RETURN(S_OK); }
// Get: Return the pin category (our only property). HRESULT XnVideoStream::Get( REFGUID guidPropSet, // Which property set. DWORD dwPropID, // Which property in that set. void *pInstanceData, // Instance data (ignore). DWORD cbInstanceData, // Size of the instance data (ignore). void *pPropData, // Buffer to receive the property data. DWORD cbPropData, // Size of the buffer. DWORD *pcbReturned // Return the size of the property. ) { XN_METHOD_START; // Taken from MSDN if (guidPropSet != AMPROPSETID_Pin) XN_METHOD_RETURN(E_PROP_SET_UNSUPPORTED); if (dwPropID != AMPROPERTY_PIN_CATEGORY) XN_METHOD_RETURN(E_PROP_ID_UNSUPPORTED); if (pPropData == NULL && pcbReturned == NULL) XN_METHOD_RETURN(E_POINTER); if (pcbReturned) *pcbReturned = sizeof(GUID); if (pPropData == NULL) // Caller just wants to know the size. XN_METHOD_RETURN(S_OK); if (cbPropData < sizeof(GUID)) // The buffer is too small. XN_METHOD_RETURN(E_UNEXPECTED); *(GUID *)pPropData = PIN_CATEGORY_CAPTURE; XN_METHOD_RETURN(S_OK); }
// // GetMediaType // // Preferred types should be ordered by quality, with zero as highest quality. // HRESULT XnVideoStream::GetMediaType(int iPosition, __inout CMediaType *pMediaType) { XN_METHOD_START; HRESULT hr = S_OK; XN_METHOD_CHECK_POINTER(pMediaType); if(iPosition < 0) { XN_METHOD_RETURN(E_INVALIDARG); } if (m_nPreferredMode >= 0) { // Once a mode was set using IAMStreamConfig::SetFormat, this should be the only mode if (iPosition == 0) { VIDEO_STREAM_CONFIG_CAPS vscc; hr = GetStreamCapability(m_nPreferredMode, *pMediaType, vscc); XN_METHOD_RETURN(hr); } else { XN_METHOD_RETURN(VFW_S_NO_MORE_ITEMS); } } else { // Have we run off the end of types? if (iPosition > int(m_aSupportedModes.GetSize())) { XN_METHOD_RETURN(VFW_S_NO_MORE_ITEMS); } VIDEO_STREAM_CONFIG_CAPS vscc; hr = GetStreamCapability(iPosition, *pMediaType, vscc); XN_METHOD_RETURN(hr); } }
HRESULT XnVideoStream::SetMediaType(const CMediaType* pMediaType) { XN_METHOD_START; XN_METHOD_CHECK_POINTER(pMediaType); Mode mode = MediaTypeToMode(*pMediaType); XnStatus nRetVal = m_imageGen.SetMapOutputMode(mode.OutputMode); if (nRetVal != XN_STATUS_OK) { XN_METHOD_RETURN(E_FAIL); } nRetVal = m_imageGen.SetPixelFormat(mode.Format); if (nRetVal != XN_STATUS_OK) { XN_METHOD_RETURN(E_FAIL); } HRESULT hr = CSourceStream::SetMediaType(pMediaType); XN_METHOD_RETURN(hr); }