diff --git a/src/archive.h b/src/archive.h
index 73e63edeac..b582e9e58a 100644
--- a/src/archive.h
+++ b/src/archive.h
@@ -34,6 +34,7 @@ namespace librealsense
         rs2_time_t      backend_timestamp = 0;
         rs2_time_t last_timestamp = 0;
         unsigned long long last_frame_number = 0;
+        bool is_blocking = false;
 
         frame_additional_data() {};
 
@@ -44,14 +45,16 @@ namespace librealsense
             const uint8_t* md_buf,
             double backend_time,
             rs2_time_t last_timestamp,
-            unsigned long long last_frame_number)
+            unsigned long long last_frame_number,
+            bool in_is_blocking)
             : timestamp(in_timestamp),
             frame_number(in_frame_number),
             system_time(in_system_time),
             metadata_size(md_size),
             backend_timestamp(backend_time),
             last_timestamp(last_timestamp),
-            last_frame_number(last_frame_number)
+            last_frame_number(last_frame_number),
+            is_blocking(in_is_blocking)
         {
             // Copy up to 255 bytes to preserve metadata as raw data
             if (metadata_size)
@@ -156,6 +159,9 @@ namespace librealsense
         void mark_fixed() override { _fixed = true; }
         bool is_fixed() const override { return _fixed; }
 
+        void set_blocking(bool state) override { additional_data.is_blocking = state; }
+        bool is_blocking() const override { return additional_data.is_blocking; }
+
     private:
         // TODO: check boost::intrusive_ptr or an alternative
         std::atomic<int> ref_count; // the reference count is on how many times this placeholder has been observed (not lifetime, not content)
@@ -303,7 +309,7 @@ namespace librealsense
                 return((depth_frame*)_original.frame)->get_distance(x, y);
 
             uint64_t pixel = 0;
-            switch (get_bpp()/8) // bits per pixel
+            switch (get_bpp() / 8) // bits per pixel
             {
             case 1: pixel = get_frame_data()[y*get_width() + x];                                    break;
             case 2: pixel = reinterpret_cast<const uint16_t*>(get_frame_data())[y*get_width() + x]; break;
@@ -353,7 +359,7 @@ namespace librealsense
                 try
                 {
                     auto depth_sensor = As<librealsense::depth_sensor>(sensor);
-                    if(depth_sensor != nullptr)
+                    if (depth_sensor != nullptr)
                     {
                         return depth_sensor->get_depth_scale();
                     }
@@ -484,4 +490,4 @@ namespace librealsense
 
     MAP_EXTENSION(RS2_EXTENSION_POSE_FRAME, librealsense::pose_frame);
 
-}
+}
\ No newline at end of file
diff --git a/src/concurrency.h b/src/concurrency.h
index 068620bd9f..d8b01c12bc 100644
--- a/src/concurrency.h
+++ b/src/concurrency.h
@@ -14,113 +14,181 @@ const int QUEUE_MAX_SIZE = 10;
 template<class T>
 class single_consumer_queue
 {
-    std::deque<T> q;
-    std::mutex mutex;
-    std::condition_variable cv; // not empty signal
-    unsigned int cap;
-    bool accepting;
+    std::deque<T> _queue;
+    std::mutex _mutex;
+    std::condition_variable _deq_cv; // not empty signal
+    std::condition_variable _enq_cv; // not empty signal
+
+    unsigned int _cap;
+    bool _accepting;
 
     // flush mechanism is required to abort wait on cv
     // when need to stop
-    std::atomic<bool> need_to_flush;
-    std::atomic<bool> was_flushed;
-    std::condition_variable was_flushed_cv;
-    std::mutex was_flushed_mutex;
+    std::atomic<bool> _need_to_flush;
+    std::atomic<bool> _was_flushed;
 public:
     explicit single_consumer_queue<T>(unsigned int cap = QUEUE_MAX_SIZE)
-        : q(), mutex(), cv(), cap(cap), need_to_flush(false), was_flushed(false), accepting(true)
+        : _queue(), _mutex(), _deq_cv(), _enq_cv(), _cap(cap), _need_to_flush(false), _was_flushed(false), _accepting(true)
     {}
 
     void enqueue(T&& item)
     {
-        std::unique_lock<std::mutex> lock(mutex);
-        if (accepting)
+        std::unique_lock<std::mutex> lock(_mutex);
+        if (_accepting)
         {
-            q.push_back(std::move(item));
-            if (q.size() > cap)
+            _queue.push_back(std::move(item));
+            if (_queue.size() > _cap)
             {
-                q.pop_front();
+                _queue.pop_front();
             }
         }
         lock.unlock();
-        cv.notify_one();
+        _deq_cv.notify_one();
     }
 
-    bool dequeue(T* item ,unsigned int timeout_ms = 5000)
+    void blocking_enqueue(T&& item)
     {
-        std::unique_lock<std::mutex> lock(mutex);
-        accepting = true;
-        was_flushed = false;
-        const auto ready = [this]() { return (q.size() > 0) || need_to_flush; };
-        if (!ready() && !cv.wait_for(lock, std::chrono::milliseconds(timeout_ms), ready))
-        {
-            return false;
-        }
+        auto pred = [this]()->bool { return _queue.size() <= _cap; };
 
-        if (q.size() <= 0)
+        std::unique_lock<std::mutex> lock(_mutex);
+        if (_accepting)
         {
-            return false;
+            _enq_cv.wait(lock, pred);
+            _queue.push_back(std::move(item));
         }
-        *item = std::move(q.front());
-        q.pop_front();
-        return true;
+        lock.unlock();
+        _deq_cv.notify_one();
     }
 
-    bool peek(T** item)
+
+    bool dequeue(T* item ,unsigned int timeout_ms = 5000)
     {
-        std::unique_lock<std::mutex> lock(mutex);
+        std::unique_lock<std::mutex> lock(_mutex);
+        _accepting = true;
+        _was_flushed = false;
+        const auto ready = [this]() { return (_queue.size() > 0) || _need_to_flush; };
+        if (!ready() && !_deq_cv.wait_for(lock, std::chrono::milliseconds(timeout_ms), ready))
+        {
+            return false;
+        }
 
-        if (q.size() <= 0)
+        if (_queue.size() <= 0)
         {
             return false;
         }
-        *item = &q.front();
+        *item = std::move(_queue.front());
+        _queue.pop_front();
+        _enq_cv.notify_one();
         return true;
     }
 
     bool try_dequeue(T* item)
     {
-        std::unique_lock<std::mutex> lock(mutex);
-        accepting = true;
-        if (q.size() > 0)
+        std::unique_lock<std::mutex> lock(_mutex);
+        _accepting = true;
+        if (_queue.size() > 0)
         {
-            auto val = std::move(q.front());
-            q.pop_front();
+            auto val = std::move(_queue.front());
+            _queue.pop_front();
             *item = std::move(val);
+            _enq_cv.notify_one();
             return true;
         }
         return false;
     }
 
+    bool peek(T** item)
+    {
+        std::unique_lock<std::mutex> lock(_mutex);
+
+        if (_queue.size() <= 0)
+        {
+            return false;
+        }
+        *item = &_queue.front();
+        return true;
+    }
+
     void clear()
     {
-        std::unique_lock<std::mutex> lock(mutex);
+        std::unique_lock<std::mutex> lock(_mutex);
 
-        accepting = false;
-        need_to_flush = true;
+        _accepting = false;
+        _need_to_flush = true;
 
-        while (q.size() > 0)
+        while (_queue.size() > 0)
         {
-            auto item = std::move(q.front());
-            q.pop_front();
+            auto item = std::move(_queue.front());
+            _queue.pop_front();
         }
-        cv.notify_all();
+        _deq_cv.notify_all();
     }
 
     void start()
     {
-        std::unique_lock<std::mutex> lock(mutex);
-        need_to_flush = false;
-        accepting = true;
+        std::unique_lock<std::mutex> lock(_mutex);
+        _need_to_flush = false;
+        _accepting = true;
     }
 
     size_t size()
     {
-        std::unique_lock<std::mutex> lock(mutex);
-        return q.size();
+        std::unique_lock<std::mutex> lock(_mutex);
+        return _queue.size();
     }
 };
 
+template<class T>
+class single_consumer_frame_queue
+{
+    single_consumer_queue<T> _queue;
+
+public:
+    single_consumer_frame_queue<T>(unsigned int cap = QUEUE_MAX_SIZE) : _queue(cap) {}
+
+    void enqueue(T&& item)
+    {
+        if (item.is_blocking())
+            _queue.blocking_enqueue(std::move(item));
+        else
+            _queue.enqueue(std::move(item));
+    }
+
+    bool dequeue(T* item, unsigned int timeout_ms = 5000)
+    {
+        return _queue.dequeue(item, timeout_ms);
+    }
+
+    bool peek(T** item)
+    {
+        return _queue.peek(item);
+    }
+
+    bool try_dequeue(T* item)
+    {
+        return _queue.try_dequeue(item);
+    }
+
+    void clear()
+    {
+        _queue.clear();
+    }
+
+    void start()
+    {
+        _queue.start();
+    }
+
+    void flush()
+    {
+        _queue.flush();
+    }
+
+    size_t size()
+    {
+        return _queue.size();
+    }
+};
 
 class dispatcher
 {
@@ -181,11 +249,14 @@ class dispatcher
     }
 
     template<class T>
-    void invoke(T item)
+    void invoke(T item, bool is_blocking = false)
     {
         if (!_was_stopped)
         {
-            _queue.enqueue(std::move(item));
+            if(is_blocking)
+                _queue.blocking_enqueue(std::move(item));
+            else
+                _queue.enqueue(std::move(item));
         }
     }
 
@@ -248,6 +319,12 @@ class dispatcher
         *wait_sucess = cv.wait_for(locker, std::chrono::seconds(10), [&]() { return invoked || _was_stopped; });
         return *wait_sucess;
     }
+
+    bool empty()
+    {
+        return _queue.size() == 0;
+    }
+
 private:
     friend cancellable_timer;
     single_consumer_queue<std::function<void(cancellable_timer)>> _queue;
diff --git a/src/core/streaming.h b/src/core/streaming.h
index 4d0668d33d..6dadd6a6ae 100644
--- a/src/core/streaming.h
+++ b/src/core/streaming.h
@@ -111,12 +111,54 @@ namespace librealsense
 
         virtual void mark_fixed() = 0;
         virtual bool is_fixed() const = 0;
+        virtual void set_blocking(bool state) = 0;
+        virtual bool is_blocking() const = 0;
 
         virtual void keep() = 0;
 
         virtual ~frame_interface() = default;
     };
 
+    struct frame_holder
+    {
+        frame_interface* frame;
+
+        frame_interface* operator->()
+        {
+            return frame;
+        }
+
+        operator bool() const { return frame != nullptr; }
+
+        operator frame_interface*() const { return frame; }
+
+        frame_holder(frame_interface* f)
+        {
+            frame = f;
+        }
+
+        ~frame_holder();
+
+        frame_holder(frame_holder&& other)
+            : frame(other.frame)
+        {
+            other.frame = nullptr;
+        }
+
+        frame_holder() : frame(nullptr) {}
+
+
+        frame_holder& operator=(frame_holder&& other);
+
+        frame_holder clone() const;
+
+        bool is_blocking() const { return frame->is_blocking(); };
+
+    private:
+        frame_holder& operator=(const frame_holder& other) = delete;
+        frame_holder(const frame_holder& other);
+    };
+
     using on_frame = std::function<void(frame_interface*)>;
     using stream_profiles = std::vector<std::shared_ptr<stream_profile_interface>>;
 
@@ -221,7 +263,7 @@ namespace librealsense
 
     MAP_EXTENSION(RS2_EXTENSION_DEPTH_STEREO_SENSOR, librealsense::depth_stereo_sensor);
 
-    class depth_stereo_sensor_snapshot : public depth_stereo_sensor,  public depth_sensor_snapshot
+    class depth_stereo_sensor_snapshot : public depth_stereo_sensor, public depth_sensor_snapshot
     {
     public:
         depth_stereo_sensor_snapshot(float depth_units, float stereo_bl_mm) :
@@ -256,4 +298,4 @@ namespace librealsense
     private:
         float m_stereo_baseline_mm;
     };
-}
+}
\ No newline at end of file
diff --git a/src/media/playback/playback_device.cpp b/src/media/playback/playback_device.cpp
index 18fc2edaf0..5ba1144125 100644
--- a/src/media/playback/playback_device.cpp
+++ b/src/media/playback/playback_device.cpp
@@ -16,8 +16,9 @@ playback_device::playback_device(std::shared_ptr<context> ctx, std::shared_ptr<d
     m_is_started(false),
     m_is_paused(false),
     m_sample_rate(1),
-    m_real_time(false),
+    m_real_time(true),
     m_prev_timestamp(0),
+    m_last_published_timestamp(0),
     m_read_thread([]() {return std::make_shared<dispatcher>(std::numeric_limits<unsigned int>::max()); })
 {
     if (serializer == nullptr)
@@ -238,7 +239,15 @@ void playback_device::seek_to_time(std::chrono::nanoseconds time)
                         std::string error_msg = to_string() << "Unexpected sensor index while playing file (Read index = " << frame->stream_id.sensor_index << ")";
                         LOG_ERROR(error_msg);
                     }
-                    m_sensors.at(frame->stream_id.sensor_index)->handle_frame(std::move(frame->frame), m_real_time);
+                    //push frame to the sensor (see handle_frame definition for more details)
+                    m_sensors.at(frame->stream_id.sensor_index)->handle_frame(std::move(frame->frame), m_real_time,
+                        []() { return device_serializer::nanoseconds(0); },
+                        []() { return false; },
+                        [this, time]()
+                        {
+                            std::lock_guard<std::mutex> locker(m_last_published_timestamp_mutex);
+                            m_last_published_timestamp = time;
+                        });
                 }
             }
         }
@@ -253,8 +262,8 @@ void playback_device::seek_to_time(std::chrono::nanoseconds time)
 rs2_playback_status playback_device::get_current_status() const
 {
     return m_is_started ?
-           m_is_paused ? RS2_PLAYBACK_STATUS_PAUSED : RS2_PLAYBACK_STATUS_PLAYING
-                        : RS2_PLAYBACK_STATUS_STOPPED;
+        m_is_paused ? RS2_PLAYBACK_STATUS_PAUSED : RS2_PLAYBACK_STATUS_PLAYING
+        : RS2_PLAYBACK_STATUS_STOPPED;
 }
 
 uint64_t playback_device::get_duration() const
@@ -275,21 +284,21 @@ void playback_device::pause()
     {
         LOG_DEBUG("Playback pause invoked");
 
-       if (m_is_paused)
-           return;
-
-       m_is_paused = true;
-
-       if(m_is_started)
-       {
-           //Wait for any remaining sensor callbacks to return
-           for (auto sensor : m_sensors)
-           {
-               sensor.second->flush_pending_frames();
-           }
-       }
-       LOG_DEBUG("Notifying RS2_PLAYBACK_STATUS_PAUSED");
-       playback_status_changed(RS2_PLAYBACK_STATUS_PAUSED);
+        if (m_is_paused)
+            return;
+
+        m_is_paused = true;
+
+        if(m_is_started)
+        {
+            //Wait for any remaining sensor callbacks to return
+            for (auto sensor : m_sensors)
+            {
+                sensor.second->flush_pending_frames();
+            }
+        }
+        LOG_DEBUG("Notifying RS2_PLAYBACK_STATUS_PAUSED");
+        playback_status_changed(RS2_PLAYBACK_STATUS_PAUSED);
     });
     if ((*m_read_thread)->flush() == false)
     {
@@ -306,7 +315,14 @@ void playback_device::resume()
     {
         LOG_DEBUG("Playback resume invoked");
         if (m_is_paused == false)
-           return;
+            return;
+
+        auto total_duration = m_reader->query_duration();
+        if (m_last_published_timestamp >= total_duration)
+            m_last_published_timestamp = device_serializer::nanoseconds(0);
+        m_reader->reset();
+        m_reader->seek_to_time(m_last_published_timestamp);
+        while (m_last_published_timestamp != device_serializer::nanoseconds(0) && !m_reader->read_next_data()->is<serialized_frame>());
 
         m_is_paused = false;
         catch_up();
@@ -356,6 +372,8 @@ void playback_device::update_time_base(device_serializer::nanoseconds base_times
 
 device_serializer::nanoseconds playback_device::calc_sleep_time(device_serializer::nanoseconds timestamp) const
 {
+    if (!m_real_time)
+        return device_serializer::nanoseconds(0);
     //The time to sleep returned here equals to the difference between the file recording time
     // and the playback time.
     auto now = std::chrono::high_resolution_clock::now();
@@ -367,9 +385,9 @@ device_serializer::nanoseconds playback_device::calc_sleep_time(device_serialize
     auto time_diff = timestamp - m_base_timestamp;
     auto recorded_time = std::chrono::duration_cast<device_serializer::nanoseconds>(time_diff / m_sample_rate.load());
 
-    LOG_DEBUG("Time Now  : " << now.time_since_epoch().count() << " ,    Time When Started: " << m_base_sys_time.time_since_epoch().count() << " , Diff: " << play_time.count() << " == " << (play_time.count()/1000)/1000 << "ms");
-    LOG_DEBUG("Original Recording Delta: " << time_diff.count() << " == " << (time_diff.count() / 1000) / 1000 << "ms");
-    LOG_DEBUG("Frame Time: " << timestamp.count() << "  , First Frame: " << m_base_timestamp.count() << " ,  Diff: " << recorded_time.count() << " == " << (recorded_time.count() / 1000) / 1000 << "ms");
+    LOG_DEBUG("Time Now  : " << now.time_since_epoch().count() << " ,    Time When Started: " << m_base_sys_time.time_since_epoch().count() << " , Diff: " << play_time.count() << " == " << (play_time.count() * 1e-6) << "ms");
+    LOG_DEBUG("Original Recording Delta: " << time_diff.count() << " == " << (time_diff.count() * 1e-6) << "ms");
+    LOG_DEBUG("Frame Time: " << timestamp.count() << "  , First Frame: " << m_base_timestamp.count() << " ,  Diff: " << recorded_time.count() << " == " << (recorded_time.count() * 1e-6) << "ms");
 
     if(recorded_time < play_time)
     {
@@ -377,7 +395,7 @@ device_serializer::nanoseconds playback_device::calc_sleep_time(device_serialize
         return device_serializer::nanoseconds(0);
     }
     auto sleep_time = (recorded_time - play_time);
-    LOG_DEBUG("Sleep Time: " << sleep_time.count() << " == " << (sleep_time.count() / 1000) / 1000 << " ms");
+    LOG_DEBUG("Sleep Time: " << sleep_time.count() << " == " << (sleep_time.count() * 1e-6) << " ms");
     return sleep_time;
 }
 
@@ -393,7 +411,7 @@ void playback_device::start()
     LOG_DEBUG("playback start called");
 
     if (m_is_started)
-        return ; //nothing to do
+        return; //nothing to do
 
     m_is_started = true;
     catch_up();
@@ -457,6 +475,9 @@ void playback_device::do_loop(T action)
         //On failure, exit thread
         if(action_succeeded == false)
         {
+            for (auto s : m_active_sensors)
+                s.second->flush_pending_frames();
+
             //Go over the sensors and stop them
             size_t active_sensors_count = m_active_sensors.size();
             for (size_t i = 0; i<active_sensors_count; i++)
@@ -467,6 +488,9 @@ void playback_device::do_loop(T action)
                 //NOTE: calling stop will remove the sensor from m_active_sensors
                 m_active_sensors.begin()->second->stop(false);
             }
+
+            m_last_published_timestamp = device_serializer::nanoseconds(0);
+
             //After all sensors were stopped, stop_internal() is called and flags m_is_started as false
             assert(m_is_started == false);
         }
@@ -479,6 +503,16 @@ void playback_device::do_loop(T action)
     });
 }
 
+bool playback_device::prefetch_done()
+{
+    for (auto s : m_active_sensors)
+    {
+        if (!s.second->streams_contains_one_frame_or_more())
+            return false;
+    }
+    return true;
+}
+
 void playback_device::try_looping()
 {
     //try_looping is called from start() or resume()
@@ -519,17 +553,22 @@ void playback_device::try_looping()
         }
 
         //Calculate the duration for the reader to sleep (i.e wait for next frame)
-        auto sleep_time = calc_sleep_time(timestamp);
-        if (sleep_time.count() > 0)
+        if (m_real_time && prefetch_done())
         {
-            if (m_sample_rate > 0)
+            auto sleep_time = calc_sleep_time(timestamp);
+            if (sleep_time.count() > 0)
             {
-                LOG_DEBUG("Sleeping for: " << (sleep_time.count() / 1000) / 1000);
-                std::this_thread::sleep_for(sleep_time);
+                if (m_sample_rate > 0)
+                {
+                    LOG_DEBUG("Sleeping for: " << (sleep_time.count() * 1e-6));
+                    std::this_thread::sleep_for(sleep_time);
+                }
             }
         }
+
         if (auto frame = data->as<serialized_frame>())
         {
+            frame->frame.frame->set_blocking(!m_real_time);
             if (frame->stream_id.device_index != get_device_index() || frame->stream_id.sensor_index >= m_sensors.size())
             {
                 std::string error_msg = to_string() << "Unexpected sensor index while playing file (Read index = " << frame->stream_id.sensor_index << ")";
@@ -541,10 +580,17 @@ void playback_device::try_looping()
             if (data->is<serialized_invalid_frame>())
             {
                 LOG_WARNING("Bad frame from reader, ignoring");
-                 return true;
+                return true;
             }
-            //Dispatch frame to the relevant sensor
-            m_sensors.at(frame->stream_id.sensor_index)->handle_frame(std::move(frame->frame), m_real_time);
+            //Dispatch frame to the relevant sensor (see handle_frame definition for more details)
+            m_active_sensors.at(frame->stream_id.sensor_index)->handle_frame(std::move(frame->frame), m_real_time,
+                [this, timestamp]() { return calc_sleep_time(timestamp); },
+                [this]() { return m_is_paused == true; },
+                [this, timestamp]()
+                {
+                    std::lock_guard<std::mutex> locker(m_last_published_timestamp_mutex);
+                    m_last_published_timestamp = timestamp;
+                });
             return true;
         }
 
diff --git a/src/media/playback/playback_device.h b/src/media/playback/playback_device.h
index 29c96fc380..71a8a4211e 100644
--- a/src/media/playback/playback_device.h
+++ b/src/media/playback/playback_device.h
@@ -15,8 +15,8 @@
 namespace librealsense
 {
     class playback_device : public device_interface,
-                            public extendable_interface,
-                            public info_container
+        public extendable_interface,
+        public info_container
     {
     public:
         playback_device(std::shared_ptr<context> context, std::shared_ptr<device_serializer::reader> serializer);
@@ -49,7 +49,7 @@ namespace librealsense
         bool is_valid() const override;
 
         std::vector<tagged_profile> get_profiles_tags() const override { return std::vector<tagged_profile>(); };//no hard-coded default streams for playback
-        void tag_profiles(stream_profiles profiles) const override 
+        void tag_profiles(stream_profiles profiles) const override
         {
             for(auto profile : profiles)
                 profile->tag_profile(profile_tag::PROFILE_TAG_DEFAULT | profile_tag::PROFILE_TAG_SUPERSET);
@@ -69,6 +69,7 @@ namespace librealsense
         void register_device_info(const device_serializer::device_snapshot& device_description);
         void register_extrinsics(const device_serializer::device_snapshot& device_description);
         void update_extensions(const device_serializer::device_snapshot& device_description);
+        bool prefetch_done();
 
     private:
         lazy<std::shared_ptr<dispatcher>> m_read_thread;
@@ -86,7 +87,8 @@ namespace librealsense
         std::shared_ptr<context> m_context;
         std::vector<std::shared_ptr<lazy<rs2_extrinsics>>> m_extrinsics_fetchers;
         std::map<int, std::pair<uint32_t, rs2_extrinsics>> m_extrinsics_map;
-
+        device_serializer::nanoseconds m_last_published_timestamp;
+        std::mutex m_last_published_timestamp_mutex;
     };
 
     MAP_EXTENSION(RS2_EXTENSION_PLAYBACK, playback_device);
diff --git a/src/media/playback/playback_sensor.cpp b/src/media/playback/playback_sensor.cpp
index 37dd0e10d2..5be3cd0260 100644
--- a/src/media/playback/playback_sensor.cpp
+++ b/src/media/playback/playback_sensor.cpp
@@ -29,7 +29,8 @@ playback_sensor::playback_sensor(const device_interface& parent_device, const de
     m_is_started(false),
     m_sensor_description(sensor_description),
     m_sensor_id(sensor_description.get_sensor_index()),
-    m_parent_device(parent_device)
+    m_parent_device(parent_device),
+    _default_queue_size(1)
 {
     register_sensor_streams(m_sensor_description.get_stream_profiles());
     register_sensor_infos(m_sensor_description);
@@ -40,6 +41,16 @@ playback_sensor::~playback_sensor()
 {
 }
 
+bool playback_sensor::streams_contains_one_frame_or_more()
+{
+    for (auto d : m_dispatchers)
+    {
+        if (d.second->empty())
+            return false;
+    }
+    return true;
+}
+
 stream_profiles playback_sensor::get_stream_profiles(int tag) const
 {
     if (tag == profile_tag::PROFILE_TAG_ANY)
@@ -74,7 +85,7 @@ void playback_sensor::open(const stream_profiles& requests)
     //For each stream, create a dedicated dispatching thread
     for (auto&& profile : requests)
     {
-        m_dispatchers.emplace(std::make_pair(profile->get_unique_id(), std::make_shared<dispatcher>(10))); //TODO: what size the queue should be?
+        m_dispatchers.emplace(std::make_pair(profile->get_unique_id(), std::make_shared<dispatcher>(_default_queue_size)));
         m_dispatchers[profile->get_unique_id()]->start();
         device_serializer::stream_identifier f{ get_device_index(), m_sensor_id, profile->get_stream_type(), static_cast<uint32_t>(profile->get_stream_index()) };
         opened_streams.push_back(f);
@@ -114,7 +125,6 @@ notifications_callback_ptr playback_sensor::get_notifications_callback() const
     return _notifications_processor.get_callback();
 }
 
-
 void playback_sensor::start(frame_callback_ptr callback)
 {
     LOG_DEBUG("Start sensor " << m_sensor_id);
@@ -125,10 +135,10 @@ void playback_sensor::start(frame_callback_ptr callback)
         m_user_callback = callback;
     }
 }
+
 void playback_sensor::stop(bool invoke_required)
 {
     LOG_DEBUG("Stop sensor " << m_sensor_id);
-
     if (m_is_started == true)
     {
         stopped(m_sensor_id, invoke_required);
@@ -160,38 +170,11 @@ const device_interface& playback_sensor::get_device()
     return m_parent_device;
 }
 
-void playback_sensor::handle_frame(frame_holder frame, bool is_real_time)
-{
-    if(frame == nullptr)
-    {
-        throw invalid_value_exception("null frame passed to handle_frame");
-    }
-    if(m_is_started)
-    {
-        frame->get_owner()->set_sensor(shared_from_this());
-        auto type = frame->get_stream()->get_stream_type();
-        auto index = static_cast<uint32_t>(frame->get_stream()->get_stream_index());
-        frame->set_stream(m_streams[std::make_pair(type, index)]);
-        frame->set_sensor(shared_from_this());
-        auto stream_id = frame.frame->get_stream()->get_unique_id();
-        //TODO: Ziv, remove usage of shared_ptr when frame_holder is cpoyable
-        auto pf = std::make_shared<frame_holder>(std::move(frame));
-        m_dispatchers.at(stream_id)->invoke([this, pf](dispatcher::cancellable_timer t)
-        {
-            frame_interface* pframe = nullptr;
-            std::swap((*pf).frame, pframe);
-            m_user_callback->on_frame((rs2_frame*)pframe);
-        });
-        if(is_real_time)
-        {
-            m_dispatchers.at(stream_id)->flush();
-        }
-    }
-}
 void playback_sensor::update_option(rs2_option id, std::shared_ptr<option> option)
 {
     register_option(id, option);
 }
+
 void playback_sensor::flush_pending_frames()
 {
     for (auto&& dispatcher : m_dispatchers)
diff --git a/src/media/playback/playback_sensor.h b/src/media/playback/playback_sensor.h
index 32d17970ec..bd1275a279 100644
--- a/src/media/playback/playback_sensor.h
+++ b/src/media/playback/playback_sensor.h
@@ -39,7 +39,6 @@ namespace librealsense
         bool is_streaming() const override;
         bool extend_to(rs2_extension extension_type, void** ext) override;
         const device_interface& get_device() override;
-        void handle_frame(frame_holder frame, bool is_real_time);
         void update_option(rs2_option id, std::shared_ptr<option> option);
         void stop(bool invoke_required);
         void flush_pending_frames();
@@ -50,6 +49,7 @@ namespace librealsense
         int register_before_streaming_changes_callback(std::function<void(bool)> callback) override;
         void unregister_before_start_callback(int token) override;
         void raise_notification(const notification& n);
+        bool streams_contains_one_frame_or_more();
     private:
         void register_sensor_streams(const stream_profiles& vector);
         void register_sensor_infos(const device_serializer::sensor_snapshot& sensor_snapshot);
@@ -67,5 +67,48 @@ namespace librealsense
         const device_interface& m_parent_device;
         stream_profiles m_available_profiles;
         stream_profiles m_active_streams;
+        const unsigned int _default_queue_size;
+
+    public:
+        //handle frame use 3 lambda functions that determines if and when a frame should be published.
+        //calc_sleep - calculates the duration that the sensor should wait before publishing the frame,
+        // the start point for this calculation is the last playback resume.
+        //is_paused - check if the playback was paused while waiting for the frame publish time.
+        //update_last_pushed_frame - lets the playback device know that a specific frame was published,
+        // the playback device will use this info to determine which frames should be played next in a pause/resume scenario.
+        template <class T, class K, class P>
+        void handle_frame(frame_holder frame, bool is_real_time, T calc_sleep, K is_paused, P update_last_pushed_frame)
+        {
+            if (frame == nullptr)
+            {
+                throw invalid_value_exception("null frame passed to handle_frame");
+            }
+            if (m_is_started)
+            {
+                frame->get_owner()->set_sensor(shared_from_this());
+                auto type = frame->get_stream()->get_stream_type();
+                auto index = static_cast<uint32_t>(frame->get_stream()->get_stream_index());
+                frame->set_stream(m_streams[std::make_pair(type, index)]);
+                frame->set_sensor(shared_from_this());
+                auto stream_id = frame.frame->get_stream()->get_unique_id();
+                //TODO: Ziv, remove usage of shared_ptr when frame_holder is cpoyable
+                auto pf = std::make_shared<frame_holder>(std::move(frame));
+
+                auto callback = [this, is_real_time, stream_id, pf, calc_sleep, is_paused, update_last_pushed_frame](dispatcher::cancellable_timer t)
+                {
+                    device_serializer::nanoseconds sleep_for = calc_sleep();
+                    if (sleep_for.count() > 0)
+                        t.try_sleep(sleep_for.count() * 1e-6);
+                    if(is_paused())
+                        return;
+
+                    frame_interface* pframe = nullptr;
+                    std::swap((*pf).frame, pframe);
+                    m_user_callback->on_frame((rs2_frame*)pframe);
+                    update_last_pushed_frame();
+                };
+                m_dispatchers.at(stream_id)->invoke(callback, !is_real_time);
+            }
+        }
     };
 }
diff --git a/src/pipeline.cpp b/src/pipeline.cpp
index 70179ab54c..cca15e81cb 100644
--- a/src/pipeline.cpp
+++ b/src/pipeline.cpp
@@ -12,7 +12,7 @@
 namespace librealsense
 {
     pipeline_processing_block::pipeline_processing_block(const std::vector<int>& streams_to_aggregate) :
-        _queue(new single_consumer_queue<frame_holder>(1)),
+        _queue(new single_consumer_frame_queue<frame_holder>(1)),
         _streams_ids(streams_to_aggregate)
     {
         auto processing_callback = [&](frame_holder frame, synthetic_source_interface* source)
diff --git a/src/pipeline.h b/src/pipeline.h
index 144694b25f..92e00304da 100644
--- a/src/pipeline.h
+++ b/src/pipeline.h
@@ -17,7 +17,7 @@ namespace librealsense
     {
         std::mutex _mutex;
         std::map<stream_id, frame_holder> _last_set;
-        std::unique_ptr<single_consumer_queue<frame_holder>> _queue;
+        std::unique_ptr<single_consumer_frame_queue<frame_holder>> _queue;
         std::vector<int> _streams_ids;
         void handle_frame(frame_holder frame, synthetic_source_interface* source);
     public:
diff --git a/src/proc/syncer-processing-block.cpp b/src/proc/syncer-processing-block.cpp
index e99f0d7b9b..2499e2a391 100644
--- a/src/proc/syncer-processing-block.cpp
+++ b/src/proc/syncer-processing-block.cpp
@@ -31,7 +31,7 @@ namespace librealsense
 
         auto f = [&](frame_holder frame, synthetic_source_interface* source)
         {
-            single_consumer_queue<frame_holder> matches;
+            single_consumer_frame_queue<frame_holder> matches;
 
             {
                 std::lock_guard<std::mutex> lock(_mutex);
diff --git a/src/proc/synthetic-stream.cpp b/src/proc/synthetic-stream.cpp
index 2080a115ee..f323133587 100644
--- a/src/proc/synthetic-stream.cpp
+++ b/src/proc/synthetic-stream.cpp
@@ -230,6 +230,7 @@ namespace librealsense
             data.timestamp_domain = original->get_frame_timestamp_domain();
             data.metadata_size = 0;
             data.system_time = _actual_source.get_time();
+            data.is_blocking = original->is_blocking();
 
             auto res = _actual_source.alloc_frame(RS2_EXTENSION_POINTS, vid_stream->get_width() * vid_stream->get_height() * sizeof(float) * 5, data, true);
             if (!res) throw wrong_api_call_sequence_exception("Out of frame resources!");
@@ -299,6 +300,7 @@ namespace librealsense
         vf->assign(width, height, stride, bpp);
         vf->set_sensor(original->get_sensor());
         res->set_stream(stream);
+
         if (frame_type == RS2_EXTENSION_DEPTH_FRAME)
         {
             original->acquire();
@@ -349,6 +351,12 @@ namespace librealsense
 
         auto cf = static_cast<composite_frame*>(res);
 
+        for (auto&& f : holders)
+        {
+            if (f.is_blocking())
+                res->set_blocking(true);
+        }
+
         auto frames = cf->get_frames();
         for (auto&& f : holders)
             copy_frames(std::move(f), frames);
diff --git a/src/rs.cpp b/src/rs.cpp
index 4548d5ac9a..939391dd2f 100644
--- a/src/rs.cpp
+++ b/src/rs.cpp
@@ -104,7 +104,7 @@ struct rs2_frame_queue
     {
     }
 
-    single_consumer_queue<librealsense::frame_holder> queue;
+    single_consumer_frame_queue<librealsense::frame_holder> queue;
 };
 
 struct rs2_processing_block : public rs2_options
diff --git a/src/sensor.cpp b/src/sensor.cpp
index ef3b5af7f6..eda19272df 100644
--- a/src/sensor.cpp
+++ b/src/sensor.cpp
@@ -468,7 +468,8 @@ namespace librealsense
                             (const uint8_t*)f.metadata,
                             f.backend_time,
                             last_timestamp,
-                            last_frame_number);
+                            last_frame_number,
+                            false);
 
                         last_frame_number = frame_counter;
                         last_timestamp = timestamp;
diff --git a/src/sync.cpp b/src/sync.cpp
index ae5e399fda..66b38968a1 100644
--- a/src/sync.cpp
+++ b/src/sync.cpp
@@ -532,6 +532,8 @@ namespace librealsense
 
     void timestamp_composite_matcher::clean_inactive_streams(frame_holder& f)
     {
+        if (f.is_blocking())
+            return;
         std::vector<stream_id> dead_matchers;
         auto now = environment::get_instance().get_time_service()->get_time();
         for(auto m: _matchers)
diff --git a/src/sync.h b/src/sync.h
index 0cafa479e7..41f21f81aa 100644
--- a/src/sync.h
+++ b/src/sync.h
@@ -58,7 +58,7 @@ namespace librealsense
     {
         synthetic_source_interface* source;
         //sync_lock& lock_ref;
-        single_consumer_queue<frame_holder>& matches;
+        single_consumer_frame_queue<frame_holder>& matches;
     };
 
     typedef int stream_id;
@@ -129,7 +129,7 @@ namespace librealsense
     protected:
         virtual void update_next_expected(const frame_holder& f) = 0;
 
-        std::map<matcher*, single_consumer_queue<frame_holder>> _frames_queue;
+        std::map<matcher*, single_consumer_frame_queue<frame_holder>> _frames_queue;
         std::map<stream_id, std::shared_ptr<matcher>> _matchers;
         std::map<matcher*, double> _next_expected;
         std::map<matcher*, rs2_timestamp_domain> _next_expected_domain;
diff --git a/src/types.h b/src/types.h
index aa7caf1d19..c796a00d13 100644
--- a/src/types.h
+++ b/src/types.h
@@ -634,43 +634,6 @@ namespace librealsense
 
     class frame_interface;
 
-    struct frame_holder
-    {
-        frame_interface* frame;
-
-        frame_interface* operator->()
-        {
-            return frame;
-        }
-
-        operator bool() const { return frame != nullptr; }
-
-        operator frame_interface*() const { return frame; }
-
-        frame_holder(frame_interface* f)
-        {
-            frame = f;
-        }
-
-        ~frame_holder();
-
-        frame_holder(frame_holder&& other)
-            : frame(other.frame)
-        {
-            other.frame = nullptr;
-        }
-
-        frame_holder() : frame(nullptr) {}
-
-
-        frame_holder& operator=(frame_holder&& other);
-
-        frame_holder clone() const;
-    private:
-        frame_holder& operator=(const frame_holder& other) = delete;
-        frame_holder(const frame_holder& other);
-    };
-
     class firmware_version
     {
         int                 m_major, m_minor, m_patch, m_build;
diff --git a/tools/convert/rs-convert.cpp b/tools/convert/rs-convert.cpp
index dddb5baa85..0296389cb6 100644
--- a/tools/convert/rs-convert.cpp
+++ b/tools/convert/rs-convert.cpp
@@ -100,9 +100,7 @@ int main(int argc, char** argv) try
     auto frameNumber = 0ULL;
 
     while (true) {
-        playback.resume();
         auto frameset = pipe->wait_for_frames();
-        playback.pause();
 
         int posP = static_cast<int>(playback.get_position() * 100. / duration.count());