StreamId.h

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <cstdint>
#include <string>
 
#include <vrs/os/Platform.h>
 
namespace vrs {
 
using std::string;
 
enum class RecordableTypeId : uint16_t {
  // for VRS internal use only
  VRSIndex = 1, 
  VRSDescription = 2, 
 
  // Generic devices using RecordFormat and DataLayout, and following DataLayout conventions.
  ImageStream = 100, 
  AudioStream = 101, 
  AnnotationStream = 102, 
  ArchiveStream = 103, 
 
  // << Start of Recordable Class IDs >>
 
  // "Recordable Class" IDs designed to make adding new enum values unnecessary going forward.
  // Use a combination of "Recordable Class" ID and "flavor" to describe your use case uniquely.
  // Many of these recordable class IDs are in anticipation of a potential future use case.
 
  // << Cameras >>
  // Cameras are arguably the most the important and common class of devices of all.
  // New devices include many different types at the same time, hence the wide variety offered.
 
  ForwardCameraRecordableClass = 200, 
  UpwardCameraRecordableClass = 201, 
  DownwardCameraRecordableClass = 202, 
  BackwardCameraRecordableClass = 203, 
  SidewardCameraRecordableClass = 204, 
  OutwardCameraRecordableClass = 205, 
  InwardCameraRecordableClass = 206, 
  InsideOutCameraRecordableClass = 207, 
  OutsideInCameraRecordableClass = 208, 
  DepthCameraRecordableClass = 209, 
  IRCameraRecordableClass = 210, 
  EyeCameraRecordableClass = 211, 
  FaceCameraRecordableClass = 212, 
  MouthCameraRecordableClass = 213, 
  RgbCameraRecordableClass = 214, 
  DisplayObserverCameraRecordableClass = 215, 
  WorldObserverCameraRecordableClass = 216, 
  DisparityCameraRecordableClass = 217, 
 
  // << Microphones >>
  MonoAudioRecordableClass = 230, 
  StereoAudioRecordableClass = 231, 
  AmbientAudioRecordableClass = 232, 
 
  // << Discrete Sensors >>
  SensorRecordableClass = 240, 
  ImuRecordableClass = 241, 
  AccelerometerRecordableClass = 242, 
  MagnetometerRecordableClass = 243, 
  GyroscopeRecordableClass = 244, 
  LidarRecordableClass = 245, 
  TemperatureRecordableClass = 246, 
  BarometerRecordableClass = 247, 
  PhotoplethysmogramRecordableClass = 248, 
  EMGRecordableClass = 249, 
  CapacitiveTouchRecordableClass = 250, 
  HeartRateRecordableClass = 251, 
  CaloriesRecordableClass = 252, 
  CsaRecordableClass = 253, 
  RadarRecordableClass = 254, 
  StepCountRecordableClass = 255, 
  ForceRecordableClass = 256, 
  DistanceRecordableClass = 257, 
  ActiveMinutesRecordableClass = 258, 
  HeadingRecordableClass = 259, 
  // << Discrete sensors continue below at 500 >>
 
  // << Calibration, Setup, Diagnostic, etc >>
  CalibrationRecordableClass = 260, 
  AlignmentRecordableClass = 261, 
  SetupRecordableClass = 262, 
  DiagnosticRecordableClass = 263, 
  PerformanceRecordableClass = 264, 
  IlluminationRecordableClass = 265, 
  DisplayRecordableClass = 266, 
 
  // << External Signals >>
  SyncRecordableClass = 280, 
  GpsRecordableClass = 281, 
  WifiBeaconRecordableClass = 282, 
  BluetoothBeaconRecordableClass = 283, 
  UsbRecordableClass = 284, 
  TimeRecordableClass = 285, 
  AttentionRecordableClass = 286, 
  GMSRecordableClass = 287, 
 
  // << User Input >>
  InputRecordableClass = 300, 
  TextInputRecordableClass = 301, 
  MouseRecordableClass = 302, 
  TouchInputRecordableClass = 303, 
  GestureInputRecordableClass = 304, 
  ControllerRecordableClass = 305, 
 
  // << Events, commands, instructions, etc >>
  EventRecordableClass = 320, 
  CommandRecordableClass = 321, 
  InstructionRecordableClass = 322, 
  ScriptRecordableClass = 323, 
  ControlRecordableClass = 324, 
  PipelineEventRecordableClass = 325, 
 
  // << Ground Truth >>
  GroundTruthRecordableClass = 340, 
  GroundTruthImuRecordableClass = 341, 
  GroundTruthAlignmentRecordableClass = 342, 
  GroundTruthPositionRecordableClass = 343, 
  GroundTruthOrientationRecordableClass = 344, 
  GroundTruthDepthRecordableClass = 345, 
 
  // << Results of all kinds >>
  ResultRecordableClass = 370, 
  PoseRecordableClass = 371, 
  MotionRecordableClass = 372, 
  GazeRecordableClass = 373, 
  MeshRecordableClass = 374, 
  MocapRecordableClass = 375, 
  PointCloudRecordableClass = 376, 
  MapRecordableClass = 377, 
  SensorVarianceBiasRecordableClass = 378, 
  AnchorRecordableClass = 379, 
  SegmentationRecordableClass = 380, 
  TextRecordableClass = 381, 
  EMGGestureRecordableClass = 382, 
  SpeechRecordableClass = 383, 
  QuaternionRecordableClass = 384, 
  UltrasonicRecordableClass = 385, 
 
  // << Annotations >>
  AnnotationRecordableClass = 400, 
 
  // << Discrete Sensors (continued) >>
  AmbientLightRecordableClass = 500, 
  ElevationRecordableClass = 501, 
 
  // << Test, Samples and other fake devices >>
  SampleDeviceRecordableClass = 998, 
  UnitTestRecordableClass = 999, 
 
  // The range 200-999 is reserved for "Recordable Class" IDs exclusively.
  FirstRecordableClassId = 200, 
  LastRecordableClassId = 999, 
 
  // << End of Recordable Class IDs >>
 
  // Legacy values needed for open source purposes.
  SlamCameraData = 1201, 
  SlamImuData = 1202, 
  SlamMagnetometerData = 1203, 
 
#if IS_VRS_FB_INTERNAL()
#include "StreamId_fb.h"
#endif
 
  // Test devices start at 65500.
  TestDevices = 65500,
  UnitTest1 = TestDevices, 
  UnitTest2, 
  SampleDevice, 
 
  Undefined = 65535 
};
 
string toString(RecordableTypeId typeId);
 
inline bool isARecordableClass(RecordableTypeId typeId) {
  return typeId >= RecordableTypeId::FirstRecordableClassId &&
      typeId <= RecordableTypeId::LastRecordableClassId;
}
 
class StreamId {
 public:
  StreamId() : typeId_{RecordableTypeId::Undefined}, instanceId_{0} {}
  StreamId(const StreamId& rhs) = default;
  StreamId(RecordableTypeId typeId, uint16_t instanceId)
      : typeId_{typeId}, instanceId_{instanceId} {}
 
  RecordableTypeId getTypeId() const {
    return typeId_;
  }
 
  uint16_t getInstanceId() const {
    return instanceId_;
  }
 
  StreamId& operator=(const StreamId& rhs) = default;
  StreamId& operator=(StreamId&& rhs) = default;
  bool operator==(const StreamId& rhs) const {
    return typeId_ == rhs.typeId_ && instanceId_ == rhs.instanceId_;
  }
 
  bool operator!=(const StreamId& rhs) const {
    return !operator==(rhs);
  }
 
  bool operator<(const StreamId& rhs) const {
    return typeId_ < rhs.typeId_ || (typeId_ == rhs.typeId_ && instanceId_ < rhs.instanceId_);
  }
 
  bool isValid() const {
    return typeId_ != RecordableTypeId::Undefined;
  }
 
  string getTypeName() const {
    return toString(typeId_);
  }
  string getName() const;
  string getFullName() const;
  string getNumericName() const;
  static StreamId fromNumericName(const string& numericName);
  static StreamId fromNumericNamePlus(const string& numericName);
 
  static bool isKnownTypeId(RecordableTypeId typeId);
 
  static StreamId lowest() {
    return {static_cast<RecordableTypeId>(0), 0};
  }
 
 private:
  RecordableTypeId typeId_; 
  uint16_t instanceId_; 
};
 
} // namespace vrs