Add data accessors for USBCamera and MJPEGServer.

USBCamera: getPath()

MJPEGServer: getListenAddress() and getPort()

src/MJPEGServerImpl.cpp

@@ -15,6 +15,7 @@
 #include "support/raw_socket_ostream.h"
 #include "tcpsockets/TCPAcceptor.h"
 
+#include "c_util.h"
 #include "cscore_cpp.h"
 #include "Handle.h"
 #include "Log.h"
@@ -401,11 +402,19 @@ void MJPEGServerImpl::ConnThread::SendJSON(llvm::raw_ostream& os,
 }
 
 MJPEGServerImpl::MJPEGServerImpl(llvm::StringRef name,
-                                 llvm::StringRef description,
+                                 llvm::StringRef listenAddress, int port,
                                  std::unique_ptr<wpi::NetworkAcceptor> acceptor)
-    : SinkImpl{name}, m_acceptor{std::move(acceptor)} {
+    : SinkImpl{name},
+      m_listenAddress(listenAddress),
+      m_port(port),
+      m_acceptor{std::move(acceptor)} {
   m_active = true;
-  SetDescription(description);
+
+  llvm::SmallString<128> descBuf;
+  llvm::raw_svector_ostream desc{descBuf};
+  desc << "HTTP Server on port " << port;
+  SetDescription(desc.str());
+
   m_serverThread = std::thread(&MJPEGServerImpl::ServerThreadMain, this);
 }
 
@@ -689,12 +698,9 @@ namespace cs {
 
 CS_Sink CreateMJPEGServer(llvm::StringRef name, llvm::StringRef listenAddress,
                           int port, CS_Status* status) {
-  llvm::SmallString<128> descBuf;
-  llvm::raw_svector_ostream desc{descBuf};
-  desc << "HTTP Server on port " << port;
   llvm::SmallString<128> str{listenAddress};
   auto sink = std::make_shared<MJPEGServerImpl>(
-      name, desc.str(),
+      name, listenAddress, port,
       std::unique_ptr<wpi::NetworkAcceptor>(
           new wpi::TCPAcceptor(port, str.c_str(), Logger::GetInstance())));
   auto handle = Sinks::GetInstance().Allocate(CS_SINK_MJPEG, sink);
@@ -702,6 +708,24 @@ CS_Sink CreateMJPEGServer(llvm::StringRef name, llvm::StringRef listenAddress,
   return handle;
 }
 
+std::string GetMJPEGServerListenAddress(CS_Sink sink, CS_Status* status) {
+  auto data = Sinks::GetInstance().Get(sink);
+  if (!data || data->kind != CS_SINK_MJPEG) {
+    *status = CS_INVALID_HANDLE;
+    return std::string{};
+  }
+  return static_cast<MJPEGServerImpl&>(*data->sink).GetListenAddress();
+}
+
+int GetMJPEGServerPort(CS_Sink sink, CS_Status* status) {
+  auto data = Sinks::GetInstance().Get(sink);
+  if (!data || data->kind != CS_SINK_MJPEG) {
+    *status = CS_INVALID_HANDLE;
+    return 0;
+  }
+  return static_cast<MJPEGServerImpl&>(*data->sink).GetPort();
+}
+
 }  // namespace cs
 
 extern "C" {
@@ -711,4 +735,12 @@ CS_Sink CS_CreateMJPEGServer(const char* name, const char* listenAddress,
   return cs::CreateMJPEGServer(name, listenAddress, port, status);
 }
 
+char* CS_GetMJPEGServerListenAddress(CS_Sink sink, CS_Status* status) {
+  return ConvertToC(cs::GetMJPEGServerListenAddress(sink, status));
+}
+
+int CS_GetMJPEGServerPort(CS_Sink sink, CS_Status* status) {
+  return cs::GetMJPEGServerPort(sink, status);
+}
+
 }  // extern "C"

src/MJPEGServerImpl.h

@@ -30,11 +30,13 @@ class SourceImpl;
 
 class MJPEGServerImpl : public SinkImpl {
  public:
-  MJPEGServerImpl(llvm::StringRef name, llvm::StringRef description,
+  MJPEGServerImpl(llvm::StringRef name, llvm::StringRef listenAddress, int port,
                   std::unique_ptr<wpi::NetworkAcceptor> acceptor);
   ~MJPEGServerImpl() override;
 
   void Stop();
+  std::string GetListenAddress() { return m_listenAddress; }
+  int GetPort() { return m_port; }
 
  private:
   void SetSourceImpl(std::shared_ptr<SourceImpl> source) override;
@@ -43,6 +45,10 @@ class MJPEGServerImpl : public SinkImpl {
 
   class ConnThread;
 
+  // Never changed, so not protected by mutex
+  std::string m_listenAddress;
+  int m_port;
+
   std::unique_ptr<wpi::NetworkAcceptor> m_acceptor;
   std::atomic_bool m_active;  // set to false to terminate threads
   std::thread m_serverThread;

src/USBCameraImpl.cpp

@@ -1405,6 +1405,15 @@ CS_Source CreateUSBCameraPath(llvm::StringRef name, llvm::StringRef path,
   return handle;
 }
 
+std::string GetUSBCameraPath(CS_Source source, CS_Status* status) {
+  auto data = Sources::GetInstance().Get(source);
+  if (!data || data->kind != CS_SOURCE_USB) {
+    *status = CS_INVALID_HANDLE;
+    return std::string{};
+  }
+  return static_cast<USBCameraImpl&>(*data->source).GetPath();
+}
+
 std::vector<USBCameraInfo> EnumerateUSBCameras(CS_Status* status) {
   std::vector<USBCameraInfo> retval;
 
@@ -1454,6 +1463,10 @@ CS_Source CS_CreateUSBCameraPath(const char* name, const char* path,
   return cs::CreateUSBCameraPath(name, path, status);
 }
 
+char* CS_GetUSBCameraPath(CS_Source source, CS_Status* status) {
+  return ConvertToC(cs::GetUSBCameraPath(source, status));
+}
+
 CS_USBCameraInfo* CS_EnumerateUSBCameras(int* count, CS_Status* status) {
   auto cameras = cs::EnumerateUSBCameras(status);
   CS_USBCameraInfo* out = static_cast<CS_USBCameraInfo*>(

src/USBCameraImpl.h

@@ -49,6 +49,8 @@ class USBCameraImpl : public SourceImpl {
   void NumSinksChanged() override;
   void NumSinksEnabledChanged() override;
 
+  std::string GetPath() { return m_path; }
+
   // Property data
   class PropertyData : public PropertyBase {
    public: