diff --git a/.travis.yml b/.travis.yml
index a260b0816c..65289c0bd4 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -47,7 +47,7 @@ before_install:
   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
       sudo add-apt-repository --yes ppa:ubuntu-toolchain-r/test;
       sudo apt-get update;
-      sudo apt-get install -qq build-essential xorg-dev libglu1-mesa-dev libglew-dev libglm-dev;
+      sudo apt-get install -qq build-essential xorg-dev libgl1-mesa-dev libglu1-mesa-dev libglew-dev libglm-dev;
       sudo apt-get install -qq libusb-1.0-0-dev;
       sudo apt-get install -qq libgtk-3-dev;
       sudo apt-get install -qq python python-dev;
@@ -93,6 +93,7 @@ script:
   # Exit immediately if a command exits with a non-zero status
   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
       set -e;
+      pyenv install 3.6.1;
       pyenv local `pyenv versions|sed 's/ //g'|grep "^3"|tail -1`;
       mkdir build && cd build;
       cmake .. -DBUILD_EXAMPLES:BOOL=true -DBUILD_PYTHON_BINDINGS:BOOL=true -DBUILD_NODEJS_BINDINGS:BOOL=true;
diff --git a/common/model-views.cpp b/common/model-views.cpp
index 155e969106..d35b9dcf9d 100644
--- a/common/model-views.cpp
+++ b/common/model-views.cpp
@@ -196,83 +196,95 @@ namespace rs2
             texture_data[idx], texture_data[idx + 1], texture_data[idx + 2]);
     }
 
-    void export_to_ply(const std::string& fname, notifications_model& ns, points points, video_frame texture)
+    void export_to_ply(const std::string& fname, notifications_model& ns, frameset frames, video_frame texture)
     {
-
-        std::thread([&ns, points, texture, fname]() {
+        std::thread([&ns, frames, texture, fname]() mutable {
             std::string texfname(fname);
             texfname += ".png";
 
-            const auto vertices = points.get_vertices();
-            const auto texcoords = points.get_texture_coordinates();
-            const auto tex = reinterpret_cast<const uint8_t*>(texture.get_data());
-            std::vector<vertex> new_vertices;
-            //std::vector<texture_coordinate> new_texcoords;
-            std::vector<std::tuple<uint8_t, uint8_t, uint8_t>> new_tex;
-            new_vertices.reserve(points.size());
-            //new_texcoords.reserve(points.size());
-            new_tex.reserve(points.size());
-
-            for (int i = 0; i < points.size(); ++i)
-                if (std::abs(vertices[i].x) >= 1e-6 || std::abs(vertices[i].y) >= 1e-6 || std::abs(vertices[i].z) >= 1e-6)
-                {
-                    new_vertices.push_back(vertices[i]);
-                    if (texture)
-                    {
-                        //new_texcoords.push_back(texcoords[i]);
-                        auto color = get_texcolor(texture, texcoords[i]);
-                        new_tex.push_back(color);
-                    }
+            points p;
 
-                }
-
-            std::ofstream out(fname);
-            out << "ply\n";
-            out << "format binary_little_endian 1.0\n" /*"format ascii 1.0\n"*/;
-            out << "comment pointcloud saved from Realsense Viewer\n";
-            //if (texture) out << "comment TextureFile " << get_file_name(texfname) << "\n";
-            out << "element vertex " << new_vertices.size() << "\n";
-            out << "property float" << sizeof(float) * 8 << " x\n";
-            out << "property float" << sizeof(float) * 8 << " y\n";
-            out << "property float" << sizeof(float) * 8 << " z\n";
-            if (texture)
+            for (auto&& f : frames)
             {
-                //out << "property float" << sizeof(float) * 8 << " u\n";
-                //out << "property float" << sizeof(float) * 8 << " v\n";
-                out << "property uchar red\n";
-                out << "property uchar green\n";
-                out << "property uchar blue\n";
+                if (p = f.as<points>())
+                {
+                    break;
+                }
             }
-            out << "end_header\n";
-            out.close();
 
-            out.open(fname, std::ios_base::app | std::ios_base::binary);
-            for (int i = 0; i < new_vertices.size(); ++i)
+            if (p)
             {
-                // we assume little endian architecture on your device
-                out.write(reinterpret_cast<const char*>(&(new_vertices[i].x)), sizeof(float));
-                out.write(reinterpret_cast<const char*>(&(new_vertices[i].y)), sizeof(float));
-                out.write(reinterpret_cast<const char*>(&(new_vertices[i].z)), sizeof(float));
-                //                out << new_vertices[i].x << ' ' << new_vertices[i].y << ' ' << new_vertices[i].z;
+                const auto vertices = p.get_vertices();
+                const auto texcoords = p.get_texture_coordinates();
+                const auto tex = reinterpret_cast<const uint8_t*>(texture.get_data());
+                std::vector<vertex> new_vertices;
+                //std::vector<texture_coordinate> new_texcoords;
+                std::vector<std::tuple<uint8_t, uint8_t, uint8_t>> new_tex;
+                new_vertices.reserve(p.size());
+                //new_texcoords.reserve(points.size());
+                new_tex.reserve(p.size());
+                assert(p.size());
+                for (size_t i = 0; i < p.size(); ++i)
+                    if (std::abs(vertices[i].x) >= 1e-6 || std::abs(vertices[i].y) >= 1e-6 || std::abs(vertices[i].z) >= 1e-6)
+                    {
+                        new_vertices.push_back(vertices[i]);
+                        if (texture)
+                        {
+                            //new_texcoords.push_back(texcoords[i]);
+                            auto color = get_texcolor(texture, texcoords[i]);
+                            new_tex.push_back(color);
+                        }
+
+                    }
+
+                std::ofstream out(fname);
+                out << "ply\n";
+                out << "format binary_little_endian 1.0\n" /*"format ascii 1.0\n"*/;
+                out << "comment pointcloud saved from Realsense Viewer\n";
+                //if (texture) out << "comment TextureFile " << get_file_name(texfname) << "\n";
+                out << "element vertex " << new_vertices.size() << "\n";
+                out << "property float" << sizeof(float) * 8 << " x\n";
+                out << "property float" << sizeof(float) * 8 << " y\n";
+                out << "property float" << sizeof(float) * 8 << " z\n";
                 if (texture)
                 {
-                    //out.write(reinterpret_cast<const char*>(&(new_texcoords[i].u)), sizeof(float));
-                    //out.write(reinterpret_cast<const char*>(&(new_texcoords[i].v)), sizeof(float));
-                    out.write(reinterpret_cast<const char*>(&(std::get<0>(new_tex[i]))), sizeof(uint8_t));
-                    out.write(reinterpret_cast<const char*>(&(std::get<1>(new_tex[i]))), sizeof(uint8_t));
-                    out.write(reinterpret_cast<const char*>(&(std::get<2>(new_tex[i]))), sizeof(uint8_t));
-                    //                    out << std::hex << ' ' << std::get<0>(new_tex[i]) << ' ' << std::get<1>(new_tex[i]) << ' ' << std::get<2>(new_tex[i]);
+                    //out << "property float" << sizeof(float) * 8 << " u\n";
+                    //out << "property float" << sizeof(float) * 8 << " v\n";
+                    out << "property uchar red\n";
+                    out << "property uchar green\n";
+                    out << "property uchar blue\n";
                 }
-                //                out << '\n';
-            }
+                out << "end_header\n";
+                out.close();
 
-            /* save texture to texfname */
-            //if (texture) stbi_write_png(texfname.data(), texture.get_width(), texture.get_height(), texture.get_bytes_per_pixel(), texture.get_data(), texture.get_width() * texture.get_bytes_per_pixel());
+                out.open(fname, std::ios_base::app | std::ios_base::binary);
+                for (int i = 0; i < new_vertices.size(); ++i)
+                {
+                    // we assume little endian architecture on your device
+                    out.write(reinterpret_cast<const char*>(&(new_vertices[i].x)), sizeof(float));
+                    out.write(reinterpret_cast<const char*>(&(new_vertices[i].y)), sizeof(float));
+                    out.write(reinterpret_cast<const char*>(&(new_vertices[i].z)), sizeof(float));
+                    //                out << new_vertices[i].x << ' ' << new_vertices[i].y << ' ' << new_vertices[i].z;
+                    if (texture)
+                    {
+                        //out.write(reinterpret_cast<const char*>(&(new_texcoords[i].u)), sizeof(float));
+                        //out.write(reinterpret_cast<const char*>(&(new_texcoords[i].v)), sizeof(float));
+                        out.write(reinterpret_cast<const char*>(&(std::get<0>(new_tex[i]))), sizeof(uint8_t));
+                        out.write(reinterpret_cast<const char*>(&(std::get<1>(new_tex[i]))), sizeof(uint8_t));
+                        out.write(reinterpret_cast<const char*>(&(std::get<2>(new_tex[i]))), sizeof(uint8_t));
+                        //                    out << std::hex << ' ' << std::get<0>(new_tex[i]) << ' ' << std::get<1>(new_tex[i]) << ' ' << std::get<2>(new_tex[i]);
+                    }
+                    //                out << '\n';
+                }
 
-            ns.add_notification({ to_string() << "Finished saving 3D view " << (texture ? "to " : "without texture to ") << fname,
-                std::chrono::duration_cast<std::chrono::duration<double,std::micro>>(std::chrono::high_resolution_clock::now().time_since_epoch()).count(),
-                RS2_LOG_SEVERITY_INFO,
-                RS2_NOTIFICATION_CATEGORY_UNKNOWN_ERROR });
+                /* save texture to texfname */
+                //if (texture) stbi_write_png(texfname.data(), texture.get_width(), texture.get_height(), texture.get_bytes_per_pixel(), texture.get_data(), texture.get_width() * texture.get_bytes_per_pixel());
+
+                ns.add_notification({ to_string() << "Finished saving 3D view " << (texture ? "to " : "without texture to ") << fname,
+                    std::chrono::duration_cast<std::chrono::duration<double,std::micro>>(std::chrono::high_resolution_clock::now().time_since_epoch()).count(),
+                    RS2_LOG_SEVERITY_INFO,
+                    RS2_NOTIFICATION_CATEGORY_UNKNOWN_ERROR });
+            }
         }).detach();
     }
 
@@ -285,7 +297,7 @@ namespace rs2
         size_t pixel_width, size_t pixels_height, size_t bytes_per_pixel,
         const void* raster_data, size_t stride_bytes)
     {
-        return stbi_write_png(filename, pixel_width, pixels_height, bytes_per_pixel, raster_data, stride_bytes);
+        return stbi_write_png(filename, (int)pixel_width, (int)pixels_height, bytes_per_pixel, raster_data, stride_bytes);
     }
 
     std::vector<const char*> get_string_pointers(const std::vector<std::string>& vec)
@@ -615,9 +627,9 @@ namespace rs2
             owner->dev, *owner->s, &owner->options_invalidated, owner, block, error_message);
     }
 
-    subdevice_model::subdevice_model(device& dev, 
+    subdevice_model::subdevice_model(device& dev,
                                      std::shared_ptr<sensor> s, std::string& error_message)
-        : s(s), dev(dev), ui(), last_valid_ui(), 
+        : s(s), dev(dev), ui(), last_valid_ui(),
           streaming(false), _pause(false), depth_colorizer(std::make_shared<rs2::colorizer>())
     {
         try
@@ -1113,15 +1125,22 @@ namespace rs2
         _pause = false;
     }
 
-    void subdevice_model::play(const std::vector<stream_profile>& profiles)
+    void subdevice_model::play(const std::vector<stream_profile>& profiles, viewer_model& viewer)
     {
         s->open(profiles);
         try {
             s->start([&](frame f) {
                 auto index = f.get_profile().unique_id();
-                queues.at(index).enqueue(std::move(f));
+                if (viewer.synchronization_enable)
+                {
+                    if (index == viewer.selected_depth_source_uid || index ==  viewer.selected_tex_source_uid)
+                        viewer.s(f);
+                }
+                queues.at(index).enqueue(f);
             });
+
         }
+
         catch (...)
         {
             s->close();
@@ -1493,7 +1512,6 @@ namespace rs2
         //    }
         //}
 
-        auto model = pc.get_points();
 
         const auto top_bar_height = 32.f;
         const auto num_of_buttons = 4;
@@ -1596,8 +1614,9 @@ namespace rs2
                 tex_sources.push_back(s.second.profile.unique_id());
 
                 auto dev_name = s.second.dev ? s.second.dev->dev.get_info(RS2_CAMERA_INFO_NAME) : "Unknown";
-                auto stream_name = rs2_stream_to_string(s.second.profile.stream_type());
-
+                std::string stream_name = rs2_stream_to_string(s.second.profile.stream_type());
+                if (s.second.profile.stream_index())
+                    stream_name += "_" + std::to_string(s.second.profile.stream_index());
                 tex_sources_str.push_back(to_string() << dev_name << " " << stream_name);
 
                 i++;
@@ -1610,9 +1629,8 @@ namespace rs2
             ImGui::SetCursorPosY(7);
             ImGui::Text("Texture Source:"); ImGui::SameLine();
 
-
             ImGui::SetCursorPosY(7);
-            ImGui::PushItemWidth(190);
+            ImGui::PushItemWidth(200);
             draw_combo_box("##Tex Source", tex_sources_str, selected_tex_source);
 
             i = 0;
@@ -1657,17 +1675,6 @@ namespace rs2
         //}
         //ImGui::PopItemWidth();
 
-        if (selected_depth_source_uid >= 0) {
-            auto depth = streams[selected_depth_source_uid].texture->get_last_frame();
-            if (depth) pc.push_frame(depth);
-        }
-
-        frame tex;
-        if (selected_tex_source_uid >= 0)
-        {
-            tex = streams[selected_tex_source_uid].texture->get_last_frame();
-            if (tex) pc.update_texture(tex);
-        }
 
         ImGui::SetCursorPos({ stream_rect.w - 32 * num_of_buttons - 5, 0 });
 
@@ -1713,6 +1720,15 @@ namespace rs2
         {
             if (auto ret = file_dialog_open(save_file, "Polygon File Format (PLY)\0*.ply\0", NULL, NULL))
             {
+                auto model = pc.get_points();
+
+                frame tex;
+                if (selected_tex_source_uid >= 0)
+                {
+                    tex = streams[selected_tex_source_uid].texture->get_last_frame();
+                    if (tex) pc.update_texture(tex);
+                }
+
                 std::string fname(ret);
                 if (!ends_with(to_lower(fname), ".ply")) fname += ".ply";
                 export_to_ply(fname.c_str(), not_model, model, tex);
@@ -1732,28 +1748,32 @@ namespace rs2
 
         ImGui::SameLine();
 
-        if (syncronize)
+        if(support_non_syncronized_mode)
         {
-            ImGui::PushStyleColor(ImGuiCol_Text, light_blue);
-            ImGui::PushStyleColor(ImGuiCol_TextSelectedBg, light_blue);
-            if (ImGui::Button(u8"\uf09c", { 24, top_bar_height }))
+            if (synchronization_enable)
             {
-                syncronize = false;
+                ImGui::PushStyleColor(ImGuiCol_Text, light_blue);
+                ImGui::PushStyleColor(ImGuiCol_TextSelectedBg, light_blue);
+                if (ImGui::Button(u8"\uf09c", { 24, top_bar_height }))
+                {
+                    synchronization_enable = false;
+                }
+                if (ImGui::IsItemHovered())
+                    ImGui::SetTooltip("Disable syncronization between the pointcloud and the texture");
+                ImGui::PopStyleColor(2);
             }
-            if (ImGui::IsItemHovered())
-                ImGui::SetTooltip("Disable syncronization between the pointcloud and the texture");
-            ImGui::PopStyleColor(2);
-        }
-        else
-        {
-            if (ImGui::Button(u8"\uf023", { 24, top_bar_height }))
+            else
             {
-                syncronize = true;
+                if (ImGui::Button(u8"\uf023", { 24, top_bar_height }))
+                {
+                    synchronization_enable = true;
+                }
+                if (ImGui::IsItemHovered())
+                    ImGui::SetTooltip("Keep the pointcloud and the texture sycronized");
             }
-            if (ImGui::IsItemHovered())
-                ImGui::SetTooltip("Keep the pointcloud and the texture sycronized");
         }
 
+
         ImGui::End();
         ImGui::PopStyleColor(6);
         ImGui::PopStyleVar();
@@ -1801,12 +1821,19 @@ namespace rs2
 
     void viewer_model::gc_streams()
     {
+        std::lock_guard<std::mutex> lock(streams_mutex);
         std::vector<int> streams_to_remove;
         for (auto&& kvp : streams)
         {
             if (!kvp.second.is_stream_visible() &&
                 (!kvp.second.dev || (!kvp.second.dev->is_paused() && !kvp.second.dev->streaming)))
+            {
+                if(kvp.first == selected_depth_source_uid)
+                {
+                    pc.depth_stream_active = false;
+                }
                 streams_to_remove.push_back(kvp.first);
+            }
         }
         for (auto&& i : streams_to_remove) {
             streams.erase(i);
@@ -2086,7 +2113,7 @@ namespace rs2
                 ImGui::Text("%s", label.c_str());
                 if (ImGui::IsItemHovered())
                 {
-                    ImGui::SetTooltip("Hardware Timestamp unavailable! This is often an indication of inproperly applied Kernel patch.\nPlease refer to installation.md for mode information");
+                    ImGui::SetTooltip("Hardware Timestamp unavailable! This is often an indication of improperly applied Kernel patch.\nPlease refer to installation.md for mode information");
                 }
                 ImGui::PopStyleColor();
             }
@@ -2363,7 +2390,7 @@ namespace rs2
                 if (profiles.empty())
                     continue;
 
-                sub->play(profiles);
+                sub->play(profiles, viewer);
 
                 for (auto&& profile : profiles)
                 {
@@ -2598,28 +2625,92 @@ namespace rs2
     {
         show_icon(font_18, "recording_icon", u8"\uf111", x, y, id, from_rgba(255, 46, 54, alpha_delta * 255));
     }
-    void async_pointclound_mapper::render_loop()
+
+    void async_pointclound_mapper::proccess(rs2::frame f, const rs2::frame_source& source)
     {
-        while (keep_calculating_pointcloud)
+
+        points p;
+        std::vector<frame> results;
+
+
+        if(viewer.synchronization_enable)
         {
-            try
+            if (auto composite = f.as<rs2::frameset>())
             {
-                frame f;
-                if (depth_frames_to_render.poll_for_frame(&f))
+                for(auto&& f: composite)
                 {
-                    if (f.get_frame_number() == last_frame_number &&
-                        f.get_timestamp() <= last_timestamp &&
-                        f.get_profile().unique_id() == last_stream_id)
-                        continue;
+                    if(f.get_profile().unique_id() == viewer.selected_depth_source_uid)
+                    {
+                        p = pc.calculate(f);
+                        results.push_back(std::move(p));
+
+                    }
+                    if(f.get_profile().unique_id() == viewer.selected_tex_source_uid)
+                    {
+                        update_texture(f);
+                        results.push_back(std::move(f));
+                    }
+                }
+            }
+
+
+            auto res = source.allocate_composite_frame(results);
+            source.frame_ready(std::move(res));
+
+
+        }
+        else
+        {
+            if(f.get_profile().unique_id() == viewer.selected_depth_source_uid)
+            {
 
-                    resulting_3d_models.enqueue(pc.calculate(f));
+                if(last_tex_frame)
+                    results.push_back(last_tex_frame);
+                p = pc.calculate(f);
+                results.push_back(std::move(p));
 
-                    last_frame_number = f.get_frame_number();
-                    last_timestamp = f.get_timestamp();
-                    last_stream_id = f.get_profile().unique_id();
+                auto res = source.allocate_composite_frame(results);
+                source.frame_ready(std::move(res));
+            }
+
+        }
+    }
+
+    void async_pointclound_mapper::render_loop()
+    {
+        while (keep_calculating_pointcloud)
+        {
+            if(depth_stream_active)
+            {
+                try
+                {
+                    if(viewer.synchronization_enable)
+                    {
+                        frameset frames;
+                        if (viewer.syncer_queue.poll_for_frame(&frames))
+                        {
+                            processing_block.invoke(frames);
+                        }
+                    }
+                    else
+                    {
+                        std::lock_guard<std::mutex> lock(viewer.streams_mutex);
+                        for (auto&& s : viewer.streams)
+                        {
+                            if(s.first == viewer.selected_tex_source_uid)
+                            {
+                                update_texture(s.second.texture->get_last_frame());
+                                last_tex_frame = s.second.texture->get_last_frame();
+                            }
+                            if(s.first == viewer.selected_depth_source_uid)
+                            {
+                                processing_block.invoke(s.second.texture->get_last_frame());
+                            }
+                        }
+                    }
                 }
+                catch (...) {}
             }
-            catch (...) {}
 
             // There is no practical reason to re-calculate the 3D model
             // at higher frequency then 100 FPS
@@ -2925,40 +3016,26 @@ namespace rs2
 
         glColor4f(1.f, 1.f, 1.f, 1.f);
 
-        if (syncronize)
-        {
-            auto tex = streams[selected_tex_source_uid].texture->get_last_frame();
-            if (tex) s(tex);
-        }
 
-        if (auto points = pc.get_points())
+        if(!paused)
         {
-            if (syncronize)
-            {
-                s(points);
-                rs2::frameset fs;
-                if (s.poll_for_frames(&fs))
-                    if (fs && fs.size() > 1)
-                    {
-                        for (auto&& f : fs)
-                        {
-                            if (f.is<rs2::points>()) last_points = f;
-                            else last_texture = f;
-                        }
-                    }
-            }
-            else
+            auto res = pc.get_points();
+
+            for (auto&& f : res)
             {
-                last_texture = streams[selected_tex_source_uid].texture->get_last_frame();
-                last_points = points;
+                if (f.is<rs2::points>())
+                    last_points = f;
+                else
+                    last_texture = f;
             }
 
-            if (draw_frustrum)
-            {
+        }
+        if (draw_frustrum && last_points)
+        {
                 glLineWidth(1.f);
                 glBegin(GL_LINES);
 
-                auto intrin = points.get_profile().as<video_stream_profile>().get_intrinsics();
+                auto intrin = last_points.get_profile().as<video_stream_profile>().get_intrinsics();
 
                 glColor4f(sensor_bg.x, sensor_bg.y, sensor_bg.z, 0.5f);
 
@@ -2990,11 +3067,11 @@ namespace rs2
                 glColor4f(1.f, 1.f, 1.f, 1.f);
             }
 
-            if (last_points && last_texture)
+            if ( last_points && last_texture)
             {
                 texture.upload(last_texture);
 
-                glPointSize((float)viewer_rect.w / points.get_profile().as<video_stream_profile>().width());
+                glPointSize((float)viewer_rect.w / last_points.get_profile().as<video_stream_profile>().width());
 
                 if (selected_tex_source_uid >= 0)
                 {
@@ -3008,23 +3085,25 @@ namespace rs2
 
                 //glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, tex_border_color);
 
-                glBegin(GL_POINTS);
 
-                auto vertices = last_points.get_vertices();
-                auto tex_coords = last_points.get_texture_coordinates();
+                    glBegin(GL_POINTS);
 
-                for (int i = 0; i < last_points.size(); i++)
-                {
-                    if (vertices[i].z)
+                    auto vertices = last_points.get_vertices();
+                    auto tex_coords = last_points.get_texture_coordinates();
+
+                    for (int i = 0; i < last_points.size(); i++)
                     {
-                        glVertex3fv(vertices[i]);
-                        glTexCoord2fv(tex_coords[i]);
+                        if (vertices[i].z)
+                        {
+                            glVertex3fv(vertices[i]);
+                            glTexCoord2fv(tex_coords[i]);
+                        }
+
                     }
+                    glEnd();
 
-                }
-                glEnd();
             }
-        }
+
 
         glDisable(GL_DEPTH_TEST);
 
@@ -3142,6 +3221,9 @@ namespace rs2
 
     void viewer_model::upload_frame(frame&& f)
     {
+        if(f.get_profile().stream_type() == RS2_STREAM_DEPTH)
+            pc.depth_stream_active = true;
+
         auto index = f.get_profile().unique_id();
         streams[index].upload_frame(std::move(f));
     }
diff --git a/common/model-views.h b/common/model-views.h
index f6b480bf27..54f851c0ff 100644
--- a/common/model-views.h
+++ b/common/model-views.h
@@ -143,10 +143,6 @@ namespace rs2
         frame_queue& at(int id)
         {
             std::lock_guard<std::mutex> lock(_lookup_mutex);
-            if (_queues.find(id) == _queues.end())
-            {
-                _queues[id] = frame_queue(4);
-            }
             return _queues[id];
         }
 
@@ -172,7 +168,8 @@ namespace rs2
         std::map<int, int> selected_format_id;
     };
 
-    class subdevice_model;
+     class viewer_model;
+     class subdevice_model;
 
     class processing_block_model
     {
@@ -209,7 +206,7 @@ namespace rs2
         bool is_selected_combination_supported();
         std::vector<stream_profile> get_selected_profiles();
         void stop();
-        void play(const std::vector<stream_profile>& profiles);
+        void play(const std::vector<stream_profile>& profiles, viewer_model& viewer);
         void update(std::string& error_message, notifications_model& model);
         void draw_options(const std::vector<rs2_option>& drawing_order,
                           bool update_read_only_options, std::string& error_message,
@@ -478,14 +475,22 @@ namespace rs2
 
     std::string get_file_name(const std::string& path);
 
+    class viewer_model;
     class async_pointclound_mapper
     {
     public:
-        async_pointclound_mapper()
-            : keep_calculating_pointcloud(true),
-              resulting_3d_models(1), depth_frames_to_render(1),
-              t([this]() {render_loop(); })
+        async_pointclound_mapper(viewer_model& viewer)
+            : processing_block([&](rs2::frame f, const rs2::frame_source& source)
+        {
+            this->proccess(std::move(f),source);
+        }),
+        viewer(viewer),
+        keep_calculating_pointcloud(true),
+        depth_stream_active(false),
+        resulting_3d_models(1),
+        t([this]() {render_loop(); })
         {
+            processing_block.start(resulting_3d_models);
         }
 
         ~async_pointclound_mapper() { stop(); }
@@ -501,17 +506,13 @@ namespace rs2
             }
         }
 
-        void push_frame(frame f)
-        {
-            depth_frames_to_render.enqueue(f);
-        }
-
-        points get_points()
+        rs2::frameset get_points()
         {
             frame f;
             if (resulting_3d_models.poll_for_frame(&f))
             {
-                model = f;
+                rs2::frameset frameset(f);
+                model = frameset;
             }
             return model;
         }
@@ -521,16 +522,22 @@ namespace rs2
             rs2::frame f{};
             model = f;
             while (resulting_3d_models.poll_for_frame(&f));
-            while (depth_frames_to_render.poll_for_frame(&f));
         }
 
+        std::atomic<bool> depth_stream_active;
+
     private:
-        void render_loop();
+        viewer_model& viewer;
 
+        void render_loop();
+        void proccess(rs2::frame f, const rs2::frame_source& source);
+        rs2::frame last_tex_frame;
+        rs2::processing_block processing_block;
         pointcloud pc;
-        points model;
+        rs2::frameset model;
         std::atomic<bool> keep_calculating_pointcloud;
-        frame_queue depth_frames_to_render;
+
+
         frame_queue resulting_3d_models;
 
         std::thread t;
@@ -552,12 +559,19 @@ namespace rs2
         float get_output_height() const { return (is_output_collapsed ? default_log_h : 20); }
 
         viewer_model()
+            :pc(*this),
+             synchronization_enable(true)
         {
             reset_camera();
             rs2_error* e = nullptr;
             not_model.add_log(to_string() << "librealsense version: " << api_version_to_string(rs2_get_api_version(&e)) << "\n");
         }
 
+        ~viewer_model()
+        {
+            pc.stop();
+            streams.clear();
+        }
         void upload_frame(frame&& f);
 
         std::map<int, rect> calc_layout(const rect& r);
@@ -586,6 +600,7 @@ namespace rs2
 
         void gc_streams();
 
+        std::mutex streams_mutex;
         std::map<int, stream_model> streams;
         bool fullscreen = false;
         stream_model* selected_stream = nullptr;
@@ -597,6 +612,7 @@ namespace rs2
         bool is_3d_view = false;
         bool paused = false;
 
+
         void draw_viewport(const rect& viewer_rect, ux_window& window, int devices, std::string& error_message);
 
         bool allow_3d_source_change = true;
@@ -606,14 +622,19 @@ namespace rs2
         bool draw_plane = false;
 
         bool draw_frustrum = true;
-        bool syncronize = false;
+        bool support_non_syncronized_mode = true;
+        std::atomic<bool> synchronization_enable;
 
         int selected_depth_source_uid = -1;
         int selected_tex_source_uid = -1;
 
         float dim_level = 1.f;
 
+        rs2::syncer s;
+        rs2::frame_queue syncer_queue;
     private:
+
+        friend class async_pointclound_mapper;
         std::map<int, rect> get_interpolated_layout(const std::map<int, rect>& l);
         void show_icon(ImFont* font_18, const char* label_str, const char* text, int x, int y,
                        int id, const ImVec4& color, const std::string& tooltip = "");
@@ -633,10 +654,10 @@ namespace rs2
         rs2::points last_points;
         rs2::frame last_texture;
         texture_buffer texture;
-        rs2::syncer s;
+
     };
 
-    void export_to_ply(const std::string& file_name, notifications_model& ns, points points, video_frame texture);
+    void export_to_ply(const std::string& file_name, notifications_model& ns, frameset points, video_frame texture);
 
     // Wrapper for cross-platform dialog control
     enum file_dialog_mode {
diff --git a/common/rendering.h b/common/rendering.h
index 23b1729419..442efbdc84 100644
--- a/common/rendering.h
+++ b/common/rendering.h
@@ -755,7 +755,7 @@ namespace rs2
             return last;
         }
 
-        texture_buffer() : last_queue(1), texture(), 
+        texture_buffer() : last_queue(1), texture(),
             colorize(std::make_shared<colorizer>()) {}
 
         GLuint get_gl_handle() const { return texture; }
@@ -777,6 +777,7 @@ namespace rs2
 
         void upload(rs2::frame frame)
         {
+            last_queue.enqueue(frame);
             // If the frame timestamp has changed since the last time show(...) was called, re-upload the texture
             if (!texture)
                 glGenTextures(1, &texture);
@@ -864,7 +865,7 @@ namespace rs2
             //}
             //break;
             default:
-                throw std::runtime_error("The requested format is not suported for rendering");
+                throw std::runtime_error("The requested format is not supported for rendering");
             }
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
@@ -873,7 +874,6 @@ namespace rs2
             glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
             glBindTexture(GL_TEXTURE_2D, 0);
 
-            last_queue.enqueue(frame);
         }
 
         static void draw_axis(float axis_size = 1.f, float axisWidth = 4.f)
diff --git a/common/ux-window.cpp b/common/ux-window.cpp
index ebc3c4aed4..5dd4b0ec12 100644
--- a/common/ux-window.cpp
+++ b/common/ux-window.cpp
@@ -14,7 +14,7 @@ namespace rs2
         _win(nullptr), _width(0), _height(0), _output_height(0),
         _font_14(nullptr), _font_18(nullptr), _app_ready(false),
         _first_frame(true), _query_devices(true), _missing_device(false),
-        _hourglass_index(0), _dev_stat_message{}
+        _hourglass_index(0), _dev_stat_message{}, _keep_alive(true)
     {
         if (!glfwInit())
             exit(1);
@@ -22,12 +22,19 @@ namespace rs2
         rs2_error* e = nullptr;
         _title_str = to_string() << title << " v" << api_version_to_string(rs2_get_api_version(&e));
 
+        _width = 1024;
+        _height = 768;
+
+        // Dynamically adjust new window size (by detecting monitor resolution)
         auto primary = glfwGetPrimaryMonitor();
-        const auto mode = glfwGetVideoMode(primary);
+        if (primary)
+        {
+            const auto mode = glfwGetVideoMode(primary);
+            _width = int(mode->width * 0.7f);
+            _height = int(mode->height * 0.7f);
+        }
 
         // Create GUI Windows
-        _width = int(mode->width * 0.7f);
-        _height = int(mode->height * 0.7f);
         _win = glfwCreateWindow(_width, _height, _title_str.c_str(), nullptr, nullptr);
         glfwMakeContextCurrent(_win);
         ImGui_ImplGlfw_Init(_win, true);
@@ -71,7 +78,7 @@ namespace rs2
 
         // Prepare the splash screen and do some initialization in the background
         int x, y, comp;
-        auto r = stbi_load_from_memory(splash, splash_size, &x, &y, &comp, false);
+        auto r = stbi_load_from_memory(splash, (int)splash_size, &x, &y, &comp, false);
         _splash_tex.upload_image(x, y, r);
 
         // Apply initial UI state
@@ -97,8 +104,10 @@ namespace rs2
 
         if (_first_frame)
         {
-            std::thread first_load([&]() {
-                do
+            assert(!_first_load.joinable()); // You must call to reset() before initiate new thread
+
+            _first_load = std::thread([&]() {
+                while (_keep_alive && !_app_ready)
                 {
                     try
                     {
@@ -108,10 +117,9 @@ namespace rs2
                     {
                         std::this_thread::sleep_for(std::chrono::seconds(1)); // Wait for connect event and retry
                     }
-                } while (!_app_ready);
+                }
             });
             _first_frame = false;
-            first_load.detach();
         }
 
         // If we are just getting started, render the Splash Screen instead of normal UI
@@ -123,7 +131,7 @@ namespace rs2
             begin_frame();
 
             glPushMatrix();
-            glViewport(0.f, 0.f, _fb_width, _fb_height);
+            glViewport(0, 0, _fb_width, _fb_height);
             glClearColor(0.036f, 0.044f, 0.051f, 1.f);
             glClear(GL_COLOR_BUFFER_BIT);
 
@@ -131,8 +139,8 @@ namespace rs2
             glOrtho(0, _width, _height, 0, -1, +1);
 
             // Fade-in the logo
-            auto opacity = smoothstep(_splash_timer.elapsed_ms(), 100.f, 2000.f);
-            _splash_tex.show({ 0.f,0.f,(float)_width,(float)_height }, opacity);
+            auto opacity = smoothstep(float(_splash_timer.elapsed_ms()), 100.f, 2000.f);
+            _splash_tex.show({ 0.f,0.f,float(_width),float(_height) }, opacity);
 
             std::string hourglass = u8"\uf250";
             static periodic_timer every_200ms(std::chrono::milliseconds(200));
@@ -163,7 +171,7 @@ namespace rs2
             ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, { 5, 5 });
             ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 1);
             ImGui::PushStyleColor(ImGuiCol_WindowBg, transparent);
-            ImGui::SetNextWindowPos({ (float)_width/2 - 150, (float)_height/2 + 70 });
+            ImGui::SetNextWindowPos({ (float)_width / 2 - 150, (float)_height / 2 + 70 });
             ImGui::PushFont(_font_18);
             ImGui::SetNextWindowSize({ (float)_width, (float)_height });
             ImGui::Begin("Splash Screen Banner", nullptr, flags);
@@ -211,6 +219,12 @@ namespace rs2
 
     ux_window::~ux_window()
     {
+        if (_first_load.joinable())
+        {
+            _keep_alive = false;
+            _first_load.join();
+        }
+
         ImGui::GetIO().Fonts->ClearFonts();  // To be refactored into Viewer theme object
         ImGui_ImplGlfw_Shutdown();
         glfwDestroyWindow(_win);
@@ -262,6 +276,13 @@ namespace rs2
 
     void ux_window::reset()
     {
+        if (_first_load.joinable())
+        {
+            _keep_alive = false;
+            _first_load.join();
+            _keep_alive = true;
+        }
+
         _query_devices = true;
         _missing_device = false;
         _hourglass_index = 0;
@@ -269,5 +290,10 @@ namespace rs2
         _app_ready = false;
         _splash_timer.reset();
         _dev_stat_message = u8"\uf287 Please connect Intel RealSense device!";
+
+        {
+            std::lock_guard<std::mutex> lock(_on_load_message_mtx);
+            _on_load_message.clear();
+        }
     }
 }
diff --git a/common/ux-window.h b/common/ux-window.h
index cbdbbc10e4..b86544af0e 100644
--- a/common/ux-window.h
+++ b/common/ux-window.h
@@ -6,6 +6,7 @@
 #include "imgui.h"
 #include <string>
 #include <functional>
+#include <thread>
 #include "rendering.h"
 
 namespace rs2
@@ -71,8 +72,10 @@ namespace rs2
         std::string              _error_message;
         float                    _scale_factor;
 
+        std::thread              _first_load;
         bool                     _first_frame;
         std::atomic<bool>        _app_ready;
+        std::atomic<bool>        _keep_alive;
         texture_buffer           _splash_tex;
         timer                    _splash_timer;
         std::string              _title_str;
diff --git a/config/99-realsense-libusb.rules b/config/99-realsense-libusb.rules
index 1f5411c9f3..4e78d7df1d 100644
--- a/config/99-realsense-libusb.rules
+++ b/config/99-realsense-libusb.rules
@@ -11,6 +11,7 @@ SUBSYSTEMS=="usb", ATTRS{idVendor}=="8086", ATTRS{idProduct}=="0ad2", MODE:="066
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="8086", ATTRS{idProduct}=="0ad3", MODE:="0666", GROUP:="plugdev"
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="8086", ATTRS{idProduct}=="0ad4", MODE:="0666", GROUP:="plugdev"
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="8086", ATTRS{idProduct}=="0ad5", MODE:="0666", GROUP:="plugdev"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="8086", ATTRS{idProduct}=="0ad6", MODE:="0666", GROUP:="plugdev"
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="8086", ATTRS{idProduct}=="0af6", MODE:="0666", GROUP:="plugdev"
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="8086", ATTRS{idProduct}=="0afe", MODE:="0666", GROUP:="plugdev"
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="8086", ATTRS{idProduct}=="0aff", MODE:="0666", GROUP:="plugdev"
diff --git a/doc/RaspberryPi3.md b/doc/RaspberryPi3.md
new file mode 100644
index 0000000000..37c491cc15
--- /dev/null
+++ b/doc/RaspberryPi3.md
@@ -0,0 +1,28 @@
+# Intel&reg; RealSense&trade; D400 cameras with Raspberry Pi
+
+This document describes how to use the Intel RealSense D400 cameras on Raspberry PI 3 Model B (which offers only USB2 interface).
+
+> **Note:** Both Raspberry Pi platform and USB2 support in general are experimental features and are **not** officially supported by Intel RealSense group at this point. Camera capabilities are severely reduced when connected to USB2 port due to lack of bandwidth.
+
+<p align="center"><img src="https://raw.githubusercontent.com/wiki/IntelRealSense/librealsense/res/RaspberryPi3Model-B.png" /></p>
+
+## Installation Instructions
+1. Install [Ubuntu MATE](https://ubuntu-mate.org/) on your [Raspberry PI 3](https://www.raspberrypi.org/products/raspberry-pi-3-model-b/).
+
+2. Clone and compile the latest [Intel&reg; RealSense&trade; SDK 2.0](https://github.com/IntelRealSense/librealsense/releases/latest) by following the instructions under [Linux Installation](https://github.com/IntelRealSense/librealsense/blob/development/doc/installation.md).
+In section [Video4Linux backend preparation](https://github.com/IntelRealSense/librealsense/blob/development/doc/installation.md#video4linux-backend-preparation), perform only the first phase "Install udev rules located in librealsense source directory".
+
+> **Note**: In some cases the RAM capacity is not sufficient to compile the SDK, so if the compilation process crashes or exits with an error-code try to create a [swap file](https://www.howtoforge.com/ubuntu-swap-file) and then recompile the SDK.
+
+3. [Activate](https://ubuntu-mate.community/t/tutorial-activate-opengl-driver-for-ubuntu-mate-16-04/7094) the OpenGL driver.
+4. Plug the D400 camera and play with RealSense SDK [examples](https://github.com/IntelRealSense/librealsense/tree/master/examples)/[tools](https://github.com/IntelRealSense/librealsense/tree/master/tools).
+
+## Expected Output
+1. Streaming Depth data with 480x270 resolution and 30 FPS using the [Intel RealSense Viewer](https://github.com/IntelRealSense/librealsense/tree/master/tools/realsense-viewer).
+<p align="center"><img width=90% src="https://raw.githubusercontent.com/wiki/IntelRealSense/librealsense/res/Rasp3-Depth-Only.png" /></p>
+
+2. Streaming Depth and IR with 424x240 resolution and 30 FPS:
+<p align="center"><img width=90% src="https://raw.githubusercontent.com/wiki/IntelRealSense/librealsense/res/Rasp3-Depth-and-IR.png" /></p>
+
+3. Point-cloud of depth and IR:
+<p align="center"><img width=90% src="https://raw.githubusercontent.com/wiki/IntelRealSense/librealsense/res/Rasp3-Depth-and-IR-pointcloud.png" /></p>
diff --git a/doc/readme.md b/doc/readme.md
index 1ef83de43a..d9c4944f29 100644
--- a/doc/readme.md
+++ b/doc/readme.md
@@ -24,4 +24,5 @@
   * [D400 at software.intel.com](https://software.intel.com/en-us/realsense/d400) - Camera specifications
   * [D400 and External Devices](rs400/external_devices.md) - Notes on integrating RS400 with external devices
   * [D400 Advanced Mode](rs400/rs400_advanced_mode.md) - Overview of the Advanced Mode APIs
+  * [D400 cameras with Raspberry Pi](./RaspberryPi3.md) - Example of low-end system without USB3 interface
 * [Record and Playback](../src/media/readme.md) - SDK Record and Playback functionality using ROS-bag file format
diff --git a/examples/C/depth/rs-depth.c b/examples/C/depth/rs-depth.c
index 48a7b5b960..3f8d24d6ad 100644
--- a/examples/C/depth/rs-depth.c
+++ b/examples/C/depth/rs-depth.c
@@ -56,7 +56,7 @@ float get_depth_unit_value(const rs2_device* const dev)
 
         if (1 == is_depth_sensor_found)
         {
-            depth_scale = rs2_get_option(sensor, RS2_OPTION_DEPTH_UNITS, &e);
+            depth_scale = rs2_get_option((const rs2_options*)sensor, RS2_OPTION_DEPTH_UNITS, &e);
             check_error(e);
             rs2_delete_sensor(sensor);
             break;
diff --git a/examples/align/rs-align.cpp b/examples/align/rs-align.cpp
index 5dc79c98d6..cf5b9548fe 100644
--- a/examples/align/rs-align.cpp
+++ b/examples/align/rs-align.cpp
@@ -36,11 +36,11 @@ int main(int argc, char * argv[]) try
     // Each depth camera might have different units for depth pixels, so we get it here
     // Using the pipeline's profile, we can retrieve the device that the pipeline uses
     float depth_scale = get_depth_scale(profile.get_device());
-    
+
     //Pipeline could choose a device that does not have a color stream
     //If there is no color stream, choose to align depth to another stream
     rs2_stream align_to = find_stream_to_align(profile.get_streams());
-    
+
     // Create a rs2::align object.
     // rs2::align allows us to perform alignment of depth frames to others frames
     //The "align_to" is the stream type to which we plan to align depth frames.
diff --git a/examples/example.hpp b/examples/example.hpp
index e33647fb11..68afb3d637 100644
--- a/examples/example.hpp
+++ b/examples/example.hpp
@@ -89,7 +89,7 @@ class texture
             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, frame.get_data());
             break;
         default:
-            throw std::runtime_error("The requested format is not suported by this demo!");
+            throw std::runtime_error("The requested format is not supported by this demo!");
         }
 
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
diff --git a/examples/pointcloud/rs-pointcloud.cpp b/examples/pointcloud/rs-pointcloud.cpp
index 1651f0b4c7..e4305e53ba 100644
--- a/examples/pointcloud/rs-pointcloud.cpp
+++ b/examples/pointcloud/rs-pointcloud.cpp
@@ -42,18 +42,18 @@ int main(int argc, char * argv[]) try
         auto frames = pipe.wait_for_frames();
 
         auto depth = frames.get_depth_frame();
-        
+
         // Generate the pointcloud and texture mappings
         points = pc.calculate(depth);
-        
+
         auto color = frames.get_color_frame();
-        
+
         // Tell pointcloud object to map to this color frame
         pc.map_to(color);
 
         // Upload the color frame to OpenGL
         app_state.tex.upload(color);
-        
+
         // Draw the pointcloud
         draw_pointcloud(app, app_state, points);
     }
diff --git a/examples/sensor-control/api_how_to.h b/examples/sensor-control/api_how_to.h
index 9d6109f85d..35d31840eb 100644
--- a/examples/sensor-control/api_how_to.h
+++ b/examples/sensor-control/api_how_to.h
@@ -32,7 +32,7 @@ class how_to
         if (devices.size() == 0)
         {
             std::cerr << "No device connected, please connect a RealSense device" << std::endl;
-                
+
             //To help with the boilerplate code of waiting for a device to connect
             //The SDK provides the rs2::device_hub class
             rs2::device_hub device_hub(ctx);
@@ -61,7 +61,7 @@ class how_to
                 throw std::out_of_range("Selected device index is out of range");
             }
 
-            // Update the selected device 
+            // Update the selected device
             selected_device = devices[selected_device_index];
         }
 
@@ -90,7 +90,7 @@ class how_to
                 std::cout << "N/A" << std::endl;
         }
     }
-    
+
     static std::string get_device_name(const rs2::device& dev)
     {
         // Each device provides some information on itself, such as name:
@@ -105,7 +105,7 @@ class how_to
 
         return name + " " + sn;
     }
-    
+
     static std::string get_sensor_name(const rs2::sensor& sensor)
     {
         // Sensors support additional information, such as a human readable name
@@ -114,7 +114,7 @@ class how_to
         else
             return "Unknown Sensor";
     }
-    
+
     static rs2::sensor get_a_sensor_from_a_device(const rs2::device& dev)
     {
         // A rs2::device is a container of rs2::sensors that have some correlation between them.
@@ -143,10 +143,10 @@ class how_to
 
         return  sensors[selected_sensor_index];
     }
-    
+
     static rs2_option get_sensor_option(const rs2::sensor& sensor)
     {
-        // Sensors usually have several options to control their properties 
+        // Sensors usually have several options to control their properties
         //  such as Exposure, Brightness etc.
 
         std::cout << "Sensor supports the following options:\n" << std::endl;
@@ -189,7 +189,7 @@ class how_to
         }
         return static_cast<rs2_option>(selected_sensor_option);
     }
-    
+
     static float get_depth_units(const rs2::sensor& sensor)
     {
         //A Depth stream contains an image that is composed of pixels with depth information.
@@ -205,11 +205,11 @@ class how_to
         else
             throw std::runtime_error("Given sensor is not a depth sensor");
     }
-    
+
     static void get_field_of_view(const rs2::stream_profile& stream)
     {
         // A sensor's stream (rs2::stream_profile) is in general a stream of data with no specific type.
-        // For video streams (streams of images), the sensor that produces the data has a lens and thus has properties such 
+        // For video streams (streams of images), the sensor that produces the data has a lens and thus has properties such
         //  as a focal point, distortion, and principal point.
         // To get these intrinsics parameters, we need to take a stream and first check if it is a video stream
         if (auto video_stream = stream.as<rs2::video_stream_profile>())
@@ -239,7 +239,7 @@ class how_to
             std::cerr << "Given stream profile is not a video stream profile" << std::endl;
         }
     }
-    
+
     static void get_extrinsics(const rs2::stream_profile& from_stream, const rs2::stream_profile& to_stream)
     {
         // If the device/sensor that you are using contains more than a single stream, and it was calibrated
@@ -258,10 +258,10 @@ class how_to
             std::cerr << "Failed to get extrinsics for the given streams. " << e.what() << std::endl;
         }
     }
-    
+
     static void change_sensor_option(const rs2::sensor& sensor, rs2_option option_type)
     {
-        // Sensors usually have several options to control their properties 
+        // Sensors usually have several options to control their properties
         //  such as Exposure, Brightness etc.
 
         // To control an option, use the following api:
@@ -305,13 +305,13 @@ class how_to
             }
             catch (const rs2::error& e)
             {
-                // Some options can only be set while the camera is streaming, 
+                // Some options can only be set while the camera is streaming,
                 // and generally the hardware might fail so it is good practice to catch exceptions from set_option
                 std::cerr << "Failed to set option " << option_type << ". (" << e.what() << ")" << std::endl;
             }
         }
     }
-    
+
     static rs2::stream_profile choose_a_streaming_profile(const rs2::sensor& sensor)
     {
         // A Sensor is an object that is capable of streaming one or more types of data.
@@ -404,7 +404,7 @@ class how_to
 
         return stream_profiles[selected_profile_index];
     }
-    
+
     static void start_streaming_a_profile(const rs2::sensor& sensor, const rs2::stream_profile& stream_profile)
     {
         // The sensor controls turning the streaming on and off
@@ -420,7 +420,7 @@ class how_to
 
         std::ostringstream oss;
         oss << "Displaying profile " << stream_profile.stream_name();
-        
+
         // In order to begin getting data from the sensor, we need to register a callback to handle frames (data)
         // To register a callback, the sensor's start() method should be invoked.
         // The start() method takes any type of callable object that takes a frame as its parameter
@@ -432,7 +432,7 @@ class how_to
         //    This behavior requires the provided frame handler to the
         //     start method to be re-entrant
 
-        // In this example we have created a class to handle the frames, 
+        // In this example we have created a class to handle the frames,
         // and we capture it by reference inside a C++11 lambda which is passed to the start() function
         helper::frame_viewer display(oss.str());
         sensor.start([&](rs2::frame f) { display(f); });
diff --git a/examples/sensor-control/rs-sensor-control.cpp b/examples/sensor-control/rs-sensor-control.cpp
index d0e8953349..f9604e26ad 100644
--- a/examples/sensor-control/rs-sensor-control.cpp
+++ b/examples/sensor-control/rs-sensor-control.cpp
@@ -23,7 +23,7 @@ int main(int argc, char * argv[]) try
     // and finally run some operations on that sensor
 
     //We will use the "how_to" class to make the code clear, expressive and encapsulate common actions inside a function
-    
+
     std::vector<sensor_action> sensor_actions = create_sensor_actions();
 
     bool choose_a_device = true;
@@ -127,7 +127,7 @@ void show_extrinsics_between_streams(rs2::device device, rs2::sensor sensor)
 std::vector<sensor_action> create_sensor_actions()
 {
     //This function creates several functions ("sensor_action") that takes a device and a sensor,
-    // and perform some specific action 
+    // and perform some specific action
     return std::vector<sensor_action> {
             std::make_pair(&control_sensor_options, "Control sensor's options"),
             std::make_pair(&display_live_stream, "Control sensor's streams"),
diff --git a/include/librealsense2/h/rs_frame.h b/include/librealsense2/h/rs_frame.h
index 01c8eb8456..5088191097 100644
--- a/include/librealsense2/h/rs_frame.h
+++ b/include/librealsense2/h/rs_frame.h
@@ -228,7 +228,7 @@ rs2_frame* rs2_allocate_composite_frame(rs2_source* source, rs2_frame** frames,
 * \param[in] index       Index of the frame to extract within the composite frame
 * \param[out] error      If non-null, receives any error that occurs during this call, otherwise, errors are ignored
 * \return                returns reference to a frame existing within the composite frame
-*                        If you wish to keep this frame after the composite is released, you need to call aquire_ref
+*                        If you wish to keep this frame after the composite is released, you need to call acquire_ref
 *                        Otherwise the resulting frame lifetime is bound by owning composite frame
 */
 rs2_frame* rs2_extract_frame(rs2_frame* composite, int index, rs2_error** error);
diff --git a/include/librealsense2/hpp/rs_sensor.hpp b/include/librealsense2/hpp/rs_sensor.hpp
index 111c1967d3..71d5191621 100644
--- a/include/librealsense2/hpp/rs_sensor.hpp
+++ b/include/librealsense2/hpp/rs_sensor.hpp
@@ -107,13 +107,8 @@ namespace rs2
     class options
     {
     public:
-        options(rs2_options* options = nullptr)
-        {
-            _options = options;
-        }
-
         /**
-        * check if particular option is supported by a subdevice
+        * check if particular option is supported
         * \param[in] option     option id to be checked
         * \return true if option is supported
         */
@@ -153,7 +148,7 @@ namespace rs2
         }
 
         /**
-        * read option value from the device
+        * read option's value
         * \param[in] option   option id to be queried
         * \return value of the option
         */
@@ -180,7 +175,7 @@ namespace rs2
         }
 
         /**
-        * write new value to device option
+        * write new value to the option
         * \param[in] option     option id to be queried
         * \param[in] value      new value for the option
         */
@@ -211,6 +206,8 @@ namespace rs2
         }
 
    protected:
+       explicit options(rs2_options* o = nullptr) : _options(o) {}
+
        template<class T>
        options& operator=(const T& dev)
        {
@@ -230,8 +227,8 @@ namespace rs2
 
         using options::supports;
         /**
-        * open subdevice for exclusive access, by committing to a configuration
-        * \param[in] profile    configuration committed by the device
+        * open sensor for exclusive access, by committing to a configuration
+        * \param[in] profile    configuration committed by the sensor
         */
         void open(const stream_profile& profile) const
         {
@@ -245,7 +242,7 @@ namespace rs2
         /**
         * check if specific camera info is supported
         * \param[in] info    the parameter to check for support
-        * \return                true if the parameter both exist and well-defined for the specific device
+        * \return                true if the parameter both exist and well-defined for the specific sensor
         */
         bool supports(rs2_camera_info info) const
         {
@@ -258,7 +255,7 @@ namespace rs2
         /**
         * retrieve camera specific information, like versions of various internal components
         * \param[in] info     camera info type to retrieve
-        * \return             the requested camera info string, in a format specific to the device model
+        * \return             the requested camera info string, in a format specific to the sensor model
         */
         const char* get_info(rs2_camera_info info) const
         {
@@ -269,9 +266,9 @@ namespace rs2
         }
 
         /**
-        * open subdevice for exclusive access, by committing to composite configuration, specifying one or more stream profiles
+        * open sensor for exclusive access, by committing to composite configuration, specifying one or more stream profiles
         * this method should be used for interdependent  streams, such as depth and infrared, that have to be configured together
-        * \param[in] profiles   vector of configurations to be commited by the device
+        * \param[in] profiles   vector of configurations to be commited by the sensor
         */
         void open(const std::vector<stream_profile>& profiles) const
         {
@@ -292,8 +289,8 @@ namespace rs2
         }
 
         /**
-        * close subdevice for exclusive access
-        * this method should be used for releasing device resource
+        * close sensor for exclusive access
+        * this method should be used for releasing sensor resource
         */
         void close() const
         {
@@ -339,8 +336,8 @@ namespace rs2
 
 
         /**
-        * check if physical subdevice is supported
-        * \return   list of stream profiles that given subdevice can provide, should be released by rs2_delete_profiles_list
+        * check if physical sensor is supported
+        * \return   list of stream profiles that given sensor can provide, should be released by rs2_delete_profiles_list
         */
         std::vector<stream_profile> get_stream_profiles() const
         {
@@ -377,19 +374,19 @@ namespace rs2
             return intrin;
         }
 
-        sensor& operator=(const std::shared_ptr<rs2_sensor> dev)
-        {  
-            options::operator=(dev);
+        sensor& operator=(const std::shared_ptr<rs2_sensor> other)
+        {
+            options::operator=(other);
             _sensor.reset();
-            _sensor = dev;
+            _sensor = other;
             return *this;
         }
 
-        sensor& operator=(const sensor& dev)
+        sensor& operator=(const sensor& other)
         {
             *this = nullptr;
-             options::operator=(dev._sensor);
-            _sensor = dev._sensor;
+             options::operator=(other._sensor);
+            _sensor = other._sensor;
             return *this;
         }
         sensor() : _sensor(nullptr) {}
diff --git a/include/librealsense2/rs.h b/include/librealsense2/rs.h
index f1c4d1d8ab..1447e0f2e6 100644
--- a/include/librealsense2/rs.h
+++ b/include/librealsense2/rs.h
@@ -24,7 +24,7 @@ extern "C" {
 
 #define RS2_API_MAJOR_VERSION    2
 #define RS2_API_MINOR_VERSION    8
-#define RS2_API_PATCH_VERSION    1
+#define RS2_API_PATCH_VERSION    2
 #define RS2_API_BUILD_VERSION    0
 
 #define STRINGIFY(arg) #arg
diff --git a/readme.md b/readme.md
index 588665a38a..99488ec726 100644
--- a/readme.md
+++ b/readme.md
@@ -37,7 +37,7 @@ Information about the Intel® RealSense™ technology at [realsense.intel.com](h
    These simple examples demonstrate how to easily use the SDK to include code snippets that access the camera into your applications.
 
 **[Wrappers](https://github.com/IntelRealSense/librealsense/tree/development/wrappers)**
-  We provide a C, C++, [Python](./wrappers/python), [Node.js](./wrappers/nodejs) API and [ROS](https://github.com/intel-ros/realsense/releases). More to come , including LabView, PCL, Unity and Matlab.
+  We provide a C, C++, [Python](./wrappers/python), [Node.js](./wrappers/nodejs) API, [ROS](https://github.com/intel-ros/realsense/releases) and [LabVIEW](./wrappers/labview). More to come, including C# and Matlab.
 
 
 ## Quick Start
diff --git a/src/backend.h b/src/backend.h
index 0d8a0ecbb9..69a4000b10 100644
--- a/src/backend.h
+++ b/src/backend.h
@@ -22,12 +22,12 @@
 #include <sstream>
 
 
-const uint16_t MAX_RETRIES           = 100;
-const uint16_t VID_INTEL_CAMERA      = 0x8086;
-const uint8_t  DEFAULT_FRAME_BUFFERS = 4;
-const uint16_t DELAY_FOR_RETRIES     = 50;
+const uint16_t MAX_RETRIES                = 100;
+const uint16_t VID_INTEL_CAMERA           = 0x8086;
+const uint8_t  DEFAULT_V4L2_FRAME_BUFFERS = 4;
+const uint16_t DELAY_FOR_RETRIES          = 50;
 
-const uint8_t MAX_META_DATA_SIZE      = 0xff; // UVC Metadata total length
+const uint8_t MAX_META_DATA_SIZE          = 0xff; // UVC Metadata total length
                                             // is limited by (UVC Bulk) design to 255 bytes
 
 namespace librealsense
@@ -362,7 +362,7 @@ namespace librealsense
         class uvc_device
         {
         public:
-            virtual void probe_and_commit( stream_profile profile, bool zero_copy,  frame_callback callback, int buffers = DEFAULT_FRAME_BUFFERS) = 0;
+            virtual void probe_and_commit(stream_profile profile, frame_callback callback, int buffers = DEFAULT_V4L2_FRAME_BUFFERS) = 0;
             virtual void stream_on(std::function<void(const notification& n)> error_handler = [](const notification& n){}) = 0;
             virtual void start_callbacks() = 0;
             virtual void stop_callbacks() = 0;
@@ -400,9 +400,9 @@ namespace librealsense
             explicit retry_controls_work_around(std::shared_ptr<uvc_device> dev)
                 : _dev(dev) {}
 
-            void probe_and_commit( stream_profile profile, bool zero_copy,  frame_callback callback, int buffers) override
+            void probe_and_commit(stream_profile profile, frame_callback callback, int buffers) override
             {
-                _dev->probe_and_commit(profile, zero_copy, callback, buffers);
+                _dev->probe_and_commit(profile, callback, buffers);
             }
 
             void stream_on(std::function<void(const notification& n)> error_handler = [](const notification& n){}) override
@@ -661,11 +661,11 @@ namespace librealsense
                 : _dev(dev)
             {}
 
-            void probe_and_commit( stream_profile profile, bool zero_copy,  frame_callback callback, int buffers) override
+            void probe_and_commit(stream_profile profile, frame_callback callback, int buffers) override
             {
                 auto dev_index = get_dev_index_by_profiles(profile);
                 _configured_indexes.insert(dev_index);
-                _dev[dev_index]->probe_and_commit(profile, zero_copy, callback, buffers);
+                _dev[dev_index]->probe_and_commit(profile, callback, buffers);
             }
 
 
diff --git a/src/device.cpp b/src/device.cpp
index 18c0df9b3f..8640dd03be 100644
--- a/src/device.cpp
+++ b/src/device.cpp
@@ -101,6 +101,7 @@ void device::hardware_reset()
 
 std::shared_ptr<matcher> librealsense::device::create_matcher(const frame_holder& frame) const
 {
+
     return std::make_shared<identity_matcher>( frame.frame->get_stream()->get_unique_id(), frame.frame->get_stream()->get_stream_type());
 }
 
diff --git a/src/ds5/advanced_mode/json_loader.hpp b/src/ds5/advanced_mode/json_loader.hpp
index 7f07f8d904..fd8062abe2 100644
--- a/src/ds5/advanced_mode/json_loader.hpp
+++ b/src/ds5/advanced_mode/json_loader.hpp
@@ -373,7 +373,6 @@ namespace librealsense
             { "aux-param-depthclampmin", make_field(p.depth_table, &STDepthTableControl::depthClampMin) },
             { "aux-param-depthclampmax", make_field(p.depth_table, &STDepthTableControl::depthClampMax) },
             { "param-disparitymode", make_field(p.depth_table, &STDepthTableControl::disparityMode) },
-            { "aux-param-disparitymultiplier", make_field(p.depth_table, &STDepthTableControl::disparityMode) },
             { "param-disparityshift", make_field(p.depth_table, &STDepthTableControl::disparityShift) },
             { "aux-param-disparityshift", make_field(p.depth_table, &STDepthTableControl::disparityShift) },
 
@@ -392,6 +391,12 @@ namespace librealsense
             { "param-regionspatialthresholdv", make_ignored_field() },
             { "result:", make_ignored_field() },
             { "result", make_ignored_field() },
+            { "aux-param-disparitymultiplier",  make_ignored_field() },
+            { "stream-depth-format",  make_ignored_field() },
+            { "stream-ir-format",  make_ignored_field() },
+            { "stream-width",  make_ignored_field() },
+            { "stream-height",  make_ignored_field() },
+            { "stream-fps",  make_ignored_field() },
         };
 
         static const std::map<std::string, float> auto_control_values{ { "False", 0.f }, { "True", 1.f } };
diff --git a/src/ds5/ds5-active.cpp b/src/ds5/ds5-active.cpp
index 76a99f01ec..eae0dda717 100644
--- a/src/ds5/ds5-active.cpp
+++ b/src/ds5/ds5-active.cpp
@@ -25,22 +25,26 @@ namespace librealsense
     {
         using namespace ds;
 
-        auto& depth_ep = get_depth_sensor();
-        auto emitter_enabled = std::make_shared<emitter_option>(depth_ep);
-        depth_ep.register_option(RS2_OPTION_EMITTER_ENABLED, emitter_enabled);
+        auto pid = group.uvc_devices.front().pid;
+        if (pid != RS_USB2_PID)
+        {
+            auto& depth_ep = get_depth_sensor();
+            auto emitter_enabled = std::make_shared<emitter_option>(depth_ep);
+            depth_ep.register_option(RS2_OPTION_EMITTER_ENABLED, emitter_enabled);
 
-        auto laser_power = std::make_shared<uvc_xu_option<uint16_t>>(depth_ep,
-                                                                     depth_xu,
-                                                                     DS5_LASER_POWER,
-                                                                     "Manual laser power in mw. applicable only when laser power mode is set to Manual");
-        depth_ep.register_option(RS2_OPTION_LASER_POWER,
-                                 std::make_shared<auto_disabling_control>(
-                                 laser_power,
-                                 emitter_enabled,
-                                 std::vector<float>{0.f, 2.f}, 1.f));
+            auto laser_power = std::make_shared<uvc_xu_option<uint16_t>>(depth_ep,
+                                                                         depth_xu,
+                                                                         DS5_LASER_POWER,
+                                                                         "Manual laser power in mw. applicable only when laser power mode is set to Manual");
+            depth_ep.register_option(RS2_OPTION_LASER_POWER,
+                                     std::make_shared<auto_disabling_control>(
+                                     laser_power,
+                                     emitter_enabled,
+                                     std::vector<float>{0.f, 2.f}, 1.f));
 
-        depth_ep.register_option(RS2_OPTION_PROJECTOR_TEMPERATURE,
-                std::make_shared<asic_and_projector_temperature_options>(depth_ep,
-                RS2_OPTION_PROJECTOR_TEMPERATURE));
+            depth_ep.register_option(RS2_OPTION_PROJECTOR_TEMPERATURE,
+                    std::make_shared<asic_and_projector_temperature_options>(depth_ep,
+                    RS2_OPTION_PROJECTOR_TEMPERATURE));
+        }
     }
 }
diff --git a/src/ds5/ds5-device.cpp b/src/ds5/ds5-device.cpp
index 3fb756d229..9d5520f11b 100644
--- a/src/ds5/ds5-device.cpp
+++ b/src/ds5/ds5-device.cpp
@@ -192,6 +192,7 @@ namespace librealsense
         std::unique_ptr<frame_timestamp_reader> ds5_timestamp_reader_backup(new ds5_timestamp_reader(backend.create_time_service()));
         auto depth_ep = std::make_shared<ds5_depth_sensor>(this, std::make_shared<platform::multi_pins_uvc_device>(depth_devices),
                                                        std::unique_ptr<frame_timestamp_reader>(new ds5_timestamp_reader_from_metadata(std::move(ds5_timestamp_reader_backup))));
+
         depth_ep->register_xu(depth_xu); // make sure the XU is initialized everytime we power the camera
 
 
@@ -229,12 +230,13 @@ namespace librealsense
                                 get_depth_sensor()));
         }
 
-        // Define Left-Right extrinsics calculation (lazy)
+        // Define Left-to-Right extrinsics calculation (lazy)
+        // Reference CS - Right-handed; positive [X,Y,Z] point to [Left,Up,Forward] accordingly.
         _left_right_extrinsics = std::make_shared<lazy<rs2_extrinsics>>([this]()
         {
             rs2_extrinsics ext = identity_matrix();
             auto table = check_calib<coefficients_table>(*_coefficients_table_raw);
-            ext.translation[0] = -0.001f * table->baseline;
+            ext.translation[0] = 0.001f * table->baseline; // mm to meters
             return ext;
         });
 
@@ -413,8 +415,9 @@ namespace librealsense
         std::vector<std::shared_ptr<matcher>> depth_matchers;
 
         for (auto& s : streams)
+        {
             depth_matchers.push_back(std::make_shared<identity_matcher>( s->get_unique_id(), s->get_stream_type()));
-
+        }
         return std::make_shared<frame_number_composite_matcher>(depth_matchers);
     }
 }
diff --git a/src/ds5/ds5-factory.cpp b/src/ds5/ds5-factory.cpp
index 5b0b2e798a..574e84cf4f 100644
--- a/src/ds5/ds5-factory.cpp
+++ b/src/ds5/ds5-factory.cpp
@@ -207,6 +207,8 @@ namespace librealsense
             return std::make_shared<rs430_rgb_mm_device>(ctx, group, register_device_notifications);
         case RS435_RGB_PID:
             return std::make_shared<rs435_device>(ctx, group, register_device_notifications);
+        case RS_USB2_PID:
+            return std::make_shared<rs410_device>(ctx, group, register_device_notifications);
         default:
             throw std::runtime_error("Unsupported RS400 model!");
         }
diff --git a/src/ds5/ds5-private.cpp b/src/ds5/ds5-private.cpp
index d4958c3e08..47a1b624ad 100644
--- a/src/ds5/ds5-private.cpp
+++ b/src/ds5/ds5-private.cpp
@@ -166,16 +166,17 @@ namespace librealsense
                     result = *it;
                     switch (info.pid)
                     {
+                    case RS_USB2_PID:
                     case RS400_PID:
                     case RS410_PID:
                     case RS460_PID:
                     case RS430_PID:
                     case RS420_PID:
-                        found = result.mi == 3;
+                        found = (result.mi == 3);
                         break;
                     case RS430_MM_PID:
                     case RS420_MM_PID:
-                        found = result.mi == 6;
+                        found = (result.mi == 6);
                         break;
                     case RS415_PID:
                     case RS435_RGB_PID:
diff --git a/src/ds5/ds5-private.h b/src/ds5/ds5-private.h
index 333a70da63..66bc46d769 100644
--- a/src/ds5/ds5-private.h
+++ b/src/ds5/ds5-private.h
@@ -27,7 +27,8 @@ namespace librealsense
         const uint16_t RS430_MM_PID     = 0x0ad5; // AWGT
         const uint16_t RS430_MM_RGB_PID = 0x0b01; // AWGCT
         const uint16_t RS435_RGB_PID    = 0x0b07; // AWGC
-        const uint16_t RS460_PID       = 0x0b03; // DS5U
+        const uint16_t RS460_PID        = 0x0b03; // DS5U
+        const uint16_t RS_USB2_PID      = 0x0ad6; // USB2
 
         // DS5 depth XU identifiers
         const uint8_t DS5_HWMONITOR                       = 1;
@@ -52,7 +53,8 @@ namespace librealsense
             ds::RS430_MM_PID,
             ds::RS430_MM_RGB_PID,
             ds::RS435_RGB_PID,
-            ds::RS460_PID
+            ds::RS460_PID,
+            ds::RS_USB2_PID
         };
 
         static const std::map<std::uint16_t, std::string> rs400_sku_names = {
@@ -68,6 +70,7 @@ namespace librealsense
             { RS430_MM_PID, "Intel RealSense 430 with Tracking Module and RGB Module"},
             { RS435_RGB_PID,"Intel RealSense 435"},
             { RS460_PID,    "Intel RealSense 460" },
+            { RS_USB2_PID,  "Intel RealSense USB2" }
         };
 
         // DS5 fisheye XU identifiers
diff --git a/src/ds5/ds5-rolling-shutter.cpp b/src/ds5/ds5-rolling-shutter.cpp
index 20fdbde008..8ffe673ac2 100644
--- a/src/ds5/ds5-rolling-shutter.cpp
+++ b/src/ds5/ds5-rolling-shutter.cpp
@@ -25,7 +25,8 @@ namespace librealsense
     {
         using namespace ds;
 
-        if (_fw_version >= firmware_version("5.5.8.0"))
+        auto pid = group.uvc_devices.front().pid;
+        if ((_fw_version >= firmware_version("5.5.8.0")) && (pid != RS_USB2_PID))
         {
             get_depth_sensor().register_option(RS2_OPTION_ENABLE_AUTO_WHITE_BALANCE,
                 std::make_shared<uvc_xu_option<uint8_t>>(get_depth_sensor(),
diff --git a/src/ivcam/sr300.cpp b/src/ivcam/sr300.cpp
index 2d36ddb6a6..57fddf463a 100644
--- a/src/ivcam/sr300.cpp
+++ b/src/ivcam/sr300.cpp
@@ -313,8 +313,9 @@ namespace librealsense
         std::vector<stream_interface*> streams = { _depth_stream.get(), _ir_stream.get()};
 
         for (auto& s : streams)
+        {
             depth_matchers.push_back(std::make_shared<identity_matcher>( s->get_unique_id(), s->get_stream_type()));
-
+        }
         std::vector<std::shared_ptr<matcher>> matchers;
         matchers.push_back( std::make_shared<frame_number_composite_matcher>(depth_matchers));
 
diff --git a/src/libuvc/libuvc.cpp b/src/libuvc/libuvc.cpp
index 0f240fdf96..20698c4e16 100644
--- a/src/libuvc/libuvc.cpp
+++ b/src/libuvc/libuvc.cpp
@@ -294,7 +294,7 @@ namespace librealsense
             }
 
             /* request to set up a streaming profile and its calback */
-            void probe_and_commit(stream_profile profile, bool zero_copy, frame_callback callback, int buffers) override
+            void probe_and_commit(stream_profile profile, frame_callback callback, int buffers) override
             {
                 uvc_error_t res;
                 uvc_stream_ctrl_t ctrl;
diff --git a/src/linux/backend-v4l2.cpp b/src/linux/backend-v4l2.cpp
index 387f5c6416..2974c4ecdd 100644
--- a/src/linux/backend-v4l2.cpp
+++ b/src/linux/backend-v4l2.cpp
@@ -132,11 +132,11 @@ namespace librealsense
             }
         }
 
-        void named_mutex::aquire()
+        void named_mutex::acquire()
         {
             auto ret = lockf(_fildes, F_LOCK, 0);
             if (ret != 0)
-                throw linux_backend_exception(to_string() << "Aquire failed");
+                throw linux_backend_exception(to_string() << "Acquire failed");
         }
 
         void named_mutex::release()
@@ -517,11 +517,8 @@ namespace librealsense
             if (_thread) _thread->join();
         }
 
-        void v4l_uvc_device::probe_and_commit( stream_profile profile, bool zero_copy,  frame_callback callback, int buffers)
+        void v4l_uvc_device::probe_and_commit(stream_profile profile, frame_callback callback, int buffers)
         {
-            if(!zero_copy)
-                buffers = 1;
-
             if(!_is_capturing && !_callback)
             {
                 v4l2_fmtdesc pixel_format = {};
@@ -538,15 +535,15 @@ namespace librealsense
                         // Microsoft Depth GUIDs for R400 series are not yet recognized
                         // by the Linux kernel, but they do not require a patch, since there
                         // are "backup" Z16 and Y8 formats in place
-                        std::set<std::string> known_problematic_formats = {
+                        static const std::set<std::string> pending_formats = {
                             "00000050-0000-0010-8000-00aa003",
                             "00000032-0000-0010-8000-00aa003",
                         };
 
-                        if (std::find(known_problematic_formats.begin(),
-                                      known_problematic_formats.end(),
+                        if (std::find(pending_formats.begin(),
+                                      pending_formats.end(),
                                       (const char*)pixel_format.description) ==
-                            known_problematic_formats.end())
+                            pending_formats.end())
                         {
                             const std::string s(to_string() << "!" << pixel_format.description);
                             std::regex rgx("!([0-9a-f]+)-.*");
diff --git a/src/linux/backend-v4l2.h b/src/linux/backend-v4l2.h
index db6e03d431..1c5381f5ee 100644
--- a/src/linux/backend-v4l2.h
+++ b/src/linux/backend-v4l2.h
@@ -54,7 +54,7 @@ namespace librealsense
 
             named_mutex(const named_mutex&) = delete;
 
-            void lock() { aquire(); }
+            void lock() { acquire(); }
             void unlock() { release(); }
 
             bool try_lock();
@@ -62,7 +62,7 @@ namespace librealsense
             ~named_mutex();
 
         private:
-            void aquire();
+            void acquire();
 
             void release();
 
@@ -141,7 +141,7 @@ namespace librealsense
 
             ~v4l_uvc_device();
 
-            void probe_and_commit( stream_profile profile, bool zero_copy,  frame_callback callback, int buffers) override;
+            void probe_and_commit(stream_profile profile, frame_callback callback, int buffers) override;
 
             void stream_on(std::function<void(const notification& n)> error_handler) override;
 
diff --git a/src/log.cpp b/src/log.cpp
index 41c3580004..df9c8b3e5e 100644
--- a/src/log.cpp
+++ b/src/log.cpp
@@ -99,12 +99,13 @@ namespace librealsense
             if (content)
             {
                 std::string content_str(content);
-                std::transform(content_str.begin(), content_str.end(), content_str.begin(), ::toupper);
+                std::transform(content_str.begin(), content_str.end(), content_str.begin(), ::tolower);
 
                 for (uint32_t i = 0; i < RS2_LOG_SEVERITY_COUNT; i++)
                 {
                     auto current = (rs2_log_severity)i;
                     std::string name = librealsense::get_string(current);
+                    std::transform(name.begin(), name.end(), name.begin(), ::tolower);
                     if (content_str == name)
                     {
                         severity = current;
diff --git a/src/mock/recorder.cpp b/src/mock/recorder.cpp
index 22ca60f117..40ef7fc41d 100644
--- a/src/mock/recorder.cpp
+++ b/src/mock/recorder.cpp
@@ -628,11 +628,11 @@ namespace librealsense
         }
 
 
-        void record_uvc_device::probe_and_commit( stream_profile profile, bool zero_copy,   frame_callback callback, int buffers)
+        void record_uvc_device::probe_and_commit(stream_profile profile, frame_callback callback, int buffers)
         {
-            _owner->try_record([this, zero_copy, callback, profile](recording* rec, lookup_key k)
+            _owner->try_record([this, callback, profile](recording* rec, lookup_key k)
             {
-                _source->probe_and_commit(profile, zero_copy, [this, callback](stream_profile p, frame_object f, std::function<void()> continuation)
+                _source->probe_and_commit(profile, [this, callback](stream_profile p, frame_object f, std::function<void()> continuation)
                 {
                     _owner->try_record([this, callback, p, &f, continuation](recording* rec1, lookup_key key1)
                     {
@@ -1179,7 +1179,7 @@ namespace librealsense
             });
         }
 
-        void playback_uvc_device::probe_and_commit( stream_profile profile, bool zero_copy,  frame_callback callback, int buffers)
+        void playback_uvc_device::probe_and_commit(stream_profile profile, frame_callback callback, int buffers)
         {
             auto stored = _rec->load_stream_profiles(_entity_id, call_type::uvc_probe_commit);
             vector<stream_profile> input{ profile };
diff --git a/src/mock/recorder.h b/src/mock/recorder.h
index bcf8086fd8..0250741bbb 100644
--- a/src/mock/recorder.h
+++ b/src/mock/recorder.h
@@ -324,7 +324,7 @@ namespace librealsense
         class record_uvc_device : public uvc_device
         {
         public:
-            void probe_and_commit( stream_profile profile, bool zero_copy,  frame_callback callback, int buffers) override;
+            void probe_and_commit(stream_profile profile, frame_callback callback, int buffers) override;
             void stream_on(std::function<void(const notification& n)> error_handler = [](const notification& n) {}) override;
             void start_callbacks() override;
             void stop_callbacks() override;
@@ -458,7 +458,7 @@ namespace librealsense
                 {
                     auto&& c = _rec->add_call(k);
                     c.had_error = true;
-                    c.inline_string = "Unknown exception has occured!";
+                    c.inline_string = "Unknown exception has occurred!";
 
                     throw;
                 }
@@ -502,7 +502,7 @@ namespace librealsense
         class playback_uvc_device : public uvc_device
         {
         public:
-            void probe_and_commit( stream_profile profile, bool zero_copy,  frame_callback callback, int buffers) override;
+            void probe_and_commit(stream_profile profile, frame_callback callback, int buffers) override;
             void stream_on(std::function<void(const notification& n)> error_handler = [](const notification& n) {}) override;
             void start_callbacks() override;
             void stop_callbacks() override;
diff --git a/src/option.h b/src/option.h
index 6053d1a3be..6bec308bf8 100644
--- a/src/option.h
+++ b/src/option.h
@@ -71,23 +71,23 @@ namespace librealsense
             _on_set = [](float x) {};
         }
 
-        void set(float value) override 
+        void set(float value) override
         { 
-            if (_max < value || _min > value) 
+            if (_max < value || _min > value)
                 throw invalid_value_exception("Given value is outside valid range!");
-            *_value = value; 
+            *_value = value;
             _on_set(value);
         }
 
-        float query() const override 
+        float query() const override
         {
             return *_value;
         }
 
-        option_range get_range() const override { 
-            return{ 
-                (float)_min, (float)_max, 
-                (float)_step, (float)_def }; 
+        option_range get_range() const override {
+            return{
+                (float)_min, (float)_max,
+                (float)_step, (float)_def };
         }
 
         bool is_enabled() const override { return true; }
@@ -199,7 +199,7 @@ namespace librealsense
                 {
                     return dev.get_xu_range(_xu, _id, sizeof(T));
                 });
-            
+
             if (uvc_range.min.size() < sizeof(int32_t)) return option_range{0,0,1,0};
 
             auto min = *(reinterpret_cast<int32_t*>(uvc_range.min.data()));
diff --git a/src/pipeline.cpp b/src/pipeline.cpp
index 8bf00305b6..039e686ef9 100644
--- a/src/pipeline.cpp
+++ b/src/pipeline.cpp
@@ -538,7 +538,6 @@ namespace librealsense
             }
             catch(...)
             {
-            
             } // Stop will throw if device was disconnected. TODO - refactoring anticipated
         }
         _active_profile.reset();
diff --git a/src/sensor.cpp b/src/sensor.cpp
index 2e1f791502..0cb036f2b2 100644
--- a/src/sensor.cpp
+++ b/src/sensor.cpp
@@ -318,7 +318,7 @@ namespace librealsense
         {
             try
             {
-                _device->probe_and_commit(mode.profile, !mode.requires_processing(),
+                _device->probe_and_commit(mode.profile,
                 [this, mode, timestamp_reader, requests](platform::stream_profile p, platform::frame_object f, std::function<void()> continuation) mutable
                 {
                     auto system_time = environment::get_instance().get_time_service()->get_time();
@@ -419,8 +419,7 @@ namespace librealsense
                         if (pref->get_stream().get())
                             _source.invoke_callback(std::move(pref));
                     }
-                },
-                static_cast<int>(_source.get_published_size_option()->query()));
+                });
             }
             catch(...)
             {
diff --git a/src/source.cpp b/src/source.cpp
index 0ebb44b67b..1db33402e5 100644
--- a/src/source.cpp
+++ b/src/source.cpp
@@ -38,7 +38,7 @@ namespace librealsense
 
     std::shared_ptr<option> frame_source::get_published_size_option()
     {
-        return std::make_shared<frame_queue_size>(&_max_publish_list_size, option_range{ 0, 32, 1, 16 });
+        return std::make_shared<frame_queue_size>(&_max_publish_list_size, option_range{ 1, 32, 1, 16 });
     }
 
     frame_source::frame_source()
diff --git a/src/sync.cpp b/src/sync.cpp
index e698bcd42d..4cd8e6f31b 100644
--- a/src/sync.cpp
+++ b/src/sync.cpp
@@ -20,7 +20,7 @@ namespace librealsense
             for (int i = 0; i < composite->get_embedded_frames_count(); i++)
             {
                 auto matched = composite->get_frame(i);
-                ss << matched->get_stream()->get_stream_type() << " " << matched->get_frame_number() << ", "<<std::fixed<< matched->get_frame_timestamp()<<" ";
+                ss << matched->get_stream()->get_stream_type() << " " << matched->get_frame_number() << ", "<<std::fixed<< matched->get_frame_timestamp()<<"\n";
             }
 
             LOG_DEBUG(ss.str());
@@ -38,47 +38,100 @@ namespace librealsense
 
             frame_holder f;
             while (matches.try_dequeue(&f))
+            {
                 get_source().frame_ready(std::move(f));
+            }
         };
         set_processing_callback(std::shared_ptr<rs2_frame_processor_callback>(
             new internal_frame_processor_callback<decltype(f)>(f)));
     }
 
-    matcher::matcher()
-    {}
-
     void matcher::set_callback(sync_callback f)
     {
         _callback = f;
     }
 
-    void  matcher::sync(frame_holder f, syncronization_environment env)
+    matcher::matcher(std::vector<stream_id> streams_id)
+        : _streams_id(streams_id){}
+
+    void matcher::sync(frame_holder f, syncronization_environment env)
     {
         auto cb = begin_callback();
         _callback(std::move(f), env);
     }
+    callback_invocation_holder matcher::begin_callback()
+    {
+        return{ _callback_inflight.allocate(), &_callback_inflight };
+    }
+
+    std::string matcher::get_name() const
+    {
+        return _name;
+    }
+
+    bool matcher::get_active() const
+    {
+        return _active;
+    }
+
+    void matcher::set_active(const bool active)
+    {
+        _active = active;
+    }
+
+    const std::vector<stream_id>& matcher::get_streams() const
+    {
+        return _streams_id;
+    }
+
+    const std::vector<rs2_stream>& matcher::get_streams_types() const
+    {
+        return _streams_type;
+    }
+
+    matcher::~matcher()
+    {
+        _callback_inflight.stop_allocation();
+
+        auto callbacks_inflight = _callback_inflight.get_size();
+        if (callbacks_inflight > 0)
+        {
+            LOG_WARNING(callbacks_inflight << " callbacks are still running on some other threads. Waiting until all callbacks return...");
+        }
+        // wait until user is done with all the stuff he chose to borrow
+        _callback_inflight.wait_until_empty();
+    }
 
     identity_matcher::identity_matcher(stream_id stream, rs2_stream stream_type)
+        :matcher({stream})
     {
-        _stream_id = { stream };
-        _stream_type = { stream_type };
+        _streams_type = {stream_type};
+        _name = "I " + std::string(rs2_stream_to_string(stream_type));
     }
 
     void identity_matcher::dispatch(frame_holder f, syncronization_environment env)
     {
+        std::stringstream s;
+        s <<_name<<"--> "<< f->get_stream()->get_stream_type() << " " << f->get_frame_number() << ", "<<std::fixed<< f->get_frame_timestamp()<<"\n";
+        LOG_DEBUG(s.str());
+
         sync(std::move(f), env);
     }
 
-    const std::vector<stream_id>& identity_matcher::get_streams() const
+    std::string create_composite_name(const std::vector<std::shared_ptr<matcher>>& matchers, std::string name)
     {
-        return  _stream_id;
-    }
+        std::stringstream s;
+        s<<"("<<name;
 
-    const std::vector<rs2_stream>& identity_matcher::get_streams_types() const
-    {
-        return  _stream_type;
+        for (auto&& matcher : matchers)
+        {
+            s<<matcher->get_name()<<" ";
+        }
+        s<<")";
+        return s.str();
     }
-    composite_matcher::composite_matcher(std::vector<std::shared_ptr<matcher>> matchers)
+
+    composite_matcher::composite_matcher(std::vector<std::shared_ptr<matcher>> matchers, std::string name)
     {
         for (auto&& matcher : matchers)
         {
@@ -89,13 +142,27 @@ namespace librealsense
                     sync(std::move(f), env);
                 });
                 _matchers[stream] = matcher;
-                _streams.push_back(stream);
+                _streams_id.push_back(stream);
             }
             for (auto&& stream : matcher->get_streams_types())
             {
                 _streams_type.push_back(stream);
             }
         }
+
+        _name = create_composite_name(matchers, name);
+    }
+
+    void composite_matcher::dispatch(frame_holder f, syncronization_environment env)
+    {
+        std::stringstream s;
+        s <<"DISPATCH "<<_name<<"--> "<< f->get_stream()->get_stream_type() << " " << f->get_frame_number() << ", "<<std::fixed<< f->get_frame_timestamp()<<"\n";
+        LOG_DEBUG(s.str());
+
+        clean_inactive_streams(f);
+        auto matcher = find_matcher(f);
+        update_last_arrived(f, matcher.get());
+        matcher->dispatch(std::move(f), env);
     }
 
     std::shared_ptr<matcher> composite_matcher::find_matcher(const frame_holder& frame)
@@ -128,6 +195,7 @@ namespace librealsense
                 {
                     matcher = dev->create_matcher(frame);
 
+
                     matcher->set_callback([&](frame_holder f, syncronization_environment env)
                     {
                         sync(std::move(f), env);
@@ -140,7 +208,7 @@ namespace librealsense
                             _frames_queue.erase(_matchers[stream].get());
                         }
                         _matchers[stream] = matcher;
-                        _streams.push_back(stream);
+                        _streams_id.push_back(stream);
 
                     }
                     for (auto stream : matcher->get_streams_types())
@@ -153,6 +221,13 @@ namespace librealsense
                         LOG_ERROR("Stream matcher not found! stream=" << rs2_stream_to_string(stream_type));
                     }
                 }
+
+                else if(!matcher->get_active())
+                {
+
+                     matcher->set_active(true);
+                     _frames_queue[matcher.get()].start();
+                }
             }
         }
 
@@ -166,8 +241,8 @@ namespace librealsense
                 {
                     _frames_queue.erase(_matchers[stream_id].get());
                 }
-                _matchers[stream_id] = std::make_shared<identity_matcher>(stream_id, stream_type);
-                _streams.push_back(stream_id);
+                 _matchers[stream_id] = std::make_shared<identity_matcher>(stream_id, stream_type);
+                _streams_id.push_back(stream_id);
                 _streams_type.push_back(stream_type);
                 matcher = _matchers[stream_id];
 
@@ -182,6 +257,10 @@ namespace librealsense
 
     void composite_matcher::sync(frame_holder f, syncronization_environment env)
     {
+        std::stringstream s;
+        s <<"SYNC "<<_name<<"--> "<< f->get_stream()->get_stream_type() << " " << f->get_frame_number() << ", "<<std::fixed<< f->get_frame_timestamp()<<"\n";
+        LOG_DEBUG(s.str());
+
         update_next_expected(f);
         auto matcher = find_matcher(f);
         _frames_queue[matcher.get()].enqueue(std::move(f));
@@ -190,7 +269,7 @@ namespace librealsense
         std::vector<librealsense::matcher*> frames_arrived_matchers;
         std::vector<librealsense::matcher*> synced_frames;
         std::vector<librealsense::matcher*> missing_streams;
-        
+
         do
         {
             auto old_frames = false;
@@ -266,8 +345,6 @@ namespace librealsense
                     frame_holder frame;
                     _frames_queue[index].dequeue(&frame);
 
-                    
-
                     match.push_back(std::move(frame));
                 }
 
@@ -297,10 +374,12 @@ namespace librealsense
 
                 }
                 s<<"\n";
-                //LOG_DEBUG(s.str());
+                LOG_DEBUG(s.str());
                 frame_holder composite = env.source->allocate_composite_frame(std::move(match));
                 if (composite.frame)
                 {
+                    s <<"SYNCED "<<_name<<"--> "<< composite->get_stream()->get_stream_type() << " " << composite->get_frame_number() << ", "<<std::fixed<< composite->get_frame_timestamp()<<"\n";
+
                     auto cb = begin_callback();
                     _callback(std::move(composite), env);
                 }
@@ -308,28 +387,14 @@ namespace librealsense
         } while (synced_frames.size() > 0);
     }
 
-    const std::vector<stream_id>& composite_matcher::get_streams() const
-    {
-        return _streams;
-    }
-
-    const std::vector<rs2_stream>& composite_matcher::get_streams_types() const
-    {
-        return _streams_type;
-    }
-
     frame_number_composite_matcher::frame_number_composite_matcher(std::vector<std::shared_ptr<matcher>> matchers)
-        :composite_matcher(matchers)
+        :composite_matcher(matchers, "FN: ")
     {
     }
 
-    void frame_number_composite_matcher::dispatch(frame_holder f, syncronization_environment env)
+    void frame_number_composite_matcher::update_last_arrived(frame_holder& f, matcher* m)
     {
-        auto f1 = f.clone();
-        auto matcher = find_matcher(f);
-        _last_arrived[matcher.get()] =f->get_frame_number();
-        matcher->dispatch(std::move(f), env);
-        clean_dead_streams(f1);
+        _last_arrived[m] =f->get_frame_number();
     }
 
     bool frame_number_composite_matcher::are_equivalent(frame_holder& a, frame_holder& b)
@@ -340,22 +405,21 @@ namespace librealsense
     {
         return a->get_frame_number() < b->get_frame_number();
     }
-    void frame_number_composite_matcher::clean_dead_streams(frame_holder& f)
+    void frame_number_composite_matcher::clean_inactive_streams(frame_holder& f)
     {
-        std::vector<stream_id> dead_matchers;
+        std::vector<stream_id> inactive_matchers;
         for(auto m: _matchers)
         {
             if(_last_arrived[m.second.get()] && (f->get_frame_number() - _last_arrived[m.second.get()]) > 5)
             {
-                dead_matchers.push_back(m.first);
+                inactive_matchers.push_back(m.first);
+                m.second->set_active(false);
             }
         }
 
-        for(auto id: dead_matchers)
+        for(auto id: inactive_matchers)
         {
             _frames_queue[_matchers[id].get()].clear();
-            _frames_queue.erase(_matchers[id].get());
-            _matchers.erase(id);
         }
     }
 
@@ -363,6 +427,9 @@ namespace librealsense
     {
         frame_holder* synced_frame;
 
+         if(!missing->get_active())
+             return true;
+
         _frames_queue[synced[0]].peek(&synced_frame);
 
         auto next_expected = _next_expected[missing];
@@ -392,7 +459,7 @@ namespace librealsense
     }
 
     timestamp_composite_matcher::timestamp_composite_matcher(std::vector<std::shared_ptr<matcher>> matchers)
-        :composite_matcher(matchers)
+        :composite_matcher(matchers, "TS: ")
     {
     }
     bool timestamp_composite_matcher::are_equivalent(frame_holder & a, frame_holder & b)
@@ -419,12 +486,9 @@ namespace librealsense
         return ts.first < ts.second;
     }
 
-    void timestamp_composite_matcher::dispatch(frame_holder f, syncronization_environment env)
+    void timestamp_composite_matcher::update_last_arrived(frame_holder& f, matcher* m)
     {
-        auto matcher = find_matcher(f);
-        _last_arrived[matcher.get()] = std::chrono::duration<double, std::milli>(std::chrono::system_clock::now().time_since_epoch()).count();
-        matcher->dispatch(std::move(f), env);
-        clean_dead_streams(f);
+        _last_arrived[m] = std::chrono::duration<double, std::milli>(std::chrono::system_clock::now().time_since_epoch()).count();
     }
 
     void timestamp_composite_matcher::update_next_expected(const frame_holder & f)
@@ -438,7 +502,7 @@ namespace librealsense
         _next_expected_domain[matcher.get()] = f.frame->get_frame_timestamp_domain();
     }
 
-    void timestamp_composite_matcher::clean_dead_streams(frame_holder& f)
+    void timestamp_composite_matcher::clean_inactive_streams(frame_holder& f)
     {
         std::vector<stream_id> dead_matchers;
         auto now = std::chrono::duration<double, std::milli>(std::chrono::system_clock::now().time_since_epoch()).count();
@@ -447,6 +511,7 @@ namespace librealsense
             if(_last_arrived[m.second.get()] && (now - _last_arrived[m.second.get()]) > 500)
             {
                 dead_matchers.push_back(m.first);
+                m.second->set_active(false);
             }
         }
 
@@ -454,12 +519,14 @@ namespace librealsense
         {
             _frames_queue[_matchers[id].get()].clear();
             _frames_queue.erase(_matchers[id].get());
-            _matchers.erase(id);
         }
     }
 
     bool timestamp_composite_matcher::skip_missing_stream(std::vector<matcher*> synced, matcher* missing)
     {
+        if(!missing->get_active())
+            return true;
+
         frame_holder* synced_frame;
 
         _frames_queue[synced[0]].peek(&synced_frame);
diff --git a/src/sync.h b/src/sync.h
index 9d6a4b1b35..4ccd4c87e6 100644
--- a/src/sync.h
+++ b/src/sync.h
@@ -2,6 +2,7 @@
 // Copyright(c) 2015 Intel Corporation. All Rights Reserved.
 
 #pragma once
+
 #include "types.h"
 #include "archive.h"
 
@@ -14,6 +15,14 @@
 namespace librealsense
 {
 
+    typedef int stream_id;
+    inline std::string generate_matcher_name(rs2_stream stream_type, stream_id stream)
+    {
+        std::stringstream s;
+        s<<rs2_stream_to_string(stream_type) << " "/*<<stream*/;
+        return s.str();
+    }
+
     template<class T>
     class internal_frame_processor_callback : public rs2_frame_processor_callback
     {
@@ -73,41 +82,42 @@ namespace librealsense
         single_consumer_queue<frame_holder>& matches;
     };
 
-
-    typedef int stream_id;
     typedef std::function<void(frame_holder, syncronization_environment)> sync_callback;
 
-    class matcher
+    class matcher_interface
     {
     public:
-        matcher();
-
         virtual void dispatch(frame_holder f, syncronization_environment env) = 0;
-        virtual void sync(frame_holder f, syncronization_environment env);
-        virtual void set_callback(sync_callback f);
+        virtual void sync(frame_holder f, syncronization_environment env) = 0;
+        virtual void set_callback(sync_callback f) = 0;
         virtual const std::vector<stream_id>& get_streams() const = 0;
         virtual const std::vector<rs2_stream>& get_streams_types() const = 0;
+        virtual std::string get_name() const = 0;
+    };
 
-        callback_invocation_holder begin_callback()
-        {
-            return{ _callback_inflight.allocate(), &_callback_inflight };
-        }
+    class matcher: public matcher_interface
+    {
+    public:
+        matcher(std::vector<stream_id> streams_id = {});
+        virtual void sync(frame_holder f, syncronization_environment env);
+        virtual void set_callback(sync_callback f);
+        const std::vector<stream_id>& get_streams() const override;
+        const std::vector<rs2_stream>& get_streams_types() const override;
 
-        virtual ~matcher()
-        {
-            _callback_inflight.stop_allocation();
+        callback_invocation_holder begin_callback();
+        virtual ~matcher();
+
+        virtual std::string get_name() const;
+        bool get_active() const;
+        void set_active(const bool active);
 
-            auto callbacks_inflight = _callback_inflight.get_size();
-            if (callbacks_inflight > 0)
-            {
-                LOG_WARNING(callbacks_inflight << " callbacks are still running on some other threads. Waiting until all callbacks return...");
-            }
-            // wait until user is done with all the stuff he chose to borrow
-            _callback_inflight.wait_until_empty();
-        }
     protected:
-        sync_callback _callback;
-        callbacks_heap _callback_inflight;
+       std::vector<stream_id> _streams_id;
+       std::vector<rs2_stream> _streams_type;
+       sync_callback _callback;
+       callbacks_heap _callback_inflight;
+       std::string _name;
+       bool _active = true;
     };
 
     class identity_matcher : public matcher
@@ -116,34 +126,28 @@ namespace librealsense
         identity_matcher(stream_id stream, rs2_stream streams_type);
 
         void dispatch(frame_holder f, syncronization_environment env) override;
-        const std::vector<stream_id>& get_streams() const override;
-        const std::vector<rs2_stream>& get_streams_types() const override;
+
 
     private:
-        std::vector<stream_id> _stream_id;
-        std::vector<rs2_stream> _stream_type;
+        rs2_stream _streams_type;
     };
 
     class composite_matcher : public matcher
     {
     public:
-        composite_matcher(std::vector<std::shared_ptr<matcher>> matchers);
+        composite_matcher(std::vector<std::shared_ptr<matcher>> matchers, std::string name);
+
 
+        virtual bool are_equivalent(frame_holder& a, frame_holder& b) = 0;
+        virtual bool is_smaller_than(frame_holder& a, frame_holder& b) = 0;
+        virtual bool skip_missing_stream(std::vector<matcher*> synced, matcher* missing)  = 0;
+        virtual void clean_inactive_streams(frame_holder& f) = 0;
+        virtual void update_last_arrived(frame_holder& f, matcher* m) = 0;
 
-        virtual bool are_equivalent(frame_holder& a, frame_holder& b) { return true; };
-        virtual bool is_smaller_than(frame_holder& a, frame_holder& b) { return true; };
-        virtual bool skip_missing_stream(std::vector<matcher*> synced, matcher* missing) { return false; };
-        virtual void clean_dead_streams(frame_holder& f) = 0;
+        void dispatch(frame_holder f, syncronization_environment env) override;
         void sync(frame_holder f, syncronization_environment env) override;
-        const std::vector<stream_id>& get_streams() const override;
-        const std::vector<rs2_stream>& get_streams_types() const override;
         std::shared_ptr<matcher> find_matcher(const frame_holder& f);
 
-    private:
-        std::vector<stream_id> _streams;
-        std::vector<rs2_stream> _streams_type;
-
-
     protected:
         virtual void update_next_expected(const frame_holder& f) = 0;
 
@@ -157,11 +161,11 @@ namespace librealsense
     {
     public:
         frame_number_composite_matcher(std::vector<std::shared_ptr<matcher>> matchers);
-        void dispatch(frame_holder f, syncronization_environment env) override;
+        virtual void update_last_arrived(frame_holder& f, matcher* m) override;
         bool are_equivalent(frame_holder& a, frame_holder& b) override;
         bool is_smaller_than(frame_holder& a, frame_holder& b) override;
         bool skip_missing_stream(std::vector<matcher*> synced, matcher* missing) override;
-        void clean_dead_streams(frame_holder& f) override;
+        void clean_inactive_streams(frame_holder& f) override;
         void update_next_expected(const frame_holder& f) override;
 
     private:
@@ -174,8 +178,8 @@ namespace librealsense
         timestamp_composite_matcher(std::vector<std::shared_ptr<matcher>> matchers);
         bool are_equivalent(frame_holder& a, frame_holder& b) override;
         bool is_smaller_than(frame_holder& a, frame_holder& b) override;
-        void dispatch(frame_holder f, syncronization_environment env) override;
-        void clean_dead_streams(frame_holder& f) override;
+        virtual void update_last_arrived(frame_holder& f, matcher* m) override;
+        void clean_inactive_streams(frame_holder& f) override;
         bool skip_missing_stream(std::vector<matcher*> synced, matcher* missing) override;
         void update_next_expected(const frame_holder & f) override;
 
@@ -197,6 +201,6 @@ namespace librealsense
     private:
         std::unique_ptr<timestamp_composite_matcher> _matcher;
         std::mutex _mutex;
-        
+
     };
 }
diff --git a/src/win/win-helpers.cpp b/src/win/win-helpers.cpp
index 5ac370c49b..ae27dc7c15 100644
--- a/src/win/win-helpers.cpp
+++ b/src/win/win-helpers.cpp
@@ -732,7 +732,7 @@ namespace librealsense
         {
             if (!try_lock())
             {
-                throw std::runtime_error("Aquire failed!");
+                throw std::runtime_error("Acquire failed!");
             }
         }
 
diff --git a/src/win/win-uvc.cpp b/src/win/win-uvc.cpp
index f57fd76890..7ec4044853 100644
--- a/src/win/win-uvc.cpp
+++ b/src/win/win-uvc.cpp
@@ -692,46 +692,50 @@ namespace librealsense
 
         void wmf_uvc_device::foreach_uvc_device(enumeration_callback action)
         {
-            CComPtr<IMFAttributes> pAttributes = nullptr;
-            CHECK_HR(MFCreateAttributes(&pAttributes, 1));
-            CHECK_HR(pAttributes->SetGUID(
-                MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE,
-                MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID));
-
-            IMFActivate ** ppDevices;
-            UINT32 numDevices;
-            CHECK_HR(MFEnumDeviceSources(pAttributes, &ppDevices, &numDevices));
-
-            for (UINT32 i = 0; i < numDevices; ++i)
+            for (auto attributes_params_set : attributes_params)
             {
-                CComPtr<IMFActivate> pDevice;
-                *&pDevice = ppDevices[i];
-
-                WCHAR * wchar_name = nullptr; UINT32 length;
-                CHECK_HR(pDevice->GetAllocatedString(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, &wchar_name, &length));
-                auto name = win_to_utf(wchar_name);
-                CoTaskMemFree(wchar_name);
-
-                uint16_t vid, pid, mi; std::string unique_id;
-                if (!parse_usb_path(vid, pid, mi, unique_id, name)) continue;
-
-                uvc_device_info info;
-                info.vid = vid;
-                info.pid = pid;
-                info.unique_id = unique_id;
-                info.mi = mi;
-                info.device_path = name;
-                try
+                CComPtr<IMFAttributes> pAttributes = nullptr;
+                CHECK_HR(MFCreateAttributes(&pAttributes, 1));
+                for (auto attribute_params : attributes_params_set)
                 {
-                    action(info, ppDevices[i]);
+                    CHECK_HR(pAttributes->SetGUID(attribute_params.first, attribute_params.second));
                 }
-                catch (...)
+
+                IMFActivate ** ppDevices;
+                UINT32 numDevices;
+                CHECK_HR(MFEnumDeviceSources(pAttributes, &ppDevices, &numDevices));
+
+                for (UINT32 i = 0; i < numDevices; ++i)
                 {
-                    // TODO
+                    CComPtr<IMFActivate> pDevice;
+                    *&pDevice = ppDevices[i];
+
+                    WCHAR * wchar_name = nullptr; UINT32 length;
+                    CHECK_HR(pDevice->GetAllocatedString(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, &wchar_name, &length));
+                    auto name = win_to_utf(wchar_name);
+                    CoTaskMemFree(wchar_name);
+
+                    uint16_t vid, pid, mi; std::string unique_id;
+                    if (!parse_usb_path(vid, pid, mi, unique_id, name)) continue;
+
+                    uvc_device_info info;
+                    info.vid = vid;
+                    info.pid = pid;
+                    info.unique_id = unique_id;
+                    info.mi = mi;
+                    info.device_path = name;
+                    try
+                    {
+                        action(info, ppDevices[i]);
+                    }
+                    catch (...)
+                    {
+                        // TODO
+                    }
                 }
-            }
 
-            CoTaskMemFree(ppDevices);
+                CoTaskMemFree(ppDevices);
+            }
         }
 
         void wmf_uvc_device::set_power_state(power_state state)
@@ -982,7 +986,7 @@ namespace librealsense
             }
         }
 
-        void wmf_uvc_device::probe_and_commit( stream_profile profile, bool zero_copy,  frame_callback callback, int /*buffers*/)
+        void wmf_uvc_device::probe_and_commit(stream_profile profile, frame_callback callback, int /*buffers*/)
         {
             if (_streaming)
                 throw std::runtime_error("Device is already streaming!");
diff --git a/src/win/win-uvc.h b/src/win/win-uvc.h
index 603531aba5..f7b3655945 100644
--- a/src/win/win-uvc.h
+++ b/src/win/win-uvc.h
@@ -15,6 +15,22 @@
 #include <mutex>
 #include <atomic>
 
+#ifndef KSCATEGORY_SENSOR_CAMERA
+DEFINE_GUIDSTRUCT("24E552D7-6523-47F7-A647-D3465BF1F5CA", KSCATEGORY_SENSOR_CAMERA);
+#define KSCATEGORY_SENSOR_CAMERA DEFINE_GUIDNAMED(KSCATEGORY_SENSOR_CAMERA)
+#endif // !KSCATEGORY_SENSOR_CAMERA
+
+
+static const std::vector<std::vector<std::pair<GUID, GUID>>> attributes_params = {
+    {
+        { MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID },
+        { MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_CATEGORY, KSCATEGORY_SENSOR_CAMERA }
+    },
+    {
+        { MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID }
+    },
+};
+
 namespace librealsense
 {
     namespace platform
@@ -37,7 +53,7 @@ namespace librealsense
             wmf_uvc_device(const uvc_device_info& info, std::shared_ptr<const wmf_backend> backend);
             ~wmf_uvc_device();
 
-            void probe_and_commit( stream_profile profile, bool zero_copy,  frame_callback callback, int buffers) override;
+            void probe_and_commit(stream_profile profile, frame_callback callback, int buffers) override;
             void stream_on(std::function<void(const notification& n)> error_handler = [](const notification& n){}) override;
             void start_callbacks() override;
             void stop_callbacks() override;
diff --git a/tools/depth-quality/depth-metrics.h b/tools/depth-quality/depth-metrics.h
index 087ad49e7d..0c1595405b 100644
--- a/tools/depth-quality/depth-metrics.h
+++ b/tools/depth-quality/depth-metrics.h
@@ -1,3 +1,8 @@
+// License: Apache 2.0. See LICENSE file in root directory.
+// Copyright(c) 2017 Intel Corporation. All Rights Reserved.
+//
+// Plane Fit implementation follows http://www.ilikebigbits.com/blog/2015/3/2/plane-from-points algorithm
+
 #pragma once
 #include <vector>
 #include <mutex>
@@ -29,11 +34,13 @@ namespace rs2
 
         using callback_type = std::function<void(
             const std::vector<rs2::float3>& points,
-            const plane p, 
+            const plane p,
             const rs2::region_of_interest roi,
-            const float baseline_mm, 
-            const float focal_length_pixels, 
-            const float* ground_thruth_mm)>;
+            const float baseline_mm,
+            const float focal_length_pixels,
+            const int ground_thruth_mm,
+            const bool plane_fit,
+            const float plane_fit_to_ground_truth_mm)>;
 
         inline plane plane_from_point_and_normal(const rs2::float3& point, const rs2::float3& normal)
         {
@@ -90,14 +97,14 @@ namespace rs2
             return plane_from_point_and_normal(centroid, dir.normalize());
         }
 
-        inline double evaluate_pixel(const plane& p, const rs2_intrinsics* intrin, int x, int y, float distance, float3& output)
+        inline double evaluate_pixel(const plane& p, const rs2_intrinsics* intrin, float x, float y, float distance, float3& output)
         {
-            float pixel[2] = { float(x), float(y) };
+            float pixel[2] = { x, y };
             rs2_deproject_pixel_to_point(&output.x, intrin, pixel, distance);
             return evaluate_plane(p, output);
         }
 
-        inline float3 approximate_intersection(const plane& p, const rs2_intrinsics* intrin, int x, int y, float min, float max)
+        inline float3 approximate_intersection(const plane& p, const rs2_intrinsics* intrin, float x, float y, float min, float max)
         {
             float3 point;
             auto far = evaluate_pixel(p, intrin, x, y, max, point);
@@ -111,7 +118,7 @@ namespace rs2
             return approximate_intersection(p, intrin, x, y, avg, max);
         }
 
-        inline float3 approximate_intersection(const plane& p, const rs2_intrinsics* intrin, int x, int y)
+        inline float3 approximate_intersection(const plane& p, const rs2_intrinsics* intrin, float x, float y)
         {
             return approximate_intersection(p, intrin, x, y, 0.f, 1000.f);
         }
@@ -121,7 +128,8 @@ namespace rs2
             float units, float baseline_mm,
             const rs2_intrinsics * intrin,
             rs2::region_of_interest roi,
-            const float* ground_thruth,
+            const int ground_truth_mm,
+            bool plane_fit_present,
             callback_type callback)
         {
             auto pixels = (const uint16_t*)frame.get_data();
@@ -149,7 +157,6 @@ namespace rs2
 
                         rs2_deproject_pixel_to_point(point, intrin, pixel, distance);
 
-
                         std::lock_guard<std::mutex> lock(m);
                         roi_pixels.push_back({ point[0], point[1], point[2] });
                     }
@@ -161,19 +168,24 @@ namespace rs2
 
             plane p = plane_from_points(roi_pixels);
 
-            if (p == plane{ 0, 0, 0, 0 }) { // The points in RoI don't span a plane
+            if (p == plane{ 0, 0, 0, 0 }) { // The points in RoI don't span a valid plane
                 return result;
             }
 
-            callback(roi_pixels, p, roi, baseline_mm, intrin->fx, ground_thruth);
+            // Calculate intersection point of the camera's optical axis with the plane fit in camera's CS
+            float3 plane_fit_pivot = approximate_intersection(p, intrin, intrin->ppx, intrin->ppy);
+            // Find the distance between the "rectified" fit and the ground truth planes.
+            float plane_fit_to_gt_dist_mm = (ground_truth_mm > 0.f) ? (plane_fit_pivot.z * 1000 - ground_truth_mm): 0;
+
+            callback(roi_pixels, p, roi, baseline_mm, intrin->fx, ground_truth_mm, (plane_fit_present > 0), plane_fit_to_gt_dist_mm);
             result.p = p;
-            result.plane_corners[0] = approximate_intersection(p, intrin, roi.min_x, roi.min_y);
-            result.plane_corners[1] = approximate_intersection(p, intrin, roi.max_x, roi.min_y);
-            result.plane_corners[2] = approximate_intersection(p, intrin, roi.max_x, roi.max_y);
-            result.plane_corners[3] = approximate_intersection(p, intrin, roi.min_x, roi.max_y);
+            result.plane_corners[0] = approximate_intersection(p, intrin, float(roi.min_x), float(roi.min_y));
+            result.plane_corners[1] = approximate_intersection(p, intrin, float(roi.max_x), float(roi.min_y));
+            result.plane_corners[2] = approximate_intersection(p, intrin, float(roi.max_x), float(roi.max_y));
+            result.plane_corners[3] = approximate_intersection(p, intrin, float(roi.min_x), float(roi.max_y));
 
             // Distance of origin (the camera) from the plane is encoded in parameter D of the plane
-            result.distance = static_cast<float>(-p.d * 1000);
+            result.distance = is_valid(result.plane_corners) ? static_cast<float>(-p.d * 1000) : -1;
             // Angle can be calculated from param C
             result.angle = static_cast<float>(std::acos(std::abs(p.c)) / M_PI * 180.);
 
diff --git a/tools/depth-quality/depth-quality-model.cpp b/tools/depth-quality/depth-quality-model.cpp
index 9ae6bc9a80..e65ef41611 100644
--- a/tools/depth-quality/depth-quality-model.cpp
+++ b/tools/depth-quality/depth-quality-model.cpp
@@ -12,10 +12,10 @@ namespace rs2
               _roi_located(std::chrono::seconds(4)),
               _too_close(std::chrono::seconds(4)),
               _too_far(std::chrono::seconds(4)),
-              _sku_right(std::chrono::seconds(1)),
-              _sku_left(std::chrono::seconds(1)),
-              _sku_up(std::chrono::seconds(1)),
-              _sku_down(std::chrono::seconds(1)),
+              _skew_right(std::chrono::seconds(1)),
+              _skew_left(std::chrono::seconds(1)),
+              _skew_up(std::chrono::seconds(1)),
+              _skew_down(std::chrono::seconds(1)),
               _angle_alert(std::chrono::seconds(4)),
               _min_dist(300.f), _max_dist(2000.f), _max_angle(10.f)
         {
@@ -23,6 +23,8 @@ namespace rs2
             _viewer_model.allow_3d_source_change = false;
             _viewer_model.allow_stream_close = false;
             _viewer_model.draw_plane = true;
+            _viewer_model.synchronization_enable = false;
+            _viewer_model.support_non_syncronized_mode = false; //pipeline outputs only syncronized frameset
         }
 
         bool tool_model::start(ux_window& window)
@@ -46,8 +48,18 @@ namespace rs2
             {
                 if (valid_config = cfg.can_resolve(_pipe))
                 {
-                    _pipe.start(cfg);
-                    break;
+                    try {
+                        _pipe.start(cfg);
+                        break;
+                    }
+                    catch (...)
+                    {
+                        if (!_device_in_use)
+                        {
+                            window.add_on_load_message("Device is not functional or busy!");
+                            _device_in_use = true;
+                        }
+                    }
                 }
             }
 
@@ -120,7 +132,9 @@ namespace rs2
 
         bool tool_model::draw_instructions(ux_window& win, const rect& viewer_rect, bool& distance, bool& orientation)
         {
-            _roi_located.add_value(is_valid(_metrics_model.get_plane()));
+            auto plane_fit_found = is_valid(_metrics_model.get_plane());
+            _metrics_model.set_plane_fit(plane_fit_found);
+            _roi_located.add_value(plane_fit_found);
             if (!_roi_located.eval())
             {
                 draw_notification(win, viewer_rect, 450,
@@ -135,16 +149,16 @@ namespace rs2
                 orientation = true;
             }
 
-            _sku_right.add_value(orientation && _metrics_model.get_last_metrics().angle_x > 0.f
+            _skew_right.add_value(orientation && _metrics_model.get_last_metrics().angle_x > 0.f
                 && fabs(_metrics_model.get_last_metrics().angle_x) > fabs(_metrics_model.get_last_metrics().angle_y));
 
-            _sku_left.add_value(orientation && _metrics_model.get_last_metrics().angle_x < 0.f
+            _skew_left.add_value(orientation && _metrics_model.get_last_metrics().angle_x < 0.f
                 && fabs(_metrics_model.get_last_metrics().angle_x) > fabs(_metrics_model.get_last_metrics().angle_y));
 
-            _sku_up.add_value(orientation && _metrics_model.get_last_metrics().angle_y < 0.f
+            _skew_up.add_value(orientation && _metrics_model.get_last_metrics().angle_y < 0.f
                 && fabs(_metrics_model.get_last_metrics().angle_x) <= fabs(_metrics_model.get_last_metrics().angle_y));
 
-            _sku_down.add_value(orientation && _metrics_model.get_last_metrics().angle_y > 0.f
+            _skew_down.add_value(orientation && _metrics_model.get_last_metrics().angle_y > 0.f
                 && fabs(_metrics_model.get_last_metrics().angle_x) <= fabs(_metrics_model.get_last_metrics().angle_y));
 
             _too_close.add_value(_metrics_model.get_last_metrics().distance < _min_dist);
@@ -153,7 +167,7 @@ namespace rs2
             constexpr const char* orientation_instruction = "                         Recommended angle: < 3 degrees"; // "             Use the orientation gimbal to align the camera";
             constexpr const char* distance_instruction    = "          Recommended distance: 0.3m-2m from the target"; // "             Use the distance locator to position the camera";
 
-            if (_sku_right.eval())
+            if (_skew_right.eval())
             {
                 draw_notification(win, viewer_rect, 400,
                     u8"\n          \uf061  Rotate the camera slightly Right",
@@ -161,7 +175,7 @@ namespace rs2
                 return false;
             }
 
-            if (_sku_left.eval())
+            if (_skew_left.eval())
             {
                 draw_notification(win, viewer_rect, 400,
                     u8"\n           \uf060  Rotate the camera slightly Left",
@@ -169,7 +183,7 @@ namespace rs2
                 return false;
             }
 
-            if (_sku_up.eval())
+            if (_skew_up.eval())
             {
                 draw_notification(win, viewer_rect, 400,
                     u8"\n            \uf062  Rotate the camera slightly Up",
@@ -177,7 +191,7 @@ namespace rs2
                 return false;
             }
 
-            if (_sku_down.eval())
+            if (_skew_down.eval())
             {
                 draw_notification(win, viewer_rect, 400,
                     u8"\n          \uf063  Rotate the camera slightly Down",
@@ -273,20 +287,20 @@ namespace rs2
             for (int i = 2; i < 7; i += 1)
             {
                 auto t = (animation_clock.elapsed_ms() / 500) * M_PI - i * (M_PI / 5);
-                auto alpha = (1.f + sin(t)) / 2.f;
+                float alpha = (1.f + float(sin(t))) / 2.f;
 
                 auto c = blend(grey, (1.f - float(i)/7.f)*fade_factor);
                 if (orientation_guide) c = blend(light_blue, alpha);
 
                 ImGui::GetWindowDrawList()->AddCircle(
-                { pos1.x + 41 - 2 * i * prev_x, pos1.y + 40 - 2 * i * prev_y }, 40 - i*i,
+                { pos1.x + 41 - 2 * i * prev_x, pos1.y + 40 - 2 * i * prev_y }, 40.f - i*i,
                     ImColor(c), 64);
             }
 
             if (angle < 50)
             {
                 ImGui::GetWindowDrawList()->AddCircleFilled(
-                { pos1.x + 41 + 70 * prev_x, pos1.y + 40 + 70 * prev_y }, 10,
+                { pos1.x + 41 + 70 * prev_x, pos1.y + 40 + 70 * prev_y }, 10.f,
                     ImColor(blend(grey, orientation_guide ? 1.f : fade_factor)), 64);
             }
 
@@ -310,7 +324,7 @@ namespace rs2
                     auto min_y = pos1.y + 10;
                     auto max_y = window_h + window_y;
                     int bar_spacing = 15;
-                    int parts = (max_y - min_y) / bar_spacing;
+                    int parts = int(max_y - min_y) / bar_spacing;
 
                     ImGui::GetWindowDrawList()->AddRect(
                     { pos1.x + 1, pos1.y },
@@ -343,7 +357,7 @@ namespace rs2
                             for (int j = -2; j < 2; j++)
                             {
                                 auto yc = yellow;
-                                auto factor = (1 - fabs(j) / 3);
+                                auto factor = (1 - abs(j) / 3.f);
                                 yc = blend(yc, factor*factor);
                                 if (!distance_guide) yc = blend(yc, fade_factor);
                                 ImGui::GetWindowDrawList()->AddRectFilled(
@@ -356,7 +370,7 @@ namespace rs2
                                 for (int j = 1; j < 5; j++)
                                 {
                                     auto t = (animation_clock.elapsed_ms() / 500) * M_PI - j * (M_PI / 5);
-                                    auto alpha = (1.f + sin(t)) / 2.f;
+                                    auto alpha = (1 + float(sin(t))) / 2.f;
 
                                     ImGui::SetCursorPos({ pos.x + 57, pos.y + bar_spacing * (i - j) + 14 });
                                     ImGui::PushStyleColor(ImGuiCol_Text,
@@ -371,7 +385,7 @@ namespace rs2
                                 for (int j = 1; j < 5; j++)
                                 {
                                     auto t = (animation_clock.elapsed_ms() / 500) * M_PI - j * (M_PI / 5);
-                                    auto alpha = (1.f + sin(t)) / 2.f;
+                                    auto alpha = (1.f + float(sin(t))) / 2.f;
 
                                     ImGui::SetCursorPos({ pos.x + 57, pos.y + bar_spacing * (i + j) + 14 });
                                     ImGui::PushStyleColor(ImGuiCol_Text,
@@ -414,7 +428,6 @@ namespace rs2
             bool distance_guide = false;
             bool orientation_guide = false;
             bool found = draw_instructions(win, viewer_rect, distance_guide, orientation_guide);
-            //draw_guides(win, viewer_rect, distance_guide, orientation_guide);
 
             ImGui::PushStyleColor(ImGuiCol_WindowBg, button_color);
             ImGui::SetNextWindowPos({ 0, 0 });
@@ -481,7 +494,7 @@ namespace rs2
                                 cfg.enable_stream(secondary.stream_type(), secondary.stream_index(),
                                     primary.width(), primary.height(), secondary.format(), primary.fps());
 
-                                // Wait till a valid device is found and responsive
+                                // Wait till a valid device is registered and responsive
                                 bool success = false;
                                 do
                                 {
@@ -565,7 +578,7 @@ namespace rs2
                         }
                         else
                         {
-                            _ground_truth = _metrics_model.get_last_metrics().distance;
+                            _ground_truth = int(_metrics_model.get_last_metrics().distance);
                             ImGui::Dummy({ 1,1 });
                         }
                         ImGui::PopStyleColor();
@@ -590,7 +603,7 @@ namespace rs2
                     ImGui::PopStyleVar();
                     ImGui::PushStyleVar(ImGuiStyleVar_ItemInnerSpacing, { 0, 0 });
 
-                    if (found && ImGui::TreeNodeEx("Metrics", ImGuiTreeNodeFlags_DefaultOpen))
+                    if (ImGui::TreeNodeEx("Metrics", ImGuiTreeNodeFlags_DefaultOpen))
                     {
                         ImGui::PopStyleVar();
                         ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, { 2, 2 });
@@ -748,6 +761,7 @@ namespace rs2
             }
             catch(...){}
 
+            _device_in_use = false;
             _first_frame = true;
             win.reset();
         }
@@ -834,7 +848,12 @@ namespace rs2
 
         metrics_model::metrics_model() :
             _frame_queue(1),
-            _depth_scale_units(0.f), _active(true)
+            _depth_scale_units(0.f),
+            _stereo_baseline_mm(0.f),
+            _ground_truth_mm(0),
+            _use_gt(false),
+            _plane_fit(false),
+            _active(true)
         {
             _worker_thread = std::thread([this]() {
                 while (_active)
@@ -852,6 +871,8 @@ namespace rs2
                     {
                         float su = 0, baseline = -1.f;
                         rs2_intrinsics intrin;
+                        int gt_mm;
+                        bool plane_fit_set;
                         region_of_interest roi;
                         {
                             std::lock_guard<std::mutex> lock(_m);
@@ -861,9 +882,8 @@ namespace rs2
                             roi = _roi;
                         }
 
-                        _ground_truth_copy = get_ground_truth(); // Copy the mutable GT into a "safe" copy variable
-                        auto gt_ptr = _use_gt ? &_ground_truth_copy : nullptr; // Borrow copy ptr to the callback
-                        auto metrics = analyze_depth_image(depth_frame, su, baseline, &intrin, roi, gt_ptr, callback);
+                        std::tie(gt_mm, plane_fit_set) = get_inputs();
+                        auto metrics = analyze_depth_image(depth_frame, su, baseline, &intrin, roi, gt_mm, plane_fit_set,callback);
 
                         {
                             std::lock_guard<std::mutex> lock(_m);
@@ -886,11 +906,11 @@ namespace rs2
         }
 
         std::shared_ptr<metric_plot> tool_model::make_metric(
-            const std::string& name, float min, float max,
+            const std::string& name, float min, float max, const bool requires_plane_fit,
             const std::string& units,
             const std::string& description)
         {
-            auto res = std::make_shared<metric_plot>(name, min, max, units, description);
+            auto res = std::make_shared<metric_plot>(name, min, max, units, description, requires_plane_fit);
             _metrics_model.add_metric(res);
             return res;
         }
@@ -1018,7 +1038,7 @@ namespace rs2
                     _description.size() + 1, desc_size, ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_ReadOnly);
                 ImGui::PopStyleColor(3);
 
-                ImGui::PlotLines(_id.c_str(), (float*)&_vals, SIZE, _idx, ss.str().c_str(), _min, _max, { 270, 50 });
+                ImGui::PlotLines(_id.c_str(), (float*)&_vals, int(SIZE), int(_idx), ss.str().c_str(), _min, _max, { 270, 50 });
 
                 ImGui::TreePop();
             }
@@ -1037,7 +1057,7 @@ namespace rs2
 
         void metrics_model::serialize_to_csv(const std::string& filename, const std::string& camera_info) const
         {
-            // RAII
+            // TODO RAII
             std::ofstream csv;
 
             csv.open(filename);
@@ -1045,7 +1065,11 @@ namespace rs2
             // Store the device info and the streaming profile details
             csv << camera_info;
 
-            // Create header line
+            //Store metric environment
+            csv << "\nEnvironment:\nPlane-Fit_distance_mm," << (_plane_fit ? std::to_string(_latest_metrics.distance) : "N/A") << std::endl;
+            csv << "Ground-Truth_Distance_mm," << (_use_gt ? std::to_string(_ground_truth_mm ) : "N/A") << std::endl;
+
+            // Generate columns header
             csv << "\nSample Id,Timestamp (ms),";
             for (auto&& plot : _plots)
             {
@@ -1053,7 +1077,7 @@ namespace rs2
             }
             csv << std::endl;
 
-            // Populate the metrics data
+            // Populate metrics data using the fill-rate persistent metric as pivot
             for (size_t i = _plots[0]->_first_idx, rec = 0; i != _plots[0]->_idx; i = (++i) % metric_plot::SIZE)
             {
                 csv << ++rec << "," << std::fixed << std::setprecision(4) << _plots[0]->_timestamps[i] << ",";
diff --git a/tools/depth-quality/depth-quality-model.h b/tools/depth-quality/depth-quality-model.h
index 89ed013909..956f8ae1e4 100644
--- a/tools/depth-quality/depth-quality-model.h
+++ b/tools/depth-quality/depth-quality-model.h
@@ -6,6 +6,7 @@
 #include "model-views.h"
 #include "ux-window.h"
 
+#include <tuple>
 #include <vector>
 #include <thread>
 #include <mutex>
@@ -45,10 +46,12 @@ namespace rs2
             }
 
             metric_plot(const std::string& name, float min, float max,
-                        const std::string& units, const std::string& description)
+                        const std::string& units, const std::string& description,
+                        const bool with_plane_fit)
                 : _idx(0), _first_idx(0),_vals(), _min(min), _max(max), _id("##" + name),
                   _label(name + " = "), _name(name),
                   _units(units), _description(description),
+                _visible(true), _requires_plane_fit(with_plane_fit),
                   _trending_up(std::chrono::milliseconds(700)),
                   _trending_down(std::chrono::milliseconds(700))
             {
@@ -68,12 +71,14 @@ namespace rs2
 
             void render(ux_window& win);
 
-            void visible(bool is_visible) 
-            { 
-                std::lock_guard<std::mutex> lock(_m); 
-                _visible = is_visible; 
+            void visible(bool is_visible)
+            {
+                std::lock_guard<std::mutex> lock(_m);
+                _visible = is_visible;
             }
 
+            bool requires_plane_fit() const { return _requires_plane_fit; }
+
         private:
             bool has_trend(bool positive);
 
@@ -84,7 +89,8 @@ namespace rs2
             std::array<double, SIZE> _timestamps;
             float _min, _max;
             std::string _id, _label, _units, _name, _description;
-            bool _visible = true;
+            bool _visible;
+            const bool _requires_plane_fit;
 
             timer _model_timer;
             temporal_event _trending_up;
@@ -143,20 +149,39 @@ namespace rs2
 
             callback_type callback;
 
-            void set_ground_truth(float gt)
+            void set_ground_truth(int gt)
             {
                 std::lock_guard<std::mutex> lock(_m);
-                _ground_truth = gt;
+                _ground_truth_mm = gt;
                 _use_gt = true;
             }
-            void disable_ground_truth() 
+
+            void set_plane_fit(bool found)
+            {
+                std::lock_guard<std::mutex> lock(_m);
+                _plane_fit = found;
+                for (auto&& plot : _plots)
+                {
+                    if (plot->requires_plane_fit())
+                        plot->visible(found);
+                }
+            }
+
+            void disable_ground_truth()
             {
                 std::lock_guard<std::mutex> lock(_m);
-                _use_gt = false; 
+                _use_gt = false;
+                _ground_truth_mm = 0;
+            }
+            std::tuple<int, bool> get_inputs() const
+            {
+                std::lock_guard<std::mutex> lock(_m);
+                return std::make_tuple(_ground_truth_mm, _plane_fit);
             }
-            float get_ground_truth() const { std::lock_guard<std::mutex> lock(_m); return _ground_truth; }
 
-            void reset() {
+            void reset()
+            {
+                _plane_fit = false;
                 rs2::frame f;
                 while (_frame_queue.poll_for_frame(&f));
             }
@@ -170,9 +195,9 @@ namespace rs2
             rs2_intrinsics          _depth_intrinsic;
             float                   _depth_scale_units;
             float                   _stereo_baseline_mm;
-            float                   _ground_truth;
-            float                   _ground_truth_copy;
-            bool                    _use_gt = false;
+            int                     _ground_truth_mm;
+            bool                    _use_gt;
+            bool                    _plane_fit;
             region_of_interest      _roi;
             snapshot_metrics        _latest_metrics;
             bool                    _active;
@@ -203,7 +228,7 @@ namespace rs2
             void draw_guides(ux_window& win, const rect& viewer_rect, bool distance_guide, bool orientation_guide);
 
             std::shared_ptr<metric_plot> make_metric(
-                const std::string& name, float min, float max,
+                const std::string& name, float min, float max, bool plane_fit,
                 const std::string& units,
                 const std::string& description);
 
@@ -222,6 +247,7 @@ namespace rs2
             std::string                     _error_message;
             bool                            _first_frame = true;
             periodic_timer                  _update_readonly_options_timer;
+            bool                            _device_in_use = false;
 
             float                           _roi_percent = 0.4f;
             int                             _roi_combo_index = 2;
@@ -229,10 +255,10 @@ namespace rs2
 
             temporal_event                  _too_far;
             temporal_event                  _too_close;
-            temporal_event                  _sku_left;
-            temporal_event                  _sku_right;
-            temporal_event                  _sku_up;
-            temporal_event                  _sku_down;
+            temporal_event                  _skew_left;
+            temporal_event                  _skew_right;
+            temporal_event                  _skew_up;
+            temporal_event                  _skew_down;
             temporal_event                  _angle_alert;
             std::map<int, temporal_event>   _depth_scale_events;
 
diff --git a/tools/depth-quality/readme.md b/tools/depth-quality/readme.md
index 59326331c3..a9953236f4 100644
--- a/tools/depth-quality/readme.md
+++ b/tools/depth-quality/readme.md
@@ -4,8 +4,8 @@
 
 ## Overview
 
-This application allows you to test the camera’s depth quality, including: average distance to plane accuracy, Z (distance) accuracy and fill rate.
-You should be able to easily get and interpret several of the depth quality metrics and record and save the data for offline analysis.
+This application allows you to test the camera’s depth quality, including: Z-Accuracy, Sub-Pixel and Z RMS errors (spatial noise) and Fill Rate.
+You should be able to easily get and interpret several of the depth quality metrics, or record and save the data for offline analysis.
 
 ## Quick Start
 * Position the depth camera within a range of 0.3 - 2 meter from a flat non-reflective surface.
@@ -19,9 +19,10 @@ You should be able to easily get and interpret several of the depth quality metr
 * User-defined Region of Interest
 * Depth Quality metrics:
   * Z-Accuracy
-  * Depth Error Average
+  * Spatial Noise:
+    * Plane Fit RMS Error
+    * Sub-Pixel RMS Error
   * Fill-Rate
-  * Subpixel RMS
   * Distance to target
 * Export metrics and device configuration
 * Depth Sensor controls
@@ -29,14 +30,11 @@ You should be able to easily get and interpret several of the depth quality metr
 ## Metrics elaborated
 ![](./res/Zi_ZPi.png)
 
-### Depth Error Average
+### Plane Fit RMS Error
 _Dist<sub>i</sub>_ - Distance from pixel coordinates to the Plane Fit (mm)  
-![](./res/avg.gif)
-### Z Accuracy
-_Z<sub>i</sub>_ - Depth value of i-th pixel in the ROI (mm)  
-_GT_ - Ground truth distance to the wall (mm)  
-![](./res/accuracy.gif)
-### Subpixel RMS Metric
+![](./res/z_error_rms.gif)
+
+### Sub-Pixel RMS Error
 _Z<sub>i</sub>_ - Depth value of i-th pixel in the ROI (mm)  
 _ZP<sub>i</sub>_ - Depth value of the i-th pixel projected onto the plane fit (mm)  
 _BL_ - Stereoscopic Baseline (mm)  
@@ -45,8 +43,17 @@ _D<sub>i</sub>_ - Disparity value of i-th pixel in the ROI (pixel)
  _DP<sub>i</sub>_ - Disparity value of i-th plane-projected pixel (pixel)
 
 ![](./res/Di.gif)  ![](./res/DPi.gif)  
-![](./res/rms.gif)
+![](./res/subpixel_rms.gif)
 
+### Z Accuracy
+![](./res/z_accuracy.png)  
+_RotationPivot<sub>x,y,z</sub>_ - Intersection point between the Camera's optical axis (principal point) and the Fitted Plane  
+_PlanesOffset<sub>mm</sub>_ - Distance (signed) from the Fitted to the Ground Truth planes (mm)  
+_D<sub>i</sub>_ - Distance (signed) from pixel coordinates to the Fitted Plane (mm)  
+_D'<sub>i</sub>_ - Distance from the rotated _D<sub>i</sub>_ coordinate to the Ground Truth Plane (mm)  
+_GT_ - Ground Truth distance to the wall (mm)  
+![](./res/z_accuracy_d_rotated.gif)  
+![](./res/z_accuracy_percentage.gif)
 <!---
 Math expressions generated with
 http://www.numberempire.com/texequationeditor/equationeditor.php
@@ -56,4 +63,6 @@ RMS = \sqrt{\frac{\sum_{1}^{n}{\left({D}_{i} -{DP}_{i}\right)}}{n}^{2}}
 AVG = \frac{\sum_{1}^{n}{\left({Dist}_{i}\right)}}{n}
 STD = \sqrt{\frac{\sum_{1}^{n}{\left({Dist}_{i}\right)}}{n}^{2}}  
 ACC = 100 \times median(\frac{\sum_{1}^{n}{\left({Z}_{i}\right - GT)}}{GT})
+{D'}_{mm}={D}_{i} -{Planes Offset}_{mm}
+Z-Accuracy = 100 \times median(\frac{\sum_{1}^{n}{\left({D'}_{i}\right - GT)}}{GT})
 --->
diff --git a/tools/depth-quality/res/DQT_Z_Accuracy.vsdx b/tools/depth-quality/res/DQT_Z_Accuracy.vsdx
new file mode 100644
index 0000000000..ce2935820d
Binary files /dev/null and b/tools/depth-quality/res/DQT_Z_Accuracy.vsdx differ
diff --git a/tools/depth-quality/res/DepthQualityTool.vsdx b/tools/depth-quality/res/DepthQualityTool.vsdx
new file mode 100644
index 0000000000..0f7dac4e18
Binary files /dev/null and b/tools/depth-quality/res/DepthQualityTool.vsdx differ
diff --git a/tools/depth-quality/res/avg.gif b/tools/depth-quality/res/avg.gif
deleted file mode 100644
index 6ed0498299..0000000000
Binary files a/tools/depth-quality/res/avg.gif and /dev/null differ
diff --git a/tools/depth-quality/res/subpixel_rms.gif b/tools/depth-quality/res/subpixel_rms.gif
new file mode 100644
index 0000000000..888d533cdf
Binary files /dev/null and b/tools/depth-quality/res/subpixel_rms.gif differ
diff --git a/tools/depth-quality/res/z_accuracy.png b/tools/depth-quality/res/z_accuracy.png
new file mode 100644
index 0000000000..e9dd9e7375
Binary files /dev/null and b/tools/depth-quality/res/z_accuracy.png differ
diff --git a/tools/depth-quality/res/z_accuracy_d_rotated.gif b/tools/depth-quality/res/z_accuracy_d_rotated.gif
new file mode 100644
index 0000000000..6e7ad0f23f
Binary files /dev/null and b/tools/depth-quality/res/z_accuracy_d_rotated.gif differ
diff --git a/tools/depth-quality/res/z_accuracy_percentage.gif b/tools/depth-quality/res/z_accuracy_percentage.gif
new file mode 100644
index 0000000000..708518dff4
Binary files /dev/null and b/tools/depth-quality/res/z_accuracy_percentage.gif differ
diff --git a/tools/depth-quality/res/z_error_rms.gif b/tools/depth-quality/res/z_error_rms.gif
new file mode 100644
index 0000000000..76dc2f2537
Binary files /dev/null and b/tools/depth-quality/res/z_error_rms.gif differ
diff --git a/tools/depth-quality/rs-depth-quality.cpp b/tools/depth-quality/rs-depth-quality.cpp
index 4ba216a993..f53b8b0421 100644
--- a/tools/depth-quality/rs-depth-quality.cpp
+++ b/tools/depth-quality/rs-depth-quality.cpp
@@ -1,6 +1,7 @@
 // License: Apache 2.0. See LICENSE file in root directory.
 // Copyright(c) 2015 Intel Corporation. All Rights Reserved.
 
+#include <numeric>
 #include <librealsense2/rs.hpp>
 #include "depth-quality-model.h"
 
@@ -14,26 +15,38 @@ int main(int argc, const char * argv[]) try
     // ===============================
     //       Metrics Definitions
     // ===============================
-
-    metric zaccuracy = model.make_metric(
-                       "Z Accuracy", 0, 100, "%",
-                       "Z Accuracy given Ground Truth\n"
-                       "Performed on the depth image in the ROI\n"
-                       "Calculate the depth-errors map\n"
-                       "i.e., Image – GT (signed values).\n"
-                       "Calculate the median of the depth-errors\n");
-
-    metric avg = model.make_metric(
-                 "Average Error", 0, 10, "(mm)",
-                 "Average Distance from Plane Fit\n"
-                 "This metric approximates a plane within\n"
-                 "the ROI and calculates the average\n"
-                 "distance of points in the ROI\n"
-                 "from that plane, in mm");
-
-    metric rms = model.make_metric(
-                 "Subpixel RMS", 0.f, 1.f, "(pixel)",
-                 "Normalized RMS .\n"
+    metric fill = model.make_metric(
+        "Fill-Rate", 0, 100, false, "%",
+        "Fill Rate.\n"
+        "Percentage of pixels with valid depth\n"
+        "values out of all pixels within the ROI\n");
+
+    metric z_accuracy = model.make_metric(
+                "Z Accuracy", -10, 10, true, "%",
+                "Z Accuracy given Ground Truth\n"
+                "Realign the Plane Fit with GT plane\n"
+                "Calculate the depth-errors map\n"
+                "GT-aligned Z values - GT (signed).\n"
+                "Calculate the median of the depth-errors\n"
+                "Positive value indicates the Plane Fit\n"
+                "is further than the Ground Truth\n"
+                "Negative value indicates the Plane Fit\n"
+                "is in front of Ground Truth\n");
+
+    metric plane_fit_rms_error = model.make_metric(
+                "Plane Fit RMS Error", 0.f, 5.f, true, "(mm)",
+                "Plane Fit RMS Error .\n"
+                "This metric calculates RMS of Z-Error (Spatial Noise)\n"
+                "and is calculated as follows:\n"
+                "Zi - depth range of i-th pixel (mm)\n"
+                "Zpi -depth of Zi projection onto plane fit (mm)\n"
+                "               n      \n"
+                "RMS = SQRT((SUM(Zi-Zpi)^2)/n)\n"
+                 "             i=1    ");
+
+    metric sub_pixel_rms_error = model.make_metric(
+                 "Subpixel RMS Error", 0.f, 1.f, true, "(pixel)",
+                 "Subpixel RMS Error .\n"
                  "This metric provides the subpixel accuracy\n"
                  "and is calculated as follows:\n"
                  "Zi - depth range of i-th pixel (mm)\n"
@@ -43,44 +56,54 @@ int main(int argc, const char * argv[]) try
                  "Di = BL*FL/Zi; Dpi = Bl*FL/Zpi\n"
                  "              n      \n"
                  "RMS = SQRT((SUM(Di-Dpi)^2)/n)\n"
-                 "             i=0    ");
-
-    metric fill = model.make_metric(
-                  "Fill-Rate", 0, 100, "%",
-                  "Fill Rate\n"
-                  "Percentage of pixels with valid depth\n"
-                  "values out of all pixels within the ROI\n");
+                 "             i=1    ");
 
     // ===============================
     //       Metrics Calculation
     // ===============================
 
     model.on_frame([&](
-        const std::vector<rs2::float3>& points, 
+        const std::vector<rs2::float3>& points,
         const rs2::plane p,
         const rs2::region_of_interest roi,
-        const float baseline_mm, 
-        const float focal_length_pixels, 
-        const float* ground_truth_mm)
+        const float baseline_mm,
+        const float focal_length_pixels,
+        const int ground_truth_mm,
+        const bool plane_fit,
+        const float plane_fit_to_ground_truth_mm)
     {
-        const float TO_METERS = 0.001f;
-        const float TO_MM = 1000.f;
-        const float TO_PERCENT = 100.f;
+        static const float TO_METERS = 0.001f;
+        static const float TO_MM = 1000.f;
+        static const float TO_PERCENT = 100.f;
+
+        // Calculate fill rate relative to the ROI
+        auto fill_rate = points.size() / float((roi.max_x - roi.min_x)*(roi.max_y - roi.min_y)) * TO_PERCENT;
+        fill->add_value(fill_rate);
+
+        if (!plane_fit) return;
 
         const float bf_factor = baseline_mm * focal_length_pixels * TO_METERS; // also convert point units from mm to meter
 
-        // Calculate the distances of all points in the ROI to the fitted plane
+        std::vector<rs2::float3> points_set = points;
         std::vector<float> distances;
         std::vector<float> disparities;
-        std::vector<float> errors;
+        std::vector<float> gt_errors;
 
         // Reserve memory for the data
         distances.reserve(points.size());
         disparities.reserve(points.size());
-        if (ground_truth_mm) errors.reserve(points.size());
-
-        // Calculate the distance and disparity errors from the point cloud to the fitted plane
-        for (auto point : points)
+        if (ground_truth_mm) gt_errors.reserve(points.size());
+
+        // Remove outliers [below 0.5% and above 99.5%)
+        std::sort(points_set.begin(), points_set.end(), [](const rs2::float3& a, const rs2::float3& b) { return a.z < b.z; });
+        size_t outliers = points_set.size() / 200;
+        points_set.erase(points_set.begin(), points_set.begin() + outliers); // crop min 0.5% of the dataset
+        points_set.resize(points_set.size() - outliers); // crop max 0.5% of the dataset
+
+        // Convert Z values into Depth values by aligning the Fitted plane with the Ground Truth (GT) plane
+        // Calculate distance and disparity of Z values to the fitted plane.
+        // Use the aligned fit to calculate GT errors
+        for (auto point : points_set)
         {
             // Find distance from point to the reconstructed plane
             auto dist2plane = p.a*point.x + p.b*point.y + p.c*point.z + p.d;
@@ -89,41 +112,35 @@ int main(int argc, const char * argv[]) try
                                             float(point.y - dist2plane*p.b),
                                             float(point.z - dist2plane*p.c) };
 
-            // Store distance, disparity and error
-            distances.push_back(std::fabs(dist2plane) * TO_MM);
+            // Store distance, disparity and gt- error
+            distances.push_back(dist2plane * TO_MM);
             disparities.push_back(bf_factor / point.length() - bf_factor / plane_intersect.length());
-            if (ground_truth_mm) errors.push_back(point.z * TO_MM - *ground_truth_mm);
+            if (ground_truth_mm) gt_errors.push_back(plane_fit_to_ground_truth_mm - (dist2plane * TO_MM));
         }
 
         // Show Z accuracy metric only when Ground Truth is available
-        zaccuracy->visible(ground_truth_mm != nullptr);
-        if (ground_truth_mm && *ground_truth_mm > 0)
+        z_accuracy->visible(ground_truth_mm > 0);
+        if (ground_truth_mm)
         {
-            std::sort(begin(errors), end(errors));
-            auto median = errors[errors.size() / 2];
-            auto accuracy = TO_PERCENT * (fabs(median) / *ground_truth_mm);
-            zaccuracy->add_value(accuracy);
+            std::sort(begin(gt_errors), end(gt_errors));
+            auto gt_median = gt_errors[gt_errors.size() / 2];
+            auto accuracy = TO_PERCENT * (gt_median / ground_truth_mm);
+            z_accuracy->add_value(accuracy);
         }
 
-        // Calculate average distance from the plane fit
-        double total_distance = 0;
-        for (auto dist : distances) total_distance += dist;
-        float avg_dist = total_distance / distances.size();
-        avg->add_value(avg_dist);
-
-        // Calculate RMS
+        // Calculate Sub-pixel RMS for Stereo-based Depth sensors
         double total_sq_disparity_diff = 0;
         for (auto disparity : disparities)
         {
             total_sq_disparity_diff += disparity*disparity;
         }
-        // Calculate Subpixel RMS for Stereo-based Depth sensors
-        auto rms_val = static_cast<float>(std::sqrt(total_sq_disparity_diff / points.size()));
-        rms->add_value(rms_val);
+        auto rms_subpixel_val = static_cast<float>(std::sqrt(total_sq_disparity_diff / disparities.size()));
+        sub_pixel_rms_error->add_value(rms_subpixel_val);
 
-        // Calculate fill ratio relative to the ROI
-        auto fill_ratio = points.size() / float((roi.max_x - roi.min_x)*(roi.max_y - roi.min_y)) * TO_PERCENT;
-        fill->add_value(fill_ratio);
+        // calculate Plane Fit RMS  (Spatial Noise) mm
+        double plane_fit_err_sqr_sum = std::inner_product(distances.begin(), distances.end(), distances.begin(), 0.);
+        auto rms_error_val = static_cast<float>(std::sqrt(plane_fit_err_sqr_sum / distances.size()));
+        plane_fit_rms_error->add_value(rms_error_val);
     });
 
     // ===============================
diff --git a/tools/enumerate-devices/rs-enumerate-devices.cpp b/tools/enumerate-devices/rs-enumerate-devices.cpp
index 69068e7f6e..0a8088214a 100644
--- a/tools/enumerate-devices/rs-enumerate-devices.cpp
+++ b/tools/enumerate-devices/rs-enumerate-devices.cpp
@@ -134,7 +134,7 @@ int main(int argc, char** argv) try
     SwitchArg compact_view_arg("s", "short", "Provide short summary of the devices");
     SwitchArg show_options("o", "option", "Show all supported options per subdevice");
     SwitchArg show_modes("m", "modes", "Show all supported stream modes per subdevice");
-    SwitchArg show_calibration_data("c", "calib_data", "Show extrinsics and intrinsics of all subdevices");
+    SwitchArg show_calibration_data("c", "calib_data", "Show extrinsic and intrinsic of all subdevices");
     cmd.add(compact_view_arg);
     cmd.add(show_options);
     cmd.add(show_modes);
@@ -279,18 +279,18 @@ int main(int argc, char** argv) try
                 }
             }
 
-            cout << "Provided Intrinsics:" << endl;
+            cout << "Provided Intrinsic:" << endl;
             for (auto& kvp : intrinsics_map)
             {
                 auto stream_res = kvp.first;
                 for (auto& intrinsics : kvp.second)
                 {
                     auto formats = get_str_formats(intrinsics.first);
-                    cout << "Intrinsics of \"" << stream_res.stream_name << "\"\t  " << stream_res.width << "x"
+                    cout << "Intrinsic of \"" << stream_res.stream_name << "\"\t  " << stream_res.width << "x"
                         << stream_res.height << "\t  " << formats << endl;
                     if (intrinsics.second == rs2_intrinsics{})
                     {
-                        cout << "Intrinsics NOT available!\n\n";
+                        cout << "Intrinsic NOT available!\n\n";
                     }
                     else
                     {
@@ -300,12 +300,12 @@ int main(int argc, char** argv) try
             }
 
             // Print Extrinsics
-            cout << "\nProvided Extrinsics:" << endl;
+            cout << "\nProvided Extrinsic:" << endl;
             for (auto kvp1 = streams.begin(); kvp1 != streams.end(); ++kvp1)
             {
                 for (auto kvp2 = streams.begin(); kvp2 != streams.end(); ++kvp2)
                 {
-                    cout << "Extrinsics from \"" << kvp1->second.stream_name() << "\"\t  " <<
+                    cout << "Extrinsic from \"" << kvp1->second.stream_name() << "\"\t  " <<
                             "To" << "\t  \"" << kvp2->second.stream_name() << "\"\n";
                     auto extrinsics = kvp1->second.get_extrinsics_to(kvp2->second);
                     print(extrinsics);
diff --git a/tools/fw-logger/rs-fw-logger.cpp b/tools/fw-logger/rs-fw-logger.cpp
index 90b8fd22e1..3a2f728e50 100644
--- a/tools/fw-logger/rs-fw-logger.cpp
+++ b/tools/fw-logger/rs-fw-logger.cpp
@@ -72,13 +72,13 @@ int main(int argc, char* argv[])
 
     while (true)
     {
-        cout << "\nWaiting for RealSense device to connect...\n";
-        auto dev = hub.wait_for_device();
-        cout << "RealSense device has connected...\n";
         try
         {
-            vector<uint8_t> input;
+            cout << "\nWaiting for RealSense device to connect...\n";
+            auto dev = hub.wait_for_device();
+            cout << "RealSense device was connected...\n";
 
+            vector<uint8_t> input;
             auto str_op_code = dev.get_info(RS2_CAMERA_INFO_DEBUG_OP_CODE);
             auto op_code = static_cast<uint8_t>(stoi(str_op_code));
             input = {0x14, 0x00, 0xab, 0xcd, op_code, 0x00, 0x00, 0x00,
diff --git a/tools/realsense-viewer/realsense-viewer.cpp b/tools/realsense-viewer/realsense-viewer.cpp
index c08b7c69ff..e6d7e41928 100644
--- a/tools/realsense-viewer/realsense-viewer.cpp
+++ b/tools/realsense-viewer/realsense-viewer.cpp
@@ -36,7 +36,7 @@ void add_playback_device(context& ctx, std::vector<device_model>& device_models,
         if (auto p = dev.as<playback>())
         {
             auto filename = p.file_name();
-            p.set_status_changed_callback([&device_models, filename](rs2_playback_status status)
+            p.set_status_changed_callback([&viewer_model, &device_models, filename](rs2_playback_status status)
             {
                 if (status == RS2_PLAYBACK_STATUS_STOPPED)
                 {
@@ -52,14 +52,14 @@ void add_playback_device(context& ctx, std::vector<device_model>& device_models,
                         if (it->_playback_repeat)
                         {
                             //Calling from different since playback callback is from reading thread
-                            std::thread{ [subs]()
+                            std::thread{ [subs, &viewer_model]()
                             {
                                 for (auto&& sub : subs)
                                 {
                                     if (sub->streaming)
                                     {
                                         auto profiles = sub->get_selected_profiles();
-                                        sub->play(profiles);
+                                        sub->play(profiles, viewer_model);
                                     }
                                 }
                             } }.detach();
@@ -125,11 +125,12 @@ void refresh_devices(std::mutex& m,
                     viewer_model.not_model.add_notification({ get_device_name(dev).first + " Disconnected\n",
                         0, RS2_LOG_SEVERITY_INFO, RS2_NOTIFICATION_CATEGORY_UNKNOWN_ERROR });
 
-                    //Remove from devices
+                    viewer_model.pc.depth_stream_active = false;
 
+                    //Remove from devices
                     auto dev_model_itr = std::find_if(begin(device_models), end(device_models),
                         [&](const device_model& other) { return get_device_name(other.dev) == get_device_name(dev); });
-                    
+
                     if (dev_model_itr != end(device_models))
                     {
                         for (auto&& s : dev_model_itr->subdevices)
@@ -143,7 +144,6 @@ void refresh_devices(std::mutex& m,
 
                     dev_itr = current_connected_devices.erase(dev_itr);
                     continue;
-                    
                 }
                 ++dev_itr;
             }
@@ -451,7 +451,7 @@ int main(int argv, const char** argc) try
                                 if (ImGui::Button(label.c_str(), { 30,30 }))
                                 {
                                     auto profiles = sub->get_selected_profiles();
-                                    sub->play(profiles);
+                                    sub->play(profiles, viewer_model);
 
                                     for (auto&& profile : profiles)
                                     {
@@ -552,9 +552,13 @@ int main(int argv, const char** argc) try
         ImGui::PopStyleVar();
         ImGui::PopStyleColor();
 
+        frameset f;
+        if(viewer_model.s.poll_for_frames(&f))
+            viewer_model.syncer_queue.enqueue(std::move(f));
+
         // Fetch frames from queues
         for (auto&& device_model : device_models)
-            for (auto&& sub : device_model.subdevices)
+           for (auto&& sub : device_model.subdevices)
             {
                 sub->queues.foreach([&](frame_queue& queue)
                 {
@@ -563,7 +567,7 @@ int main(int argv, const char** argc) try
                         frame f;
                         if (queue.poll_for_frame(&f))
                         {
-                            viewer_model.upload_frame(std::move(f));
+                           viewer_model.upload_frame(std::move(f));
                         }
                     }
                     catch (const error& ex)
diff --git a/unit-tests/unit-tests-live.cpp b/unit-tests/unit-tests-live.cpp
index 4cac3c9846..c39dec8a5f 100644
--- a/unit-tests/unit-tests-live.cpp
+++ b/unit-tests/unit-tests-live.cpp
@@ -3751,7 +3751,6 @@ TEST_CASE("Pipeline - multicam scenario with specific devices", "[live][multicam
         CAPTURE(required_profile);
         auto vid_profile = required_profile.as<video_stream_profile>();
 
-        
         rs2::device dev;
         rs2::pipeline pipe(ctx);
         rs2::config cfg;
@@ -3759,7 +3758,7 @@ TEST_CASE("Pipeline - multicam scenario with specific devices", "[live][multicam
         //Using the config object to request the serial and stream that we found above
         REQUIRE_NOTHROW(cfg.enable_device(required_serial));
         REQUIRE_NOTHROW(cfg.enable_stream(vid_profile.stream_type(), vid_profile.stream_index(), vid_profile.width(), vid_profile.height(), vid_profile.format(), vid_profile.fps()));
-        
+
         //Testing that config.resolve() returns the right data
         rs2::pipeline_profile resolved_profile;
         REQUIRE_NOTHROW(resolved_profile = cfg.resolve(pipe));
@@ -3773,7 +3772,7 @@ TEST_CASE("Pipeline - multicam scenario with specific devices", "[live][multicam
         rs2::device dev_from_start;
         REQUIRE_NOTHROW(dev_from_start = resolved_profile_from_start.get_device());
         REQUIRE(dev_from_start);
-        
+
         //Compare serial number
         std::string actual_serial;
         std::string actual_serial_from_start;
@@ -3781,7 +3780,7 @@ TEST_CASE("Pipeline - multicam scenario with specific devices", "[live][multicam
         REQUIRE_NOTHROW(actual_serial_from_start = dev_from_start.get_info(RS2_CAMERA_INFO_SERIAL_NUMBER));
         REQUIRE(actual_serial == required_serial);
         REQUIRE(actual_serial == actual_serial_from_start);
-        
+
         //Compare Stream
         std::vector<rs2::stream_profile> actual_streams;
         REQUIRE_NOTHROW(actual_streams = resolved_profile.get_streams());
@@ -3813,7 +3812,7 @@ TEST_CASE("Pipeline - multicam scenario with specific devices", "[live][multicam
         std::string started_serial;
         REQUIRE_NOTHROW(started_serial = started_dev.get_info(RS2_CAMERA_INFO_SERIAL_NUMBER));
         REQUIRE(started_serial == required_serial);
-        
+
         //Compare Stream
         std::vector<rs2::stream_profile> started_streams;
         REQUIRE_NOTHROW(started_streams = strarted_profile.get_streams());
@@ -4050,9 +4049,8 @@ TEST_CASE("Pipeline record and playback", "[live]") {
             REQUIRE(frames);
             REQUIRE(frames.size() > 0);
             REQUIRE_NOTHROW(p.stop());
-        } 
+        }
         //Scoping the above code to make sure no one holds the device
-        
         REQUIRE(file_exists(filename));
 
         {
diff --git a/wrappers/labview/readme.md b/wrappers/labview/readme.md
new file mode 100644
index 0000000000..3a5c421aaf
--- /dev/null
+++ b/wrappers/labview/readme.md
@@ -0,0 +1,80 @@
+# Getting Started with RealSense™ SDK2.0 for LabVIEW®
+
+> **Download Link**: [RealSense SDK2 for LabVIEW 1.0](http://realsense-hw-public.s3.amazonaws.com/Releases/RS4xx/Windows/labview_2_8_1.zip)
+
+## Introduction:
+The latest generation of RealSense Depth Cameras can be controlled via the RealSense SDK2.0, also referred to as libRealSense 2.x.x, or LibRS for short. This includes stereo depth cameras D415 and D435 as well as their corresponding modules RS410 and RS430. 
+
+
+To get started controlling the RealSense Cameras with LabVIEW® in Windows 10, we have created a [VI-library](http://realsense-hw-public.s3.amazonaws.com/Releases/RS4xx/Windows/labview_2_8_1.zip) that wraps most of the core functions of the realsense2.dll, and we have also created some simple “Hello World” VI’s to get started capturing Color, Depth Maps, and displaying Point-Clouds.  This uses LabVIEW 2016 and requires a Windows 10 laptop with a USB3 port.   
+
+
+The realsense2.dll that is included in this package is 64bit for Windows 10. Other versions (ex: 32bit) could be compiled by following the [instructions on GitHub](https://github.com/IntelRealSense/librealsense/blob/master/doc/installation_windows.md).  Just rename them realsense2.dll and replace the file in the location used by the LabVIEW demos. 
+
+## Getting Started: 
+Unzip the package called “RealSense SDK2.0  for LabVIEW”
+
+
+It will contain 5 simple demos to help you get started. We will start by explaining the demos and will then go into the programming.
+
+### RealSense Hello World: Color + Depth
+
+To run it, plug in a RealSense D415 or D435 depth camera, and press the run arrow. It should start streaming color and depth. The color is from the left camera of the stereo pair. There is also a different Color Camera that can be interfaced to that has better quality images that have been processed by an ISP, but one benefit of the “Left color” is that it is matched pixel perfect to the depth and does not need any host UV-mapping and calibration. 
+
+
+You can stop the app and change the resolution in the pull-down menu and try different resolutions. However please note that for Stereo Depth Cameras the depth resolution (i.e. the Z-axis or ranging resolution) scales with resolution, so if you chose a smaller resolution expect not just smaller X,Y resolution, but also more error in the depth error.  We do note also that the minimum range, aka MinZ also scales with resolution. So while a D415 running at 1280x720 resolution will have a minZ of about 44cm, reducing the resolution to 640x360 will reduce the minZ to 22cm.   
+
+
+In this app you can also turn the projector on/off. While the stereo depth cameras work great on naturally textured surfaces, objects that have only a single color (ex. A white wall) with no texture will not be resolved very well in depth range if the laser projector is not turned on. 
+
+
+Another important feature is the “presets”. You can change the ASIC parameters that affect depth and color by changing them through the shown drop-down menus in the lower right of the screen. For example, try “Face2” for Depth and “DS410 (DS5a) 4” for Color which will give good results for the D415 camera. We do emphasize that the color image is the left image of the stereo pair, and it sees IR light as well as visible light. This means that when you are near sunlight that generated lots of IR light, the image will perhaps be a bit purple. Also, when the projector is on, the projector pattern will be visible.  We do however have an interesting trick that can remove this: When in 1280x720, try to select the Color preset called “Remove IR2”. This will not affect the depth adversely, as we are removing the pattern in the ASIC.   
+
+![Color + Depth](https://raw.githubusercontent.com/wiki/IntelRealSense/librealsense/res/labview/1.png)
+
+### RealSense Hello World: Left-Right
+You can also access directly the left and right channels of the stereo camera. We should note that only certain combinations are allowed, such as Color+Depth or Monochrome L+R. The monochrome images in this demo are 8 bit grey-scale and are after rectification by the RealSense ASIC. This is the input that will go to the stereo calculation engine inside the ASIC. It is therefore perfectly calibrated to the depth. 
+
+![Color + Depth](https://raw.githubusercontent.com/wiki/IntelRealSense/librealsense/res/labview/2.png)
+
+### RealSense Hello World: Left-Right UnRectified
+
+This is similar to demo 2 above, but allows you to look at the raw images that are input into the ASIC before calibration and rectification. This can be useful in for debugging if depth is bad, but more importantly it can give 2MP 16bit monochrome images
+
+![Color + Depth](https://raw.githubusercontent.com/wiki/IntelRealSense/librealsense/res/labview/3.png)
+
+### RealSense Hello World: Point Cloud
+
+This demo builds on the Color+Depth demo, and reads the intrinsic and extrinsic parameters from the ASIC so that it can render a Point Cloud by mapping the each pixel consisting of (Red, Green, Blue, Depth) to points in 3D space. Here you can rotate the 3D view of the point cloud. 
+
+![Color + Depth](https://raw.githubusercontent.com/wiki/IntelRealSense/librealsense/res/labview/4.png)
+
+### RealSense Hello World: Point Cloud Plus
+
+This demo builds on the Point Cloud demo, by adding time stamping and also showing some simple post-processing of the Point-Cloud data to enhance it will edge-preserving temporal and spatial  filters. You can select increase the filtering by setting the alpha values to near 0, and reduce the filtering by settings alpha near 1. The step size should be less than 20 for best results.
+
+![Color + Depth](https://raw.githubusercontent.com/wiki/IntelRealSense/librealsense/res/labview/5.png)
+
+## Understanding the Programming: 
+While all the VI’s do have embedded documentation, it should in principle all be “self-explanatory”. It is however not completely straight forward and it requires some explanation about the LibRS architecture and in particular in what sequence the commands need to be executed, as well as what parameters are valid.
+
+First we look at the hierarchy of devices, sensors, and streams. 
+
+
+![Color + Depth](https://raw.githubusercontent.com/wiki/IntelRealSense/librealsense/res/labview/6.png)
+
+* LibRS supports being able to connect multiple <font color="orange">**DEVICES**</font>.  For example, multiple RealSense Cameras can be connected at once. 
+* Each DEVICE can have multiple <font color="green">**SENSORS**</font>. For example, the D415 has a Stereo Sensor and an extra RGB Sensor. Other devices may also have Fisheye sensors or IMU sensors.
+* Each SENSOR can in turn have multiple <font color="blue">**STREAMS**</font>. These are, for example, the depth and color and monochrome streams. Each STREAM will be described by many different traits, such as frame rate, resolution, format, etc. Most importantly though that that each stream can be uniquely identified by a PROFILE number.  A single sensor can have hundreds of streams. 
+
+
+When initializing and preparing to stream specific STREAMs, it is necessary to find their specific PROFILE numbers.  So this means that the best way to start a RealSense Device to stream data, is to enumerate ALL device, sensors, and streams, and search for the one that has the features you are looking for, and remembering its PROFILE number. An array of these profiles numbers is input into the Configure VI, and the stream is officially started with the Start VI. 
+
+
+So now you are streaming data. To grab data you call the Capture VI inside a loop. This will give you a Frame pointer each time it is called. The VI will also tell you the type of frame captured, ie. What stream it belongs to. You can use the Get Frame Data to get a pointer to the payload.  So if it is a “depth frame” we will treat the data as depth data (in this case 16bit data), and if it is a “color frame” we will treat it as color (in the case R, G, B), or as a Left Monochrome, Right monochrome etc.    
+
+
+Note that frames can arrive asynchronously. You can query their time stamp or counters to align them, or just grab the nearest frames in time.     
+
+
+Finally, it is VERY important that you use the Release Frame VI to release each frame when it is no longer needed, or you will very quickly stop streaming. Also, be sure to CLOSE everything properly, or you will have problems streaming the next time, and LabVIEW may crash.   
diff --git a/wrappers/nodejs/README.md b/wrappers/nodejs/README.md
index b0cfc1e99b..2e2c11876f 100644
--- a/wrappers/nodejs/README.md
+++ b/wrappers/nodejs/README.md
@@ -6,9 +6,26 @@ This is the Node.js wrapper for the C++ `librealsense2` for Intel® RealSense™
 ## 1.1. Install Build Prerequisites
 
 ### Install Node.js
-Install [`Node.js`](https://nodejs.org/en/download/).
+The version should be at least v6.x and the releases can be found [here](https://nodejs.org/en/download/).
 
-After `Node.js` is installed, run the following command to install required modules.
+#### Ubuntu 16.04
+In Ubuntu16.04, the default apt-get installed version is lower than v6.x. The following command could install the latest v6.x release:
+
+```
+curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash -
+sudo apt-get install -y nodejs
+```
+#### Windows 10
+Please download the .msi file of v6.x (for example v6.12.0) from [x86](https://nodejs.org/download/release/v6.12.0/node-v6.12.0-x86.msi) or [x64](https://nodejs.org/download/release/v6.12.0/node-v6.12.0-x64.msi) and install it.
+
+#### Verfication
+The version can be checked through this command:
+
+```
+node -v
+```
+#### Install required modules
+After Node.js is installed, run the following command to install required modules.
 
 ```
 npm install -g jsdoc     # Required for document generation
diff --git a/wrappers/nodejs/index.js b/wrappers/nodejs/index.js
index 6f9a572ea3..df676b19a7 100644
--- a/wrappers/nodejs/index.js
+++ b/wrappers/nodejs/index.js
@@ -18,6 +18,7 @@ class Device {
   constructor(dev) {
     this.cxxDev = dev;
     this._events = new EventEmitter();
+    internal.addObject(this);
   }
 
   /**
@@ -166,8 +167,10 @@ class Device {
    * Release resources associated with the object
    */
   destroy() {
-    this.cxxDev.destroy();
-    this.cxxDev = undefined;
+    if (this.cxxDev) {
+      this.cxxDev.destroy();
+      this.cxxDev = undefined;
+    }
     this._events = undefined;
   }
 }
@@ -260,8 +263,10 @@ class StreamProfile {
   }
 
   destroy() {
-    if (this.cxxProfile) this.cxxProfile.destroy();
-    this.cxxProfile = undefined;
+    if (this.cxxProfile) {
+      this.cxxProfile.destroy();
+      this.cxxProfile = undefined;
+    }
   }
 }
 
@@ -271,14 +276,17 @@ class StreamProfile {
 class DeviceList {
   constructor(cxxList) {
     this.cxxList = cxxList;
+    internal.addObject(this);
   }
 
   /**
    * Release resources associated with the object
    */
   destroy() {
-    this.cxxList.destroy();
-    this.cxxList = undefined;
+    if (this.cxxList) {
+      this.cxxList.destroy();
+      this.cxxList = undefined;
+    }
   }
 
   /**
@@ -386,6 +394,10 @@ class Options {
   constructor(cxxObj) {
     this.cxxObj = cxxObj;
   }
+
+  setCxxOptionsObject(cxxObj) {
+    this.cxxObj = cxxObj;
+  }
   /**
   * Check if particular option is read-only
   * @param {String|Number} option The option to be checked
@@ -538,6 +550,7 @@ class Sensor extends Options {
     super(sensor);
     this.cxxSensor = sensor;
     this._events = new EventEmitter();
+    internal.addObject(this);
   }
 
   /**
@@ -599,8 +612,10 @@ class Sensor extends Options {
   */
   destroy() {
     this.events_ = null;
-    this.cxxSensor.destroy();
-    this.cxxSensor = undefined;
+    if (this.cxxSensor) {
+      this.cxxSensor.destroy();
+      this.cxxSensor = undefined;
+    }
   }
 
   /**
@@ -871,12 +886,21 @@ class DepthSensor extends Sensor {
 
 const internal = {
   ctx: [],
+  objs: [],
 
   addContext: function(c) {
     this.ctx.push(c);
   },
 
+  addObject: function(o) {
+    this.objs.push(o);
+  },
+
   cleanup: function() {
+    this.objs.forEach((obj) => {
+      obj.destroy();
+    });
+    this.objs = [];
     this.ctx.forEach((context) => {
       context.destroy();
     });
@@ -901,19 +925,21 @@ const internal = {
 class Context {
   constructor(cxxCtx) {
     this._events = new EventEmitter();
-    if (arguments.length === 1 && arguments[0] === 'no-cxx-context') {
-      // Subclass will do the cxxCtx
+    if (arguments.length === 0) {
+      this.cxxCtx = new RS2.RSContext();
+      this.cxxCtx.create();
     } else {
-      if (arguments.length === 0) {
-        this.cxxCtx = new RS2.RSContext();
+      if (arguments[0] === 'recording' || arguments[0] === 'playback') {
+        this.cxxCtx = new (Function.prototype.bind.apply(
+            RS2.RSContext, [null].concat(Array.from(arguments))))();
         this.cxxCtx.create();
-      } else {
+      } else if (arguments[0] instanceof RS2.RSContext) {
         this.cxxCtx = cxxCtx;
+      } else {
+        throw new TypeError('Invalid arguement for Context.constructor()');
       }
-
-      this.cxxCtx._events = this._events;
     }
-
+    this.cxxCtx._events = this._events;
     internal.addContext(this);
   }
 
@@ -922,9 +948,11 @@ class Context {
    * The JavaScript Context object(s) will not be garbage-collected without call(s) to this function
    */
   destroy() {
-    this.cxxCtx.destroy();
-    this.cxxCtx = undefined;
-    internal.cleanupContext();
+    if (this.cxxCtx) {
+      this.cxxCtx.destroy();
+      this.cxxCtx = undefined;
+      internal.cleanupContext();
+    }
   }
 
   /**
@@ -1039,27 +1067,36 @@ class Context {
 }
 
 /**
- * Record camera data to a disk file
+ * This class is for testing purpose.
+ * It is used to record all operations over librealsense into a file
  * @extends Context
  */
-class RecordContext extends Context {
+class RecordingContext extends Context {
   /**
-   * @param {String} fileName The file name of the recording data
-   * @param {String} section The section name to record
-   * @param {String|Integer} mode Recording mode, default to 'best-quality'
-   *
+   * @param {String} fileName The file name to store the recorded data
+   * @param {String} section The section name within the recording
+   * @param {String|Integer} mode Recording mode, default to 'blank-frames'
    * @see [enum recording_mode]{@link recording_mode}
    */
-  constructor(fileName, section, mode = 'best-quality') {
-    super('no-cxx-context');
-    // TODO: create this.cxxCtx in child class
-    // this.cxxCtx = ...
-    this.cxxCtx._events = this._events;
+  constructor(fileName, section = '', mode = 'blank-frames') {
+    if (!isString(fileName) || !isString(section)) {
+      throw new TypeError('RecordingContext constructor\'s argument type is invalid');
+    }
+    let m = checkStringNumber(mode,
+        constants.recording_mode.RECORDING_MODE_BLANK_FRAMES,
+        constants.recording_mode.RECORDING_MODE_STREAM_COUNT,
+        recordingMode2Int,
+        'RecordingContext constructor expects a string or an integer for the 3rd argument',
+        'RecordingContext constructor\'s 3rd argument value is invalid');
+    super('recording', fileName, section, m);
   }
 }
 
 /**
- * Playback camera recordings
+ * This class is for testing purpose.
+ * It is used to reproduce the same responses for the same operations as
+ * recording. The user must call the same methods as recorded in the file
+ * to get correct response.
  * @extends Context
  */
 class PlaybackContext extends Context {
@@ -1067,11 +1104,11 @@ class PlaybackContext extends Context {
    * @param {String} fileName The file name of the recording
    * @param {String} section The section name used in recording
    */
-  constructor(fileName = '', section = '') {
-    super('no-cxx-context');
-    // TODO: create this.cxxCtx in child class
-    // this.cxxCtx = ...
-    this.cxxCtx._events = this._events;
+  constructor(fileName, section = '') {
+    if (!isString(fileName) || !isString(section)) {
+      throw new TypeError('PlaybackContext constructor\'s argument type is invalid');
+    }
+    super('playback', fileName, section);
   }
 }
 
@@ -1089,6 +1126,9 @@ class PlaybackDevice extends Device {
   }
 }
 
+internal.RecordingContext = RecordingContext;
+internal.PlaybackContext = PlaybackContext;
+
 /**
  * PointCloud accepts depth frames and outputs Points frames
  * In addition, given non-depth frame, the block will align texture coordinate to the non-depth
@@ -1147,10 +1187,12 @@ class PointCloud {
 /**
  * The Colorizer can be used to quickly visualize the depth data by tranform data into RGB8 format
  */
-class Colorizer {
+class Colorizer extends Options {
   constructor() {
+    super();
     this.cxxColorizer = new RS2.RSColorizer();
     this.cxxColorizer.create();
+    this.setCxxOptionsObject(this.cxxColorizer);
     this.depthRGB = new VideoFrame();
   }
 
@@ -1257,6 +1299,7 @@ class Frame {
   constructor(cxxFrame) {
     this.cxxFrame = cxxFrame || new RS2.RSFrame();
     this.updateProfile();
+    internal.addObject(this);
   }
 
   updateProfile() {
@@ -1670,24 +1713,11 @@ class FrameSet {
    * @return {DepthFrame|VideoFrame|Frame|undefined}
    */
   at(index) {
-    //
-    // TODO(ting): mapping index to stream and use this.cache[]
-    //   e.g. return getFrame(this.cxxFrameSet.indexToStream(index));
-    //
-
-    let cxxFrame = this.cxxFrameSet.at(index);
-
-    if (!cxxFrame) return undefined;
-
-    if (cxxFrame.isDepthFrame()) {
-      return new DepthFrame(cxxFrame);
+    if ((arguments.length !== 1) || (typeof index !== 'number') ||
+        (parseInt(index) >= this.size)) {
+      throw new TypeError('FrameSet.at(index) expects a valid integer argument');
     }
-
-    if (cxxFrame.isVideoFrame()) {
-      return new VideoFrame(cxxFrame);
-    }
-
-    return new Frame(cxxFrame);
+    return this.getFrame(this.cxxFrameSet.indexToStream(index));
   }
 
   __internalAssembleFrame(cxxFrame) {
@@ -1801,6 +1831,7 @@ class Pipeline {
     this.cxxPipeline.create(this.ctx.cxxCtx);
     this.started = false;
     this.frameSet = new FrameSet();
+    internal.addObject(this);
   }
 
   /**
@@ -1811,9 +1842,12 @@ class Pipeline {
   destroy() {
     if (this.started === true) this.stop();
 
-    this.cxxPipeline.destroy();
-    this.cxxPipeline = undefined;
-    if (this.ownCtx) {
+    if (this.cxxPipeline) {
+      this.cxxPipeline.destroy();
+      this.cxxPipeline = undefined;
+    }
+
+    if (this.ownCtx && this.ctx) {
       this.ctx.destroy();
     }
     this.ctx = undefined;
@@ -1946,6 +1980,7 @@ class Pipeline {
 class PipelineProfile {
   constructor(profile) {
     this.cxxPipelineProfile = profile;
+    internal.addObject(this);
   }
 
   /**
@@ -1985,6 +2020,18 @@ class PipelineProfile {
   getDevice() {
     return new Device(this.cxxPipelineProfile.getDevice());
   }
+
+  /**
+   * Destroy the resource associated with this object
+   *
+   * @return {undefined}
+   */
+  destroy() {
+    if (this.cxxPipelineProfile) {
+      this.cxxPipelineProfile.destroy();
+      this.cxxPipelineProfile = undefined;
+    }
+  }
 }
 
 /**
@@ -2203,12 +2250,15 @@ class Syncer {
    * Release resources associated with the object
    */
   destroy() {
-    this.cxxSyncer.destroy();
-    this.cxxSyncer = undefined;
+    if (this.cxxSyncer) {
+      this.cxxSyncer.destroy();
+      this.cxxSyncer = undefined;
+    }
+
     if (this.frameset) {
       this.frameSet.destroy();
+      this.frameSet = undefined;
     }
-    this.frameSet = undefined;
   }
 }
 
@@ -2248,8 +2298,10 @@ class DeviceHub {
    * Release resources associated with the object
    */
   destroy() {
-    this.cxxHub.destroy();
-    this.cxxHub = undefined;
+    if (this.cxxHub) {
+      this.cxxHub.destroy();
+      this.cxxHub = undefined;
+    }
   }
 }
 
@@ -3032,38 +3084,43 @@ const recording_mode = {
    * but pixel data will be replaced with zeros to save space. <br>Equivalent to its uppercase
    * counterpart.
    */
-  blank_frames: 'blank-frames',
+  recording_mode_blank_frames: 'blank-frames',
   /**
    * String literal of <code>'compressed'</code>. <br>Frames will be encoded using a proprietary
    * lossy encoding, aiming at x5 compression at some CPU expense. <br>Equivalent to its uppercase
    * counterpart.
    */
-  compressed: 'compressed',
+  recording_mode_compressed: 'compressed',
   /**
    * String literal of <code>'best-quality'</code>. <br>Frames will not be compressed,
    * but rather stored as-is. This gives best quality and low CPU overhead, but you might run out
    * of memory. <br>Equivalent to its uppercase counterpart.
    */
-  best_quality: 'best-quality',
+  recording_mode_best_quality: 'best-quality',
 
   /**
    * Frame metadata will be recorded, but pixel data will be replaced with zeros to save space.
    * <br>Equivalent to its lowercase counterpart.
    * @type {Integer}
    */
-  BLANK_FRAMES: RS2.RS2_RECORDING_MODE_BLANK_FRAMES,
+  RECORDING_MODE_BLANK_FRAMES: RS2.RS2_RECORDING_MODE_BLANK_FRAMES,
   /**
    * Frames will be encoded using a proprietary lossy encoding, aiming at x5 compression at some
    * CPU expense.<br>Equivalent to its lowercase counterpart.
    * @type {Integer}
    */
-  COMPRESSED: RS2.RS2_RECORDING_MODE_COMPRESSED,
+  RECORDING_MODE_COMPRESSED: RS2.RS2_RECORDING_MODE_COMPRESSED,
   /**
    * Frames will not be compressed, but rather stored as-is. This gives best quality and low CPU
    * overhead, but you might run out of memory.<br>Equivalent to its lowercase counterpart.
    * @type {Integer}
    */
-  BEST_QUALITY: RS2.RS2_RECORDING_MODE_BEST_QUALITY,
+  RECORDING_MODE_BEST_QUALITY: RS2.RS2_RECORDING_MODE_BEST_QUALITY,
+  /**
+   * Number of enumeration values. Not a valid input: intended to be used in for-loops.
+   * @type {Integer}
+  */
+  RECORDING_MODE_COUNT: RS2.RS2_RECORDING_MODE_COUNT,
 };
 
 /**
@@ -3238,7 +3295,36 @@ const option = {
    * correction of the motion data . <br>Equivalent to its uppercase counterpart.
    */
   option_enable_motion_correction: 'enable-motion-correction',
+  /**
+   * String literal of <code>'auto-exposure-priority'</code>.
+   * <br>Allows sensor to dynamically ajust the frame rate
+   * depending on lighting conditions <br>Equivalent to its uppercase counterpart
+   */
+  option_auto_exposure_priority: 'auto-exposure-priority',
+
+  /**
+   * String literal of <code>''color-scheme'</code>. <br>Color scheme for data visualization
+   * <br>Equivalent to its uppercase counterpart
+   */
+  option_color_scheme: 'color-scheme',
+
+  /**
+   * String literal of <code>''histogram-equalization-enabled'</code>. <br>Perform histogram
+   * equalization post-processing on the depth data <br>Equivalent to its uppercase counterpart
+   */
+  option_histogram_equalization_enabled: 'histogram-equalization-enabled',
+
+  /**
+   * String literal of <code>''min-distance'</code>. <br>Minimal distance to the target
+   * <br>Equivalent to its uppercase counterpart
+   */
+  option_min_distance: 'min-distance',
 
+  /**
+   * String literal of <code>''max-distance'</code>. <br>Maximum distance to the target
+   * <br>Equivalent to its uppercase counterpart
+   */
+  option_max_distance: 'max-distance',
   /**
    * Enable / disable color backlight compensatio.<br>Equivalent to its lowercase counterpart.
    * @type {Integer}
@@ -3406,6 +3492,32 @@ const option = {
    * @type {Integer}
    */
   OPTION_ENABLE_MOTION_CORRECTION: RS2.RS2_OPTION_ENABLE_MOTION_CORRECTION,
+  /**
+   * Allows sensor to dynamically ajust the frame rate depending on lighting conditions.
+   * <br>Equivalent to its uppercase counterpart
+   */
+  OPTION_AUTO_EXPOSURE_PRIORITY: RS2.OPTION_AUTO_EXPOSURE_PRIORITY,
+
+  /**
+   * Color scheme for data visualization <br>Equivalent to its uppercase counterpart
+   */
+  OPTION_COLOR_SCHEME: RS2.OPTION_COLOR_SCHEME,
+
+  /**
+   * Perform histogram equalization post-processing on the depth data.
+   * <br>Equivalent to its uppercase counterpart
+   */
+  OPTION_HISTOGRAM_EQUALIZATION_ENABLED: RS2.OPTION_HISTOGRAM_EQUALIZATION_ENABLED,
+
+  /**
+   * Minimal distance to the target <br>Equivalent to its uppercase counterpart
+   */
+  OPTION_MIN_DISTANCE: RS2.OPTION_MIN_DISTANCE,
+
+  /**
+   * Maximum distance to the target <br>Equivalent to its uppercase counterpart
+   */
+  OPTION_MAX_DISTANCE: RS2.OPTION_MAX_DISTANCE,
   /**
    * Number of enumeration values. Not a valid input: intended to be used in for-loops.
    * @type {Integer}
@@ -3487,6 +3599,19 @@ const option = {
           return this.option_depth_units;
         case this.OPTION_ENABLE_MOTION_CORRECTION:
           return this.option_enable_motion_correction;
+        case this.OPTION_AUTO_EXPOSURE_PRIORITY:
+          return this.option_auto_exposure_priority;
+        case this.OPTION_COLOR_SCHEME:
+          return this.option_color_scheme;
+        case this.OPTION_HISTOGRAM_EQUALIZATION_ENABLED:
+          return this.option_histogram_equalization_enabled;
+        case this.OPTION_MIN_DISTANCE:
+          return this.option_min_distance;
+        case this.OPTION_MAX_DISTANCE:
+          return this.option_max_distance;
+        default:
+          throw new TypeError(
+              'option.optionToString(option) expects a valid value as the 1st argument');
       }
     }
   },
@@ -4252,8 +4377,6 @@ module.exports = {
   Align: Align,
   PointCloud: PointCloud,
   Points: Points,
-  // PlaybackContext: PlaybackContext,
-  // RecordingContext: RecordingContext,
   Syncer: Syncer,
 
   stream: stream,
@@ -4269,6 +4392,7 @@ module.exports = {
   visual_preset: visual_preset,
 
   util: util,
+  internal: internal,
 
   stringConstantToIntegerValue: str2Int,
 };
diff --git a/wrappers/nodejs/package-lock.json b/wrappers/nodejs/package-lock.json
index e19ca2765f..6ede1706e1 100644
--- a/wrappers/nodejs/package-lock.json
+++ b/wrappers/nodejs/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "node-librealsense",
-  "version": "0.279.3",
+  "version": "0.281.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -33,8 +33,7 @@
     "fs-compare": {
       "version": "0.0.4",
       "resolved": "https://registry.npmjs.org/fs-compare/-/fs-compare-0.0.4.tgz",
-      "integrity": "sha1-FwdvkbhjxqDVOSIOc8DYjEZSPno=",
-      "dev": true
+      "integrity": "sha1-FwdvkbhjxqDVOSIOc8DYjEZSPno="
     },
     "graceful-fs": {
       "version": "4.1.11",
@@ -53,7 +52,7 @@
     "jsdoc": {
       "version": "3.5.5",
       "resolved": "https://registry.npmjs.org/jsdoc/-/jsdoc-3.5.5.tgz",
-      "integrity": "sha512-6PxB65TAU4WO0Wzyr/4/YhlGovXl0EVYfpKbpSroSj0qBxT4/xod/l40Opkm38dRHRdQgdeY836M0uVnJQG7kg==",
+      "integrity": "sha1-SEUhsSboGQTWMv+D7JqqCWcI+k0=",
       "dev": true,
       "requires": {
         "babylon": "7.0.0-beta.19",
@@ -119,8 +118,7 @@
     "nan": {
       "version": "2.7.0",
       "resolved": "https://registry.npmjs.org/nan/-/nan-2.7.0.tgz",
-      "integrity": "sha1-2Vv3IeyHfgjbJ27T/G63j5CDrUY=",
-      "dev": true
+      "integrity": "sha1-2Vv3IeyHfgjbJ27T/G63j5CDrUY="
     },
     "pngjs": {
       "version": "3.3.0",
diff --git a/wrappers/nodejs/package.json b/wrappers/nodejs/package.json
index ec995a63ba..e6de08edc6 100644
--- a/wrappers/nodejs/package.json
+++ b/wrappers/nodejs/package.json
@@ -1,6 +1,6 @@
 {
   "name": "node-librealsense",
-  "version": "0.279.3",
+  "version": "0.281.0",
   "description": "Node.js API for Intel® RealSense™ SDK 2.0",
   "main": "index.js",
   "directories": {
@@ -25,12 +25,12 @@
   "license": "Apache-2.0",
   "dependencies": {
     "bindings": "^1.2.1",
+    "fs-compare": "0.0.4",
     "jsonfile": "^3.0.1",
+    "nan": "^2.7.0",
     "pngjs": "^3.3.0"
   },
   "devDependencies": {
-    "fs-compare": "0.0.4",
-    "jsdoc": "^3.5.5",
-    "nan": "^2.7.0"
+    "jsdoc": "^3.5.5"
   }
 }
diff --git a/wrappers/nodejs/src/addon.cpp b/wrappers/nodejs/src/addon.cpp
index 9cb1d8f2b3..d722d9c01f 100644
--- a/wrappers/nodejs/src/addon.cpp
+++ b/wrappers/nodejs/src/addon.cpp
@@ -3,6 +3,7 @@
 // that can be found in the LICENSE file.
 
 #include <librealsense2/rs.h>
+#include <librealsense2/h/rs_internal.h>
 #include <librealsense2/h/rs_pipeline.h>
 #include <librealsense2/hpp/rs_types.hpp>
 #include <nan.h>
@@ -1177,9 +1178,9 @@ class RSFrameSet : public Nan::ObjectWrap {
 
     Nan::SetPrototypeMethod(tpl, "destroy", Destroy);
     Nan::SetPrototypeMethod(tpl, "getSize", GetSize);
-    Nan::SetPrototypeMethod(tpl, "at", At);
     Nan::SetPrototypeMethod(tpl, "getFrame", GetFrame);
     Nan::SetPrototypeMethod(tpl, "replaceFrame", ReplaceFrame);
+    Nan::SetPrototypeMethod(tpl, "indexToStream", IndexToStream);
 
     constructor_.Reset(tpl->GetFunction());
     exports->Set(Nan::New("RSFrameSet").ToLocalChecked(), tpl->GetFunction());
@@ -1306,17 +1307,34 @@ class RSFrameSet : public Nan::ObjectWrap {
     info.GetReturnValue().Set(Nan::False());
   }
 
-  static NAN_METHOD(At) {
+  static NAN_METHOD(IndexToStream) {
     auto me = Nan::ObjectWrap::Unwrap<RSFrameSet>(info.Holder());
     int32_t index = info[0]->IntegerValue();
-    if (me && me->frames_) {
-      rs2_frame* frame = rs2_extract_frame(me->frames_, index, &me->error_);
-      if (frame) {
-        info.GetReturnValue().Set(RSFrame::NewInstance(frame));
-        return;
-      }
+    if (!(me && me->frames_)) {
+      info.GetReturnValue().Set(Nan::Undefined());
+      return;
     }
-    info.GetReturnValue().Set(Nan::Undefined());
+    rs2_frame* frame = rs2_extract_frame(me->frames_, index, &me->error_);
+    if (!frame) {
+      info.GetReturnValue().Set(Nan::Undefined());
+      return;
+    }
+    const rs2_stream_profile* profile = rs2_get_frame_stream_profile(
+        frame, &me->error_);
+    if (!profile) {
+      rs2_release_frame(frame);
+      info.GetReturnValue().Set(Nan::Undefined());
+      return;
+    }
+    rs2_stream stream = RS2_STREAM_ANY;
+    rs2_format format = RS2_FORMAT_ANY;
+    int32_t fps = 0;
+    int32_t idx = 0;
+    int32_t unique_id = 0;
+    rs2_get_stream_profile_data(profile, &stream, &format, &idx,
+        &unique_id, &fps, &me->error_);
+    info.GetReturnValue().Set(Nan::New(stream));
+    rs2_release_frame(frame);
   }
 
  private:
@@ -1455,47 +1473,87 @@ Nan::Persistent<v8::Function> RSSyncer::constructor_;
 
 class Options {
  public:
-  explicit Options(rs2_options* options) : options_(options), error_(nullptr) {}
+  Options() : error_(nullptr) {}
 
-  ~Options() {
+  virtual ~Options() {
     if (error_) rs2_free_error(error_);
   }
 
-  bool SupportsOption(rs2_option option) {
-    return (rs2_supports_option(options_, option, &error_) != 0);
-  }
+  virtual rs2_options* GetOptionsPointer() = 0;
 
-  float GetOption(rs2_option option) {
-    return rs2_get_option(options_, option, &error_);
+  void SupportsOptionInternal(
+      const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    int32_t option = info[0]->IntegerValue();
+    auto on = rs2_supports_option(
+        GetOptionsPointer(), static_cast<rs2_option>(option), &error_);
+    info.GetReturnValue().Set(Nan::New(on ? true : false));
+    return;
   }
 
-  const char* GetOptionDescription(rs2_option option) {
-    return rs2_get_option_description(options_, option, &error_);
+  void GetOptionInternal(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    int32_t option = info[0]->IntegerValue();
+    auto value = rs2_get_option(
+        GetOptionsPointer(), static_cast<rs2_option>(option), &error_);
+    info.GetReturnValue().Set(Nan::New(value));
   }
 
-  const char* GetOptionValueDescription(rs2_option option, float val) {
-    return rs2_get_option_value_description(options_, option, val, &error_);
+  void GetOptionDescriptionInternal(
+      const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    int32_t option = info[0]->IntegerValue();
+    auto desc = rs2_get_option_description(
+        GetOptionsPointer(), static_cast<rs2_option>(option), &error_);
+    if (desc)
+      info.GetReturnValue().Set(Nan::New(desc).ToLocalChecked());
+    else
+      info.GetReturnValue().Set(Nan::Undefined());
   }
 
-  void SetOption(rs2_option option, float val) {
-    rs2_set_option(options_, option, val, &error_);
+  void GetOptionValueDescriptionInternal(
+      const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    int32_t option = info[0]->IntegerValue();
+    auto val = info[1]->NumberValue();
+    auto desc = rs2_get_option_value_description(
+        GetOptionsPointer(), static_cast<rs2_option>(option), val, &error_);
+    if (desc)
+      info.GetReturnValue().Set(Nan::New(desc).ToLocalChecked());
+    else
+      info.GetReturnValue().Set(Nan::Undefined());
   }
 
-  void GetOptionRange(
-      rs2_option option, float* min, float* max, float* step, float* def) {
-    rs2_get_option_range(options_, option, min, max, step, def, &error_);
+  void SetOptionInternal(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    int32_t option = info[0]->IntegerValue();
+    auto val = info[1]->NumberValue();
+    rs2_set_option(
+        GetOptionsPointer(), static_cast<rs2_option>(option), val, &error_);
+    info.GetReturnValue().Set(Nan::Undefined());
   }
 
-  bool IsOptionReadonly(rs2_option option) {
-    return (rs2_is_option_read_only(options_, option, &error_) != 0);
+  void GetOptionRangeInternal(
+      const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    int32_t option = info[0]->IntegerValue();
+    float min = 0;
+    float max = 0;
+    float step = 0;
+    float def = 0;
+    rs2_get_option_range(
+        GetOptionsPointer(), static_cast<rs2_option>(option), &min, &max, &step,
+        &def, &error_);
+    info.GetReturnValue().Set(RSOptionRange(min, max, step, def).GetObject());
+  }
+
+  void IsOptionReadonlyInternal(
+      const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    int32_t option = info[0]->IntegerValue();
+    auto val = rs2_is_option_read_only(
+        GetOptionsPointer(), static_cast<rs2_option>(option), &error_);
+    info.GetReturnValue().Set(Nan::New((val) ? true : false));
   }
 
  private:
-  rs2_options* options_;
   rs2_error* error_;
 };
 
-class RSSensor : public Nan::ObjectWrap {
+class RSSensor : public Nan::ObjectWrap, Options {
  public:
   static void Init(v8::Local<v8::Object> exports) {
     v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
@@ -1544,10 +1602,15 @@ class RSSensor : public Nan::ObjectWrap {
 
     auto me = Nan::ObjectWrap::Unwrap<RSSensor>(instance);
     me->sensor_ = sensor;
-    me->options_ = new Options(reinterpret_cast<rs2_options*>(sensor));
     return scope.Escape(instance);
   }
 
+  rs2_options* GetOptionsPointer() override {
+    // TODO(shaoting) find better way to avoid the reinterpret_cast which was
+    // caused the inheritance relation was hidden
+    return reinterpret_cast<rs2_options*>(sensor_);
+  }
+
   void ReplaceFrame(rs2_frame* raw_frame) {
     // clear old frame first.
     frame_->Replace(nullptr);
@@ -1567,8 +1630,7 @@ class RSSensor : public Nan::ObjectWrap {
 
  private:
   RSSensor() : sensor_(nullptr), error_(nullptr), profile_list_(nullptr),
-      frame_(nullptr), video_frame_(nullptr), depth_frame_(nullptr),
-      options_(nullptr) {}
+      frame_(nullptr), video_frame_(nullptr), depth_frame_(nullptr) {}
 
   ~RSSensor() {
     DestroyMe();
@@ -1583,8 +1645,6 @@ class RSSensor : public Nan::ObjectWrap {
     sensor_ = nullptr;
     if (profile_list_) rs2_delete_stream_profiles_list(profile_list_);
     profile_list_ = nullptr;
-    if (options_) delete options_;
-    options_ = nullptr;
   }
 
   static void New(const Nan::FunctionCallbackInfo<v8::Value>& info) {
@@ -1596,89 +1656,51 @@ class RSSensor : public Nan::ObjectWrap {
   }
 
   static NAN_METHOD(SupportsOption) {
-    int32_t option = info[0]->IntegerValue();
     auto me = Nan::ObjectWrap::Unwrap<RSSensor>(info.Holder());
-    if (me) {
-      auto on = me->options_->SupportsOption(static_cast<rs2_option>(option));
-      info.GetReturnValue().Set(Nan::New(on ? true : false));
-      return;
-    }
+    if (me) return me->SupportsOptionInternal(info);
+
     info.GetReturnValue().Set(Nan::False());
   }
 
   static NAN_METHOD(GetOption) {
-    int32_t option = info[0]->IntegerValue();
     auto me = Nan::ObjectWrap::Unwrap<RSSensor>(info.Holder());
-    if (me) {
-      auto value = me->options_->GetOption(static_cast<rs2_option>(option));
-      info.GetReturnValue().Set(Nan::New(value));
-      return;
-    }
+    if (me) return me->GetOptionInternal(info);
+
     info.GetReturnValue().Set(Nan::Undefined());
   }
 
   static NAN_METHOD(GetOptionDescription) {
-    int32_t option = info[0]->IntegerValue();
     auto me = Nan::ObjectWrap::Unwrap<RSSensor>(info.Holder());
-    if (me) {
-      auto desc = me->options_->GetOptionDescription(static_cast<rs2_option>(
-          option));
-      info.GetReturnValue().Set(Nan::New(desc).ToLocalChecked());
-      return;
-    }
+    if (me) return me->GetOptionDescriptionInternal(info);
+
     info.GetReturnValue().Set(Nan::Undefined());
   }
 
   static NAN_METHOD(GetOptionValueDescription) {
-    int32_t option = info[0]->IntegerValue();
-    auto val = info[1]->NumberValue();
     auto me = Nan::ObjectWrap::Unwrap<RSSensor>(info.Holder());
-    if (me) {
-      auto desc = me->options_->GetOptionValueDescription(
-          static_cast<rs2_option>(option), val);
-      if (desc) {
-        info.GetReturnValue().Set(Nan::New(desc).ToLocalChecked());
-        return;
-      }
-    }
+    if (me) return me->GetOptionValueDescriptionInternal(info);
+
     info.GetReturnValue().Set(Nan::Undefined());
   }
 
   static NAN_METHOD(SetOption) {
-    int32_t option = info[0]->IntegerValue();
-    auto value = info[1]->NumberValue();
     auto me = Nan::ObjectWrap::Unwrap<RSSensor>(info.Holder());
-    if (me) {
-      me->options_->SetOption(static_cast<rs2_option>(option), value);
-    }
+    if (me) return me->SetOptionInternal(info);
+
     info.GetReturnValue().Set(Nan::Undefined());
   }
 
   static NAN_METHOD(GetOptionRange) {
-    int32_t option = info[0]->IntegerValue();
     auto me = Nan::ObjectWrap::Unwrap<RSSensor>(info.Holder());
-    if (me) {
-      float min = 0;
-      float max = 0;
-      float step = 0;
-      float def = 0;
-      me->options_->GetOptionRange(static_cast<rs2_option>(option), &min, &max,
-          &step, &def);
-      info.GetReturnValue().Set(RSOptionRange(min, max, step, def).GetObject());
-      return;
-    }
+    if (me) return me->GetOptionRangeInternal(info);
+
     info.GetReturnValue().Set(Nan::Undefined());
   }
 
   static NAN_METHOD(IsOptionReadonly) {
-    int32_t option = info[0]->IntegerValue();
     auto me = Nan::ObjectWrap::Unwrap<RSSensor>(info.Holder());
-    if (me) {
-      auto val = me->options_->IsOptionReadonly(
-          static_cast<rs2_option>(option));
-      info.GetReturnValue().Set(Nan::New((val) ? true : false));
-      return;
-    }
+    if (me) return me->IsOptionReadonlyInternal(info);
+
     info.GetReturnValue().Set(Nan::False());
   }
 
@@ -1898,7 +1920,6 @@ class RSSensor : public Nan::ObjectWrap {
   RSFrame* frame_;
   RSFrame* video_frame_;
   RSFrame* depth_frame_;
-  Options* options_;
   friend class RSContext;
   friend class DevicesChangedCallbackInfo;
   friend class FrameCallbackInfo;
@@ -2312,6 +2333,11 @@ Nan::Persistent<v8::Function> RSDeviceList::constructor_;
 
 class RSContext : public Nan::ObjectWrap {
  public:
+  enum ContextType {
+    kNormal = 0,
+    kRecording,
+    kPlayback,
+  };
   static void Init(v8::Local<v8::Object> exports) {
     v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
     tpl->SetClassName(Nan::New("RSContext").ToLocalChecked());
@@ -2349,7 +2375,8 @@ class RSContext : public Nan::ObjectWrap {
   }
 
  private:
-  RSContext() : ctx_(nullptr), error_(nullptr) {}
+  explicit RSContext(ContextType type = kNormal) : ctx_(nullptr),
+      error_(nullptr), type_(type), mode_(RS2_RECORDING_MODE_BLANK_FRAMES) {}
 
   ~RSContext() {
     DestroyMe();
@@ -2365,20 +2392,52 @@ class RSContext : public Nan::ObjectWrap {
   }
 
   static void New(const Nan::FunctionCallbackInfo<v8::Value>& info) {
-    if (info.IsConstructCall()) {
-      RSContext* obj = new RSContext();
-      obj->Wrap(info.This());
-      info.GetReturnValue().Set(info.This());
-    }
+    if (!info.IsConstructCall())
+      return;
+
+    ContextType type = kNormal;
+    if (info.Length()) {
+      v8::String::Utf8Value type_str(info[0]->ToString());
+      std::string std_type_str(*type_str);
+      if (!std_type_str.compare("recording"))
+        type = kRecording;
+      else if (!std_type_str.compare("playback"))
+        type = kPlayback;
+    }
+    RSContext* obj = new RSContext(type);
+    if (type == kRecording || type == kPlayback) {
+      v8::String::Utf8Value file(info[1]->ToString());
+      v8::String::Utf8Value section(info[2]->ToString());
+      obj->file_name_ = std::string(*file);
+      obj->section_ = std::string(*section);
+    }
+    if (type == kRecording)
+      obj->mode_ = static_cast<rs2_recording_mode>(info[3]->IntegerValue());
+    obj->Wrap(info.This());
+    info.GetReturnValue().Set(info.This());
   }
 
   static NAN_METHOD(Create) {
     MainThreadCallback::Init();
+    info.GetReturnValue().Set(Nan::Undefined());
     auto me = Nan::ObjectWrap::Unwrap<RSContext>(info.Holder());
-    if (me) {
-      me->ctx_ = rs2_create_context(RS2_API_VERSION, &me->error_);
+    if (!me)
+      return;
+
+    switch (me->type_) {
+      case kRecording:
+        me->ctx_ = rs2_create_recording_context(RS2_API_VERSION,
+            me->file_name_.c_str(), me->section_.c_str(), me->mode_,
+            &me->error_);
+        break;
+      case kPlayback:
+        me->ctx_ = rs2_create_mock_context(RS2_API_VERSION,
+            me->file_name_.c_str(), me->section_.c_str(), &me->error_);
+        break;
+      default:
+        me->ctx_ = rs2_create_context(RS2_API_VERSION, &me->error_);
+        break;
     }
-    info.GetReturnValue().Set(Nan::True());
   }
 
   static NAN_METHOD(Destroy) {
@@ -2447,6 +2506,10 @@ class RSContext : public Nan::ObjectWrap {
   rs2_context* ctx_;
   rs2_error* error_;
   std::string device_changed_callback_name_;
+  ContextType type_;
+  std::string file_name_;
+  std::string section_;
+  rs2_recording_mode mode_;
   friend class DevicesChangedCallbackInfo;
   friend class RSPipeline;
   friend class RSDeviceHub;
@@ -3080,7 +3143,7 @@ bool RSConfig::CanResolveInternal(rs2_config* config,
     return rs2_config_can_resolve(config, pipe->pipeline_, error);
   }
 
-class RSColorizer : public Nan::ObjectWrap {
+class RSColorizer : public Nan::ObjectWrap, Options {
  public:
   static void Init(v8::Local<v8::Object> exports) {
     v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
@@ -3090,6 +3153,14 @@ class RSColorizer : public Nan::ObjectWrap {
     Nan::SetPrototypeMethod(tpl, "destroy", Destroy);
     Nan::SetPrototypeMethod(tpl, "create", Create);
     Nan::SetPrototypeMethod(tpl, "colorize", Colorize);
+    Nan::SetPrototypeMethod(tpl, "supportsOption", SupportsOption);
+    Nan::SetPrototypeMethod(tpl, "getOption", GetOption);
+    Nan::SetPrototypeMethod(tpl, "setOption", SetOption);
+    Nan::SetPrototypeMethod(tpl, "getOptionRange", GetOptionRange);
+    Nan::SetPrototypeMethod(tpl, "isOptionReadonly", IsOptionReadonly);
+    Nan::SetPrototypeMethod(tpl, "getOptionDescription", GetOptionDescription);
+    Nan::SetPrototypeMethod(tpl, "getOptionValueDescription",
+        GetOptionValueDescription);
 
     constructor_.Reset(tpl->GetFunction());
     exports->Set(Nan::New("RSColorizer").ToLocalChecked(), tpl->GetFunction());
@@ -3108,6 +3179,12 @@ class RSColorizer : public Nan::ObjectWrap {
     return scope.Escape(instance);
   }
 
+  rs2_options* GetOptionsPointer() override {
+    // TODO(shaoting) find better way to avoid the reinterpret_cast which was
+    // caused the inheritance relation was hidden
+    return reinterpret_cast<rs2_options*>(colorizer_);
+  }
+
  private:
   RSColorizer() : colorizer_(nullptr), frame_queue_(nullptr), error_(nullptr) {}
 
@@ -3171,6 +3248,55 @@ class RSColorizer : public Nan::ObjectWrap {
     info.GetReturnValue().Set(Nan::False());
   }
 
+  static NAN_METHOD(SupportsOption) {
+    auto me = Nan::ObjectWrap::Unwrap<RSColorizer>(info.Holder());
+    if (me) return me->SupportsOptionInternal(info);
+
+    info.GetReturnValue().Set(Nan::False());
+  }
+
+  static NAN_METHOD(GetOption) {
+    auto me = Nan::ObjectWrap::Unwrap<RSColorizer>(info.Holder());
+    if (me) return me->GetOptionInternal(info);
+
+    info.GetReturnValue().Set(Nan::Undefined());
+  }
+
+  static NAN_METHOD(GetOptionDescription) {
+    auto me = Nan::ObjectWrap::Unwrap<RSColorizer>(info.Holder());
+    if (me) return me->GetOptionDescriptionInternal(info);
+
+    info.GetReturnValue().Set(Nan::Undefined());
+  }
+
+  static NAN_METHOD(GetOptionValueDescription) {
+    auto me = Nan::ObjectWrap::Unwrap<RSColorizer>(info.Holder());
+    if (me) return me->GetOptionValueDescriptionInternal(info);
+
+    info.GetReturnValue().Set(Nan::Undefined());
+  }
+
+  static NAN_METHOD(SetOption) {
+    auto me = Nan::ObjectWrap::Unwrap<RSColorizer>(info.Holder());
+    if (me) return me->SetOptionInternal(info);
+
+    info.GetReturnValue().Set(Nan::Undefined());
+  }
+
+  static NAN_METHOD(GetOptionRange) {
+    auto me = Nan::ObjectWrap::Unwrap<RSColorizer>(info.Holder());
+    if (me) return me->GetOptionRangeInternal(info);
+
+    info.GetReturnValue().Set(Nan::Undefined());
+  }
+
+  static NAN_METHOD(IsOptionReadonly) {
+    auto me = Nan::ObjectWrap::Unwrap<RSColorizer>(info.Holder());
+    if (me) me->IsOptionReadonlyInternal(info);
+
+    info.GetReturnValue().Set(Nan::False());
+  }
+
  private:
   static Nan::Persistent<v8::Function> constructor_;
 
@@ -3432,6 +3558,11 @@ void InitModule(v8::Local<v8::Object> exports) {
   _FORCE_SET_ENUM(RS2_OPTION_MOTION_MODULE_TEMPERATURE);
   _FORCE_SET_ENUM(RS2_OPTION_DEPTH_UNITS);
   _FORCE_SET_ENUM(RS2_OPTION_ENABLE_MOTION_CORRECTION);
+  _FORCE_SET_ENUM(RS2_OPTION_AUTO_EXPOSURE_PRIORITY);
+  _FORCE_SET_ENUM(RS2_OPTION_COLOR_SCHEME);
+  _FORCE_SET_ENUM(RS2_OPTION_HISTOGRAM_EQUALIZATION_ENABLED);
+  _FORCE_SET_ENUM(RS2_OPTION_MIN_DISTANCE);
+  _FORCE_SET_ENUM(RS2_OPTION_MAX_DISTANCE);
   _FORCE_SET_ENUM(RS2_OPTION_COUNT);
 
   // rs2_camera_info
@@ -3465,6 +3596,12 @@ void InitModule(v8::Local<v8::Object> exports) {
   _FORCE_SET_ENUM(RS2_TIMESTAMP_DOMAIN_HARDWARE_CLOCK);
   _FORCE_SET_ENUM(RS2_TIMESTAMP_DOMAIN_SYSTEM_TIME);
   _FORCE_SET_ENUM(RS2_TIMESTAMP_DOMAIN_COUNT);
+
+  // rs2_recording_mode
+  _FORCE_SET_ENUM(RS2_RECORDING_MODE_BLANK_FRAMES);
+  _FORCE_SET_ENUM(RS2_RECORDING_MODE_COMPRESSED);
+  _FORCE_SET_ENUM(RS2_RECORDING_MODE_BEST_QUALITY);
+  _FORCE_SET_ENUM(RS2_RECORDING_MODE_COUNT);
 }
 
 NODE_MODULE(node_librealsense, InitModule);
diff --git a/wrappers/nodejs/test/test-colorizer.js b/wrappers/nodejs/test/test-colorizer.js
index 867de5563b..6b05750f37 100644
--- a/wrappers/nodejs/test/test-colorizer.js
+++ b/wrappers/nodejs/test/test-colorizer.js
@@ -54,13 +54,13 @@ describe('Colorizer test', function() {
     let n = 0;
     while (!endTest) {
       const frameSet = pipeline.waitForFrames();
-      const depthf = frameSet.depthFrame;
-      const colorf = frameSet.colorFrame;
-      frameSet.destroy();
       n++;
       console.log(`retring left ...${10 - n} times`);
-      if (colorf !== undefined &&
-        depthf !== undefined) {
+      if (frameSet !== undefined &&
+          frameSet.colorFrame !== undefined &&
+          frameSet.depthFrame !== undefined) {
+        const depthf = frameSet.depthFrame;
+        const colorf = frameSet.colorFrame;
         assert(depthf instanceof rs2.DepthFrame);
         assert(colorf instanceof rs2.VideoFrame);
         let videoFrame;
@@ -69,19 +69,19 @@ describe('Colorizer test', function() {
           videoFrame = colorizer.colorize(depthf);
         });
         assert(videoFrame instanceof rs2.VideoFrame);
-        assert.doesNotThrow(() => { // jshint ignore:line
+        assert.throws(() => { // jshint ignore:line
           videoFrameNull = colorizer.colorize();
         });
         assert(videoFrameNull === undefined);
         colorizer.destroy();
+        if (colorf) colorf.destroy();
+        if (depthf) depthf.destroy();
         endTest = true;
         if (videoFrame) videoFrame.destroy();
       }
       if (n >= 10) {
         assert(false, 'could not get colorFrame or depthFrame, try to reset camera');
       }
-      if (colorf) colorf.destroy();
-      if (depthf) depthf.destroy();
     }
     pipeline.destroy();
   });
diff --git a/wrappers/nodejs/test/test-context.js b/wrappers/nodejs/test/test-context.js
index 9f48bd4c64..5d196b17dc 100644
--- a/wrappers/nodejs/test/test-context.js
+++ b/wrappers/nodejs/test/test-context.js
@@ -29,20 +29,18 @@ describe('Context test', function() {
     assert(context._events instanceof EventEmitter);
   });
 
-  it('testing constructor - new Pointcloud, should get Pointcloud', () => {
-    let pointcloud;
+  it('testing constructor - new Context, should get Context', () => {
+    let context;
     assert.doesNotThrow(() => {
-      pointcloud = new librealsense2.Pointcloud();
+      context = new librealsense2.Context();
     });
-    assert(pointcloud instanceof librealsense2.Pointcloud);
+    assert(context instanceof librealsense2.Context);
   });
 
-  it('testing constructor - new Pointcloud, invalid 1 option', () => {
-    let pointcloud;
-    assert.doesNotThrow(() => {
-      pointcloud = new librealsense2.Pointcloud(1);
+  it('testing constructor - new Context, invalid 1 option', () => {
+    assert.throws(() => {
+      new librealsense2.Context(1);
     });
-    assert(pointcloud instanceof librealsense2.Pointcloud);
   });
 
   it('testing method - destroy, call 1 time', () => {
diff --git a/wrappers/nodejs/test/test-depthsensor.js b/wrappers/nodejs/test/test-depthsensor.js
index cc7bb19bad..d2f17923c5 100644
--- a/wrappers/nodejs/test/test-depthsensor.js
+++ b/wrappers/nodejs/test/test-depthsensor.js
@@ -13,7 +13,7 @@ let depthSensor;
 describe('Device test', function() {
   before(function() {
     ctx = new rs2.Context();
-    const devices = ctx.queryDevices();
+    const devices = ctx.queryDevices().devices;
     assert(devices.length > 0); // Device must be connected
     const dev = devices[0];
     const pipeline = new rs2.Pipeline();
@@ -33,7 +33,7 @@ describe('Device test', function() {
   });
 
   it('Testing constructor', () => {
-    assert.throws(() => {
+    assert.doesNotThrow(() => {
       new rs2.DepthFrame();
     });
   });
diff --git a/wrappers/nodejs/test/test-device.js b/wrappers/nodejs/test/test-device.js
index 2fa3a0122f..6903ae5e3a 100644
--- a/wrappers/nodejs/test/test-device.js
+++ b/wrappers/nodejs/test/test-device.js
@@ -13,7 +13,7 @@ let dev;
 describe('Device test', function() {
   beforeEach(function() {
     ctx = new rs2.Context();
-    const devices = ctx.queryDevices();
+    const devices = ctx.queryDevices().devices;
     assert(devices.length > 0); // Device must be connected
     dev = devices[0];
   });
@@ -45,24 +45,24 @@ describe('Device test', function() {
 
   it('Testing method getCameraInfo - return value', () => {
     let rtn = dev.getCameraInfo();
-    // assert.equal(typeof rtn.deviceName, 'string');
-    // assert.equal(typeof rtn.moduleName, 'string');
+    // assert.equal(typeof rtn.deviceName, 'string'); // skip deviceName checking
+    // assert.equal(typeof rtn.moduleName, 'string'); // skip moduleName checking
     assert.equal(typeof rtn.serialNumber, 'string');
     assert.equal(typeof rtn.firmwareVersion, 'string');
     assert.equal(typeof rtn.location, 'string');
     assert.equal(typeof rtn.debugOpCode, 'string');
     assert.equal(typeof rtn.advancedMode, 'string');
     assert.equal(typeof rtn.productId, 'string');
-    // assert.equal(typeof rtn.cameraLocked, 'boolean');
+    // assert.equal(typeof rtn.cameraLocked, 'boolean'); // skip cameraLocked checking
   });
 
   it('Testing method getCameraInfo - with argument', () => {
     for (let i in rs2.camera_info) {
       if (rs2.camera_info[i] &&
-      i.toUpperCase() !== 'CAMERA_INFO_LOCATION' && // BUG-7429
-      i.toUpperCase() !== 'CAMERA_INFO_COUNT' && // skip counter
-      i.toUpperCase() !== 'CAMERA_INFO_CAMERA_LOCKED' &&
-      i !== 'cameraInfoToString' // skip method
+        i.toUpperCase() !== 'CAMERA_INFO_LOCATION' && // location is not ready
+        i.toUpperCase() !== 'CAMERA_INFO_COUNT' && // skip counter
+        i.toUpperCase() !== 'CAMERA_INFO_CAMERA_LOCKED' &&
+        i !== 'cameraInfoToString' // skip method
       ) {
         assert.doesNotThrow(() => { // jshint ignore:line
           dev.getCameraInfo(rs2.camera_info[i]);
diff --git a/wrappers/nodejs/test/test-frame.js b/wrappers/nodejs/test/test-frame.js
index 525834d8d8..befdfd9684 100644
--- a/wrappers/nodejs/test/test-frame.js
+++ b/wrappers/nodejs/test/test-frame.js
@@ -24,7 +24,7 @@ describe('Frame test', function() {
   });
 
   it('Testing constructor', () => {
-    assert.throws(() => {
+    assert.doesNotThrow(() => {
       new rs2.Frame();
     });
   });
@@ -55,7 +55,6 @@ describe('Frame test', function() {
     assert.equal(typeof frame.timestamp, 'number');
   });
 
-  // DSO-7440
   it.skip('Testing property streamType', () => {
     assert.equal(typeof frame.streamType, 'number');
   });
diff --git a/wrappers/nodejs/test/test-frameset.js b/wrappers/nodejs/test/test-frameset.js
new file mode 100644
index 0000000000..475f56af79
--- /dev/null
+++ b/wrappers/nodejs/test/test-frameset.js
@@ -0,0 +1,113 @@
+// Copyright (c) 2017 Intel Corporation. All rights reserved.
+// Use of this source code is governed by an Apache 2.0 license
+// that can be found in the LICENSE file.
+
+'use strict';
+
+/* global describe, it, before, after */
+const assert = require('assert');
+const rs2 = require('../index.js');
+
+let frameset;
+describe('FrameSet test', function() {
+  before(function() {
+    const pipeline = new rs2.Pipeline();
+    pipeline.start();
+    while (frameset === undefined) {
+      const f = pipeline.waitForFrames();
+      if (f.size > 1) {
+        frameset = f;
+      }
+    }
+  });
+
+  after(function() {
+    rs2.cleanup();
+  });
+
+  it('Testing constructor', () => {
+    assert.doesNotThrow(() => {
+      new rs2.FrameSet();
+    });
+  });
+
+  it('Testing member size', () => {
+    assert.equal(typeof frameset.size, 'number');
+  });
+
+  it('Testing member depthFrame', () => {
+    assert(frameset.depthFrame instanceof rs2.DepthFrame);
+  });
+
+  it('Testing member colorFrame', () => {
+    assert(frameset.colorFrame instanceof rs2.VideoFrame);
+  });
+
+  it('Testing method at - 0 argument', () => {
+    assert.doesNotThrow(() => {
+      frameset.at();
+    });
+  });
+
+  it('Testing method at - invalid argument', () => {
+    const len = frameset.size;
+    let f;
+    assert.doesNotThrow(() => {
+      f = frameset.at(len + 1);
+    });
+    assert.equal(f, undefined);
+  });
+
+  it('Testing method at - valid argument', () => {
+    const len = frameset.size;
+    for (let i = 0; i < len; i++) {
+      let f;
+      assert.doesNotThrow(() => { // jshint ignore:line
+        f = frameset.at(i);
+      });
+      assert(f instanceof rs2.DepthFrame || f instanceof rs2.VideoFrame);
+    }
+  });
+
+  it('Testing method getFrame - 0 argument', () => {
+    assert.throws(() => {
+      frameset.getFrame();
+    });
+  });
+
+  it('Testing method getFrame - invalid argument', () => {
+    assert.throws(() => {
+      frameset.getFrame('dummy');
+    });
+  });
+
+  it('Testing method getFrame - valid argument', () => {
+    for (let i in rs2.stream) {
+      if (rs2.stream[i] &&
+        i.toUpperCase() !== 'STREAM_COUNT' && // skip counter
+        i !== 'streamToString' // skip method
+      ) {
+        assert.doesNotThrow(() => { // jshint ignore:line
+          frameset.getFrame(rs2.stream[i]);
+        });
+        assert.doesNotThrow(() => { // jshint ignore:line
+          frameset.getFrame(rs2.stream[i]);
+        });
+      }
+    }
+  });
+
+  it('Testing method getFrame - stream_depth', () => {
+    let d = frameset.getFrame(rs2.stream['stream_depth']); // jshint ignore:line
+    assert(d instanceof rs2.DepthFrame);
+    let D = frameset.getFrame(rs2.stream['STREAM_DEPTH']); // jshint ignore:line
+    assert(D instanceof rs2.DepthFrame);
+  });
+
+  it('Testing method getFrame - stream_color', () => {
+    let d = frameset.getFrame(rs2.stream['stream_color']); // jshint ignore:line
+    assert(d instanceof rs2.VideoFrame);
+    let D = frameset.getFrame(rs2.stream['STREAM_COLOR']); // jshint ignore:line
+    assert(D instanceof rs2.VideoFrame);
+  });
+});
diff --git a/wrappers/nodejs/test/test-functional.js b/wrappers/nodejs/test/test-functional.js
index 6ede45967c..c98df97d55 100644
--- a/wrappers/nodejs/test/test-functional.js
+++ b/wrappers/nodejs/test/test-functional.js
@@ -193,6 +193,29 @@ describe('Colorizer test', function() {
     assert.equal(depthRGB.width, depth.width);
     assert.equal(depthRGB.format, rs2.format.FORMAT_RGB8);
   });
+  it('colorizer option API test', () => {
+    for (let i = rs2.option.OPTION_BACKLIGHT_COMPENSATION; i < rs2.option.OPTION_COUNT; i++) {
+      let readonly = colorizer.isOptionReadOnly(i);
+      assert.equal((readonly === undefined) || (typeof readonly === 'boolean'), true);
+      let supports = colorizer.supportsOption(i);
+      assert.equal((supports === undefined) || (typeof supports === 'boolean'), true);
+      let value = colorizer.getOption(i);
+      assert.equal((value === undefined) || (typeof value === 'number'), true);
+      let des = colorizer.getOptionDescription(i);
+      assert.equal((des === undefined) || (typeof des === 'string'), true);
+      des = colorizer.getOptionDescription(i, 1);
+      assert.equal((des === undefined) || (typeof des === 'string'), true);
+
+      if (supports && !readonly) {
+        let range = colorizer.getOptionRange(i);
+        for (let j = range.minvalue; j <= range.maxValue; j += range.step) {
+          colorizer.setOption(i, j);
+          let val = colorizer.getOption(i);
+          assert.equal(val, j);
+        }
+      }
+    }
+  });
 });
 
 
@@ -414,9 +437,6 @@ describe('Sensor tests', function() {
   it('Notification test', () => {
     return new Promise((resolve, reject) => {
       let dev = ctx.queryDevices().devices[0];
-      setTimeout(() => {
-        dev.cxxDev.triggerErrorForTest();
-      }, 500);
       sensors[0].setNotificationsCallback((n) => {
         assert.equal(typeof n.descr, 'string');
         assert.equal(typeof n.timestamp, 'number');
@@ -424,6 +444,9 @@ describe('Sensor tests', function() {
         assert.equal(typeof n.category, 'number');
         resolve();
       });
+      setTimeout(() => {
+        dev.cxxDev.triggerErrorForTest();
+      }, 100);
     });
   });
 });
diff --git a/wrappers/nodejs/test/test-pipeline.js b/wrappers/nodejs/test/test-pipeline.js
index ed2e9f5dc7..ce59de8d7e 100644
--- a/wrappers/nodejs/test/test-pipeline.js
+++ b/wrappers/nodejs/test/test-pipeline.js
@@ -87,7 +87,7 @@ describe('Pipeline test', function() {
       pipeline.start();
       pipeline.stop();
       pipeline.destroy();
-    });
+   });
   });
 
   it('Testing method waitForFrames', () => {
@@ -97,7 +97,6 @@ describe('Pipeline test', function() {
       pipeline = new rs2.Pipeline();
       pipeline.start();
       frameSet = pipeline.waitForFrames();
-      frameSet.destroy();
     });
     let endTest = false;
     let n = 0;
@@ -111,8 +110,6 @@ describe('Pipeline test', function() {
         assert(frameSet.colorFrame instanceof rs2.VideoFrame);
         endTest = true;
       }
-      // always destroy it
-      frameSet.destroy();
       if (n >= 10) {
         assert(false, 'could not get colorFrame or depthFrame, try to reset camera');
       }
diff --git a/wrappers/nodejs/test/test-pointcloud.js b/wrappers/nodejs/test/test-pointcloud.js
index 848be85ce3..2c5dc1e782 100644
--- a/wrappers/nodejs/test/test-pointcloud.js
+++ b/wrappers/nodejs/test/test-pointcloud.js
@@ -23,7 +23,7 @@ describe('Pointcloud test', function() {
   it('Testing method destroy', () => {
     let pointcloud;
     assert.doesNotThrow(() => {
-      pointcloud= new rs2.Pointcloud();
+      pointcloud= new rs2.PointCloud();
       pointcloud.destroy();
     });
     setTimeout(() => {
@@ -37,7 +37,7 @@ describe('Pointcloud test', function() {
     let pointcloud;
     assert.doesNotThrow(() => {
       pipeline = new rs2.Pipeline();
-      pointcloud = new rs2.Pointcloud();
+      pointcloud = new rs2.PointCloud();
       pipeline.start();
     });
     let endTest = false;
@@ -56,7 +56,7 @@ describe('Pointcloud test', function() {
           points = pointcloud.calculate(frameSet.depthFrame);
         });
         assert(points instanceof rs2.Points);
-        assert.doesNotThrow(() => { // jshint ignore:line
+        assert.throws(() => { // jshint ignore:line
           pointsNull = pointcloud.calculate();
         });
         assert(pointsNull === undefined);
@@ -77,7 +77,7 @@ describe('Pointcloud test', function() {
     let pointcloud;
     assert.doesNotThrow(() => {
       pipeline = new rs2.Pipeline();
-      pointcloud = new rs2.Pointcloud();
+      pointcloud = new rs2.PointCloud();
       pipeline.start();
     });
     let endTest = false;
diff --git a/wrappers/nodejs/test/test-points.js b/wrappers/nodejs/test/test-points.js
index 2f6bd6ecf1..30a26c4bbd 100644
--- a/wrappers/nodejs/test/test-points.js
+++ b/wrappers/nodejs/test/test-points.js
@@ -20,13 +20,13 @@ describe('Points test', function() {
     rs2.cleanup();
   });
 
-  it('Testing method getTextureCoordinates', () => {
+  it('Testing member textureCoordinates', () => {
     let pipeline;
     let frameSet;
     let pointcloud;
     assert.doesNotThrow(() => {
       pipeline = new rs2.Pipeline();
-      pointcloud = new rs2.Pointcloud();
+      pointcloud = new rs2.PointCloud();
       pipeline.start();
     });
     let endTest = false;
@@ -41,7 +41,7 @@ describe('Points test', function() {
         let arr;
         assert.doesNotThrow(() => { // jshint ignore:line
           points = pointcloud.calculate(frameSet.depthFrame);
-          arr = points.getTextureCoordinates();
+          arr = points.textureCoordinates;
         });
         assert.equal(typeof arr[0], 'number');
         assert.equal(Object.prototype.toString.call(arr), '[object Int32Array]');
@@ -56,13 +56,13 @@ describe('Points test', function() {
     pipeline.destroy();
   });
 
-  it('Testing method getVertices', () => {
+  it('Testing member vertices', () => {
     let pipeline;
     let frameSet;
     let pointcloud;
     assert.doesNotThrow(() => {
       pipeline = new rs2.Pipeline();
-      pointcloud = new rs2.Pointcloud();
+      pointcloud = new rs2.PointCloud();
       pipeline.start();
     });
     let endTest = false;
@@ -77,7 +77,7 @@ describe('Points test', function() {
         let arr;
         assert.doesNotThrow(() => { // jshint ignore:line
           points = pointcloud.calculate(frameSet.depthFrame);
-          arr = points.getVertices();
+          arr = points.vertices;
         });
         assert.equal(typeof arr[0], 'number');
         assert.equal(Object.prototype.toString.call(arr), '[object Float32Array]');
diff --git a/wrappers/nodejs/test/test-sensor.js b/wrappers/nodejs/test/test-sensor.js
index 342a930b2d..d6cc01cd82 100644
--- a/wrappers/nodejs/test/test-sensor.js
+++ b/wrappers/nodejs/test/test-sensor.js
@@ -49,10 +49,18 @@ describe('Sensor test', function() {
     sensors.forEach((sensor) => {
       Object.keys(rs2.option).forEach((o) => {
         if (o === 'OPTION_COUNT' || o === 'optionToString') return;
-        assert.equal(typeof sensor.isOptionReadOnly(rs2.option[o]), 'boolean');
+        if (sensor.supportsOption(rs2.option[o])) {
+          assert.equal(typeof sensor.isOptionReadOnly(rs2.option[o]), 'boolean');
+        } else {
+          assert.equal(typeof sensor.isOptionReadOnly(rs2.option[o]), 'undefined');
+        }
       });
       optionsTestArray.forEach((o) => {
-        assert.equal(typeof sensor.isOptionReadOnly(o), 'boolean');
+        if (sensor.supportsOption(o)) {
+          assert.equal(typeof sensor.isOptionReadOnly(o), 'boolean');
+        } else {
+          assert.equal(typeof sensor.isOptionReadOnly(o), 'undefined');
+        }
       });
     });
   });
@@ -103,10 +111,18 @@ describe('Sensor test', function() {
     sensors.forEach((sensor) => {
       Object.keys(rs2.option).forEach((o) => {
         if (o === 'OPTION_COUNT' || o === 'optionToString') return;
-        assert.equal(typeof sensor.getOption(rs2.option[o]), 'number');
+        if (sensor.supportsOption(rs2.option[o])) {
+          assert.equal(typeof sensor.getOption(rs2.option[o]), 'number');
+        } else {
+          assert.equal(typeof sensor.getOption(rs2.option[o]), 'undefined');
+        }
       });
       optionsTestArray.forEach((o) => {
-        assert.equal(typeof sensor.getOption(o), 'number');
+        if (sensor.supportsOption(o)) {
+          assert.equal(typeof sensor.getOption(o), 'number');
+        } else {
+          assert.equal(typeof sensor.getOption(o), 'undefined');
+        }
       });
     });
   });
@@ -134,20 +150,28 @@ describe('Sensor test', function() {
     sensors.forEach((sensor) => {
       Object.keys(rs2.option).forEach((o) => {
         if (o === 'OPTION_COUNT' || o === 'optionToString') return;
-        const r = sensor.getOptionRange(rs2.option[o]);
-        assert.equal(typeof r, 'object');
-        assert.equal(typeof r.minValue, 'number');
-        assert.equal(typeof r.maxValue, 'number');
-        assert.equal(typeof r.defaultValue, 'number');
-        assert.equal(typeof r.step, 'number');
+        if (sensor.supportsOption(rs2.option[o])) {
+          const r = sensor.getOptionRange(rs2.option[o]);
+          assert.equal(typeof r, 'object');
+          assert.equal(typeof r.minValue, 'number');
+          assert.equal(typeof r.maxValue, 'number');
+          assert.equal(typeof r.defaultValue, 'number');
+          assert.equal(typeof r.step, 'number');
+        } else {
+          assert.equal(typeof sensor.getOptionRange(rs2.option[o]), 'undefined');
+        }
       });
       optionsTestArray.forEach((o) => {
-        const r = sensor.getOptionRange(o);
-        assert.equal(typeof r, 'object');
-        assert.equal(typeof r.minValue, 'number');
-        assert.equal(typeof r.maxValue, 'number');
-        assert.equal(typeof r.defaultValue, 'number');
-        assert.equal(typeof r.step, 'number');
+        if (sensor.supportsOption(o)) {
+          const r = sensor.getOptionRange(o);
+          assert.equal(typeof r, 'object');
+          assert.equal(typeof r.minValue, 'number');
+          assert.equal(typeof r.maxValue, 'number');
+          assert.equal(typeof r.defaultValue, 'number');
+          assert.equal(typeof r.step, 'number');
+        } else {
+          assert.equal(typeof sensor.getOptionRange(o), 'undefined');
+        }
       });
     });
   });
diff --git a/wrappers/python/examples/align-depth2color.py b/wrappers/python/examples/align-depth2color.py
new file mode 100644
index 0000000000..420276e9bf
--- /dev/null
+++ b/wrappers/python/examples/align-depth2color.py
@@ -0,0 +1,77 @@
+## License: Apache 2.0. See LICENSE file in root directory.
+## Copyright(c) 2017 Intel Corporation. All Rights Reserved.
+
+#####################################################
+##              Align Depth to Color               ##
+#####################################################
+
+# First import the library
+import pyrealsense2 as rs
+# Import Numpy for easy array manipulation
+import numpy as np
+# Import OpenCV for easy image rendering
+import cv2
+
+# Create a pipeline
+pipeline = rs.pipeline()
+
+#Create a config and configure the pipeline to stream
+#  different resolutions of color and depth streams
+config = rs.config()
+config.enable_stream(rs.stream.depth, 640, 360, rs.format.z16, 30)
+config.enable_stream(rs.stream.color, 640, 480, rs.format.bgr8, 30)
+
+# Start streaming
+profile = pipeline.start(config)
+
+# Getting the depth sensor's depth scale (see rs-align example for explanation)
+depth_sensor = profile.get_device().first_depth_sensor()
+depth_scale = depth_sensor.get_depth_scale()
+print "Depth Scale is: " , depth_scale
+
+# We will be removing the background of objects more than
+#  clipping_distance_in_meters meters away
+clipping_distance_in_meters = 1 #1 meter
+clipping_distance = clipping_distance_in_meters / depth_scale
+
+# Create an align object
+# rs.align allows us to perform alignment of depth frames to others frames
+# The "align_to" is the stream type to which we plan to align depth frames.
+align_to = rs.stream.color
+align = rs.align(align_to)
+
+# Streaming loop
+try:
+    while True:
+        # Get frameset of color and depth
+        frames = pipeline.wait_for_frames()
+        # frames.get_depth_frame() is a 640x360 depth image
+        
+        # Align the depth frame to color frame
+        aligned_frames = align.proccess(frames)
+        
+        # Get aligned frames
+        aligned_depth_frame = aligned_frames.get_depth_frame() # aligned_depth_frame is a 640x480 depth image
+        color_frame = aligned_frames.get_color_frame()
+        
+        # Validate that both frames are valid
+        if not aligned_depth_frame or not color_frame:
+            continue
+        
+        depth_image = np.asanyarray(aligned_depth_frame.get_data())
+        color_image = np.asanyarray(color_frame.get_data())
+        
+        # Remove background - Set pixels further than clipping_distance to grey
+        grey_color = 153
+        depth_image_3d = np.dstack((depth_image,depth_image,depth_image)) #depth image is 1 channel, color is 3 channels
+        bg_removed = np.where((depth_image_3d > clipping_distance) | (depth_image_3d <= 0), grey_color, color_image)#& (depth_image_3d < 0.1)
+        
+        # Render images
+        depth_colormap = cv2.applyColorMap(cv2.convertScaleAbs(depth_image, None, 0.5, 0), cv2.COLORMAP_JET)
+        images = np.hstack((bg_removed, depth_colormap))
+        cv2.namedWindow('Align Example', cv2.WINDOW_AUTOSIZE)
+        cv2.imshow('Align Example', images)
+        cv2.waitKey(1)
+finally:
+    pipeline.stop()
+
diff --git a/wrappers/python/opencv_viewer_example.py b/wrappers/python/examples/opencv_viewer_example.py
similarity index 82%
rename from wrappers/python/opencv_viewer_example.py
rename to wrappers/python/examples/opencv_viewer_example.py
index 3c069a72fe..642188e5ab 100644
--- a/wrappers/python/opencv_viewer_example.py
+++ b/wrappers/python/examples/opencv_viewer_example.py
@@ -1,3 +1,10 @@
+## License: Apache 2.0. See LICENSE file in root directory.
+## Copyright(c) 2015-2017 Intel Corporation. All Rights Reserved.
+
+###############################################
+##      Open CV and Numpy integration        ##
+###############################################
+
 import pyrealsense2 as rs
 import numpy as np
 import cv2
diff --git a/wrappers/python/pybackend_example_1_general.py b/wrappers/python/examples/pybackend_example_1_general.py
similarity index 97%
rename from wrappers/python/pybackend_example_1_general.py
rename to wrappers/python/examples/pybackend_example_1_general.py
index 9fcde5d8e3..910b6f1b40 100644
--- a/wrappers/python/pybackend_example_1_general.py
+++ b/wrappers/python/examples/pybackend_example_1_general.py
@@ -1,5 +1,5 @@
 ## License: Apache 2.0. See LICENSE file in root directory.
-## Copyright(c) 2015 Intel Corporation. All Rights Reserved.
+## Copyright(c) 2015-2017 Intel Corporation. All Rights Reserved.
 
 ###############################################
 ## pybackend example #1 - A general overview ##
diff --git a/wrappers/python/python-rs400-advanced-mode-example.py b/wrappers/python/examples/python-rs400-advanced-mode-example.py
similarity index 100%
rename from wrappers/python/python-rs400-advanced-mode-example.py
rename to wrappers/python/examples/python-rs400-advanced-mode-example.py
diff --git a/wrappers/python/python-tutorial-1-depth.py b/wrappers/python/examples/python-tutorial-1-depth.py
similarity index 96%
rename from wrappers/python/python-tutorial-1-depth.py
rename to wrappers/python/examples/python-tutorial-1-depth.py
index 3cebd581f4..5dc5328c8a 100644
--- a/wrappers/python/python-tutorial-1-depth.py
+++ b/wrappers/python/examples/python-tutorial-1-depth.py
@@ -1,5 +1,5 @@
 ## License: Apache 2.0. See LICENSE file in root directory.
-## Copyright(c) 2015 Intel Corporation. All Rights Reserved.
+## Copyright(c) 2015-2017 Intel Corporation. All Rights Reserved.
 
 #####################################################
 ## librealsense tutorial #1 - Accessing depth data ##
diff --git a/wrappers/python/examples/readme.md b/wrappers/python/examples/readme.md
new file mode 100644
index 0000000000..b688f3c780
--- /dev/null
+++ b/wrappers/python/examples/readme.md
@@ -0,0 +1,12 @@
+
+# Sample Code for Intel® RealSense™ Python Wrapper
+
+These Examples demonstrate how to use the python wrapper of the SDK.
+
+## List of Exmples:
+
+1. [Tutorial 1](./python-tutorial-1-depth.py) - Demonstrates how to start streaming depth frames from the camera and display the image in the console as an ASCII art.
+2. [NumPy and OpenCV](./opencv_viewer_example.py) - Example of rendering depth and color images using the help of OpenCV and Numpy
+3. [Stream Alignment](./align-depth2color.py) - Demonstrate a way of performing background removal by aligning depth images to color images and performing simple calculation to strip the background.
+4. [RS400 Advanced Mode](./python-rs400-advanced-mode-example.py) - Example of the advanced mode interface for controlling different options of the D400 cameras
+5. [Realsense Backend](./pybackend_example_1_general.py) - Example of controlling devices using the backend interface
diff --git a/wrappers/python/pybackend.cpp b/wrappers/python/pybackend.cpp
index a3617c5d47..30be44744c 100644
--- a/wrappers/python/pybackend.cpp
+++ b/wrappers/python/pybackend.cpp
@@ -230,7 +230,7 @@ PYBIND11_PLUGIN(NAME) {
         .def("probe_and_commit",
             [](platform::retry_controls_work_around& dev, const platform::stream_profile& profile,
                 std::function<void(const platform::stream_profile&, const platform::frame_object&)> callback) {
-        dev.probe_and_commit(profile, false, [=](const platform::stream_profile& p,
+        dev.probe_and_commit(profile, [=](const platform::stream_profile& p,
             const platform::frame_object& fo, std::function<void()> next)
         {
             callback(p, fo);
diff --git a/wrappers/python/python.cpp b/wrappers/python/python.cpp
index 1f800d271e..1f90784d59 100644
--- a/wrappers/python/python.cpp
+++ b/wrappers/python/python.cpp
@@ -187,6 +187,10 @@ PYBIND11_PLUGIN(NAME) {
           .value("depth_units", RS2_OPTION_DEPTH_UNITS)
           .value("enable_motion_correction", RS2_OPTION_ENABLE_MOTION_CORRECTION)
           .value("auto_exposure_priority", RS2_OPTION_AUTO_EXPOSURE_PRIORITY)
+          .value("color_scheme", RS2_OPTION_COLOR_SCHEME)
+          .value("histogram_equalization_enabled", RS2_OPTION_HISTOGRAM_EQUALIZATION_ENABLED)
+          .value("min_distance", RS2_OPTION_MIN_DISTANCE)
+          .value("max_distance", RS2_OPTION_MAX_DISTANCE)
           .value("count", RS2_OPTION_COUNT);
 
     // Multi-dimensional c-array rs2_motion_device_instrinc::data causing trouble
@@ -462,9 +466,24 @@ PYBIND11_PLUGIN(NAME) {
                     }, "Poll if a new frame is available and dequeue it if it is")
                .def("__call__", &rs2::frame_queue::operator());
 
+    // Base class for options interface. Should be used via sensor
+    py::class_<rs2::options> options(m, "options");
+    options.def("is_option_read_only", &rs2::options::is_option_read_only, "Check if particular option "
+        "is read only.", "option"_a)
+        .def("get_option", &rs2::options::get_option, "Read option value from the device.", "option"_a)
+        .def("get_option_range", &rs2::options::get_option_range, "Retrieve the available range of values "
+            "of a supported option", "option"_a)
+        .def("set_option", &rs2::options::set_option, "Write new value to device option", "option"_a, "value"_a)
+        .def("supports", (bool (rs2::options::*)(rs2_option option) const) &rs2::options::supports, "Check if particular "
+            "option is supported by a subdevice", "option"_a)
+        .def("get_option_description", &rs2::options::get_option_description, "Get option description.", "option"_a)
+        .def("get_option_value_description", &rs2::options::get_option_value_description, "Get option value description "
+            "(In case a specific option value holds special meaning)", "option"_a, "value"_a);
+
     py::class_<rs2::pointcloud> pointcloud(m, "pointcloud");
-    pointcloud.def("calculate", &rs2::pointcloud::calculate, "depth"_a)
-              .def("map_to", &rs2::pointcloud::map_to, "mapped"_a);
+    pointcloud.def(py::init<>())
+        .def("calculate", &rs2::pointcloud::calculate, "depth"_a)
+        .def("map_to", &rs2::pointcloud::map_to, "mapped"_a);
 
     py::class_<rs2::syncer> syncer(m, "syncer");
     syncer.def(py::init<>())
@@ -478,11 +497,15 @@ PYBIND11_PLUGIN(NAME) {
                }, "Check if a coherent set of frames is available");
           /*.def("__call__", &rs2::syncer::operator(), "frame"_a)*/;
 
-    py::class_<rs2::colorizer> colorizer(m, "colorizer");
+    py::class_<rs2::colorizer, rs2::options> colorizer(m, "colorizer");
     colorizer.def(py::init<>())
              .def("colorize", &rs2::colorizer::colorize, "depth"_a)
              /*.def("__call__", &rs2::colorizer::operator())*/;
 
+    py::class_<rs2::align> align(m, "align");
+    align.def(py::init<rs2_stream>(), "align_to"_a)
+        .def("proccess", &rs2::align::proccess, "depth"_a);
+
     /* rs2_record_playback.hpp */
     py::class_<rs2::playback, rs2::device> playback(m, "playback");
     playback.def(py::init<rs2::device>(), "device"_a)
@@ -562,36 +585,26 @@ PYBIND11_PLUGIN(NAME) {
             "Retrieve the notification's severity.");
 
     // not binding notifications_callback, templated
-
-    py::class_<rs2::sensor> sensor(m, "sensor");
+    py::class_<rs2::sensor, rs2::options> sensor(m, "sensor");
     sensor.def("open", (void (rs2::sensor::*)(const rs2::stream_profile&) const) &rs2::sensor::open,
-               "Open subdevice for exclusive access, by commiting to a configuration", "profile"_a)
-          .def("supports", (bool (rs2::sensor::*)(rs2_camera_info) const) &rs2::device::supports,
-               "Check if speific camera info is supported.", "info")
+               "Open sensor for exclusive access, by commiting to a configuration", "profile"_a)
+          .def("supports", (bool (rs2::sensor::*)(rs2_camera_info) const) &rs2::sensor::supports,
+               "Check if specific camera info is supported.", "info")
+          .def("supports", (bool (rs2::sensor::*)(rs2_option) const) &rs2::options::supports,
+            "Check if specific camera info is supported.", "info")
           .def("get_info", &rs2::sensor::get_info, "Retrieve camera specific information, "
                "like versions of various internal components.", "info"_a)
+           .def("set_notifications_callback", [](const rs2::sensor& self, std::function<void(rs2::notification)> callback)
+               { self.set_notifications_callback(callback); }, "Register Notifications callback", "callback"_a)
           .def("open", (void (rs2::sensor::*)(const std::vector<rs2::stream_profile>&) const) &rs2::sensor::open,
-               "Open subdevice for exclusive access, by committing to a composite configuration, specifying one or "
+               "Open sensor for exclusive access, by committing to a composite configuration, specifying one or "
                "more stream profiles.", "profiles"_a)
-          .def("close", [](const rs2::sensor& self){ py::gil_scoped_release lock; self.close(); }, "Close subdevice for exclusive access.")
+          .def("close", [](const rs2::sensor& self){ py::gil_scoped_release lock; self.close(); }, "Close sensor for exclusive access.")
           .def("start", [](const rs2::sensor& self, std::function<void(rs2::frame)> callback)
                { self.start(callback); }, "Start passing frames into user provided callback.", "callback"_a)
           .def("start", [](const rs2::sensor& self, rs2::frame_queue& queue) { self.start(queue); })
           .def("stop", &rs2::sensor::stop, "Stop streaming.")
-          .def("is_option_read_only", &rs2::sensor::is_option_read_only, "Check if particular option "
-               "is read only.", "option"_a)
-          .def("set_notifications_callback", [](const rs2::sensor& self, std::function<void(rs2::notification)> callback)
-               { self.set_notifications_callback(callback); }, "Register Notifications callback", "callback"_a)
-          .def("get_option", &rs2::sensor::get_option, "Read option value from the device.", "option"_a)
-          .def("get_option_range", &rs2::sensor::get_option_range, "Retrieve the available range of values "
-               "of a supported option", "option"_a)
-          .def("set_option", &rs2::sensor::set_option, "Write new value to device option", "option"_a, "value"_a)
-          .def("supports", (bool (rs2::sensor::*)(rs2_option option) const) &rs2::sensor::supports, "Check if particular "
-               "option is supported by a subdevice", "option"_a)
-          .def("get_option_description", &rs2::sensor::get_option_description, "Get option description.", "option"_a)
-          .def("get_option_value_description", &rs2::sensor::get_option_value_description, "Get option value description "
-               "(In case a specific option value holds special meaning)", "option"_a, "value"_a)
-          .def("get_stream_profiles", &rs2::sensor::get_stream_profiles, "Check if physical subdevice is supported.")
+          .def("get_stream_profiles", &rs2::sensor::get_stream_profiles, "Check if physical sensor is supported.")
           .def("get_motion_intrinsics", &rs2::sensor::get_motion_intrinsics, "Returns scale and bias of a motion stream.",
                "stream"_a)
           .def(py::init<>())
diff --git a/wrappers/python/readme.md b/wrappers/python/readme.md
index 3f179cd831..5cad69bd85 100644
--- a/wrappers/python/readme.md
+++ b/wrappers/python/readme.md
@@ -22,8 +22,17 @@
 1. Install Python 2 or 3 for windows
   * You can find the downloads on the official Python website [here](https://www.python.org/downloads/windows/)
 2. When running cmake, select the BUILD_PYTHON_BINDINGS option
+> `-DBUILD_PYTHON_BINDINGS=true`
+3. If you have multiple python installations on your machine you can use:
+> `-DPYTHON_EXECUTABLE=<path to python executable`
+
+  For example: `-DPYTHON_EXECUTABLE=C:/Python27/python.exe`
 
 ## Examples
+
+> For a list of full code examples see the [examples](./examples) folder
+
+#### Streaming using _rs.pipeline_
 ```python
 # First import the library
 import pyrealsense2 as rs
@@ -47,7 +56,7 @@ try:
                 dist = depth.get_distance(x, y)
                 if 0 < dist and dist < 1:
                     coverage[x/10] += 1
-            
+
             if y%20 is 19:
                 line = ""
                 for c in coverage:
@@ -56,12 +65,7 @@ try:
                 print(line)
 ```
 
-Additionally the following examples are available:
- - [Tutorial 1](./python-tutorial-1-depth.py)
- - [RS400 Advanced Mode](./python-rs400-advanced-mode-example.py)
- - [Backend Example](./pybackend_example_1_general.py)
-
-### NumPy Integration
+#### NumPy Integration
 Librealsense frames support the buffer protocol. A numpy array can be constructed using this protocol with no data marshalling overhead:
 ```python
 import numpy as np
@@ -69,4 +73,4 @@ depth = frames.get_depth_frame()
 depth_data = depth.as_frame().get_data()
 np_image = np.asanyarray(depth_data)
 ```
-A simple viewer example with NumPy and OpenCV can be found [here](./opencv_viewer_example.py)
\ No newline at end of file
+
diff --git a/wrappers/readme.md b/wrappers/readme.md
index 0cb32c2027..9f271b7b72 100644
--- a/wrappers/readme.md
+++ b/wrappers/readme.md
@@ -2,6 +2,7 @@
 
 * [Python](./python/) - supports both Python 2 and 3
 * [Node.js](./nodejs) - support Node.js v6 above
-* [ROS 2.0](https://github.com/intel-ros/realsense/releases) - separate repository
+* [ROS](https://github.com/intel-ros/realsense/releases) - integration with Robot Operating System
+* [LabVIEW](./labview) - integration with National Instruments LabVIEW
 * .NET - TBD
 * Matlab - TBD