Feed analog data into separate deinterleaved analog data objects per channel

diff --git a/pv/data/analogsnapshot.cpp b/pv/data/analogsnapshot.cpp
index 36fad7f73477d9da08d9ddb475ab85c882a720a1..4907d7954a186af7c6d7b5f0c2c8447714edc32a 100644 (file)
--- a/pv/data/analogsnapshot.cpp
+++ b/pv/data/analogsnapshot.cpp
@@ -47,12 +47,11 @@ const float AnalogSnapshot::LogEnvelopeScaleFactor =
        logf(EnvelopeScaleFactor);
 const uint64_t AnalogSnapshot::EnvelopeDataUnit = 64*1024;     // bytes
 
        logf(EnvelopeScaleFactor);
 const uint64_t AnalogSnapshot::EnvelopeDataUnit = 64*1024;     // bytes
 

-AnalogSnapshot::AnalogSnapshot(const sr_datafeed_analog &analog) :
+AnalogSnapshot::AnalogSnapshot() :

        Snapshot(sizeof(float))
 {
        lock_guard<recursive_mutex> lock(_mutex);
        memset(_envelope_levels, 0, sizeof(_envelope_levels));
        Snapshot(sizeof(float))
 {
        lock_guard<recursive_mutex> lock(_mutex);
        memset(_envelope_levels, 0, sizeof(_envelope_levels));

-       append_payload(analog);

 }
 
 AnalogSnapshot::~AnalogSnapshot()
 }
 
 AnalogSnapshot::~AnalogSnapshot()


@@ -62,11 +61,24 @@ AnalogSnapshot::~AnalogSnapshot()
                free(e.samples);
 }
 
                free(e.samples);
 }
 

-void AnalogSnapshot::append_payload(
-       const sr_datafeed_analog &analog)
+void AnalogSnapshot::append_interleaved_samples(const float *data,
+       size_t sample_count, size_t stride)

 {
 {

+       assert(_unit_size == sizeof(float));
+

        lock_guard<recursive_mutex> lock(_mutex);
        lock_guard<recursive_mutex> lock(_mutex);

-       append_data(analog.data, analog.num_samples);
+
+       _data = realloc(_data, (_sample_count + sample_count) * sizeof(float));
+
+       float *dst = (float*)_data + _sample_count;
+       const float *dst_end = dst + sample_count;
+       while (dst != dst_end)
+       {
+               *dst++ = *data;
+               data += stride;
+       }
+
+       _sample_count += sample_count;

 
        // Generate the first mip-map from the data
        append_payload_to_envelope_levels();
 
        // Generate the first mip-map from the data
        append_payload_to_envelope_levels();

diff --git a/pv/data/analogsnapshot.h b/pv/data/analogsnapshot.h
index 74d26763825167a41c81390c08647ba0a3b03560..9c7f4d51ae982bc76cad204995cbcbbc380ec241 100644 (file)
--- a/pv/data/analogsnapshot.h
+++ b/pv/data/analogsnapshot.h
@@ -66,11 +66,12 @@ private:
        static const uint64_t EnvelopeDataUnit;
 
 public:
        static const uint64_t EnvelopeDataUnit;
 
 public:

-       AnalogSnapshot(const sr_datafeed_analog &analog);
+       AnalogSnapshot();

 
        virtual ~AnalogSnapshot();
 
 
        virtual ~AnalogSnapshot();
 

-       void append_payload(const sr_datafeed_analog &analog);
+       void append_interleaved_samples(const float *data,
+               size_t sample_count, size_t stride);

 
        const float* get_samples(int64_t start_sample,
                int64_t end_sample) const;
 
        const float* get_samples(int64_t start_sample,
                int64_t end_sample) const;

diff --git a/pv/sigsession.cpp b/pv/sigsession.cpp
index ad0b5d298637b9eeaa58c7157e3654d78a456c5f..8d22296c40e89e57da2ad24ec12aec88112c7be9 100644 (file)
--- a/pv/sigsession.cpp
+++ b/pv/sigsession.cpp
@@ -385,7 +385,6 @@ void SigSession::update_signals(const sr_dev_inst *const sdi)
        assert(_capture_state == Stopped);
 
        unsigned int logic_probe_count = 0;
        assert(_capture_state == Stopped);
 
        unsigned int logic_probe_count = 0;

-       unsigned int analog_probe_count = 0;

 
        // Clear the decode traces
        _decode_traces.clear();
 
        // Clear the decode traces
        _decode_traces.clear();


@@ -401,15 +400,11 @@ void SigSession::update_signals(const sr_dev_inst *const sdi)
                        case SR_PROBE_LOGIC:
                                logic_probe_count++;
                                break;
                        case SR_PROBE_LOGIC:
                                logic_probe_count++;
                                break;

-
-                       case SR_PROBE_ANALOG:
-                               analog_probe_count++;
-                               break;

                        }
                }
        }
 
                        }
                }
        }
 

-       // Create data containers for the data snapshots
+       // Create data containers for the logic data snapshots

        {
                lock_guard<mutex> data_lock(_data_mutex);
 
        {
                lock_guard<mutex> data_lock(_data_mutex);
 


@@ -419,12 +414,6 @@ void SigSession::update_signals(const sr_dev_inst *const sdi)
                                logic_probe_count));
                        assert(_logic_data);
                }
                                logic_probe_count));
                        assert(_logic_data);
                }

-
-               _analog_data.reset();
-               if (analog_probe_count != 0) {
-                       _analog_data.reset(new data::Analog());
-                       assert(_analog_data);
-               }

        }
 
        // Make the Signals list
        }
 
        // Make the Signals list


@@ -449,10 +438,14 @@ void SigSession::update_signals(const sr_dev_inst *const sdi)
                                break;
 
                        case SR_PROBE_ANALOG:
                                break;
 
                        case SR_PROBE_ANALOG:

+                       {
+                               shared_ptr<data::Analog> data(
+                                       new data::Analog());

                                signal = shared_ptr<view::Signal>(
                                        new view::AnalogSignal(*this, probe,
                                signal = shared_ptr<view::Signal>(
                                        new view::AnalogSignal(*this, probe,

-                                               _analog_data));
+                                               data));

                                break;
                                break;

+                       }

 
                        default:
                                assert(0);
 
                        default:
                                assert(0);


@@ -512,10 +505,12 @@ void SigSession::read_sample_rate(const sr_dev_inst *const sdi)
                g_variant_unref(gvar);
        }
 
                g_variant_unref(gvar);
        }
 

-       if(_analog_data)
-               _analog_data->set_samplerate(sample_rate);
-       if(_logic_data)
-               _logic_data->set_samplerate(sample_rate);
+       // Set the sample rate of all data
+       const set< shared_ptr<data::SignalData> > data_set = get_data();
+       BOOST_FOREACH(shared_ptr<data::SignalData> data, data_set) {
+               assert(data);
+               data->set_samplerate(sample_rate);
+       }

 }
 
 void SigSession::load_session_thread_proc(
 }
 
 void SigSession::load_session_thread_proc(


@@ -534,7 +529,7 @@ void SigSession::load_session_thread_proc(
 
        // Confirm that SR_DF_END was received
        assert(!_cur_logic_snapshot);
 
        // Confirm that SR_DF_END was received
        assert(!_cur_logic_snapshot);

-       assert(!_cur_analog_snapshot);
+       assert(_cur_analog_snapshots.empty());

 }
 
 void SigSession::load_input_thread_proc(const string name,
 }
 
 void SigSession::load_input_thread_proc(const string name,


@@ -556,7 +551,7 @@ void SigSession::load_input_thread_proc(const string name,
 
        // Confirm that SR_DF_END was received
        assert(!_cur_logic_snapshot);
 
        // Confirm that SR_DF_END was received
        assert(!_cur_logic_snapshot);

-       assert(!_cur_analog_snapshot);
+       assert(_cur_analog_snapshots.empty());

 
        delete in;
 }
 
        delete in;
 }


@@ -599,8 +594,11 @@ void SigSession::sample_thread_proc(struct sr_dev_inst *sdi,
        set_capture_state(Stopped);
 
        // Confirm that SR_DF_END was received
        set_capture_state(Stopped);
 
        // Confirm that SR_DF_END was received

-       assert(!_cur_logic_snapshot);
-       assert(!_cur_analog_snapshot);
+       if (_cur_logic_snapshot)
+       {
+               qDebug("SR_DF_END was not received.");
+               assert(0);
+       }

 }
 
 void SigSession::feed_in_header(const sr_dev_inst *sdi)
 }
 
 void SigSession::feed_in_header(const sr_dev_inst *sdi)


@@ -641,6 +639,7 @@ void SigSession::feed_in_logic(const sr_datafeed_logic &logic)
 
        if (!_cur_logic_snapshot)
        {
 
        if (!_cur_logic_snapshot)
        {

+               // This could be the first packet after a trigger

                set_capture_state(Running);
 
                // Create a new data snapshot
                set_capture_state(Running);
 
                // Create a new data snapshot


@@ -661,25 +660,58 @@ void SigSession::feed_in_analog(const sr_datafeed_analog &analog)
 {
        lock_guard<mutex> lock(_data_mutex);
 
 {
        lock_guard<mutex> lock(_data_mutex);
 

-       if(!_analog_data)
-       {
-               qDebug() << "Unexpected analog packet";
-               return; // This analog packet was not expected.
-       }
+       const unsigned int probe_count = g_slist_length(analog.probes);
+       const size_t sample_count = analog.num_samples / probe_count;
+       const float *data = analog.data;
+       bool sweep_beginning = false;

 
 

-       if (!_cur_analog_snapshot)
+       for (GSList *p = analog.probes; p; p = p->next)

        {
        {

-               set_capture_state(Running);
+               shared_ptr<data::AnalogSnapshot> snapshot;

 
 

-               // Create a new data snapshot
-               _cur_analog_snapshot = shared_ptr<data::AnalogSnapshot>(
-                       new data::AnalogSnapshot(analog));
-               _analog_data->push_snapshot(_cur_analog_snapshot);
+               sr_probe *const probe = (sr_probe*)p->data;
+               assert(probe);
+
+               // Try to get the snapshot of the probe
+               const map< const sr_probe*, shared_ptr<data::AnalogSnapshot> >::
+                       iterator iter = _cur_analog_snapshots.find(probe);
+               if (iter != _cur_analog_snapshots.end())
+                       snapshot = (*iter).second;
+               else
+               {
+                       // If no snapshot was found, this means we havn't
+                       // created one yet. i.e. this is the first packet
+                       // in the sweep containing this snapshot.
+                       sweep_beginning = true;
+
+                       // Create a snapshot, keep it in the maps of probes
+                       snapshot = shared_ptr<data::AnalogSnapshot>(
+                               new data::AnalogSnapshot());
+                       _cur_analog_snapshots[probe] = snapshot;
+
+                       // Find the annalog data associated with the probe
+                       shared_ptr<view::AnalogSignal> sig =
+                               dynamic_pointer_cast<view::AnalogSignal>(
+                                       signal_from_probe(probe));
+                       assert(sig);
+
+                       shared_ptr<data::Analog> data(sig->analog_data());
+                       assert(data);
+
+                       // Push the snapshot into the analog data.
+                       data->push_snapshot(snapshot);
+               }
+
+               assert(snapshot);
+
+               // Append the samples in the snapshot
+               snapshot->append_interleaved_samples(data++, sample_count,
+                       probe_count);

        }
        }

-       else
-       {
-               // Append to the existing data snapshot
-               _cur_analog_snapshot->append_payload(analog);
+
+       if (sweep_beginning) {
+               // This could be the first packet after a trigger
+               set_capture_state(Running);

        }
 
        data_updated();
        }
 
        data_updated();


@@ -717,7 +749,7 @@ void SigSession::data_feed_in(const struct sr_dev_inst *sdi,
                {
                        lock_guard<mutex> lock(_data_mutex);
                        _cur_logic_snapshot.reset();
                {
                        lock_guard<mutex> lock(_data_mutex);
                        _cur_logic_snapshot.reset();

-                       _cur_analog_snapshot.reset();
+                       _cur_analog_snapshots.clear();

                }
                data_updated();
                break;
                }
                data_updated();
                break;

diff --git a/pv/sigsession.h b/pv/sigsession.h
index 319acf9ae110f33af3be1d85ee43d1b4b05c95f1..cda49b5ca5c3ada9a3b4853c61909a6aa66d35a6 100644 (file)
--- a/pv/sigsession.h
+++ b/pv/sigsession.h
@@ -177,8 +177,8 @@ private:
        mutable boost::mutex _data_mutex;
        boost::shared_ptr<data::Logic> _logic_data;
        boost::shared_ptr<data::LogicSnapshot> _cur_logic_snapshot;
        mutable boost::mutex _data_mutex;
        boost::shared_ptr<data::Logic> _logic_data;
        boost::shared_ptr<data::LogicSnapshot> _cur_logic_snapshot;

-       boost::shared_ptr<data::Analog> _analog_data;
-       boost::shared_ptr<data::AnalogSnapshot> _cur_analog_snapshot;
+       std::map< const sr_probe*, boost::shared_ptr<data::AnalogSnapshot> >
+               _cur_analog_snapshots;

 
        boost::thread _sampling_thread;
 
 
        boost::thread _sampling_thread;