types.h

Go to the documentation of this file.

#pragma once
 
#include <string>
 
namespace duvc {
 
enum class CamProp {
  Pan,                   
  Tilt,                  
  Roll,                  
  Zoom,                  
  Exposure,              
  Iris,                  
  Focus,                 
  ScanMode,              
  Privacy,               
  PanRelative,           
  TiltRelative,          
  RollRelative,          
  ZoomRelative,          
  ExposureRelative,      
  IrisRelative,          
  FocusRelative,         
  PanTilt,               
  PanTiltRelative,       
  FocusSimple,           
  DigitalZoom,           
  DigitalZoomRelative,   
  BacklightCompensation, 
  Lamp                   
};
 
enum class VidProp {
  Brightness,            
  Contrast,              
  Hue,                   
  Saturation,            
  Sharpness,             
  Gamma,                 
  ColorEnable,           
  WhiteBalance,          
  BacklightCompensation, 
  Gain,                  
  DigitalMultiplier,     
  DigitalMultiplierLimit, 
  WhiteBalanceComponent, 
  PowerLineFrequency,    
};
 
enum class CamMode {
  Auto,  
  Manual 
};
 
struct PropSetting {
  int value;    
  CamMode mode; 
 
  PropSetting() = default;
 
  PropSetting(int v, CamMode m) : value(v), mode(m) {}
};
 
struct PropRange {
  int min;              
  int max;              
  int step;             
  int default_val;      
  CamMode default_mode; 
 
  PropRange() = default;
 
  bool is_valid(int value) const {
    if (step <= 0) {
      return false;
    }
 
    return value >= min && value <= max && ((value - min) % step == 0);
  }
 
  int clamp(int value) const {
    if (step <= 0) {
      if (value <= min)
        return min;
      if (value >= max)
        return max;
      return value;
    }
 
    if (value <= min)
      return min;
    if (value >= max)
      return max;
 
    // Round to nearest step
    int steps = (value - min + step / 2) / step;
    return min + steps * step;
  }
};
 
struct Device {
    std::wstring name; 
    std::wstring path; 
 
    Device() = default;
 
    Device(std::wstring n, std::wstring p)
        : name(std::move(n)), path(std::move(p)) {}
 
    Device(const Device& other)
        : name(other.name), path(other.path) {}
 
    Device& operator=(const Device& other) {
        if (this != &other) {
            name = other.name;
            path = other.path;
        }
        return *this;
    }
 
    Device(Device&&) noexcept = default;
 
    Device& operator=(Device&&) noexcept = default;
 
    bool is_valid() const { return !name.empty() && !path.empty(); }
 
    const std::wstring &get_id() const { return path.empty() ? name : path; }
};
 
} // namespace duvc