Create VideoCamera base class and move camera settings functions to it.

This makes them available for both UsbCamera and HttpCamera / AxisCamera.

To avoid virtual functions in the public-facing interface, move the
implementation of the camera settings functions to the core library.

src/CvSourceImpl.cpp

@@ -82,6 +82,41 @@ void CvSourceImpl::SetStringProperty(int property, llvm::StringRef value,
   UpdatePropertyValue(property, true, 0, value);
 }
 
+// These are only valid for cameras (should never get called)
+
+void CvSourceImpl::SetBrightness(int brightness, CS_Status* status) {
+  *status = CS_INVALID_HANDLE;
+}
+
+int CvSourceImpl::GetBrightness(CS_Status* status) const {
+  *status = CS_INVALID_HANDLE;
+  return 0;
+}
+
+void CvSourceImpl::SetWhiteBalanceAuto(CS_Status* status) {
+  *status = CS_INVALID_HANDLE;
+}
+
+void CvSourceImpl::SetWhiteBalanceHoldCurrent(CS_Status* status) {
+  *status = CS_INVALID_HANDLE;
+}
+
+void CvSourceImpl::SetWhiteBalanceManual(int value, CS_Status* status) {
+  *status = CS_INVALID_HANDLE;
+}
+
+void CvSourceImpl::SetExposureAuto(CS_Status* status) {
+  *status = CS_INVALID_HANDLE;
+}
+
+void CvSourceImpl::SetExposureHoldCurrent(CS_Status* status) {
+  *status = CS_INVALID_HANDLE;
+}
+
+void CvSourceImpl::SetExposureManual(int value, CS_Status* status) {
+  *status = CS_INVALID_HANDLE;
+}
+
 bool CvSourceImpl::SetVideoMode(const VideoMode& mode, CS_Status* status) {
   // can't set video mode on OpenCV source
   return false;

src/CvSourceImpl.h

@@ -28,6 +28,16 @@ class CvSourceImpl : public SourceImpl {
   void SetStringProperty(int property, llvm::StringRef value,
                          CS_Status* status) override;
 
+  // Standard common camera properties
+  void SetBrightness(int brightness, CS_Status* status) override;
+  int GetBrightness(CS_Status* status) const override;
+  void SetWhiteBalanceAuto(CS_Status* status) override;
+  void SetWhiteBalanceHoldCurrent(CS_Status* status) override;
+  void SetWhiteBalanceManual(int value, CS_Status* status) override;
+  void SetExposureAuto(CS_Status* status) override;
+  void SetExposureHoldCurrent(CS_Status* status) override;
+  void SetExposureManual(int value, CS_Status* status) override;
+
   bool SetVideoMode(const VideoMode& mode, CS_Status* status) override;
 
   void NumSinksChanged() override;

src/HttpCameraImpl.cpp

@@ -387,6 +387,39 @@ void HttpCameraImpl::SetStringProperty(int property, llvm::StringRef value,
   // TODO
 }
 
+void HttpCameraImpl::SetBrightness(int brightness, CS_Status* status) {
+  // TODO
+}
+
+int HttpCameraImpl::GetBrightness(CS_Status* status) const {
+  // TODO
+  return 0;
+}
+
+void HttpCameraImpl::SetWhiteBalanceAuto(CS_Status* status) {
+  // TODO
+}
+
+void HttpCameraImpl::SetWhiteBalanceHoldCurrent(CS_Status* status) {
+  // TODO
+}
+
+void HttpCameraImpl::SetWhiteBalanceManual(int value, CS_Status* status) {
+  // TODO
+}
+
+void HttpCameraImpl::SetExposureAuto(CS_Status* status) {
+  // TODO
+}
+
+void HttpCameraImpl::SetExposureHoldCurrent(CS_Status* status) {
+  // TODO
+}
+
+void HttpCameraImpl::SetExposureManual(int value, CS_Status* status) {
+  // TODO
+}
+
 bool HttpCameraImpl::SetVideoMode(const VideoMode& mode, CS_Status* status) {
   if (mode.pixelFormat != VideoMode::kMJPEG) return false;
   std::lock_guard<std::mutex> lock(m_mutex);

src/HttpCameraImpl.h

@@ -37,6 +37,16 @@ class HttpCameraImpl : public SourceImpl {
   void SetStringProperty(int property, llvm::StringRef value,
                          CS_Status* status) override;
 
+  // Standard common camera properties
+  void SetBrightness(int brightness, CS_Status* status) override;
+  int GetBrightness(CS_Status* status) const override;
+  void SetWhiteBalanceAuto(CS_Status* status) override;
+  void SetWhiteBalanceHoldCurrent(CS_Status* status) override;
+  void SetWhiteBalanceManual(int value, CS_Status* status) override;
+  void SetExposureAuto(CS_Status* status) override;
+  void SetExposureHoldCurrent(CS_Status* status) override;
+  void SetExposureManual(int value, CS_Status* status) override;
+
   bool SetVideoMode(const VideoMode& mode, CS_Status* status) override;
 
   void NumSinksChanged() override;

src/SourceImpl.h

@@ -107,6 +107,16 @@ class SourceImpl {
   std::vector<std::string> GetEnumPropertyChoices(int property,
                                                   CS_Status* status) const;
 
+  // Standard common camera properties
+  virtual void SetBrightness(int brightness, CS_Status* status) = 0;
+  virtual int GetBrightness(CS_Status* status) const = 0;
+  virtual void SetWhiteBalanceAuto(CS_Status* status) = 0;
+  virtual void SetWhiteBalanceHoldCurrent(CS_Status* status) = 0;
+  virtual void SetWhiteBalanceManual(int value, CS_Status* status) = 0;
+  virtual void SetExposureAuto(CS_Status* status) = 0;
+  virtual void SetExposureHoldCurrent(CS_Status* status) = 0;
+  virtual void SetExposureManual(int value, CS_Status* status) = 0;
+
   // Video mode functions
   VideoMode GetVideoMode(CS_Status* status) const;
   virtual bool SetVideoMode(const VideoMode& mode, CS_Status* status) = 0;

src/UsbCameraImpl.cpp

@@ -42,6 +42,12 @@
 
 using namespace cs;
 
+static constexpr char const* kPropWbAuto = "white_balance_temperature_auto";
+static constexpr char const* kPropWbValue = "white_balance_temperature";
+static constexpr char const* kPropExAuto = "exposure_auto";
+static constexpr char const* kPropExValue = "exposure_absolute";
+static constexpr char const* kPropBrValue = "brightness";
+
 #ifdef __linux__
 
 // Conversions v4l2_fract time per frame from/to frames per second (fps)
@@ -1139,6 +1145,51 @@ void UsbCameraImpl::SetStringProperty(int property, llvm::StringRef value,
   *status = SendAndWait(std::move(msg));
 }
 
+void UsbCameraImpl::SetBrightness(int brightness, CS_Status* status) {
+  if (brightness > 100) {
+    brightness = 100;
+  } else if (brightness < 0) {
+    brightness = 0;
+  }
+  SetProperty(GetPropertyIndex(kPropBrValue), brightness, status);
+}
+
+int UsbCameraImpl::GetBrightness(CS_Status* status) const {
+  return GetProperty(GetPropertyIndex(kPropBrValue), status);
+}
+
+void UsbCameraImpl::SetWhiteBalanceAuto(CS_Status* status) {
+  SetProperty(GetPropertyIndex(kPropWbAuto), 1, status);  // auto
+}
+
+void UsbCameraImpl::SetWhiteBalanceHoldCurrent(CS_Status* status) {
+  SetProperty(GetPropertyIndex(kPropWbAuto), 0, status);  // manual
+}
+
+void UsbCameraImpl::SetWhiteBalanceManual(int value, CS_Status* status) {
+  SetProperty(GetPropertyIndex(kPropWbAuto), 0, status);  // manual
+  SetProperty(GetPropertyIndex(kPropWbValue), value, status);
+}
+
+void UsbCameraImpl::SetExposureAuto(CS_Status* status) {
+  // auto; yes, this is opposite of WB
+  SetProperty(GetPropertyIndex(kPropExAuto), 0, status);
+}
+
+void UsbCameraImpl::SetExposureHoldCurrent(CS_Status* status) {
+  SetProperty(GetPropertyIndex(kPropExAuto), 1, status);  // manual
+}
+
+void UsbCameraImpl::SetExposureManual(int value, CS_Status* status) {
+  SetProperty(GetPropertyIndex(kPropExAuto), 1, status);  // manual
+  if (value > 100) {
+    value = 100;
+  } else if (value < 0) {
+    value = 0;
+  }
+  SetProperty(GetPropertyIndex(kPropExValue), value, status);
+}
+
 bool UsbCameraImpl::SetVideoMode(const VideoMode& mode, CS_Status* status) {
   Message msg{Message::kCmdSetMode};
   msg.data[0] = mode.pixelFormat;

src/UsbCameraImpl.h

@@ -39,6 +39,16 @@ class UsbCameraImpl : public SourceImpl {
   void SetStringProperty(int property, llvm::StringRef value,
                          CS_Status* status) override;
 
+  // Standard common camera properties
+  void SetBrightness(int brightness, CS_Status* status) override;
+  int GetBrightness(CS_Status* status) const override;
+  void SetWhiteBalanceAuto(CS_Status* status) override;
+  void SetWhiteBalanceHoldCurrent(CS_Status* status) override;
+  void SetWhiteBalanceManual(int value, CS_Status* status) override;
+  void SetExposureAuto(CS_Status* status) override;
+  void SetExposureHoldCurrent(CS_Status* status) override;
+  void SetExposureManual(int value, CS_Status* status) override;
+
   bool SetVideoMode(const VideoMode& mode, CS_Status* status) override;
   bool SetPixelFormat(VideoMode::PixelFormat pixelFormat,
                       CS_Status* status) override;

src/cscore_c.cpp

@@ -186,6 +186,41 @@ void CS_ReleaseSource(CS_Source source, CS_Status* status) {
   return cs::ReleaseSource(source, status);
 }
 
+void CS_SetCameraBrightness(CS_Source source, int brightness,
+                            CS_Status* status) {
+  return cs::SetCameraBrightness(source, brightness, status);
+}
+
+int CS_GetCameraBrightness(CS_Source source, CS_Status* status) {
+  return cs::GetCameraBrightness(source, status);
+}
+
+void CS_SetCameraWhiteBalanceAuto(CS_Source source, CS_Status* status) {
+  return cs::SetCameraWhiteBalanceAuto(source, status);
+}
+
+void CS_SetCameraWhiteBalanceHoldCurrent(CS_Source source, CS_Status* status) {
+  return cs::SetCameraWhiteBalanceHoldCurrent(source, status);
+}
+
+void CS_SetCameraWhiteBalanceManual(CS_Source source, int value,
+                                    CS_Status* status) {
+  return cs::SetCameraWhiteBalanceManual(source, value, status);
+}
+
+void CS_SetCameraExposureAuto(CS_Source source, CS_Status* status) {
+  return cs::SetCameraExposureAuto(source, status);
+}
+
+void CS_SetCameraExposureHoldCurrent(CS_Source source, CS_Status* status) {
+  return cs::SetCameraExposureHoldCurrent(source, status);
+}
+
+void CS_SetCameraExposureManual(CS_Source source, int value,
+                                CS_Status* status) {
+  return cs::SetCameraExposureManual(source, value, status);
+}
+
 CS_SinkKind CS_GetSinkKind(CS_Sink sink, CS_Status* status) {
   return cs::GetSinkKind(sink, status);
 }

src/cscore_cpp.cpp

@@ -348,6 +348,83 @@ void ReleaseSource(CS_Source source, CS_Status* status) {
   }
 }
 
+//
+// Camera Source Common Property Fuctions
+//
+
+void SetCameraBrightness(CS_Source source, int brightness, CS_Status* status) {
+  auto data = Sources::GetInstance().Get(source);
+  if (!data) {
+    *status = CS_INVALID_HANDLE;
+    return;
+  }
+  data->source->SetBrightness(brightness, status);
+}
+
+int GetCameraBrightness(CS_Source source, CS_Status* status) {
+  auto data = Sources::GetInstance().Get(source);
+  if (!data) {
+    *status = CS_INVALID_HANDLE;
+    return 0;
+  }
+  return data->source->GetBrightness(status);
+}
+
+void SetCameraWhiteBalanceAuto(CS_Source source, CS_Status* status) {
+  auto data = Sources::GetInstance().Get(source);
+  if (!data) {
+    *status = CS_INVALID_HANDLE;
+    return;
+  }
+  data->source->SetWhiteBalanceAuto(status);
+}
+
+void SetCameraWhiteBalanceHoldCurrent(CS_Source source, CS_Status* status) {
+  auto data = Sources::GetInstance().Get(source);
+  if (!data) {
+    *status = CS_INVALID_HANDLE;
+    return;
+  }
+  data->source->SetWhiteBalanceHoldCurrent(status);
+}
+
+void SetCameraWhiteBalanceManual(CS_Source source, int value,
+                                 CS_Status* status) {
+  auto data = Sources::GetInstance().Get(source);
+  if (!data) {
+    *status = CS_INVALID_HANDLE;
+    return;
+  }
+  data->source->SetWhiteBalanceManual(value, status);
+}
+
+void SetCameraExposureAuto(CS_Source source, CS_Status* status) {
+  auto data = Sources::GetInstance().Get(source);
+  if (!data) {
+    *status = CS_INVALID_HANDLE;
+    return;
+  }
+  data->source->SetExposureAuto(status);
+}
+
+void SetCameraExposureHoldCurrent(CS_Source source, CS_Status* status) {
+  auto data = Sources::GetInstance().Get(source);
+  if (!data) {
+    *status = CS_INVALID_HANDLE;
+    return;
+  }
+  data->source->SetExposureHoldCurrent(status);
+}
+
+void SetCameraExposureManual(CS_Source source, int value, CS_Status* status) {
+  auto data = Sources::GetInstance().Get(source);
+  if (!data) {
+    *status = CS_INVALID_HANDLE;
+    return;
+  }
+  data->source->SetExposureManual(value, status);
+}
+
 //
 // Sink Functions
 //