Level recording schema specification 1.1

The FBS schema view provides a structured representation of the FBS data model for analysis and integration.

You can download the FBS schema here.


namespace Lr;

// Schema Version: v1.1.0
table SchemaVersion {
  major:ubyte;
  minor:ubyte;
  patch:ubyte;
}

enum MdState:byte {Connected, Updating, Syncing, Sleeping, Disconnected}
enum HeadphonePlugState:byte {NotAvailable, Unplugged, Plugged}
enum AntennaPort:byte {A,B,C,D}
enum RfChannelId:byte {_1, _2}
enum InputSource:byte {Madi1, Madi2, AoIP}
enum OutputMode:byte {On, Off, Mute, Talk}
enum AntennaState:byte {Initialized,
                      Updating,
                      Connected,
                      Error,
                      Unconnected}
enum AntennaBinding:byte {RfChannel1, RfChannel2, Scan, NotBound}
enum RfBandwidth:byte { _6MHz, _8MHz, _10MHz}
enum RfState:byte {RfActive, RfMuted}
enum PsuState:byte {Connected, Disconnected, Unconnected}
enum SystemState:byte {Initializing, Normal, Warmup, Cooldown, FactoryReset, Standby, CriticalFailure}
enum TemperatureStateOverall:byte {Low, Normal, High, Critical}
enum FanError:byte {Ok, Error1, Error2, Broken}
enum AoipType:byte {None, Unknown, Dante, Ravenna} // Type of audio over IP (AoIP) interface: None=no AoIP interface, Unknown=unknown AoIP interface, Dante=Dante AoIP interface, Ravenna=Ravenna AoIP interface
enum MadiModuleType:byte {None, Unknown, Coax, OpticalMultimode} // Status of MADI slot module: None=no MADI module found, Unknown=unknown MADI module found, Coax=BNC Coax MADI module found, OpticalMultimode=Optical Multimode MADI module found
enum SampleRateClassHz:byte {_0, _16000, _22050, _24000, _32000, _44100, _48000, _64000, _88200, _96000, _128000, _176400, _192000} // Sample rate classes in Hz
enum SampleRateClassHzOutput:byte {_0, _48000, _96000} // Possible output sample rate classes in Hz
// Status of audio clock input signal
enum ClockStatus:byte {
  NoToggle,       // Input signal is not toggling or too slow
  TooFast,        // Input signal is too fast
  Mismatch,       // Input signal is detected but could not be used (only for MADI)
  Unlocked,       // Input signal is toggling but PLL is not locked (yet)
  Locked,         // Input signal is valid and PLL is locked
  LoopThrough     // Input signal is looped through to the output (only for Word Clock, only in non-operational state)
}
// Possible audio clock sources
enum OutputClockSource:byte {
  Internal48kHz,  // Leader mode, use internal 48 kHz
  Internal96kHz,  // Leader mode, use internal 96 kHz
  WordclockIn,    // Follow Word Clock BNC input
  AoIp,           // Follow Audio over IP
  Madi1In,        // Follow MADI 1 input
  Madi2In         // Follow MADI 2 input
}
enum CommandState:byte {Unknown, NotAvailable, Released, Pressed, Unlatched, Latched}
enum CommandBehavior:byte {Disabled, Momentary, Latching}
enum MicLineSelection:byte {Auto, Mic, Line}
enum MicLineSelectionAutoValue:byte {Unknown, Mic, Line}

// **** Base Station ****

struct PsuStates {
  state:[PsuState:2];
}
struct FanErrors {
  error:[FanError:3];
}
table BaseStation {
  psu_states:PsuStates;
  system_state:SystemState;
  temperature_state_overall:TemperatureStateOverall;
  fan_errors:FanErrors;
}

// **** Audio Metering ****

struct AudioMeteringPerChannel {
  peak:[ubyte:64]; // 64 times per frame, [0..255] -> [-127.5..0] in 0.5 dB steps
  rms:[ubyte:64];  // 64 times per frame, [0..255] -> [-127.5..0] in 0.5 dB steps
}

struct AudioMetering {
  madi1_in:[AudioMeteringPerChannel:32];
  madi2_in:[AudioMeteringPerChannel:32];
  aoip_in:[AudioMeteringPerChannel:32];
  madi1_out:[AudioMeteringPerChannel:32];
  madi2_out:[AudioMeteringPerChannel:32];
  aoip_out:[AudioMeteringPerChannel:32];
}

// **** Mobile Device ****

struct IemLqi {
  value:ubyte; // 3 bit, once per frame
}

struct MicLqi {
  value:[ubyte:64]; // 3 bit, 64 times per frame
}

struct MicRssiPerAntenna {
  value:[byte:64]; // [-100..20]dBm, 64 times per frame
}

struct MicRssi {
  antenna:[MicRssiPerAntenna:4]; // 4 antennas
}

struct ControlRssi {
  value:byte; // [-100..20]dBm, once per frame
}

struct DominantAntenna {
  value:AntennaPort;
}

struct InterferenceSeverityMd {
  value:ubyte; // 3 bit, 0: none, 1: low, 2: mid, 3: high, 7: not available
}

table Battery {
  percentage:ubyte; // 0..100
  runtime:ushort; // in minutes
  is_low:ubyte;
}

table IemLink {
  audiolink_mode:uint32;
  input_channel:uint8;
  input_source:InputSource;
  lqi:IemLqi;
}

table MicChannel {
  output_channel:uint8;
  output_mode_madi1:OutputMode;
  output_mode_madi2:OutputMode;
  output_mode_aoip:OutputMode;
}

table MicLinkSek {
  audiolink_mode:uint32;
  channels:[MicChannel];
  lqi:MicLqi;
  command_state:CommandState;
  mic_line_selection_auto_value:MicLineSelectionAutoValue;
}

table MicLinkSkm {
  audiolink_mode:uint32;
  channels:[MicChannel];
  lqi:MicLqi;
  command_state:CommandState;
}

table Sek {

  // fields that are always available, independent from the state.
  uid:uint32;
  rf_channel_id:RfChannelId;
  name:string;
  state:MdState;
  headphone_volume:ubyte; // [0..255] -> [-100..27.5] in 0.5 dB steps
  headphone_plug_state:HeadphonePlugState;
  
  // fields that are present if MdState is not Disconnected or Sleeping
  battery:Battery;
  control_rssi:ControlRssi;
  dominant_antenna:DominantAntenna;
  interference_severity:InterferenceSeverityMd;
  mic_rssi:MicRssi;

  iem_link:IemLink; // present if a iem link is configured
  mic_link:MicLinkSek; // present if a mic link is configured
  
  command_behavior:CommandBehavior;
  mic_line_selection:MicLineSelection;
}

table Skm {

  // fields that are always available, independent from the state.
  uid:uint32;
  rf_channel_id:RfChannelId;
  name:string;
  state:MdState;
  
  // fields that are present if MdState is not Disconnected or Sleeping
  battery:Battery;
  control_rssi:ControlRssi;
  dominant_antenna:DominantAntenna;
  interference_severity:InterferenceSeverityMd;
  mic_rssi:MicRssi;

  mic_link:MicLinkSkm; // present if a mic link is configured
  
  command_behavior:CommandBehavior;
}

// **** Antenna ****

struct AntennaTemperature {
  temperature:byte; // [-55 .. 150] in degrees Celsius
  warning_high_temperature:bool;
}

struct ScanSlot {
  input_power:[byte:64]; // [-100..20]dBm, 64 times per frame
  residual_power:[byte:64]; // [-100..20]dBm, 64 times per frame
  total_severity:[ubyte:64]; // 2bit, 64 times per frame
  residual_severity:[ubyte:64]; // 2bit, 64 times per frame
}

table Antenna {

  // fields that are always available, independent from the state
  port:AntennaPort;
  state:AntennaState;
  binding:AntennaBinding;
  warning_packet_error:bool;

  temperature:AntennaTemperature; // present if AntennaState is not Unconnected or Error
  scanslot:ScanSlot; // present if AntennaState is Initialized and bound to an RF channel
}

// **** RF Channel ****

table RfChannel {
  id:RfChannelId;
  center_frequency:uint32;
  bandwidth:RfBandwidth;
  state:RfState;
}

// **** Audio Interfaces ****

table Aoip {
  type:AoipType;
  clock_status:ClockStatus;
  sample_rate_class:SampleRateClassHz;
  mute:bool;
}

table WclkInput {
  clock_status:ClockStatus;
  sample_rate_class:SampleRateClassHz;
}

table WclkOutput {
  clock_source:OutputClockSource;
  clock_source_status:ClockStatus;
  fallback_clock_active:bool; // True if selected input source is not valid and fallback to internal rate was necessary
  sample_rate_class:SampleRateClassHzOutput;
}

table WCLK {
  input:WclkInput;
  output:WclkOutput;
}

table MadiInput {
  clock_status:ClockStatus;
  sample_rate_class:SampleRateClassHz;
  mute:bool;
  channels:uint8; // Detected number of MADI input channels (0 if ModuleType is None or Status is not Locked)
  fewer_channels_than_used:bool; // True if at least one audio link is configured to a MADI input channel that is not available
}

table MadiOutput {
  clock_source:OutputClockSource;
  clock_source_status:ClockStatus;
  fallback_clock_active:bool; // True if selected input source is not valid and fallback to internal rate was necessary
  sample_rate_class:SampleRateClassHzOutput;
  mute:bool;
  channels:uint8; // Number of MADI output channels (0 if ModuleType is None)
}

table MADI {
  module_type:MadiModuleType;
  input:MadiInput;
  output:MadiOutput;
}

table AudioInterfaces {
  aoip:Aoip;
  wclk:WCLK;
  madi1:MADI;
  madi2:MADI;
}

// **** Root Table ****

table LRFrame {
  index:uint64;
  time_stamp:uint64; // unix time in ms

  audio_metering:AudioMetering;
  seks:[Sek];
  skms:[Skm];
  antennas:[Antenna];
  rf_channels:[RfChannel];
  schema_version:SchemaVersion;
  base_station:BaseStation;
  audio_interfaces:AudioInterfaces;
}

root_type LRFrame;