diff --git a/DSView/darkstyle/style.qss b/DSView/darkstyle/style.qss
index 9cca2c81..cacf5e26 100755
--- a/DSView/darkstyle/style.qss
+++ b/DSView/darkstyle/style.qss
@@ -369,7 +369,7 @@ QScrollBar:horizontal
 QScrollBar::handle:horizontal
 {
     background-color: #605F5F;
-    min-width: 5px;
+    min-width: 15px;
     border-radius: 4px;
 }
 
@@ -435,7 +435,7 @@ QScrollBar:vertical
 QScrollBar::handle:vertical
 {
     background-color: #605F5F;
-    min-height: 5px;
+    min-height: 15px;
     border-radius: 4px;
 }
 
diff --git a/DSView/pv/data/analog.cpp b/DSView/pv/data/analog.cpp
index ad0c052f..e5c85b39 100644
--- a/DSView/pv/data/analog.cpp
+++ b/DSView/pv/data/analog.cpp
@@ -24,6 +24,8 @@
 #include "analog.h"
 #include "analogsnapshot.h"
 
+#include <boost/foreach.hpp>
+
 using namespace boost;
 using namespace std;
 
@@ -47,7 +49,9 @@ deque< boost::shared_ptr<AnalogSnapshot> >& Analog::get_snapshots()
 
 void Analog::clear()
 {
-    _snapshots.clear();
+    //_snapshots.clear();
+    BOOST_FOREACH(const boost::shared_ptr<AnalogSnapshot> s, _snapshots)
+        s->clear();
 }
 
 } // namespace data
diff --git a/DSView/pv/data/analogsnapshot.cpp b/DSView/pv/data/analogsnapshot.cpp
index 085cf20c..66bf5833 100644
--- a/DSView/pv/data/analogsnapshot.cpp
+++ b/DSView/pv/data/analogsnapshot.cpp
@@ -46,13 +46,10 @@ const float AnalogSnapshot::LogEnvelopeScaleFactor =
 	logf(EnvelopeScaleFactor);
 const uint64_t AnalogSnapshot::EnvelopeDataUnit = 64*1024;	// bytes
 
-AnalogSnapshot::AnalogSnapshot(const sr_datafeed_analog &analog, uint64_t _total_sample_len, unsigned int channel_num) :
-    Snapshot(sizeof(uint16_t)*channel_num, _total_sample_len, channel_num)
+AnalogSnapshot::AnalogSnapshot() :
+    Snapshot(sizeof(uint16_t), 1, 1)
 {
-	boost::lock_guard<boost::recursive_mutex> lock(_mutex);
 	memset(_envelope_levels, 0, sizeof(_envelope_levels));
-    init(_total_sample_len * channel_num);
-	append_payload(analog);
 }
 
 AnalogSnapshot::~AnalogSnapshot()
@@ -62,6 +59,24 @@ AnalogSnapshot::~AnalogSnapshot()
 		free(e.samples);
 }
 
+void AnalogSnapshot::clear()
+{
+    _sample_count = 0;
+    _ring_sample_count = 0;
+}
+
+void AnalogSnapshot::first_payload(const sr_datafeed_analog &analog, uint64_t total_sample_count, unsigned int channel_num)
+{
+    _total_sample_count = total_sample_count;
+    _channel_num = channel_num;
+    _unit_size = sizeof(uint16_t)*channel_num;
+    boost::lock_guard<boost::recursive_mutex> lock(_mutex);
+    if (init(_total_sample_count*_channel_num) == SR_OK) {
+        append_payload(analog);
+        _last_ended = false;
+    }
+}
+
 void AnalogSnapshot::append_payload(
 	const sr_datafeed_analog &analog)
 {
@@ -89,7 +104,7 @@ const uint16_t* AnalogSnapshot::get_samples(
 //    memcpy(data, (uint16_t*)_data + start_sample, sizeof(uint16_t) *
 //		(end_sample - start_sample));
 //	return data;
-    return (uint16_t*)_data + start_sample * _channel_num;
+    return (uint16_t*)_data.data() + start_sample * _channel_num;
 }
 
 void AnalogSnapshot::get_envelope_section(EnvelopeSection &s,
@@ -154,7 +169,7 @@ void AnalogSnapshot::append_payload_to_envelope_levels()
         dest_ptr = e0.samples + prev_length;
 
         // Iterate through the samples to populate the first level mipmap
-        const uint16_t *const stop_src_ptr = (uint16_t*)_data +
+        const uint16_t *const stop_src_ptr = (uint16_t*)_data.data() +
             e0.length * EnvelopeScaleFactor * _channel_num;
 //        for (const uint16_t *src_ptr = (uint16_t*)_data +
 //            prev_length * EnvelopeScaleFactor;
@@ -167,7 +182,7 @@ void AnalogSnapshot::append_payload_to_envelope_levels()
 
 //            *dest_ptr++ = sub_sample;
 //        }
-        for (const uint16_t *src_ptr = (uint16_t*)_data +
+        for (const uint16_t *src_ptr = (uint16_t*)_data.data() +
             prev_length * EnvelopeScaleFactor * _channel_num + i;
             src_ptr < stop_src_ptr; src_ptr += EnvelopeScaleFactor * _channel_num)
         {
diff --git a/DSView/pv/data/analogsnapshot.h b/DSView/pv/data/analogsnapshot.h
index 3282f257..7df1e111 100644
--- a/DSView/pv/data/analogsnapshot.h
+++ b/DSView/pv/data/analogsnapshot.h
@@ -69,10 +69,14 @@ private:
 	static const uint64_t EnvelopeDataUnit;
 
 public:
-    AnalogSnapshot(const sr_datafeed_analog &analog, uint64_t _total_sample_len, unsigned int channel_num);
+    AnalogSnapshot();
 
 	virtual ~AnalogSnapshot();
 
+    void clear();
+
+    void first_payload(const sr_datafeed_analog &analog, uint64_t total_sample_count, unsigned int channel_num);
+
 	void append_payload(const sr_datafeed_analog &analog);
 
     const uint16_t* get_samples(int64_t start_sample,
diff --git a/DSView/pv/data/decoderstack.cpp b/DSView/pv/data/decoderstack.cpp
index e9ac125d..ef4c0589 100644
--- a/DSView/pv/data/decoderstack.cpp
+++ b/DSView/pv/data/decoderstack.cpp
@@ -56,8 +56,8 @@ namespace data {
 
 const double DecoderStack::DecodeMargin = 1.0;
 const double DecoderStack::DecodeThreshold = 0.2;
-const int64_t DecoderStack::DecodeChunkLength = 1024 * 1024;
-const unsigned int DecoderStack::DecodeNotifyPeriod = 1;
+const int64_t DecoderStack::DecodeChunkLength = 4 * 1024;
+const unsigned int DecoderStack::DecodeNotifyPeriod = 1024;
 
 mutex DecoderStack::_global_decode_mutex;
 
@@ -332,7 +332,7 @@ void DecoderStack::clear()
 	_sample_count = 0;
 	_frame_complete = false;
 	_samples_decoded = 0;
-    //new_decode_data();
+    new_decode_data();
 	_error_message = QString();
     for (map<const Row, RowData>::const_iterator i = _rows.begin();
         i != _rows.end(); i++)
@@ -342,7 +342,7 @@ void DecoderStack::clear()
 
 void DecoderStack::stop_decode()
 {
-    _snapshot.reset();
+    //_snapshot.reset();
 
     if(_decode_state == Stopped) {
         clear();
@@ -397,12 +397,14 @@ void DecoderStack::begin_decode()
 	if (snapshots.empty())
 		return;
 	_snapshot = snapshots.front();
+    if (_snapshot->empty())
+        return;
 
 	// Get the samplerate and start time
 	_start_time = data->get_start_time();
 	_samplerate = data->samplerate();
-	if (_samplerate == 0.0)
-		_samplerate = 1.0;
+    if (_samplerate == 0.0)
+        return;
 
     //_decode_thread = boost::thread(&DecoderStack::decode_proc, this);
     _decode_thread.reset(new boost::thread(&DecoderStack::decode_proc, this));
@@ -437,7 +439,8 @@ void DecoderStack::decode_data(
     const unsigned int unit_size, srd_session *const session)
 {
     uint8_t *chunk = NULL;
-
+    uint64_t last_cnt = 0;
+    uint64_t notify_cnt = (decode_end - decode_start + 1)/100;
     const uint64_t chunk_sample_count =
         DecodeChunkLength / _snapshot->unit_size();
 
@@ -463,8 +466,10 @@ void DecoderStack::decode_data(
             _samples_decoded = chunk_end - decode_start + 1;
         }
 
-        if (i % DecodeNotifyPeriod == 0)
+        if ((i - last_cnt) > notify_cnt) {
+            last_cnt = i;
             new_decode_data();
+        }
 
     }
     _options_changed = false;
@@ -492,6 +497,12 @@ void DecoderStack::decode_proc()
 	// Create the decoders
 	const unsigned int unit_size = _snapshot->unit_size();
 
+    // Get the intial sample count
+    {
+        unique_lock<mutex> input_lock(_input_mutex);
+        sample_count = _sample_count = _snapshot->get_sample_count();
+    }
+
 	BOOST_FOREACH(const shared_ptr<decode::Decoder> &dec, _stack)
 	{
 		srd_decoder_inst *const di = dec->create_decoder_inst(session, unit_size);
@@ -508,13 +519,7 @@ void DecoderStack::decode_proc()
 
 		prev_di = di;
         decode_start = dec->decode_start();
-        decode_end = min(dec->decode_end(), _snapshot->get_sample_count());
-	}
-
-	// Get the intial sample count
-	{
-		unique_lock<mutex> input_lock(_input_mutex);
-        sample_count = _sample_count = _snapshot->get_sample_count();
+        decode_end = min(dec->decode_end(), _sample_count-1);
 	}
 
 	// Start the session
diff --git a/DSView/pv/data/dso.cpp b/DSView/pv/data/dso.cpp
index 43663737..fa4cf4a5 100644
--- a/DSView/pv/data/dso.cpp
+++ b/DSView/pv/data/dso.cpp
@@ -23,6 +23,8 @@
 #include "dso.h"
 #include "dsosnapshot.h"
 
+#include <boost/foreach.hpp>
+
 using namespace boost;
 using namespace std;
 
@@ -46,7 +48,9 @@ deque< boost::shared_ptr<DsoSnapshot> >& Dso::get_snapshots()
 
 void Dso::clear()
 {
-    _snapshots.clear();
+    //_snapshots.clear();
+    BOOST_FOREACH(const boost::shared_ptr<DsoSnapshot> s, _snapshots)
+        s->clear();
 }
 
 } // namespace data
diff --git a/DSView/pv/data/dsosnapshot.cpp b/DSView/pv/data/dsosnapshot.cpp
index 4e0e1b26..7fdd78f8 100644
--- a/DSView/pv/data/dsosnapshot.cpp
+++ b/DSView/pv/data/dsosnapshot.cpp
@@ -47,16 +47,13 @@ const uint64_t DsoSnapshot::EnvelopeDataUnit = 4*1024;	// bytes
 
 const int DsoSnapshot::VrmsScaleFactor = 1 << 8;
 
-DsoSnapshot::DsoSnapshot(const sr_datafeed_dso &dso, uint64_t _total_sample_len, unsigned int channel_num, bool instant) :
-    Snapshot(sizeof(uint16_t), _total_sample_len, channel_num),
+DsoSnapshot::DsoSnapshot() :
+    Snapshot(sizeof(uint16_t), 1, 1),
     _envelope_en(false),
     _envelope_done(false),
-    _instant(instant)
+    _instant(false)
 {
-	boost::lock_guard<boost::recursive_mutex> lock(_mutex);
 	memset(_envelope_levels, 0, sizeof(_envelope_levels));
-    init(_total_sample_len);
-    append_payload(dso);
 }
 
 DsoSnapshot::~DsoSnapshot()
@@ -66,6 +63,24 @@ DsoSnapshot::~DsoSnapshot()
 		free(e.samples);
 }
 
+void DsoSnapshot::clear()
+{
+    _sample_count = 0;
+    _ring_sample_count = 0;
+}
+
+void DsoSnapshot::first_payload(const sr_datafeed_dso &dso, uint64_t total_sample_count, unsigned int channel_num, bool instant)
+{
+    _total_sample_count = total_sample_count;
+    _channel_num = channel_num;
+    _instant = instant;
+    boost::lock_guard<boost::recursive_mutex> lock(_mutex);
+    if (init(_total_sample_count) == SR_OK) {
+        append_payload(dso);
+        _last_ended = false;
+    }
+}
+
 void DsoSnapshot::append_payload(const sr_datafeed_dso &dso)
 {
 	boost::lock_guard<boost::recursive_mutex> lock(_mutex);
@@ -103,7 +118,7 @@ const uint8_t *DsoSnapshot::get_samples(
 //    memcpy(data, (uint16_t*)_data + start_sample, sizeof(uint16_t) *
 //		(end_sample - start_sample));
 //	return data;
-    return (uint8_t*)_data + start_sample * _channel_num + index * (_channel_num != 1);
+    return (uint8_t*)_data.data() + start_sample * _channel_num + index * (_channel_num != 1);
 }
 
 void DsoSnapshot::get_envelope_section(EnvelopeSection &s,
@@ -170,9 +185,9 @@ void DsoSnapshot::append_payload_to_envelope_levels(bool header)
         dest_ptr = e0.samples + prev_length;
 
         // Iterate through the samples to populate the first level mipmap
-        const uint8_t *const stop_src_ptr = (uint8_t*)_data +
+        const uint8_t *const stop_src_ptr = (uint8_t*)_data.data() +
             e0.length * EnvelopeScaleFactor * _channel_num;
-        for (const uint8_t *src_ptr = (uint8_t*)_data +
+        for (const uint8_t *src_ptr = (uint8_t*)_data.data() +
             prev_length * EnvelopeScaleFactor * _channel_num + i;
             src_ptr < stop_src_ptr; src_ptr += EnvelopeScaleFactor * _channel_num)
         {
@@ -248,9 +263,9 @@ double DsoSnapshot::cal_vrms(double zero_off, int index) const
     double tmp;
 
     // Iterate through the samples to populate the first level mipmap
-    const uint8_t *const stop_src_ptr = (uint8_t*)_data +
+    const uint8_t *const stop_src_ptr = (uint8_t*)_data.data() +
         _sample_count * _channel_num;
-    for (const uint8_t *src_ptr = (uint8_t*)_data + index;
+    for (const uint8_t *src_ptr = (uint8_t*)_data.data() + index;
         src_ptr < stop_src_ptr; src_ptr += VrmsScaleFactor * _channel_num)
     {
         const uint8_t * begin_src_ptr =
@@ -282,9 +297,9 @@ double DsoSnapshot::cal_vmean(int index) const
     double vmean = 0;
 
     // Iterate through the samples to populate the first level mipmap
-    const uint8_t *const stop_src_ptr = (uint8_t*)_data +
+    const uint8_t *const stop_src_ptr = (uint8_t*)_data.data() +
         _sample_count * _channel_num;
-    for (const uint8_t *src_ptr = (uint8_t*)_data + index;
+    for (const uint8_t *src_ptr = (uint8_t*)_data.data() + index;
         src_ptr < stop_src_ptr; src_ptr += VrmsScaleFactor * _channel_num)
     {
         const uint8_t * begin_src_ptr =
diff --git a/DSView/pv/data/dsosnapshot.h b/DSView/pv/data/dsosnapshot.h
index eb3788bc..fbbdf849 100644
--- a/DSView/pv/data/dsosnapshot.h
+++ b/DSView/pv/data/dsosnapshot.h
@@ -70,10 +70,14 @@ private:
     static const int VrmsScaleFactor;
 
 public:
-    DsoSnapshot(const sr_datafeed_dso &dso, uint64_t _total_sample_len, unsigned int channel_num, bool instant);
+    DsoSnapshot();
 
     virtual ~DsoSnapshot();
 
+    void clear();
+
+    void first_payload(const sr_datafeed_dso &dso, uint64_t total_sample_count, unsigned int channel_num, bool instant);
+
     void append_payload(const sr_datafeed_dso &dso);
 
     const uint8_t* get_samples(int64_t start_sample,
diff --git a/DSView/pv/data/groupsnapshot.h b/DSView/pv/data/groupsnapshot.h
index 729b57a7..ed475b3a 100644
--- a/DSView/pv/data/groupsnapshot.h
+++ b/DSView/pv/data/groupsnapshot.h
@@ -98,7 +98,7 @@ private:
 private:
 	struct Envelope _envelope_levels[ScaleStepCount];
     mutable boost::recursive_mutex _mutex;
-    void *_data;
+    const void *_data;
     uint64_t _sample_count;
     int _unit_size;
     boost::shared_ptr<view::Signal> _signal;
diff --git a/DSView/pv/data/logic.cpp b/DSView/pv/data/logic.cpp
index 4116942a..a249eda8 100644
--- a/DSView/pv/data/logic.cpp
+++ b/DSView/pv/data/logic.cpp
@@ -24,6 +24,8 @@
 #include "logic.h"
 #include "logicsnapshot.h"
 
+#include <boost/foreach.hpp>
+
 using namespace boost;
 using namespace std;
 
@@ -48,7 +50,9 @@ deque< boost::shared_ptr<LogicSnapshot> >& Logic::get_snapshots()
 
 void Logic::clear()
 {
-    _snapshots.clear();
+    //_snapshots.clear();
+    BOOST_FOREACH(const boost::shared_ptr<LogicSnapshot> s, _snapshots)
+        s->clear();
 }
 
 } // namespace data
diff --git a/DSView/pv/data/logicsnapshot.cpp b/DSView/pv/data/logicsnapshot.cpp
index ebdb904e..df77821f 100644
--- a/DSView/pv/data/logicsnapshot.cpp
+++ b/DSView/pv/data/logicsnapshot.cpp
@@ -43,21 +43,37 @@ const int LogicSnapshot::MipMapScaleFactor = 1 << MipMapScalePower;
 const float LogicSnapshot::LogMipMapScaleFactor = logf(MipMapScaleFactor);
 const uint64_t LogicSnapshot::MipMapDataUnit = 64*1024;	// bytes
 
-LogicSnapshot::LogicSnapshot(const sr_datafeed_logic &logic, uint64_t _total_sample_len, unsigned int channel_num) :
-    Snapshot(logic.unitsize, _total_sample_len, channel_num),
-	_last_append_sample(0)
+LogicSnapshot::LogicSnapshot() :
+    Snapshot(1, 1, 1),
+    _last_append_sample(0)
 {
-	boost::lock_guard<boost::recursive_mutex> lock(_mutex);
-	memset(_mip_map, 0, sizeof(_mip_map));
-    if (init(_total_sample_len * channel_num) == SR_OK)
-        append_payload(logic);
+    memset(_mip_map, 0, sizeof(_mip_map));
 }
 
 LogicSnapshot::~LogicSnapshot()
 {
 	boost::lock_guard<boost::recursive_mutex> lock(_mutex);
-	BOOST_FOREACH(MipMapLevel &l, _mip_map)
-		free(l.data);
+    BOOST_FOREACH(MipMapLevel &l, _mip_map)
+        free(l.data);
+}
+
+void LogicSnapshot::clear()
+{
+    _sample_count = 0;
+    _ring_sample_count = 0;
+    memset(_mip_map, 0, sizeof(_mip_map));
+}
+
+void LogicSnapshot::first_payload(const sr_datafeed_logic &logic, uint64_t total_sample_count, unsigned int channel_num)
+{
+    _total_sample_count = total_sample_count;
+    _channel_num = channel_num;
+    _unit_size = logic.unitsize;
+    boost::lock_guard<boost::recursive_mutex> lock(_mutex);
+    if (init(_total_sample_count * _channel_num) == SR_OK) {
+        append_payload(logic);
+        _last_ended = false;
+    }
 }
 
 void LogicSnapshot::append_payload(
@@ -88,7 +104,7 @@ uint8_t * LogicSnapshot::get_samples(int64_t start_sample, int64_t end_sample) c
 
     //const size_t size = (end_sample - start_sample) * _unit_size;
     //memcpy(data, (const uint8_t*)_data + start_sample * _unit_size, size);
-    return (uint8_t*)_data + start_sample * _unit_size;
+    return (uint8_t*)_data.data() + start_sample * _unit_size;
 }
 
 void LogicSnapshot::reallocate_mipmap_level(MipMapLevel &m)
@@ -127,9 +143,9 @@ void LogicSnapshot::append_payload_to_mipmap()
 	dest_ptr = (uint8_t*)m0.data + prev_length * _unit_size;
 
 	// Iterate through the samples to populate the first level mipmap
-	const uint8_t *const end_src_ptr = (uint8_t*)_data +
+    const uint8_t *const end_src_ptr = (uint8_t*)_data.data() +
 		m0.length * _unit_size * MipMapScaleFactor;
-	for (src_ptr = (uint8_t*)_data +
+    for (src_ptr = (uint8_t*)_data.data() +
 		prev_length * _unit_size * MipMapScaleFactor;
 		src_ptr < end_src_ptr;)
 	{
@@ -201,7 +217,7 @@ void LogicSnapshot::get_subsampled_edges(
 	assert(sig_index >= 0);
 	assert(sig_index < 64);
 
-    if (!_data)
+    if (_data.size() == 0)
         return;
 
 	boost::lock_guard<boost::recursive_mutex> lock(_mutex);
diff --git a/DSView/pv/data/logicsnapshot.h b/DSView/pv/data/logicsnapshot.h
index ba40df84..ecaab06b 100644
--- a/DSView/pv/data/logicsnapshot.h
+++ b/DSView/pv/data/logicsnapshot.h
@@ -61,10 +61,14 @@ public:
     typedef std::pair<uint64_t, bool> EdgePair;
 
 public:
-    LogicSnapshot(const sr_datafeed_logic &logic, uint64_t _total_sample_len, unsigned int channel_num);
+    LogicSnapshot();
 
 	virtual ~LogicSnapshot();
 
+    void clear();
+
+    void first_payload(const sr_datafeed_logic &logic, uint64_t total_sample_count, unsigned int channel_num);
+
 	void append_payload(const sr_datafeed_logic &logic);
 
     uint8_t * get_samples(int64_t start_sample, int64_t end_sample) const;
diff --git a/DSView/pv/data/mathstack.cpp b/DSView/pv/data/mathstack.cpp
index 99e3e0b4..6494351c 100644
--- a/DSView/pv/data/mathstack.cpp
+++ b/DSView/pv/data/mathstack.cpp
@@ -56,7 +56,8 @@ MathStack::MathStack(pv::SigSession &session, int index) :
     _index(index),
     _dc_ignore(true),
     _sample_interval(1),
-    _math_state(Init)
+    _math_state(Init),
+    _fft_plan(NULL)
 {
 }
 
@@ -65,7 +66,8 @@ MathStack::~MathStack()
     _xn.clear();
     _xk.clear();
     _power_spectrum.clear();
-    fftw_destroy_plan(_fft_plan);
+    if (_fft_plan)
+        fftw_destroy_plan(_fft_plan);
 }
 
 void MathStack::clear()
diff --git a/DSView/pv/data/snapshot.cpp b/DSView/pv/data/snapshot.cpp
index 57be15e7..e5e9e741 100644
--- a/DSView/pv/data/snapshot.cpp
+++ b/DSView/pv/data/snapshot.cpp
@@ -33,12 +33,13 @@ namespace pv {
 namespace data {
 
 Snapshot::Snapshot(int unit_size, uint64_t total_sample_count, unsigned int channel_num) :
-    _data(NULL),
     _channel_num(channel_num),
     _sample_count(0),
     _total_sample_count(total_sample_count),
     _ring_sample_count(0),
-    _unit_size(unit_size)
+    _unit_size(unit_size),
+    _memory_failed(true),
+    _last_ended(true)
 {
 	boost::lock_guard<boost::recursive_mutex> lock(_mutex);
 	assert(_unit_size > 0);
@@ -47,41 +48,65 @@ Snapshot::Snapshot(int unit_size, uint64_t total_sample_count, unsigned int chan
 Snapshot::~Snapshot()
 {
 	boost::lock_guard<boost::recursive_mutex> lock(_mutex);
-    if (_data != NULL)
-        free(_data);
-    _data = NULL;
+    _data.clear();
 }
 
 int Snapshot::init(uint64_t _total_sample_len)
 {
-    boost::lock_guard<boost::recursive_mutex> lock(_mutex);
-    _data = malloc(_total_sample_len * _unit_size +
-        sizeof(uint64_t));
+//    boost::lock_guard<boost::recursive_mutex> lock(_mutex);
+//    _data = malloc(_total_sample_len * _unit_size +
+//        sizeof(uint64_t));
 
-    if (_data == NULL)
+//    if (_data == NULL)
+//        return SR_ERR_MALLOC;
+//    else
+//        return SR_OK;
+
+    boost::lock_guard<boost::recursive_mutex> lock(_mutex);
+    uint64_t size = _total_sample_len * _unit_size + sizeof(uint64_t);
+    try{
+        _data.resize(size);
+    } catch(...) {
+        _memory_failed = true;
         return SR_ERR_MALLOC;
-    else
-        return SR_OK;
+    }
+    _memory_failed = false;
+    return SR_OK;
 }
 
-bool Snapshot::buf_null() const
+bool Snapshot::memory_failed() const
 {
-    if (_data == NULL)
+    return _memory_failed;
+}
+
+bool Snapshot::empty() const
+{
+    if (_sample_count == 0 || _memory_failed)
         return true;
     else
         return false;
 }
 
+bool Snapshot::last_ended() const
+{
+    return _last_ended;
+}
+
+void Snapshot::set_last_ended(bool ended)
+{
+    _last_ended = ended;
+}
+
 uint64_t Snapshot::get_sample_count() const
 {
 	boost::lock_guard<boost::recursive_mutex> lock(_mutex);
     return _sample_count;
 }
 
-void* Snapshot::get_data() const
+const void* Snapshot::get_data() const
 {
     boost::lock_guard<boost::recursive_mutex> lock(_mutex);
-    return _data;
+    return _data.data();
 }
 
 int Snapshot::unit_size() const
@@ -100,10 +125,10 @@ uint64_t Snapshot::get_sample(uint64_t index) const
 {
     boost::lock_guard<boost::recursive_mutex> lock(_mutex);
 
-    assert(_data);
+    assert(_data.data());
     assert(index < _sample_count);
 
-    return *(uint64_t*)((uint8_t*)_data + index * _unit_size);
+    return *(uint64_t*)((uint8_t*)_data.data() + index * _unit_size);
 }
 
 void Snapshot::append_data(void *data, uint64_t samples)
@@ -117,13 +142,13 @@ void Snapshot::append_data(void *data, uint64_t samples)
         _sample_count = _total_sample_count;
 
     if (_ring_sample_count + samples > _total_sample_count) {
-        memcpy((uint8_t*)_data + _ring_sample_count * _unit_size,
+        memcpy((uint8_t*)_data.data() + _ring_sample_count * _unit_size,
             data, (_total_sample_count - _ring_sample_count) * _unit_size);
         _ring_sample_count = (samples + _ring_sample_count - _total_sample_count) % _total_sample_count;
-        memcpy((uint8_t*)_data,
+        memcpy((uint8_t*)_data.data(),
             data, _ring_sample_count * _unit_size);
     } else {
-        memcpy((uint8_t*)_data + _ring_sample_count * _unit_size,
+        memcpy((uint8_t*)_data.data() + _ring_sample_count * _unit_size,
             data, samples * _unit_size);
         _ring_sample_count += samples;
     }
@@ -134,10 +159,10 @@ void Snapshot::refill_data(void *data, uint64_t samples, bool instant)
     boost::lock_guard<boost::recursive_mutex> lock(_mutex);
 
     if (instant) {
-        memcpy((uint8_t*)_data + _sample_count * _channel_num, data, samples*_channel_num);
+        memcpy((uint8_t*)_data.data() + _sample_count * _channel_num, data, samples*_channel_num);
         _sample_count = (_sample_count + samples) % (_total_sample_count + 1);
     } else {
-        memcpy((uint8_t*)_data, data, samples*_channel_num);
+        memcpy((uint8_t*)_data.data(), data, samples*_channel_num);
         _sample_count = samples;
     }
 
diff --git a/DSView/pv/data/snapshot.h b/DSView/pv/data/snapshot.h
index b128a83c..9f2be22c 100644
--- a/DSView/pv/data/snapshot.h
+++ b/DSView/pv/data/snapshot.h
@@ -42,11 +42,15 @@ public:
 
 	uint64_t get_sample_count() const;
 
-    void * get_data() const;
+    const void * get_data() const;
 
     int unit_size() const;
 
-    bool buf_null() const;
+    bool memory_failed() const;
+    bool empty() const;
+
+    bool last_ended() const;
+    void set_last_ended(bool ended);
 
     unsigned int get_channel_num() const;
 
@@ -58,12 +62,14 @@ protected:
 
 protected:
 	mutable boost::recursive_mutex _mutex;
-	void *_data;
+    std::vector<uint8_t> _data;
     unsigned int _channel_num;
 	uint64_t _sample_count;
     uint64_t _total_sample_count;
     uint64_t _ring_sample_count;
 	int _unit_size;
+    bool _memory_failed;
+    bool _last_ended;
 };
 
 } // namespace data
diff --git a/DSView/pv/dock/protocoldock.cpp b/DSView/pv/dock/protocoldock.cpp
index 087a63bb..730c6e6f 100644
--- a/DSView/pv/dock/protocoldock.cpp
+++ b/DSView/pv/dock/protocoldock.cpp
@@ -166,14 +166,6 @@ int ProtocolDock::decoder_name_cmp(const void *a, const void *b)
         ((const srd_decoder*)b)->name);
 }
 
-void ProtocolDock::paintEvent(QPaintEvent *)
-{
-     //QStyleOption opt;
-     //opt.init(this);
-     //QPainter p(this);
-     //style()->drawPrimitive(QStyle::PE_Widget, &opt, &p, this);
-}
-
 void ProtocolDock::add_protocol()
 {
     if (_session.get_device()->dev_inst()->mode != LOGIC) {
@@ -228,7 +220,7 @@ void ProtocolDock::add_protocol()
             // progress connection
             const std::vector< boost::shared_ptr<pv::view::DecodeTrace> > decode_sigs(
                 _session.get_decode_signals());
-            //connect(decode_sigs.back().get(), SIGNAL(decoded_progress(int)), this, SLOT(decoded_progess(int)));
+            connect(decode_sigs.back().get(), SIGNAL(decoded_progress(int)), this, SLOT(decoded_progess(int)));
 
             protocol_updated();
         }
@@ -363,6 +355,7 @@ void ProtocolDock::decoded_progess(int progress)
         _progress_label_list.at(index)->setText(progress_str);
         index++;
     }
+    update_model();
 }
 
 void ProtocolDock::set_model()
diff --git a/DSView/pv/dock/protocoldock.h b/DSView/pv/dock/protocoldock.h
index 8ca0d198..195f89b7 100644
--- a/DSView/pv/dock/protocoldock.h
+++ b/DSView/pv/dock/protocoldock.h
@@ -61,8 +61,6 @@ public:
     ProtocolDock(QWidget *parent, SigSession &session);
     ~ProtocolDock();
 
-    void paintEvent(QPaintEvent *);
-
     void del_all_protocol();
 
 signals:
diff --git a/DSView/pv/sigsession.cpp b/DSView/pv/sigsession.cpp
index a3851d27..51141f24 100644
--- a/DSView/pv/sigsession.cpp
+++ b/DSView/pv/sigsession.cpp
@@ -487,6 +487,13 @@ void SigSession::start_capture(bool instant,
 void SigSession::stop_capture()
 {
     _instant = false;
+#ifdef ENABLE_DECODE
+    for (vector< boost::shared_ptr<view::DecodeTrace> >::iterator i =
+        _decode_traces.begin();
+        i != _decode_traces.end();
+        i++)
+        (*i)->decoder()->stop_decode();
+#endif
     if (get_capture_state() != Running)
 		return;
 	sr_session_stop();
@@ -527,7 +534,7 @@ bool SigSession::get_instant()
     return _instant;
 }
 
-void* SigSession::get_buf(int& unit_size, uint64_t &length)
+const void* SigSession::get_buf(int& unit_size, uint64_t &length)
 {
     if (_dev_inst->dev_inst()->mode == LOGIC) {
         const deque< boost::shared_ptr<pv::data::LogicSnapshot> > &snapshots =
@@ -597,12 +604,12 @@ void SigSession::sample_thread_proc(boost::shared_ptr<device::DevInst> dev_inst,
     set_capture_state(Stopped);
 
     // Confirm that SR_DF_END was received
-    assert(!_cur_logic_snapshot);
-    assert(!_cur_dso_snapshot);
-    assert(!_cur_analog_snapshot);
+    assert(_cur_logic_snapshot->last_ended());
+    assert(_cur_dso_snapshot->last_ended());
+    assert(_cur_analog_snapshot->last_ended());
 }
 
-void SigSession::update_data_header(const sr_dev_inst *const sdi)
+void SigSession::feed_in_header(const sr_dev_inst *sdi)
 {
     GVariant *gvar;
     int ret;
@@ -631,15 +638,12 @@ void SigSession::update_data_header(const sr_dev_inst *const sdi)
 
     // Set the sample rate of all SignalData
     // Logic/Analog/Dso
-    set< boost::shared_ptr<data::SignalData> > data_set;
-    BOOST_FOREACH(const boost::shared_ptr<view::Signal> sig, _signals) {
-        assert(sig);
-        data_set.insert(sig->data());
-    }
-    BOOST_FOREACH(boost::shared_ptr<data::SignalData> data, data_set) {
-        assert(data);
-        data->set_samplerate(_cur_samplerate);
-    }
+    if (_logic_data)
+        _logic_data->set_samplerate(_cur_samplerate);
+    if (_analog_data)
+        _analog_data->set_samplerate(_cur_samplerate);
+    if (_dso_data)
+        _dso_data->set_samplerate(_cur_samplerate);
 #ifdef ENABLE_DECODE
     // DecoderStack
     BOOST_FOREACH(const boost::shared_ptr<view::DecodeTrace> d, _decode_traces)
@@ -658,19 +662,6 @@ void SigSession::update_data_header(const sr_dev_inst *const sdi)
     _group_data->set_samplerate(_cur_samplerate);
 }
 
-void SigSession::feed_in_header(const sr_dev_inst *sdi)
-{
-#ifdef ENABLE_DECODE
-    for (vector< boost::shared_ptr<view::DecodeTrace> >::iterator i =
-        _decode_traces.begin();
-        i != _decode_traces.end();
-        i++)
-        (*i)->decoder()->stop_decode();
-#endif
-    update_data_header(sdi);
-    //receive_data(0);
-}
-
 void SigSession::add_group()
 {
     std::list<int> probe_index_list;
@@ -786,21 +777,36 @@ void SigSession::init_signals()
         }
     }
 
+    // Create snapshots
+    {
+        _cur_logic_snapshot.reset(new data::LogicSnapshot());
+        assert(_cur_logic_snapshot);
+
+        _cur_dso_snapshot.reset(new data::DsoSnapshot());
+        assert(_cur_dso_snapshot);
+
+        _cur_analog_snapshot.reset(new data::AnalogSnapshot());
+        assert(_cur_analog_snapshot);
+    }
+
     // Create data containers for the coming data snapshots
     {
         if (logic_probe_count != 0) {
             _logic_data.reset(new data::Logic());
             assert(_logic_data);
+            _logic_data->push_snapshot(_cur_logic_snapshot);
         }
 
         if (dso_probe_count != 0) {
             _dso_data.reset(new data::Dso());
             assert(_dso_data);
+            _dso_data->push_snapshot(_cur_dso_snapshot);
         }
 
         if (analog_probe_count != 0) {
             _analog_data.reset(new data::Analog());
             assert(_analog_data);
+            _analog_data->push_snapshot(_cur_analog_snapshot);
         }
 
         _group_data.reset(new data::Group());
@@ -914,7 +920,7 @@ void SigSession::refresh(int holdtime)
 {
     if (_logic_data) {
         _logic_data->clear();
-        _cur_logic_snapshot.reset();
+        //_cur_logic_snapshot.reset();
 #ifdef ENABLE_DECODE
         BOOST_FOREACH(const boost::shared_ptr<view::DecodeTrace> d, _decode_traces)
         {
@@ -925,7 +931,8 @@ void SigSession::refresh(int holdtime)
     }
     if (_dso_data) {
         _dso_data->clear();
-        _cur_dso_snapshot.reset();
+        //_cur_dso_snapshot.reset();
+        _cur_dso_snapshot->set_last_ended(true);
         // MathStack
         BOOST_FOREACH(const boost::shared_ptr<view::MathTrace> m, _math_traces)
         {
@@ -935,7 +942,7 @@ void SigSession::refresh(int holdtime)
     }
     if (_analog_data) {
         _analog_data->clear();
-        _cur_analog_snapshot.reset();
+        //_cur_analog_snapshot.reset();
     }
     if (strncmp(_dev_inst->dev_inst()->driver->name, "virtual", 7)) {
         _data_lock = true;
@@ -997,8 +1004,7 @@ void SigSession::feed_in_logic(const sr_datafeed_logic &logic)
 {
 	boost::lock_guard<boost::mutex> lock(_data_mutex);
 
-	if (!_logic_data)
-	{
+    if (!_logic_data || !_cur_logic_snapshot) {
 		qDebug() << "Unexpected logic packet";
 		return;
 	}
@@ -1007,29 +1013,20 @@ void SigSession::feed_in_logic(const sr_datafeed_logic &logic)
         test_data_error();
     }
 
-	if (!_cur_logic_snapshot)
-	{
-		// Create a new data snapshot
-		_cur_logic_snapshot = boost::shared_ptr<data::LogicSnapshot>(
-            new data::LogicSnapshot(logic, _dev_inst->get_sample_limit(), 1));
-        if (_cur_logic_snapshot->buf_null())
-        {
+    if (_cur_logic_snapshot->last_ended()) {
+        _cur_logic_snapshot->first_payload(logic, _dev_inst->get_sample_limit(), 1);
+        if (_cur_logic_snapshot->memory_failed()) {
             malloc_error();
             return;
-        } else {
-            _logic_data->push_snapshot(_cur_logic_snapshot);
         }
-
         // @todo Putting this here means that only listeners querying
         // for logic will be notified. Currently the only user of
         // frame_began is DecoderStack, but in future we need to signal
         // this after both analog and logic sweeps have begun.
         frame_began();
-    } else if(!_cur_logic_snapshot->buf_null()) {
+    } else {
 		// Append to the existing data snapshot
 		_cur_logic_snapshot->append_payload(logic);
-    } else {
-        return;
     }
 
     emit receive_data(logic.length/logic.unitsize);
@@ -1041,13 +1038,13 @@ void SigSession::feed_in_dso(const sr_datafeed_dso &dso)
 {
     boost::lock_guard<boost::mutex> lock(_data_mutex);
 
-    if(!_dso_data)
+    if(!_dso_data || !_cur_dso_snapshot)
     {
         qDebug() << "Unexpected dso packet";
         return;	// This dso packet was not expected.
     }
 
-    if (!_cur_dso_snapshot)
+    if (_cur_dso_snapshot->last_ended())
     {
         // reset scale of dso signal
         BOOST_FOREACH(const boost::shared_ptr<view::Signal> s, _signals)
@@ -1058,24 +1055,17 @@ void SigSession::feed_in_dso(const sr_datafeed_dso &dso)
                 dsoSig->set_scale(dsoSig->get_view_rect().height() / 256.0f);
         }
 
-        // Create a new data snapshot
-        _cur_dso_snapshot = boost::shared_ptr<data::DsoSnapshot>(
-                    new data::DsoSnapshot(dso, _dev_inst->get_sample_limit(), get_ch_num(SR_CHANNEL_DSO), _instant));
-        if (_cur_dso_snapshot->buf_null())
-        {
+        // first payload
+        _cur_dso_snapshot->first_payload(dso, _dev_inst->get_sample_limit(), get_ch_num(SR_CHANNEL_DSO), _instant);
+        if (_cur_dso_snapshot->memory_failed()) {
             malloc_error();
             return;
-        } else {
-            _dso_data->push_snapshot(_cur_dso_snapshot);
         }
-    } else if(!_cur_dso_snapshot->buf_null()) {
+    } else {
         // Append to the existing data snapshot
         _cur_dso_snapshot->append_payload(dso);
-    } else {
-        return;
     }
-
-    // reset scale of dso signal
+    // calculate related math results
     BOOST_FOREACH(const boost::shared_ptr<view::MathTrace> m, _math_traces)
     {
         assert(m);
@@ -1085,36 +1075,29 @@ void SigSession::feed_in_dso(const sr_datafeed_dso &dso)
 
     receive_data(dso.num_samples);
     data_updated();
-    //if (!_instant)
-    //    start_timer(ViewTime);
 }
 
 void SigSession::feed_in_analog(const sr_datafeed_analog &analog)
 {
 	boost::lock_guard<boost::mutex> lock(_data_mutex);
 
-	if(!_analog_data)
+    if(!_analog_data || !_cur_analog_snapshot)
 	{
 		qDebug() << "Unexpected analog packet";
 		return;	// This analog packet was not expected.
 	}
 
-	if (!_cur_analog_snapshot)
+    if (_cur_analog_snapshot->last_ended())
 	{
-		// Create a new data snapshot
-		_cur_analog_snapshot = boost::shared_ptr<data::AnalogSnapshot>(
-                    new data::AnalogSnapshot(analog, _dev_inst->get_sample_limit(), get_ch_num(SR_CHANNEL_ANALOG)));
-        if (_cur_analog_snapshot->buf_null())
-        {
+        // first payload
+        _cur_analog_snapshot->first_payload(analog, _dev_inst->get_sample_limit(), get_ch_num(SR_CHANNEL_ANALOG));
+        if (_cur_analog_snapshot->memory_failed()) {
+            malloc_error();
             return;
-        } else if(!_cur_analog_snapshot->buf_null()) {
-            _analog_data->push_snapshot(_cur_analog_snapshot);
         }
-    } else if(!_cur_analog_snapshot->buf_null()) {
+    } else {
 		// Append to the existing data snapshot
 		_cur_analog_snapshot->append_payload(analog);
-    } else {
-        return;
     }
 
     receive_data(analog.num_samples);
@@ -1165,7 +1148,7 @@ void SigSession::data_feed_in(const struct sr_dev_inst *sdi,
 	{
 		{
             boost::lock_guard<boost::mutex> lock(_data_mutex);
-            if (_cur_logic_snapshot) {
+            if (!_cur_logic_snapshot->empty()) {
                 BOOST_FOREACH(const boost::shared_ptr<view::GroupSignal> g, _group_traces)
                 {
                     assert(g);
@@ -1176,9 +1159,9 @@ void SigSession::data_feed_in(const struct sr_dev_inst *sdi,
                     _cur_group_snapshot.reset();
                 }
             }
-            _cur_logic_snapshot.reset();
-            _cur_dso_snapshot.reset();
-            _cur_analog_snapshot.reset();
+            _cur_logic_snapshot->set_last_ended(true);
+            _cur_dso_snapshot->set_last_ended(true);
+            _cur_analog_snapshot->set_last_ended(true);
 #ifdef ENABLE_DECODE
             BOOST_FOREACH(const boost::shared_ptr<view::DecodeTrace> d, _decode_traces)
                 d->frame_ended();
diff --git a/DSView/pv/sigsession.h b/DSView/pv/sigsession.h
index 55e9ec53..5092b19b 100644
--- a/DSView/pv/sigsession.h
+++ b/DSView/pv/sigsession.h
@@ -173,7 +173,7 @@ public:
 
     void del_group();
 
-    void* get_buf(int& unit_size, uint64_t& length);
+    const void* get_buf(int& unit_size, uint64_t& length);
 
     void start_hotplug_proc(boost::function<void (const QString)> error_handler);
     void stop_hotplug_proc();
@@ -191,8 +191,6 @@ public:
 private:
 	void set_capture_state(capture_state state);
 
-    void update_data_header(const sr_dev_inst *const sdi);
-
 private:
     /**
      * Attempts to autodetect the format. Failing that
diff --git a/DSView/pv/toolbars/filebar.cpp b/DSView/pv/toolbars/filebar.cpp
index cd7e0d94..3c5efd30 100644
--- a/DSView/pv/toolbars/filebar.cpp
+++ b/DSView/pv/toolbars/filebar.cpp
@@ -158,7 +158,7 @@ void FileBar::show_session_error(
 void FileBar::on_actionExport_triggered(){
     int unit_size;
     uint64_t length;
-    void* buf = _session.get_buf(unit_size, length);
+    const void* buf = _session.get_buf(unit_size, length);
     if (!buf) {
         QMessageBox msg(this);
         msg.setText(tr("Data Export"));
@@ -192,7 +192,7 @@ void FileBar::on_actionSave_triggered()
     //save();
     int unit_size;
     uint64_t length;
-    void* buf = _session.get_buf(unit_size, length);
+    const void* buf = _session.get_buf(unit_size, length);
     if (!buf) {
         QMessageBox msg(this);
         msg.setText(tr("File Save"));
diff --git a/DSView/pv/view/analogsignal.cpp b/DSView/pv/view/analogsignal.cpp
index de501262..d9cc46b2 100644
--- a/DSView/pv/view/analogsignal.cpp
+++ b/DSView/pv/view/analogsignal.cpp
@@ -94,6 +94,8 @@ void AnalogSignal::paint_mid(QPainter &p, int left, int right)
     _scale = _totalHeight * 1.0f / 65536;
 	const boost::shared_ptr<pv::data::AnalogSnapshot> &snapshot =
 		snapshots.front();
+    if (snapshot->empty())
+        return;
 
     if (get_index() >= (int)snapshot->get_channel_num())
         return;
diff --git a/DSView/pv/view/decodetrace.cpp b/DSView/pv/view/decodetrace.cpp
index 8d9ea2d7..f3ba3af0 100644
--- a/DSView/pv/view/decodetrace.cpp
+++ b/DSView/pv/view/decodetrace.cpp
@@ -229,16 +229,10 @@ void DecodeTrace::paint_mid(QPainter &p, int left, int right)
 	const QString err = _decoder_stack->error_message();
 	if (!err.isEmpty())
 	{
-        //draw_unresolved_period(p, annotation_height, left, right,
-        //	samples_per_pixel, pixels_offset);
 		draw_error(p, err, left, right);
 		return;
 	}
 
-    // Draw the hatching
-    if (draw_unresolved_period(p, annotation_height, left, right))
-        return;
-
 	// Iterate through the rows
 	assert(_view);
     int y =  get_y() - (_totalHeight - annotation_height)*0.5;
@@ -637,40 +631,6 @@ void DecodeTrace::draw_error(QPainter &p, const QString &message,
 	p.drawText(text_rect, message);
 }
 
-bool DecodeTrace::draw_unresolved_period(QPainter &p, int h, int left,
-    int right)
-{
-	using namespace pv::data;
-	using pv::data::decode::Decoder;
-
-	assert(_decoder_stack);	
-
-    boost::shared_ptr<Logic> data;
-    boost::shared_ptr<LogicSignal> logic_signal;
-
-    //const int64_t need_sample_count = _decoder_stack->sample_count();
-    const uint64_t need_sample_count = _decode_end - _decode_start + 1;
-    if (need_sample_count == 0)
-        return true;
-
-    const uint64_t samples_decoded = _decoder_stack->samples_decoded();
-    if (need_sample_count == samples_decoded)
-        return false;
-
-    const int y = get_y();
-    const QRectF no_decode_rect(left, y - h/2 + 0.5, right - left, h);
-
-    const int progress100 = ceil(samples_decoded * 100.0 / need_sample_count);
-    p.setPen(dsLightBlue);
-    QFont font=p.font();
-    font.setPointSize(_view->get_signalHeight()*2/3);
-    font.setBold(true);
-    p.setFont(font);
-    p.drawText(no_decode_rect, Qt::AlignCenter | Qt::AlignVCenter, QString::number(_progress)+"%");
-
-    return true;
-}
-
 void DecodeTrace::draw_unshown_row(QPainter &p, int y, int h, int left,
     int right, QString info)
 {
@@ -830,12 +790,13 @@ void DecodeTrace::commit_probes()
 
 void DecodeTrace::on_new_decode_data()
 {
-    const uint64_t need_sample_count = _decode_end - _decode_start + 1;
-    if (need_sample_count == 0) {
+    uint64_t real_end = min(_decoder_stack->sample_count(), _decode_end+1);
+    const int64_t need_sample_count = real_end - _decode_start;
+    if (need_sample_count <= 0) {
         _progress = 100;
     } else {
         const uint64_t samples_decoded = _decoder_stack->samples_decoded();
-        _progress = ceil(samples_decoded * 100.0 / need_sample_count);
+        _progress = floor(samples_decoded * 100.0 / need_sample_count);
     }
     decoded_progress(_progress);
 
@@ -850,10 +811,11 @@ int DecodeTrace::get_progress() const
 
 void DecodeTrace::on_decode_done()
 {
-    if (_view) {
-        _view->set_update(_viewport, true);
-        _view->signals_changed();
-    }
+//    if (_view) {
+//        _view->set_update(_viewport, true);
+//        _view->signals_changed();
+//    }
+    on_new_decode_data();
     _session.decode_done();
 }
 
diff --git a/DSView/pv/view/decodetrace.h b/DSView/pv/view/decodetrace.h
index 41cc94fe..39db68e6 100644
--- a/DSView/pv/view/decodetrace.h
+++ b/DSView/pv/view/decodetrace.h
@@ -170,9 +170,6 @@ private:
 	void draw_error(QPainter &p, const QString &message,
 		int left, int right);
 
-    bool draw_unresolved_period(QPainter &p, int h, int left,
-        int right);
-
     void draw_unshown_row(QPainter &p, int y, int h, int left,
                           int right, QString info);
 
diff --git a/DSView/pv/view/dsosignal.cpp b/DSView/pv/view/dsosignal.cpp
index f2a4b66b..4113c65f 100644
--- a/DSView/pv/view/dsosignal.cpp
+++ b/DSView/pv/view/dsosignal.cpp
@@ -305,7 +305,7 @@ bool DsoSignal::go_hDialPre(bool setted)
 {
     int ch_num = _view->session().get_ch_num(SR_CHANNEL_DSO);
     if (ch_num != 0 && !_hDial->isMin()) {
-        uint64_t sample_rate = _view->session().cur_samplerate();
+        uint64_t sample_rate = _view->session().get_device()->get_sample_rate();
         const uint64_t min_div = std::pow(10.0, 9.0) / sample_rate;
         if (_view->session().get_capture_state() != SigSession::Running &&
             !_data->get_snapshots().empty()) {
@@ -764,8 +764,8 @@ void DsoSignal::paint_back(QPainter &p, int left, int right)
 
     p.setPen(Trace::dsLightBlue);
     p.drawLine(left, UpMargin/2, left + width, UpMargin/2);
-    const uint64_t sample_len = _view->session().cur_samplelimits();
-    const double samplerate = _view->session().cur_samplerate();
+    const uint64_t sample_len = _view->session().get_device()->get_sample_limit();
+    const double samplerate = _view->session().get_device()->get_sample_rate();
     const double samples_per_pixel = samplerate * _view->scale();
     const double shown_rate = min(samples_per_pixel * width * 1.0 / sample_len, 1.0);
     const double start_time = _data->get_start_time();
@@ -835,6 +835,8 @@ void DsoSignal::paint_mid(QPainter &p, int left, int right)
             return;
         const boost::shared_ptr<pv::data::DsoSnapshot> &snapshot =
             snapshots.front();
+        if (snapshot->empty())
+            return;
 
         const uint16_t number_channels = snapshot->get_channel_num();
         if ((strcmp(_dev_inst->dev_inst()->driver->name, "DSLogic") == 0) &&
@@ -843,7 +845,7 @@ void DsoSignal::paint_mid(QPainter &p, int left, int right)
 
         const double pixels_offset = offset / scale;
         //const double samplerate = _data->samplerate();
-        const double samplerate = _view->session().cur_samplerate();
+        const double samplerate = _view->session().get_device()->get_sample_rate();
         const double start_time = _data->get_start_time();
         const int64_t last_sample = max((int64_t)(snapshot->get_sample_count() - 1), (int64_t)0);
         const double samples_per_pixel = samplerate * scale;
@@ -1280,7 +1282,7 @@ void DsoSignal::paint_measure(QPainter &p)
         double value_p2p = value_max - value_min;
         _period = (count == 0) ? period * 10.0 : period * 10.0 / count;
         const int channel_count = _view->session().get_ch_num(SR_CHANNEL_DSO);
-        uint64_t sample_rate = _view->session().cur_samplerate();
+        uint64_t sample_rate = _view->session().get_device()->get_sample_rate();
         _period = _period * 200.0 / (channel_count * sample_rate * 1.0 / SR_MHZ(1));
         _ms_string[DSO_MS_VMAX] = "Vmax: " + (abs(value_max) > 1000 ? QString::number(value_max/1000.0, 'f', 2) + "V" : QString::number(value_max, 'f', 2) + "mV");
         _ms_string[DSO_MS_VMIN] = "Vmin: " + (abs(value_min) > 1000 ? QString::number(value_min/1000.0, 'f', 2) + "V" : QString::number(value_min, 'f', 2) + "mV");
@@ -1448,14 +1450,14 @@ bool DsoSignal::measure(const QPointF &p)
 
     const boost::shared_ptr<pv::data::DsoSnapshot> &snapshot =
         snapshots.front();
-    if (snapshot->buf_null())
+    if (snapshot->empty())
         return false;
 
     const double scale = _view->scale();
     assert(scale > 0);
     const double offset = _view->offset();
     const double pixels_offset = offset / scale;
-    const double samplerate = _view->session().cur_samplerate();
+    const double samplerate = _view->session().get_device()->get_sample_rate();
     const double samples_per_pixel = samplerate * scale;
 
     _hover_index = floor((p.x() + pixels_offset) * samples_per_pixel+0.5);
diff --git a/DSView/pv/view/logicsignal.cpp b/DSView/pv/view/logicsignal.cpp
index 94e96d7b..fb911fd7 100644
--- a/DSView/pv/view/logicsignal.cpp
+++ b/DSView/pv/view/logicsignal.cpp
@@ -142,23 +142,18 @@ void LogicSignal::paint_mid(QPainter &p, int left, int right)
 
 	const deque< boost::shared_ptr<pv::data::LogicSnapshot> > &snapshots =
 		_data->get_snapshots();
-	if (snapshots.empty())
+    double samplerate = _data->samplerate();
+    if (snapshots.empty() || samplerate == 0)
 		return;
 
 	const boost::shared_ptr<pv::data::LogicSnapshot> &snapshot =
 		snapshots.front();
-    if (snapshot->buf_null())
+    if (snapshot->empty())
         return;
 
-    double samplerate = _data->samplerate();
-
-	// Show sample rate as 1Hz when it is unknown
-	if (samplerate == 0.0)
-		samplerate = 1.0;
-
 	const double pixels_offset = offset / scale;
 	const double start_time = _data->get_start_time();
-    const int64_t last_sample = snapshot->get_sample_count() - 1;
+    const int64_t last_sample =  snapshot->get_sample_count() - 1;
 	const double samples_per_pixel = samplerate * scale;
 	const double start = samplerate * (offset - start_time);
 	const double end = start + samples_per_pixel * (right - left);
@@ -308,7 +303,7 @@ bool LogicSignal::measure(const QPointF &p, uint64_t &index0, uint64_t &index1,
 
         const boost::shared_ptr<pv::data::LogicSnapshot> &snapshot =
             snapshots.front();
-        if (snapshot->buf_null())
+        if (snapshot->empty())
             return false;
 
         uint64_t index = _data->samplerate() * (_view->offset() - _data->get_start_time() + p.x() * _view->scale());
@@ -353,7 +348,7 @@ bool LogicSignal::edges(const QPointF &p, uint64_t start, uint64_t &rising, uint
 
         const boost::shared_ptr<pv::data::LogicSnapshot> &snapshot =
             snapshots.front();
-        if (snapshot->buf_null())
+        if (snapshot->empty())
             return false;
 
         end = _data->samplerate() * (_view->offset() - _data->get_start_time() + p.x() * _view->scale());