Merge pull request #5357 from arilowen/fix-l500-resolutions

ev-mp · web-flow · commit 2bed2dd7011f · 2019-12-02T22:04:34.000+02:00
Fix l500 resolutions
diff --git a/src/context.cpp b/src/context.cpp
@@ -241,7 +241,6 @@ namespace librealsense
                 assign_stream(_default_stream, p);
                 environment::get_instance().get_extrinsics_graph().register_same_extrinsics(*_default_stream, *p);
             }
-            add_source_profiles_missing_data();
 
             return results;
         }
diff --git a/src/ds5/ds5-color.cpp b/src/ds5/ds5-color.cpp
@@ -67,7 +67,7 @@ namespace librealsense
         std::unique_ptr<frame_timestamp_reader> ds5_timestamp_reader_metadata(new ds5_timestamp_reader_from_metadata(std::move(ds5_timestamp_reader_backup)));
 
         auto enable_global_time_option = std::shared_ptr<global_time_option>(new global_time_option());
-        auto raw_color_ep = std::make_shared<uvc_sensor>("Raw RGB Sensor",
+        auto raw_color_ep = std::make_shared<uvc_sensor>("Raw RGB Camera",
             backend.create_uvc_device(color_devices_info.front()),
             std::unique_ptr<frame_timestamp_reader>(new global_timestamp_reader(std::move(ds5_timestamp_reader_metadata), _tf_keeper, enable_global_time_option)),
             this);
@@ -223,7 +223,6 @@ namespace librealsense
                     return rs2_intrinsics{};
             });
         }
-        add_source_profiles_missing_data();
 
         return results;
     }
diff --git a/src/ds5/ds5-color.h b/src/ds5/ds5-color.h
@@ -43,7 +43,7 @@ namespace librealsense
             std::shared_ptr<uvc_sensor> uvc_sensor,
             std::map<uint32_t, rs2_format> ds5_color_fourcc_to_rs2_format,
             std::map<uint32_t, rs2_stream> ds5_color_fourcc_to_rs2_stream)
-            : synthetic_sensor("RGB Sensor", uvc_sensor, owner, ds5_color_fourcc_to_rs2_format, ds5_color_fourcc_to_rs2_stream),
+            : synthetic_sensor("RGB Camera", uvc_sensor, owner, ds5_color_fourcc_to_rs2_format, ds5_color_fourcc_to_rs2_stream),
             _owner(owner)
         {}
 
diff --git a/src/ds5/ds5-device.cpp b/src/ds5/ds5-device.cpp
@@ -41,23 +41,27 @@
 namespace librealsense
 {
     std::map<uint32_t, rs2_format> ds5_depth_fourcc_to_rs2_format = {
+        {rs_fourcc('Y','U','Y','2'), RS2_FORMAT_YUYV},
+        {rs_fourcc('Y','U','Y','V'), RS2_FORMAT_YUYV},
+        {rs_fourcc('U','Y','V','Y'), RS2_FORMAT_UYVY},
         {rs_fourcc('G','R','E','Y'), RS2_FORMAT_Y8},
         {rs_fourcc('Y','8','I',' '), RS2_FORMAT_Y8I},
         {rs_fourcc('W','1','0',' '), RS2_FORMAT_W10},
         {rs_fourcc('Y','1','6',' '), RS2_FORMAT_Y16},
         {rs_fourcc('Y','1','2','I'), RS2_FORMAT_Y12I},
         {rs_fourcc('Z','1','6',' '), RS2_FORMAT_Z16},
-        {rs_fourcc('U','Y','V','Y'), RS2_FORMAT_UYVY},
         {rs_fourcc('R','G','B','2'), RS2_FORMAT_BGR8}
         
     };
     std::map<uint32_t, rs2_stream> ds5_depth_fourcc_to_rs2_stream = {
+        {rs_fourcc('Y','U','Y','2'), RS2_STREAM_INFRARED},
+        {rs_fourcc('Y','U','Y','V'), RS2_STREAM_INFRARED},
+        {rs_fourcc('U','Y','V','Y'), RS2_STREAM_INFRARED},
         {rs_fourcc('G','R','E','Y'), RS2_STREAM_INFRARED},
         {rs_fourcc('Y','8','I',' '), RS2_STREAM_INFRARED},
         {rs_fourcc('W','1','0',' '), RS2_STREAM_INFRARED},
         {rs_fourcc('Y','1','6',' '), RS2_STREAM_INFRARED},
         {rs_fourcc('Y','1','2','I'), RS2_STREAM_INFRARED},
-        {rs_fourcc('U','Y','V','Y'), RS2_STREAM_INFRARED},
         {rs_fourcc('R','G','B','2'), RS2_STREAM_INFRARED},
         {rs_fourcc('Z','1','6',' '), RS2_STREAM_DEPTH},
     };
@@ -284,7 +288,7 @@ namespace librealsense
     public:
         explicit ds5_depth_sensor(ds5_device* owner,
             std::shared_ptr<uvc_sensor> uvc_sensor)
-            : synthetic_sensor("Depth Sensor", uvc_sensor, owner, ds5_depth_fourcc_to_rs2_format, ds5_depth_fourcc_to_rs2_stream),
+            : synthetic_sensor(ds::DEPTH_STEREO, uvc_sensor, owner, ds5_depth_fourcc_to_rs2_format, ds5_depth_fourcc_to_rs2_stream),
             _owner(owner),
             _depth_units(-1)
         {}
@@ -364,7 +368,6 @@ namespace librealsense
                     });
                 }
             }
-            add_source_profiles_missing_data();
 
             return results;
         }
@@ -451,7 +454,6 @@ namespace librealsense
                     });
                 }
             }
-            add_source_profiles_missing_data();
 
             return results;
         }
@@ -915,7 +917,7 @@ namespace librealsense
         std::unique_ptr<frame_timestamp_reader> ds5_timestamp_reader_metadata(new ds5_timestamp_reader_from_metadata(std::move(ds5_timestamp_reader_backup)));
 
         auto enable_global_time_option = std::shared_ptr<global_time_option>(new global_time_option());
-        auto raw_depth_ep = std::make_shared<uvc_sensor>("Depth Sensor", std::make_shared<platform::multi_pins_uvc_device>(depth_devices), std::unique_ptr<frame_timestamp_reader>(new global_timestamp_reader(std::move(ds5_timestamp_reader_metadata), _tf_keeper, enable_global_time_option)), this);
+        auto raw_depth_ep = std::make_shared<uvc_sensor>(ds::DEPTH_STEREO, std::make_shared<platform::multi_pins_uvc_device>(depth_devices), std::unique_ptr<frame_timestamp_reader>(new global_timestamp_reader(std::move(ds5_timestamp_reader_metadata), _tf_keeper, enable_global_time_option)), this);
         auto depth_ep = std::make_shared<ds5u_depth_sensor>(this, raw_depth_ep);
 
         depth_ep->register_option(RS2_OPTION_GLOBAL_TIME_ENABLED, enable_global_time_option);
@@ -926,11 +928,8 @@ namespace librealsense
         depth_ep->register_processing_block({ {RS2_FORMAT_W10} }, { {RS2_FORMAT_RAW10, RS2_STREAM_INFRARED, 1} }, []() { return std::make_shared<w10_converter>(RS2_FORMAT_RAW10); });
         depth_ep->register_processing_block({ {RS2_FORMAT_W10} }, { {RS2_FORMAT_Y10BPACK, RS2_STREAM_INFRARED, 1} }, []() { return std::make_shared<w10_converter>(RS2_FORMAT_Y10BPACK); });
 
-        depth_ep->register_processing_block({ {RS2_FORMAT_UYVY} }, { {RS2_FORMAT_RGB8, RS2_STREAM_INFRARED} }, []() { return std::make_shared<uyvy_converter>(RS2_FORMAT_RGB8, RS2_STREAM_INFRARED); });
-        depth_ep->register_processing_block({ {RS2_FORMAT_UYVY} }, { {RS2_FORMAT_RGBA8, RS2_STREAM_INFRARED} }, []() { return std::make_shared<uyvy_converter>(RS2_FORMAT_RGBA8, RS2_STREAM_INFRARED); });
-        depth_ep->register_processing_block({ {RS2_FORMAT_UYVY} }, { {RS2_FORMAT_BGR8, RS2_STREAM_INFRARED} }, []() { return std::make_shared<uyvy_converter>(RS2_FORMAT_BGR8, RS2_STREAM_INFRARED); });
-        depth_ep->register_processing_block({ {RS2_FORMAT_UYVY} }, { {RS2_FORMAT_BGRA8, RS2_STREAM_INFRARED} }, []() { return std::make_shared<uyvy_converter>(RS2_FORMAT_BGRA8, RS2_STREAM_INFRARED); });
-        depth_ep->register_processing_block(processing_block_factory::create_id_pbf(RS2_FORMAT_UYVY, RS2_STREAM_INFRARED));
+        depth_ep->register_processing_block(processing_block_factory::create_pbf_vector<uyvy_converter>(RS2_FORMAT_UYVY, map_supported_color_formats(RS2_FORMAT_UYVY), RS2_STREAM_INFRARED));
+
 
         return depth_ep;
     }
diff --git a/src/ds5/ds5-nonmonochrome.cpp b/src/ds5/ds5-nonmonochrome.cpp
@@ -28,29 +28,26 @@ namespace librealsense
         using namespace ds;
 
         auto pid = group.uvc_devices.front().pid;
+        auto& depth_ep = get_depth_sensor();
         if ((_fw_version >= firmware_version("5.5.8.0")) && (!val_in_range(pid, { RS_USB2_PID, RS465_PID })))
         {
-            auto& depth_ep = get_depth_sensor();
             depth_ep.register_option(RS2_OPTION_ENABLE_AUTO_WHITE_BALANCE,
                 std::make_shared<uvc_xu_option<uint8_t>>(get_raw_depth_sensor(),
                                                          depth_xu,
                                                          DS5_ENABLE_AUTO_WHITE_BALANCE,
                                                          "Enable Auto White Balance"));
 
             // RS400 rolling-shutter Skus allow to get low-quality color image from the same viewport as the depth
-            depth_ep.register_processing_block({ {RS2_FORMAT_UYVY} }, { {RS2_FORMAT_RGB8, RS2_STREAM_INFRARED} }, []() { return std::make_shared<uyvy_converter>(RS2_FORMAT_RGB8, RS2_STREAM_INFRARED); });
-            depth_ep.register_processing_block({ {RS2_FORMAT_UYVY} }, { {RS2_FORMAT_RGBA8, RS2_STREAM_INFRARED} }, []() { return std::make_shared<uyvy_converter>(RS2_FORMAT_RGBA8, RS2_STREAM_INFRARED); });
-            depth_ep.register_processing_block({ {RS2_FORMAT_UYVY} }, { {RS2_FORMAT_BGR8, RS2_STREAM_INFRARED} }, []() { return std::make_shared<uyvy_converter>(RS2_FORMAT_BGR8, RS2_STREAM_INFRARED); });
-            depth_ep.register_processing_block({ {RS2_FORMAT_UYVY} }, { {RS2_FORMAT_BGRA8, RS2_STREAM_INFRARED} }, []() { return std::make_shared<uyvy_converter>(RS2_FORMAT_BGRA8, RS2_STREAM_INFRARED); });
-            depth_ep.register_processing_block(processing_block_factory::create_id_pbf(RS2_FORMAT_UYVY, RS2_STREAM_INFRARED));
-
             depth_ep.register_processing_block({ {RS2_FORMAT_BGR8} }, { {RS2_FORMAT_RGB8, RS2_STREAM_INFRARED} }, []() { return std::make_shared<bgr_to_rgb>(); });
 
             depth_ep.register_processing_block(processing_block_factory::create_id_pbf(RS2_FORMAT_Z16, RS2_STREAM_DEPTH));
             depth_ep.register_processing_block({ {RS2_FORMAT_W10} }, { {RS2_FORMAT_RAW10, RS2_STREAM_INFRARED, 1} }, []() { return std::make_shared<w10_converter>(RS2_FORMAT_RAW10); });
             depth_ep.register_processing_block({ {RS2_FORMAT_W10} }, { {RS2_FORMAT_Y10BPACK, RS2_STREAM_INFRARED, 1} }, []() { return std::make_shared<w10_converter>(RS2_FORMAT_Y10BPACK); });
         }
 
+        depth_ep.register_processing_block(processing_block_factory::create_pbf_vector<yuy2_converter>(RS2_FORMAT_YUYV, map_supported_color_formats(RS2_FORMAT_YUYV), RS2_STREAM_INFRARED));
+        depth_ep.register_processing_block(processing_block_factory::create_pbf_vector<uyvy_converter>(RS2_FORMAT_UYVY, map_supported_color_formats(RS2_FORMAT_UYVY), RS2_STREAM_INFRARED));
+
         get_depth_sensor().unregister_option(RS2_OPTION_EMITTER_ON_OFF);
 
         if ((_fw_version >= firmware_version("5.9.13.6") &&
diff --git a/src/ivcam/sr300.cpp b/src/ivcam/sr300.cpp
@@ -94,7 +94,7 @@ namespace librealsense
     std::shared_ptr<synthetic_sensor> sr300_camera::create_color_device(std::shared_ptr<context> ctx,
         const platform::uvc_device_info& color)
     {
-        auto raw_color_ep = std::make_shared<uvc_sensor>("Raw RGB Sensor", ctx->get_backend().create_uvc_device(color),
+        auto raw_color_ep = std::make_shared<uvc_sensor>("Raw RGB Camera", ctx->get_backend().create_uvc_device(color),
             std::unique_ptr<frame_timestamp_reader>(new sr300_timestamp_reader_from_metadata()),
             this);
         auto color_ep = std::make_shared<sr300_color_sensor>(this,
diff --git a/src/ivcam/sr300.h b/src/ivcam/sr300.h
@@ -280,7 +280,6 @@ namespace librealsense
                             return rs2_intrinsics{};
                     });
                 }
-                add_source_profiles_missing_data();
 
                 return results;
             }
@@ -343,7 +342,6 @@ namespace librealsense
                             return rs2_intrinsics{};
                     });
                 }
-                add_source_profiles_missing_data();
 
                 return results;
             }
diff --git a/src/l500/l500-color.cpp b/src/l500/l500-color.cpp
@@ -14,11 +14,15 @@ namespace librealsense
     using namespace ivcam2;
 
     std::map<uint32_t, rs2_format> l500_color_fourcc_to_rs2_format = {
-        {rs_fourcc('Y','U','Y','2'), RS2_FORMAT_YUYV}
+        {rs_fourcc('Y','U','Y','2'), RS2_FORMAT_YUYV},
+        {rs_fourcc('Y','U','Y','V'), RS2_FORMAT_YUYV},
+        {rs_fourcc('U','Y','V','Y'), RS2_FORMAT_UYVY}
     };
 
     std::map<uint32_t, rs2_stream> l500_color_fourcc_to_rs2_stream = {
         {rs_fourcc('Y','U','Y','2'), RS2_STREAM_COLOR},
+        {rs_fourcc('Y','U','Y','V'), RS2_STREAM_COLOR},
+        {rs_fourcc('U','Y','V','Y'), RS2_STREAM_COLOR}
     };
 
     std::shared_ptr<synthetic_sensor> l500_color::create_color_device(std::shared_ptr<context> ctx, const std::vector<platform::uvc_device_info>& color_devices_info)
@@ -27,7 +31,7 @@ namespace librealsense
 
         std::unique_ptr<frame_timestamp_reader> timestamp_reader_metadata(new ivcam2::l500_timestamp_reader_from_metadata(backend.create_time_service()));
         auto enable_global_time_option = std::shared_ptr<global_time_option>(new global_time_option());
-        auto raw_color_ep = std::make_shared<uvc_sensor>("RGB Sensor", ctx->get_backend().create_uvc_device(color_devices_info.front()),
+        auto raw_color_ep = std::make_shared<uvc_sensor>("RGB Camera", ctx->get_backend().create_uvc_device(color_devices_info.front()),
             std::unique_ptr<frame_timestamp_reader>(new global_timestamp_reader(std::move(timestamp_reader_metadata), _tf_keeper, enable_global_time_option)),
             this);
         auto color_ep = std::make_shared<l500_color_sensor>(this, raw_color_ep, ctx, l500_color_fourcc_to_rs2_format, l500_color_fourcc_to_rs2_stream);
diff --git a/src/l500/l500-color.h b/src/l500/l500-color.h
@@ -48,7 +48,7 @@ namespace librealsense
                 std::shared_ptr<context> ctx,
                 std::map<uint32_t, rs2_format> l500_color_fourcc_to_rs2_format,
                 std::map<uint32_t, rs2_stream> l500_color_fourcc_to_rs2_stream)
-                : synthetic_sensor("RGB Sensor", uvc_sensor, owner, l500_color_fourcc_to_rs2_format, l500_color_fourcc_to_rs2_stream),
+                : synthetic_sensor("RGB Camera", uvc_sensor, owner, l500_color_fourcc_to_rs2_format, l500_color_fourcc_to_rs2_stream),
                 _owner(owner)
             {}
 
@@ -118,7 +118,6 @@ namespace librealsense
                             return rs2_intrinsics{};
                     });
                 }
-                add_source_profiles_missing_data();
 
                 return results;
             }
diff --git a/src/l500/l500-depth.h b/src/l500/l500-depth.h
@@ -86,7 +86,7 @@ namespace librealsense
     {
     public:
         explicit l500_depth_sensor(l500_device* owner, std::shared_ptr<uvc_sensor> uvc_sensor, std::map<uint32_t,rs2_format> l500_depth_fourcc_to_rs2_format_map, std::map<uint32_t, rs2_stream> l500_depth_fourcc_to_rs2_stream_map)
-            : synthetic_sensor("Depth Sensor", uvc_sensor, owner, l500_depth_fourcc_to_rs2_format_map, l500_depth_fourcc_to_rs2_stream_map), _owner(owner), _depth_invalidation_enabled(false)
+            : synthetic_sensor("L500 Depth Sensor", uvc_sensor, owner, l500_depth_fourcc_to_rs2_format_map, l500_depth_fourcc_to_rs2_stream_map), _owner(owner), _depth_invalidation_enabled(false)
         {
             register_option(RS2_OPTION_DEPTH_UNITS, std::make_shared<const_value_option>("Number of meters represented by a single depth unit",
                 lazy<float>([&]() {
@@ -194,7 +194,6 @@ namespace librealsense
                         return rs2_intrinsics{};
                 });
             }
-            add_source_profiles_missing_data();
 
             return results;
         }
diff --git a/src/l500/l500-device.cpp b/src/l500/l500-device.cpp
@@ -172,6 +172,26 @@ namespace librealsense
             }
         );
 
+        depth_ep->register_processing_block(
+            { {RS2_FORMAT_Z16}, {RS2_FORMAT_Y8} },
+            { {RS2_FORMAT_Z16, RS2_STREAM_DEPTH} },
+            [weak_is_zo_enabled_opt]() {
+                auto is_zo_enabled_opt = weak_is_zo_enabled_opt.lock();
+                auto z16rot = std::make_shared<identity_processing_block>();
+                auto y8rot = std::make_shared<identity_processing_block>();
+                auto sync = std::make_shared<syncer_process_unit>(is_zo_enabled_opt);
+                auto zo = std::make_shared<zero_order>(is_zo_enabled_opt);
+
+                auto cpb = std::make_shared<composite_processing_block>();
+                cpb->add(z16rot);
+                cpb->add(y8rot);
+                cpb->add(sync);
+                cpb->add(zo);
+
+                return cpb;
+            }
+        );
+
         depth_ep->register_processing_block(
             { {RS2_FORMAT_Z16}, {RS2_FORMAT_Y8}, {RS2_FORMAT_RAW8} },
             {
@@ -199,16 +219,20 @@ namespace librealsense
 
         depth_ep->register_processing_block(
             { {RS2_FORMAT_Y8} },
-            { {RS2_FORMAT_Y8, RS2_STREAM_INFRARED, 1, 0, 0, 0, &rotate_resolution} },
+            { {RS2_FORMAT_Y8, RS2_STREAM_INFRARED, 0, 0, 0, 0, &rotate_resolution} },
             []() { return std::make_shared<rotation_transform>(RS2_FORMAT_Y8, RS2_STREAM_INFRARED, RS2_EXTENSION_VIDEO_FRAME); }
         );
 
+        depth_ep->register_processing_block(processing_block_factory::create_id_pbf(RS2_FORMAT_Y8, RS2_STREAM_INFRARED));
+
         depth_ep->register_processing_block(
             { {RS2_FORMAT_RAW8} },
             { {RS2_FORMAT_RAW8, RS2_STREAM_CONFIDENCE, 0, 0, 0, 0, &l500_confidence_resolution} },
             []() { return std::make_shared<confidence_rotation_transform>(); }
         );
 
+        depth_ep->register_processing_block(processing_block_factory::create_id_pbf(RS2_FORMAT_RAW8, RS2_STREAM_CONFIDENCE));
+
         return depth_ep;
     }
 
diff --git a/src/sensor.cpp b/src/sensor.cpp
@@ -1181,6 +1181,11 @@ namespace librealsense
                             if (is_duplicated_profile(cloned_profile, result_profiles))
                                 continue;
 
+                            // Only injective cloning in many to one mapping.
+                            // One to many is not affected.
+                            if (sources.size() > 1 && target.format != source.format)
+                                continue;
+
                             result_profiles.push_back(cloned_profile);
                         }
                     }
@@ -1225,28 +1230,21 @@ namespace librealsense
         return {best_match_processing_block_factory, best_match_requests};
     }
 
-    void synthetic_sensor::add_source_profile_missing_data(std::shared_ptr<stream_profile_interface>& source_profile)
+    void synthetic_sensor::add_source_profile_missing_data(std::shared_ptr<stream_profile_interface>& target)
     {
         // Add the missing data to the desired source profile.
         // This is needed because we duplicate the source profile into multiple target profiles in the init_stream_profiles() method.
-        
-        auto&& target_profiles = _source_to_target_profiles_map[source_profile];
-
-        // find the closest target profile to the source profile, if there is none, just take the first.
-        auto best_match = std::find_if(target_profiles.begin(), target_profiles.end(),
-            [source_profile](const std::shared_ptr<stream_profile_interface>& sp)
-        {
-            return source_profile->get_format() == sp->get_format();
-        });
 
         // Update the source profile's fields with the correlated target profile.
         // This profile will be propagated to the generated frame received from the backend sensor.
-        auto&& correlated_target_profile = best_match != target_profiles.end() ? *best_match : target_profiles.front();
-        source_profile->set_stream_index(correlated_target_profile->get_stream_index());
-        source_profile->set_unique_id(correlated_target_profile->get_unique_id());
-        source_profile->set_stream_type(correlated_target_profile->get_stream_type());
+
+        auto source_profile_ = _target_to_source_profiles_map[to_profile(target.get())];
+        auto source_profile = source_profile_[0];
+        source_profile->set_stream_index(target->get_stream_index());
+        source_profile->set_unique_id(target->get_unique_id());
+        source_profile->set_stream_type(target->get_stream_type());
         auto&& vsp = As<video_stream_profile, stream_profile_interface>(source_profile);
-        const auto&& cvsp = As<video_stream_profile, stream_profile_interface>(correlated_target_profile);
+        const auto&& cvsp = As<video_stream_profile, stream_profile_interface>(target);
         if (vsp)
         {
             vsp->set_intrinsics([cvsp]() {
@@ -1256,6 +1254,7 @@ namespace librealsense
                 else
                     return rs2_intrinsics{};
             });
+
             vsp->set_dims(cvsp->get_width(), cvsp->get_height());
         }
     }
@@ -1334,6 +1333,9 @@ namespace librealsense
     {
         std::lock_guard<std::mutex> lock(_synthetic_configure_lock);
 
+        for (auto source : requests)
+            add_source_profile_missing_data(source);
+
         const auto&& resolved_req = resolve_requests(requests);
 
         _raw_sensor->set_source_owner(this);

Original file line number	Diff line number	Diff line change
`@@ -241,7 +241,6 @@ namespace librealsense`
`241`	`241`	`assign_stream(_default_stream, p);`
`242`	`242`	`environment::get_instance().get_extrinsics_graph().register_same_extrinsics(_default_stream, p);`
`243`	`243`	`}`
`244`		`- add_source_profiles_missing_data();`
`245`	`244`
`246`	`245`	`return results;`
`247`	`246`	`}`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ namespace librealsense`
`67`	`67`	`std::unique_ptr<frame_timestamp_reader> ds5_timestamp_reader_metadata(new ds5_timestamp_reader_from_metadata(std::move(ds5_timestamp_reader_backup)));`
`68`	`68`
`69`	`69`	`auto enable_global_time_option = std::shared_ptr<global_time_option>(new global_time_option());`
`70`		`- auto raw_color_ep = std::make_shared<uvc_sensor>("Raw RGB Sensor",`
	`70`	`+ auto raw_color_ep = std::make_shared<uvc_sensor>("Raw RGB Camera",`
`71`	`71`	`backend.create_uvc_device(color_devices_info.front()),`
`72`	`72`	`std::unique_ptr<frame_timestamp_reader>(new global_timestamp_reader(std::move(ds5_timestamp_reader_metadata), _tf_keeper, enable_global_time_option)),`
`73`	`73`	`this);`
`@@ -223,7 +223,6 @@ namespace librealsense`
`223`	`223`	`return rs2_intrinsics{};`
`224`	`224`	`});`
`225`	`225`	`}`
`226`		`- add_source_profiles_missing_data();`
`227`	`226`
`228`	`227`	`return results;`
`229`	`228`	`}`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ namespace librealsense`
`94`	`94`	`std::shared_ptr<synthetic_sensor> sr300_camera::create_color_device(std::shared_ptr<context> ctx,`
`95`	`95`	`const platform::uvc_device_info& color)`
`96`	`96`	`{`
`97`		`- auto raw_color_ep = std::make_shared<uvc_sensor>("Raw RGB Sensor", ctx->get_backend().create_uvc_device(color),`
	`97`	`+ auto raw_color_ep = std::make_shared<uvc_sensor>("Raw RGB Camera", ctx->get_backend().create_uvc_device(color),`
`98`	`98`	`std::unique_ptr<frame_timestamp_reader>(new sr300_timestamp_reader_from_metadata()),`
`99`	`99`	`this);`
`100`	`100`	`auto color_ep = std::make_shared<sr300_color_sensor>(this,`
Original file line number	Diff line number	Diff line change
`@@ -280,7 +280,6 @@ namespace librealsense`
`280`	`280`	`return rs2_intrinsics{};`
`281`	`281`	`});`
`282`	`282`	`}`
`283`		`- add_source_profiles_missing_data();`
`284`	`283`
`285`	`284`	`return results;`
`286`	`285`	`}`
`@@ -343,7 +342,6 @@ namespace librealsense`
`343`	`342`	`return rs2_intrinsics{};`
`344`	`343`	`});`
`345`	`344`	`}`
`346`		`- add_source_profiles_missing_data();`
`347`	`345`
`348`	`346`	`return results;`
`349`	`347`	`}`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ namespace librealsense`
`48`	`48`	`std::shared_ptr<context> ctx,`
`49`	`49`	`std::map<uint32_t, rs2_format> l500_color_fourcc_to_rs2_format,`
`50`	`50`	`std::map<uint32_t, rs2_stream> l500_color_fourcc_to_rs2_stream)`
`51`		`- : synthetic_sensor("RGB Sensor", uvc_sensor, owner, l500_color_fourcc_to_rs2_format, l500_color_fourcc_to_rs2_stream),`
	`51`	`+ : synthetic_sensor("RGB Camera", uvc_sensor, owner, l500_color_fourcc_to_rs2_format, l500_color_fourcc_to_rs2_stream),`
`52`	`52`	`_owner(owner)`
`53`	`53`	`{}`
`54`	`54`
`@@ -118,7 +118,6 @@ namespace librealsense`
`118`	`118`	`return rs2_intrinsics{};`
`119`	`119`	`});`
`120`	`120`	`}`
`121`		`- add_source_profiles_missing_data();`
`122`	`121`
`123`	`122`	`return results;`
`124`	`123`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ namespace librealsense`
`86`	`86`	`{`
`87`	`87`	`public:`
`88`	`88`	`explicit l500_depth_sensor(l500_device* owner, std::shared_ptr<uvc_sensor> uvc_sensor, std::map<uint32_t,rs2_format> l500_depth_fourcc_to_rs2_format_map, std::map<uint32_t, rs2_stream> l500_depth_fourcc_to_rs2_stream_map)`
`89`		`- : synthetic_sensor("Depth Sensor", uvc_sensor, owner, l500_depth_fourcc_to_rs2_format_map, l500_depth_fourcc_to_rs2_stream_map), _owner(owner), _depth_invalidation_enabled(false)`
	`89`	`+ : synthetic_sensor("L500 Depth Sensor", uvc_sensor, owner, l500_depth_fourcc_to_rs2_format_map, l500_depth_fourcc_to_rs2_stream_map), _owner(owner), _depth_invalidation_enabled(false)`
`90`	`90`	`{`
`91`	`91`	`register_option(RS2_OPTION_DEPTH_UNITS, std::make_shared<const_value_option>("Number of meters represented by a single depth unit",`
`92`	`92`	`lazy<float>([&]() {`
`@@ -194,7 +194,6 @@ namespace librealsense`
`194`	`194`	`return rs2_intrinsics{};`
`195`	`195`	`});`
`196`	`196`	`}`
`197`		`- add_source_profiles_missing_data();`
`198`	`197`
`199`	`198`	`return results;`
`200`	`199`	`}`