Add --native-format argument to transmit data in original (unscaled) int32 for better precision.

Author: cboulay

README.md

@@ -35,6 +35,7 @@ The CLI provides a lightweight alternative to the GUI:
 - `--amp-id <id>` - Amplifier ID (default: 0)
 - `--sample-rate <hz>` - Sample rate in Hz (default: 1000)
 - `--impedance` - Enable impedance testing mode
+- `--native-format` - Transmit raw int32 ADC counts instead of float microvolts
 - `--shutdown` - Shutdown the Amp Server (terminates all connections)
 - `--help` - Show help message
 
@@ -45,6 +46,9 @@ The CLI provides a lightweight alternative to the GUI:
 
 # With impedance testing
 ./EGIAmpServerCLI --address 10.10.10.51 --impedance
+
+# With native format (int32 ADC counts)
+./EGIAmpServerCLI --address 10.10.10.51 --native-format
 ```
 
 ## Impedance Testing
@@ -87,9 +91,17 @@ Currently not implemented in GUI. Use CLI or config file.
 - **Type**: `EEG`
 - **Rate**: Configured sample rate (e.g., 1000 Hz)
 - **Channels**: Depends on sensor net (32-256 channels)
-- **Unit**: microvolts
+- **Format**: `float32` (default) or `int32` (with `--native-format`)
+- **Unit**: `microvolts` (default) or `counts` (with `--native-format`)
 - **Behavior**: Streams continuously with raw amplifier data (includes test signals during impedance mode)
 
+##### Native Format Mode
+When `--native-format` is enabled:
+- Data is transmitted as raw int32 ADC counts instead of float microvolts
+- Channel metadata includes a `conversion` field with the scaling factor
+- Downstream consumers can convert to microvolts: `microvolts = counts × conversion`
+- This mode is useful for applications that need maximum precision or want to handle scaling themselves (e.g., NWB export)
+
 #### 2. Impedance Stream
 - **Name**: `EGI NetAmp <amp_id> Impedance`
 - **Type**: `Impedance`

src/cli/main.cpp

@@ -32,6 +32,7 @@ void printUsage(const char* programName) {
               << "  --amp-id <id>      Amplifier ID (default: 0)\n"
               << "  --sample-rate <hz> Sample rate (default: 1000)\n"
               << "  --impedance        Enable impedance testing mode (default: disabled)\n"
+              << "  --native-format    Transmit raw int32 ADC counts instead of float microvolts\n"
               << "  --shutdown         Shutdown the Amp Server (terminates all connections)\n"
               << "  --help             Show this help message\n";
 }
@@ -62,6 +63,8 @@ int main(int argc, char* argv[]) {
             config.sampleRate = std::stoi(argv[++i]);
         } else if (arg == "--impedance") {
             config.impedance = true;
+        } else if (arg == "--native-format") {
+            config.nativeFormat = true;
         } else if (arg == "--shutdown") {
             shutdownMode = true;
         } else {
@@ -141,6 +144,7 @@ int main(int argc, char* argv[]) {
               << "  Amplifier ID: " << config.amplifierId << "\n"
               << "  Sample Rate: " << config.sampleRate << " Hz\n"
               << "  Impedance Mode: " << (config.impedance ? "enabled" : "disabled") << "\n"
+              << "  Data Format: " << (config.nativeFormat ? "native (int32 counts)" : "microvolts (float32)") << "\n"
               << "Press Ctrl+C to stop.\n\n";
 
     // Connect and stream

src/core/include/egiamp/AmpServerConfig.h

@@ -15,6 +15,7 @@ struct AmpServerConfig {
     int amplifierId = 0;
     int sampleRate = 1000;
     bool impedance = false;
+    bool nativeFormat = false;  // When true, transmit raw int32 ADC counts instead of float microvolts
 
     static AmpServerConfig loadFromFile(const std::string& filename);
     void saveToFile(const std::string& filename) const;

src/core/include/egiamp/LSLStreamer.h

@@ -25,20 +25,25 @@ class LSLStreamer {
     void createOutlet(const std::string& streamName, int eegChannelCount,
                       int physioChannelCount, int sampleRate,
                       const std::string& hostname,
-                      const AmplifierDetails& details);
+                      const AmplifierDetails& details,
+                      bool nativeFormat = false);
 
     void createImpedanceOutlet(const std::string& streamName, int channelCount,
                                const std::string& hostname,
                                const AmplifierDetails& details);
 
     void pushSample(const std::vector<float>& sample);
+    void pushSampleInt32(const std::vector<int32_t>& sample);
+
+    bool isNativeFormat() const { return nativeFormat_; }
 
     bool hasOutlet() const { return outlet_ != nullptr; }
 
     void closeOutlet();
 
 private:
     std::unique_ptr<lsl::stream_outlet> outlet_;
+    bool nativeFormat_ = false;
 };
 
 } // namespace egiamp

src/core/src/AmpServerConfig.cpp

@@ -43,6 +43,9 @@ AmpServerConfig AmpServerConfig::loadFromFile(const std::string& filename) {
         if (auto node = settings.child("impedance")) {
             config.impedance = node.text().as_bool(config.impedance);
         }
+        if (auto node = settings.child("nativeformat")) {
+            config.nativeFormat = node.text().as_bool(config.nativeFormat);
+        }
     }
 
     return config;
@@ -63,6 +66,7 @@ void AmpServerConfig::saveToFile(const std::string& filename) const {
     settings.append_child("amplifierid").text().set(amplifierId);
     settings.append_child("samplingrate").text().set(sampleRate);
     settings.append_child("impedance").text().set(impedance);
+    settings.append_child("nativeformat").text().set(nativeFormat);
 
     if (!doc.save_file(filename.c_str())) {
         throw ConfigError("Could not write to config file: " + filename);

src/core/src/EGIAmpClient.cpp

@@ -562,7 +562,8 @@ void EGIAmpClient::readPacketFormat2() {
                 // Create LSL outlet for EEG (+ Physio if connected)
                 std::string streamName = "EGI NetAmp " + std::to_string(header.ampID);
                 streamer_.createOutlet(streamName, nChannels, physioChannelCount,
-                                       config_.sampleRate, config_.serverAddress, details_);
+                                       config_.sampleRate, config_.serverAddress, details_,
+                                       config_.nativeFormat);
 
                 // Create LSL outlet for impedance if enabled
                 if (config_.impedance) {
@@ -633,7 +634,8 @@ void EGIAmpClient::readPacketFormat2() {
                             int physioChCount = (physioConnectionStatus_ == 3) ? 32 :
                                                 (physioConnectionStatus_ > 0) ? 16 : 0;
                             streamer_.createOutlet(streamName, nChannels, physioChCount,
-                                                   config_.sampleRate, config_.serverAddress, details_);
+                                                   config_.sampleRate, config_.serverAddress, details_,
+                                                   config_.nativeFormat);
 
                             // Recreate impedance outlet if enabled
                             if (config_.impedance) {
@@ -663,43 +665,72 @@ void EGIAmpClient::readPacketFormat2() {
                 lastPacketCounterWithTimeStamp_ = packet.packetCounter;
             }
 
-            // Convert and push sample to EEG stream (PacketFormat2 is little endian natively)
-            std::vector<float> eegSamples;
+            // Push sample to EEG stream (PacketFormat2 is little endian natively)
             int physioChannels = (physioConnectionStatus_ == 3) ? 32 :
                                  (physioConnectionStatus_ > 0) ? 16 : 0;
-            eegSamples.reserve(nChannels + physioChannels);
-            for (int ch = 0; ch < nChannels; ch++) {
-                eegSamples.push_back(static_cast<float>(packet.eegData[ch]) *
-                                     details_.scalingFactor);
-            }
 
-            // Add PIB1 channels (if port 1 connected: status 1 or 3)
-            // Channels 1-8 use negative scaling, 9-16 use positive scaling
-            if (physioConnectionStatus_ & 0x01) {
-                for (int ch = 0; ch < 8; ch++) {
-                    eegSamples.push_back(static_cast<float>(packet.pib1_Data[ch]) *
-                                         PHYSIO_SCALING_1_8);
+            if (config_.nativeFormat) {
+                // Native format: push raw int32 ADC counts
+                std::vector<int32_t> rawSamples;
+                rawSamples.reserve(nChannels + physioChannels);
+
+                for (int ch = 0; ch < nChannels; ch++) {
+                    rawSamples.push_back(packet.eegData[ch]);
                 }
-                for (int ch = 8; ch < 16; ch++) {
-                    eegSamples.push_back(static_cast<float>(packet.pib1_Data[ch]) *
-                                         PHYSIO_SCALING_9_16);
+
+                // Add PIB1 channels (if port 1 connected: status 1 or 3)
+                if (physioConnectionStatus_ & 0x01) {
+                    for (int ch = 0; ch < 16; ch++) {
+                        rawSamples.push_back(packet.pib1_Data[ch]);
+                    }
                 }
-            }
 
-            // Add PIB2 channels (if port 2 connected: status 2 or 3)
-            // Channels 1-8 use negative scaling, 9-16 use positive scaling
-            if (physioConnectionStatus_ & 0x02) {
-                for (int ch = 0; ch < 8; ch++) {
-                    eegSamples.push_back(static_cast<float>(packet.pib2_Data[ch]) *
-                                         PHYSIO_SCALING_1_8);
+                // Add PIB2 channels (if port 2 connected: status 2 or 3)
+                if (physioConnectionStatus_ & 0x02) {
+                    for (int ch = 0; ch < 16; ch++) {
+                        rawSamples.push_back(packet.pib2_Data[ch]);
+                    }
                 }
-                for (int ch = 8; ch < 16; ch++) {
-                    eegSamples.push_back(static_cast<float>(packet.pib2_Data[ch]) *
-                                         PHYSIO_SCALING_9_16);
+
+                streamer_.pushSampleInt32(rawSamples);
+            } else {
+                // Default: convert to float microvolts
+                std::vector<float> eegSamples;
+                eegSamples.reserve(nChannels + physioChannels);
+
+                for (int ch = 0; ch < nChannels; ch++) {
+                    eegSamples.push_back(static_cast<float>(packet.eegData[ch]) *
+                                         details_.scalingFactor);
                 }
-            }
 
-            streamer_.pushSample(eegSamples);
+                // Add PIB1 channels (if port 1 connected: status 1 or 3)
+                // Channels 1-8 use negative scaling, 9-16 use positive scaling
+                if (physioConnectionStatus_ & 0x01) {
+                    for (int ch = 0; ch < 8; ch++) {
+                        eegSamples.push_back(static_cast<float>(packet.pib1_Data[ch]) *
+                                             PHYSIO_SCALING_1_8);
+                    }
+                    for (int ch = 8; ch < 16; ch++) {
+                        eegSamples.push_back(static_cast<float>(packet.pib1_Data[ch]) *
+                                             PHYSIO_SCALING_9_16);
+                    }
+                }
+
+                // Add PIB2 channels (if port 2 connected: status 2 or 3)
+                // Channels 1-8 use negative scaling, 9-16 use positive scaling
+                if (physioConnectionStatus_ & 0x02) {
+                    for (int ch = 0; ch < 8; ch++) {
+                        eegSamples.push_back(static_cast<float>(packet.pib2_Data[ch]) *
+                                             PHYSIO_SCALING_1_8);
+                    }
+                    for (int ch = 8; ch < 16; ch++) {
+                        eegSamples.push_back(static_cast<float>(packet.pib2_Data[ch]) *
+                                             PHYSIO_SCALING_9_16);
+                    }
+                }
+
+                streamer_.pushSample(eegSamples);
+            }
 
             // Push impedance data if in impedance mode and current is injecting
             if (config_.impedance && impedanceStreamer_.hasOutlet()) {
@@ -777,9 +808,12 @@ void EGIAmpClient::readPacketFormat1() {
                 emitChannelCount(nChannels);
 
                 // Create LSL outlet (no Physio16 support for PacketFormat1)
+                // Note: PacketFormat1 (NA300) already provides float data, so nativeFormat
+                // doesn't apply - we always use float for Format1
                 std::string streamName = "EGI NetAmp " + std::to_string(header.ampID);
                 streamer_.createOutlet(streamName, nChannels, 0,
-                                       config_.sampleRate, config_.serverAddress, details_);
+                                       config_.sampleRate, config_.serverAddress, details_,
+                                       false);  // Format1 is always float
             }
 
             // Convert endianness and push sample

src/core/src/LSLStreamer.cpp

@@ -86,22 +86,26 @@ std::string getCapName(NetCode netCode) {
 void LSLStreamer::createOutlet(const std::string& streamName, int eegChannelCount,
                                int physioChannelCount, int sampleRate,
                                const std::string& hostname,
-                               const AmplifierDetails& details) {
+                               const AmplifierDetails& details,
+                               bool nativeFormat) {
     // Close existing outlet if any
     closeOutlet();
 
+    nativeFormat_ = nativeFormat;
     int totalChannelCount = eegChannelCount + physioChannelCount;
 
     // Create stream info with unique source ID
     // Include all parameters that make streams incompatible so clients
     // won't auto-reconnect when these change
+    std::string formatSuffix = nativeFormat ? "_i32" : "_f32";
     std::string sourceId = "EGI_" + hostname +
                            "_ch" + std::to_string(totalChannelCount) +
                            "_sr" + std::to_string(sampleRate) +
-                           "_f32";
+                           formatSuffix;
+    lsl::channel_format_t channelFormat = nativeFormat ? lsl::cf_int32 : lsl::cf_float32;
     lsl::stream_info info(streamName, "EEG", totalChannelCount,
                           static_cast<double>(sampleRate),
-                          lsl::cf_float32, sourceId);
+                          channelFormat, sourceId);
 
     // Get the description root
     lsl::xml_element desc = info.desc();
@@ -178,12 +182,16 @@ void LSLStreamer::createOutlet(const std::string& streamName, int eegChannelCoun
         }
         ch.append_child_value("label", label.c_str());
         ch.append_child_value("type", "EEG");
-        ch.append_child_value("unit", "microvolts");
 
-        // Scaling factor (raw to microvolts)
-        if (details.scalingFactor > 0) {
-            ch.append_child_value("scaling_factor",
-                                  std::to_string(details.scalingFactor).c_str());
+        if (nativeFormat) {
+            ch.append_child_value("unit", "counts");
+            // Conversion factor: multiply by this to get microvolts
+            if (details.scalingFactor != 0) {
+                ch.append_child_value("conversion",
+                                      std::to_string(details.scalingFactor).c_str());
+            }
+        } else {
+            ch.append_child_value("unit", "microvolts");
         }
     }
 
@@ -195,12 +203,17 @@ void LSLStreamer::createOutlet(const std::string& streamName, int eegChannelCoun
         std::string label = "PIB" + std::to_string(i + 1);
         ch.append_child_value("label", label.c_str());
         ch.append_child_value("type", "AUX");
-        ch.append_child_value("unit", "microvolts");
 
-        // Scaling factor (raw to microvolts) - same as EEG
-        if (details.scalingFactor > 0) {
-            ch.append_child_value("scaling_factor",
-                                  std::to_string(details.scalingFactor).c_str());
+        if (nativeFormat) {
+            ch.append_child_value("unit", "counts");
+            // PIB channels 1-8 use negative scaling, 9-16 use positive scaling
+            // Channel index within each PIB port: 0-7 negative, 8-15 positive
+            int portChannel = i % 16;
+            float conversion = (portChannel < 8) ? PHYSIO_SCALING_1_8 : PHYSIO_SCALING_9_16;
+            ch.append_child_value("conversion",
+                                  std::to_string(conversion).c_str());
+        } else {
+            ch.append_child_value("unit", "microvolts");
         }
     }
 
@@ -288,6 +301,12 @@ void LSLStreamer::pushSample(const std::vector<float>& sample) {
     }
 }
 
+void LSLStreamer::pushSampleInt32(const std::vector<int32_t>& sample) {
+    if (outlet_) {
+        outlet_->push_sample(sample);
+    }
+}
+
 void LSLStreamer::closeOutlet() {
     outlet_.reset();
 }