Added possibility to control the exposure of webcams in Media::MediaFoundation

Summary: This feature was simply missing.

Reviewed By: enpe

Differential Revision:
D79011737

Privacy Context Container: L1241821

fbshipit-source-id: 2d54a1b4d1000b969b4b8d59e1e118cf2393c940

Author: janherlingmeta

impl/ocean/media/mediafoundation/MFLiveVideo.cpp

@@ -9,6 +9,10 @@
 #include "ocean/media/mediafoundation/MFLibrary.h"
 #include "ocean/media/mediafoundation/Utilities.h"
 
+#include <ks.h>
+#include <ksmedia.h>
+#include <ksproxy.h>
+
 namespace Ocean
 {
 
@@ -173,6 +177,78 @@ MFLiveVideo::StreamConfigurations MFLiveVideo::supportedStreamConfigurations(con
 	return streamConfigurations;
 }
 
+double MFLiveVideo::exposureDuration(double* minDuration, double* maxDuration, ControlMode* exposureMode) const
+{
+	const ScopedLock scopedLock(lock_);
+
+	ScopedIKsControl iKsControl;
+	if (S_OK != mediaSource_->QueryInterface(IID_IKsControl, (void**)(&iKsControl.resetObject())))
+	{
+		return false;
+	}
+
+	if (minDuration != nullptr || maxDuration != nullptr)
+	{
+		double minExposure = NumericD::minValue();
+		double maxExposure = NumericD::minValue();
+
+		const bool result = exposureRange(*iKsControl, minExposure, maxExposure);
+		ocean_assert_and_suppress_unused(result, result);
+
+		if (minDuration != nullptr)
+		{
+			*minDuration = minExposure;
+		}
+
+		if (maxDuration != nullptr)
+		{
+			*maxDuration = maxExposure;
+		}
+	}
+
+	double duration = Numeric::minValue();
+
+	ControlMode controlMode = CM_INVALID;
+	if (!exposure(*iKsControl, duration, controlMode))
+	{
+		return -1.0;
+	}
+
+	if (exposureMode != nullptr)
+	{
+		*exposureMode = controlMode;
+	}
+
+	return duration;
+}
+
+bool MFLiveVideo::setExposureDuration(const double duration, const bool /*allowShorterExposure*/)
+{
+	if (duration < 0.0)
+	{
+		Log::warning() << "MFLiveVideo::setExposureDuration() does not support one-time auto exposure";
+
+		return false;
+	}
+
+	const ScopedLock scopedLock(lock_);
+
+	if (!sesssionStarted_)
+	{
+		delayedExposureDuration_ = duration;
+
+		return true;
+	}
+
+	ScopedIKsControl iKsControl;
+	if (S_OK != mediaSource_->QueryInterface(IID_IKsControl, (void**)(&iKsControl.resetObject())))
+	{
+		return false;
+	}
+
+	return setExposure(*iKsControl, duration);
+}
+
 bool MFLiveVideo::enumerateVideoDevices(Library::Definitions& definitions)
 {
 	definitions.clear();
@@ -294,6 +370,178 @@ void MFLiveVideo::releaseTopology()
 	MFMedium::releaseTopology();
 }
 
+void MFLiveVideo::onSessionStarted()
+{
+	const ScopedLock scopedLock(lock_);
+
+	MFFrameMedium::onSessionStarted();
+
+	sesssionStarted_ = true;
+
+	if (delayedExposureDuration_ != NumericD::minValue())
+	{
+		setExposureDuration(delayedExposureDuration_);
+
+		delayedExposureDuration_ = NumericD::minValue();
+	}
+}
+
+void MFLiveVideo::onSessionStopped()
+{
+	const ScopedLock scopedLock(lock_);
+
+	MFFrameMedium::onSessionStopped();
+
+	sesssionStarted_ = false;
+}
+
+bool MFLiveVideo::exposureRange(IKsControl* iKsControl, double& minExposure, double& maxExposure)
+{
+	// User-mode clients use the KSPROPERTY_CAMERACONTROL_EXPOSURE property to get or set a digital camera's exposure time. This property is optional.
+
+	KSPROPERTY ksProperty = {};
+	ksProperty.Set = PROPSETID_VIDCAP_CAMERACONTROL;
+	ksProperty.Id = KSPROPERTY_CAMERACONTROL_EXPOSURE;
+	ksProperty.Flags = KSPROPERTY_TYPE_BASICSUPPORT;
+
+	KSPROPERTY_DESCRIPTION ksPropertyDescription = {};
+	ULONG bytesReturned = 0;
+	if (S_OK != iKsControl->KsProperty(&ksProperty, sizeof(ksProperty), &ksPropertyDescription, sizeof(ksPropertyDescription), &bytesReturned))
+	{
+		return false;
+	}
+
+	if (bytesReturned < sizeof(KSPROPERTY_DESCRIPTION))
+	{
+		return false;
+	}
+
+	constexpr size_t expectedSize = sizeof(KSPROPERTY_DESCRIPTION) + sizeof(KSPROPERTY_MEMBERSHEADER) + sizeof(KSPROPERTY_STEPPING_LONG);
+
+	if (ksPropertyDescription.DescriptionSize < expectedSize)
+	{
+		return false;
+	}
+
+	std::vector<uint8_t> buffer(ksPropertyDescription.DescriptionSize);
+
+	bytesReturned = 0;
+	if (S_OK != iKsControl->KsProperty(&ksProperty, sizeof(ksProperty), buffer.data(), ULONG(buffer.size()), &bytesReturned))
+	{
+		return false;
+	}
+
+	const KSPROPERTY_MEMBERSHEADER* propertyMember = (const KSPROPERTY_MEMBERSHEADER*)(buffer.data() + sizeof(KSPROPERTY_DESCRIPTION));
+
+	if (propertyMember->MembersFlags & KSPROPERTY_MEMBER_RANGES)
+	{
+		const KSPROPERTY_STEPPING_LONG* range = (const KSPROPERTY_STEPPING_LONG*)(buffer.data() + sizeof(KSPROPERTY_DESCRIPTION) + sizeof(KSPROPERTY_MEMBERSHEADER));
+
+		const LONG minLogBase2 = range->Bounds.SignedMinimum;
+		const LONG maxLogBase2 = range->Bounds.SignedMaximum;
+
+		minExposure = translateExposure(minLogBase2);
+		maxExposure = translateExposure(maxLogBase2);
+
+		return true;
+	}
+
+	return false;
+}
+
+bool MFLiveVideo::setExposure(IKsControl* iKsControl, const double exposure)
+{
+	ocean_assert(iKsControl != nullptr);
+
+	LONG exposureValue = 0;
+
+	if (exposure > 0.0)
+	{
+		exposureValue = translateExposure(exposure);
+	}
+
+	KSPROPERTY_CAMERACONTROL_S cameraControl = {};
+
+	cameraControl.Property.Set = PROPSETID_VIDCAP_CAMERACONTROL;
+	cameraControl.Property.Id = KSPROPERTY_CAMERACONTROL_EXPOSURE;
+	cameraControl.Property.Flags = KSPROPERTY_TYPE_SET;
+	cameraControl.Value = exposureValue;
+	cameraControl.Flags = exposure > 0.0 ? KSPROPERTY_CAMERACONTROL_FLAGS_MANUAL : KSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
+	cameraControl.Capabilities = KSPROPERTY_CAMERACONTROL_FLAGS_ABSOLUTE;
+
+	ULONG bytesReturned = 0;
+
+    const HRESULT result = iKsControl->KsProperty(&cameraControl.Property, sizeof(cameraControl), &cameraControl, sizeof(cameraControl), &bytesReturned);
+
+	return result == S_OK;
+}
+
+bool MFLiveVideo::exposure(IKsControl* iKsControl, double& exposure, ControlMode& controlMode)
+{
+	KSPROPERTY_CAMERACONTROL_S cameraControl = {};
+
+	cameraControl.Property.Set = PROPSETID_VIDCAP_CAMERACONTROL;
+	cameraControl.Property.Id = KSPROPERTY_CAMERACONTROL_EXPOSURE;
+	cameraControl.Property.Flags = KSPROPERTY_TYPE_GET;
+	cameraControl.Value = 0;
+	cameraControl.Flags = 0;
+	cameraControl.Capabilities = 0;
+
+	ULONG bytesReturned = 0;
+
+    if (S_OK != iKsControl->KsProperty(&cameraControl.Property, sizeof(cameraControl), &cameraControl, sizeof(cameraControl), &bytesReturned))
+	{
+		return false;
+	}
+
+	exposure = translateExposure(cameraControl.Value);
+
+	if (cameraControl.Flags & KSPROPERTY_CAMERACONTROL_FLAGS_AUTO)
+	{
+		controlMode = CM_DYNAMIC;
+	}
+	else if (cameraControl.Flags & KSPROPERTY_CAMERACONTROL_FLAGS_MANUAL)
+	{
+		controlMode = CM_FIXED;
+	}
+	else
+	{
+		controlMode = CM_INVALID;
+	}
+
+	return true;
+}
+
+double MFLiveVideo::translateExposure(const LONG logBase2)
+{
+	if (logBase2 >= 0)
+	{
+		return double(logBase2) * 2.0;
+	}
+	else
+	{
+		return 1.0 / NumericD::pow(2.0, double(-logBase2));
+	}
+}
+
+LONG MFLiveVideo::translateExposure(const double exposure)
+{
+	ocean_assert(exposure > 0.0);
+
+	if (exposure >= 1.0)
+	{
+		const double exposureValueD = exposure / 2.0;
+
+		return NumericD::round32(exposureValueD);
+	}
+	else
+	{
+		const double exposureValueD = NumericD::log2(exposure);
+
+		return NumericD::round32(exposureValueD);
+	}
+}
+
 }
 
 }

impl/ocean/media/mediafoundation/MFLiveVideo.h

@@ -54,6 +54,18 @@ class OCEAN_MEDIA_MF_EXPORT MFLiveVideo :
 		 */
 		StreamConfigurations supportedStreamConfigurations(const StreamType streamType) const override;
 
+		/**
+		 * Returns the current exposure duration of this device.
+		 * @see LiveVideo::exposureDuration().
+		 */
+		double exposureDuration(double* minDuration = nullptr, double* maxDuration = nullptr, ControlMode* exposureMode = nullptr) const override;
+
+		/**
+		 * Sets the exposure duration of this device.
+		 * @see LiveVideo::setExposureDuration().
+		 */
+		bool setExposureDuration(const double duration, const bool allowShorterExposure = false) override;
+
 		/**
 		 * Enumerates all currently available video devices.
 		 * @param definitions The resulting video devices
@@ -92,10 +104,68 @@ class OCEAN_MEDIA_MF_EXPORT MFLiveVideo :
 		 */
 		void releaseTopology() override;
 
+		/**
+		 * Session started event function.
+		 * @see MFMedium::onSessionStarted().
+		 */
+		void onSessionStarted() override;
+
+		/**
+		 * Session stopped event function.
+		 * @see MFMedium::onSessionStopped().
+		 */
+		void onSessionStopped() override;
+
+		/**
+		 * Determines the exposure range of the camera.
+		 * @param iKsControl The IKsControl interface of the camera, must be valid
+		 * @param minExposure The resulting minimal exposure value, in seconds
+		 * @param maxExposure The resulting maximal exposure value, in seconds
+		 * @return True, if succeeded
+		 */
+		static bool exposureRange(IKsControl* iKsControl, double& minExposure, double& maxExposure);
+
+		/**
+		 * Sets the exposure of the camera.
+		 * @param iKsControl The IKsControl interface of the camera, must be valid
+		 * @param exposure The exposure to be set, in seconds, with range (0, infinity), 0 for auto exposure
+		 * @return True, if succeeded
+		 */
+		static bool setExposure(IKsControl* iKsControl, const double exposure);
+
+		/**
+		 * Returns the exposure of the camera.
+		 * @param iKsControl The IKsControl interface of the camera, must be valid
+		 * @param exposure The resulting exposure value, in seconds
+		 * @param controlMode The resulting control mode
+		 * @return True, if succeeded
+		 */
+		static bool exposure(IKsControl* iKsControl, double& exposure, ControlMode& controlMode);
+
+		/**
+		 * Translates the exposure value from log base 2 to a linear exposure in seconds.
+		 * @param logBase2 The exposure value in log base 2, with range (-infinity, infinity)
+		 * @return The resulting exposure value in seconds, with range [0, infinity)
+		 */
+		static double translateExposure(const LONG logBase2);
+
+		/**
+		 * Translates the exposure value from a linear exposure in seconds to log base 2.
+		 * @param exposure The exposure value in seconds, with range [0, infinity)
+		 * @return The resulting exposure value in log base 2, with range (-infinity, infinity)
+		 */
+		static LONG translateExposure(const double exposure);
+
 	protected:
 
 		/// The symbolic link of the device.
 		std::string symbolicLink_;
+
+		/// True, if the session has been started.
+		bool sesssionStarted_ = false;
+
+		/// The exposure duration of the camera which will be set once the session has been started.
+		double delayedExposureDuration_ = NumericD::minValue();
 };
 
 }

impl/ocean/media/mediafoundation/MediaFoundation.h

@@ -28,6 +28,9 @@
 #endif
 
 DISABLE_WARNINGS_BEGIN
+	#include <devicetopology.h>
+	#include <ks.h>
+	#include <ksproxy.h>
 	#include <mfapi.h>
 	#include <mfidl.h>
 DISABLE_WARNINGS_END
@@ -106,6 +109,13 @@ template <class T> void release(T *object);
 template <typename T>
 using ScopedMediaFoundationObject = ScopedObjectCompileTimeVoidT<T*, release>;
 
+/**
+ * Definition of a scoped object holding a IKsControl object.
+ * The wrapped IKsControl object will be released automatically once the scoped object does not exist anymore.
+ * @ingroup mediamf
+ */
+using ScopedIKsControl = ScopedMediaFoundationObject<IKsControl>;
+
 /**
  * Definition of a scoped object holding a IMFActivate object.
  * The wrapped IMFActivate object will be released automatically once the scoped object does not exist anymore.

impl/ocean/media/mediafoundation/SampleGrabber.cpp

@@ -97,7 +97,7 @@ STDMETHODIMP SampleGrabber::OnSetPresentationClock(IMFPresentationClock* /*pCloc
 	return S_OK;
 }
 
-STDMETHODIMP SampleGrabber::OnProcessSample(REFGUID guidMajorMediaType, DWORD dwSampleFlags, LONGLONG llSampleTime, LONGLONG llSampleDuration, const BYTE * pSampleBuffer, DWORD dwSampleSize)
+STDMETHODIMP SampleGrabber::OnProcessSample(REFGUID guidMajorMediaType, DWORD dwSampleFlags, LONGLONG llSampleTime, LONGLONG llSampleDuration, const BYTE* pSampleBuffer, DWORD dwSampleSize)
 {
 	if (active_)
 	{

impl/ocean/media/mediafoundation/SampleGrabber.h

@@ -135,7 +135,7 @@ class SampleGrabber final : public IMFSampleGrabberSinkCallback
 		 * @param pSampleBuffer A pointer to a buffer that contains the sample data
 		 * @param dwSampleSize Size of the pSampleBuffer buffer, in bytes
 		 */
-		STDMETHODIMP OnProcessSample(REFGUID guidMajorMediaType, DWORD dwSampleFlags, LONGLONG llSampleTime, LONGLONG llSampleDuration, const BYTE * pSampleBuffer, DWORD dwSampleSize) override;
+		STDMETHODIMP OnProcessSample(REFGUID guidMajorMediaType, DWORD dwSampleFlags, LONGLONG llSampleTime, LONGLONG llSampleDuration, const BYTE* pSampleBuffer, DWORD dwSampleSize) override;
 
 		/**
 		 * Called when the sample-grabber sink is shut down.