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);
}
