Level recording schema specification 1.0

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;
            
            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}
            
            // **** 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; // 2 bit
            }
            
            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 MicLink {
            audiolink_mode:uint32;
            channels:[MicChannel];
            lqi:MicLqi;
            }
            
            table Sek {
            
            // fields that are always available, independent from the state.
            uid:uint32;
            rf_channel_id:RfChannelId;
            name:string;
            state:MdState;
            headphone_volume:ubyte;
            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:MicLink; // present if a mic link is configured
            }
            
            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:MicLink; // present if a mic link is configured
            }
            
            // **** 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;
            }
            
            // **** 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];
            }
            
            root_type LRFrame;