move fourcc to rsutils

maloel · Oct 7, 2024 · d65c42c · d65c42c
1 parent 9bba62e
commit d65c42c
Show file tree

Hide file tree

Showing 13 changed files with 175 additions and 111 deletions.
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -135,7 +135,6 @@ target_sources(${LRS_TARGET}
         "${CMAKE_CURRENT_LIST_DIR}/environment.h"
         "${CMAKE_CURRENT_LIST_DIR}/firmware-version.h"
         "${CMAKE_CURRENT_LIST_DIR}/float3.h"
-        "${CMAKE_CURRENT_LIST_DIR}/fourcc.h"
         "${CMAKE_CURRENT_LIST_DIR}/log.h"
         "${CMAKE_CURRENT_LIST_DIR}/error-handling.h"
         "${CMAKE_CURRENT_LIST_DIR}/firmware_logger_device.h"

diff --git a/src/ds/d400/d400-color.cpp b/src/ds/d400/d400-color.cpp
@@ -1,5 +1,5 @@
 // License: Apache 2.0. See LICENSE file in root directory.
-// Copyright(c) 2016 Intel Corporation. All Rights Reserved.
+// Copyright(c) 2016-24 Intel Corporation. All Rights Reserved.
 
 #include <cstddef>
 #include "metadata.h"
@@ -11,23 +11,24 @@
 #include "d400-info.h"
 #include <src/backend.h>
 #include <src/platform/platform-utils.h>
-#include <src/fourcc.h>
 #include <src/metadata-parser.h>
 
 #include <src/ds/features/auto-exposure-roi-feature.h>
 
 #include <rsutils/string/from.h>
+#include <rsutils/type/fourcc.h>
+using rs_fourcc = rsutils::type::fourcc;
 
 namespace librealsense
 {
-    std::map<uint32_t, rs2_format> d400_color_fourcc_to_rs2_format = {
+    std::map<rs_fourcc::value_type, rs2_format> d400_color_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('M','J','P','G'), RS2_FORMAT_MJPEG},
          {rs_fourcc('B','Y','R','2'), RS2_FORMAT_RAW16}
     };
-    std::map<uint32_t, rs2_stream> d400_color_fourcc_to_rs2_stream = {
+    std::map<rs_fourcc::value_type, rs2_stream> d400_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},

diff --git a/src/ds/d400/d400-device.cpp b/src/ds/d400/d400-device.cpp
@@ -1,5 +1,5 @@
 // License: Apache 2.0. See LICENSE file in root directory.
-// Copyright(c) 2016 Intel Corporation. All Rights Reserved.
+// Copyright(c) 2016-24 Intel Corporation. All Rights Reserved.
 
 #include <librealsense2/h/rs_internal.h>
 #include <src/device.h>
@@ -19,7 +19,6 @@
 #include "d400-color.h"
 #include "d400-nonmonochrome.h"
 #include <src/platform/platform-utils.h>
-#include <src/fourcc.h>
 
 #include <src/ds/features/amplitude-factor-feature.h>
 #include <src/ds/features/emitter-frequency-feature.h>
@@ -37,6 +36,9 @@
 #include <common/fw/firmware-version.h>
 #include <src/fw-update/fw-update-unsigned.h>
 
+#include <rsutils/type/fourcc.h>
+using rsutils::type::fourcc;
+
 #include <rsutils/string/hexdump.h>
 #include <regex>
 #include <iterator>
@@ -52,36 +54,36 @@ constexpr bool hw_mon_over_xu = false;
 
 namespace librealsense
 {
-    std::map<uint32_t, rs2_format> d400_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('Z','1','6','H'), RS2_FORMAT_Z16H},
-        {rs_fourcc('R','G','B','2'), RS2_FORMAT_BGR8},
-        {rs_fourcc('M','J','P','G'), RS2_FORMAT_MJPEG},
-        {rs_fourcc('B','Y','R','2'), RS2_FORMAT_RAW16}
+    std::map<fourcc::value_type, rs2_format> d400_depth_fourcc_to_rs2_format = {
+        {fourcc('Y','U','Y','2'), RS2_FORMAT_YUYV},
+        {fourcc('Y','U','Y','V'), RS2_FORMAT_YUYV},
+        {fourcc('U','Y','V','Y'), RS2_FORMAT_UYVY},
+        {fourcc('G','R','E','Y'), RS2_FORMAT_Y8},
+        {fourcc('Y','8','I',' '), RS2_FORMAT_Y8I},
+        {fourcc('W','1','0',' '), RS2_FORMAT_W10},
+        {fourcc('Y','1','6',' '), RS2_FORMAT_Y16},
+        {fourcc('Y','1','2','I'), RS2_FORMAT_Y12I},
+        {fourcc('Z','1','6',' '), RS2_FORMAT_Z16},
+        {fourcc('Z','1','6','H'), RS2_FORMAT_Z16H},
+        {fourcc('R','G','B','2'), RS2_FORMAT_BGR8},
+        {fourcc('M','J','P','G'), RS2_FORMAT_MJPEG},
+        {fourcc('B','Y','R','2'), RS2_FORMAT_RAW16}
 
     };
-    std::map<uint32_t, rs2_stream> d400_depth_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_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('R','G','B','2'), RS2_STREAM_INFRARED},
-        {rs_fourcc('Z','1','6',' '), RS2_STREAM_DEPTH},
-        {rs_fourcc('Z','1','6','H'), RS2_STREAM_DEPTH},
-        {rs_fourcc('B','Y','R','2'), RS2_STREAM_COLOR},
-        {rs_fourcc('M','J','P','G'), RS2_STREAM_COLOR}
+    std::map<fourcc::value_type, rs2_stream> d400_depth_fourcc_to_rs2_stream = {
+        {fourcc('Y','U','Y','2'), RS2_STREAM_COLOR},
+        {fourcc('Y','U','Y','V'), RS2_STREAM_COLOR},
+        {fourcc('U','Y','V','Y'), RS2_STREAM_INFRARED},
+        {fourcc('G','R','E','Y'), RS2_STREAM_INFRARED},
+        {fourcc('Y','8','I',' '), RS2_STREAM_INFRARED},
+        {fourcc('W','1','0',' '), RS2_STREAM_INFRARED},
+        {fourcc('Y','1','6',' '), RS2_STREAM_INFRARED},
+        {fourcc('Y','1','2','I'), RS2_STREAM_INFRARED},
+        {fourcc('R','G','B','2'), RS2_STREAM_INFRARED},
+        {fourcc('Z','1','6',' '), RS2_STREAM_DEPTH},
+        {fourcc('Z','1','6','H'), RS2_STREAM_DEPTH},
+        {fourcc('B','Y','R','2'), RS2_STREAM_COLOR},
+        {fourcc('M','J','P','G'), RS2_STREAM_COLOR}
     };
 
     std::vector<uint8_t> d400_device::send_receive_raw_data(const std::vector<uint8_t>& input)

diff --git a/src/ds/d400/d400-motion.cpp b/src/ds/d400/d400-motion.cpp
@@ -1,5 +1,5 @@
 // License: Apache 2.0. See LICENSE file in root directory.
-// Copyright(c) 2016 Intel Corporation. All Rights Reserved.
+// Copyright(c) 2016-24 Intel Corporation. All Rights Reserved.
 
 #include "d400-motion.h"
 
@@ -19,18 +19,21 @@
 #include "stream.h"
 #include "proc/motion-transform.h"
 #include "proc/auto-exposure-processor.h"
-#include <src/fourcc.h>
 #include <src/metadata-parser.h>
 #include <src/hid-sensor.h>
-using namespace librealsense;
+
+#include <rsutils/type/fourcc.h>
+using rsutils::type::fourcc;
+
+
 namespace librealsense
 {
     // D457 development
-    const std::map<uint32_t, rs2_format> motion_fourcc_to_rs2_format = {
-        {rs_fourcc('G','R','E','Y'), RS2_FORMAT_MOTION_XYZ32F},
+    const std::map<fourcc::value_type, rs2_format> motion_fourcc_to_rs2_format = {
+        {fourcc('G','R','E','Y'), RS2_FORMAT_MOTION_XYZ32F},
     };
-    const std::map<uint32_t, rs2_stream> motion_fourcc_to_rs2_stream = {
-        {rs_fourcc('G','R','E','Y'), RS2_STREAM_ACCEL},
+    const std::map<fourcc::value_type, rs2_stream> motion_fourcc_to_rs2_stream = {
+        {fourcc('G','R','E','Y'), RS2_STREAM_ACCEL},
     };
 
     rs2_motion_device_intrinsic d400_motion_base::get_motion_intrinsics(rs2_stream stream) const

diff --git a/src/ds/d500/d500-color.cpp b/src/ds/d500/d500-color.cpp
@@ -1,5 +1,5 @@
 // License: Apache 2.0. See LICENSE file in root directory.
-// Copyright(c) 2022 Intel Corporation. All Rights Reserved.
+// Copyright(c) 2022-4 Intel Corporation. All Rights Reserved.
 
 #include <cstddef>
 #include "metadata.h"
@@ -11,29 +11,31 @@
 #include "d500-info.h"
 #include "backend.h"
 #include "platform/platform-utils.h"
-#include <src/fourcc.h>
 #include <src/metadata-parser.h>
 #include <src/ds/ds-thermal-monitor.h>
 
 #include <src/ds/features/auto-exposure-roi-feature.h>
 
+#include <rsutils/type/fourcc.h>
+using rsutils::type::fourcc;
+
 namespace librealsense
 {
-    std::map<uint32_t, rs2_format> d500_color_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('M','J','P','G'), RS2_FORMAT_MJPEG},
-         {rs_fourcc('B','Y','R','2'), RS2_FORMAT_RAW16},
-         {rs_fourcc('M','4','2','0'), RS2_FORMAT_M420}
+    std::map<fourcc::value_type, rs2_format> d500_color_fourcc_to_rs2_format = {
+         {fourcc('Y','U','Y','2'), RS2_FORMAT_YUYV},
+         {fourcc('Y','U','Y','V'), RS2_FORMAT_YUYV},
+         {fourcc('U','Y','V','Y'), RS2_FORMAT_UYVY},
+         {fourcc('M','J','P','G'), RS2_FORMAT_MJPEG},
+         {fourcc('B','Y','R','2'), RS2_FORMAT_RAW16},
+         {fourcc('M','4','2','0'), RS2_FORMAT_M420}
     };
-    std::map<uint32_t, rs2_stream> d500_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},
-        {rs_fourcc('B','Y','R','2'), RS2_STREAM_COLOR},
-        {rs_fourcc('M','J','P','G'), RS2_STREAM_COLOR},
-        {rs_fourcc('M','4','2','0'), RS2_STREAM_COLOR}
+    std::map<fourcc::value_type, rs2_stream> d500_color_fourcc_to_rs2_stream = {
+        {fourcc('Y','U','Y','2'), RS2_STREAM_COLOR},
+        {fourcc('Y','U','Y','V'), RS2_STREAM_COLOR},
+        {fourcc('U','Y','V','Y'), RS2_STREAM_COLOR},
+        {fourcc('B','Y','R','2'), RS2_STREAM_COLOR},
+        {fourcc('M','J','P','G'), RS2_STREAM_COLOR},
+        {fourcc('M','4','2','0'), RS2_STREAM_COLOR}
     };
 
     d500_color::d500_color( std::shared_ptr< const d500_info > const & dev_info, rs2_format native_format )

diff --git a/src/ds/d500/d500-device.cpp b/src/ds/d500/d500-device.cpp
@@ -1,5 +1,5 @@
 // License: Apache 2.0. See LICENSE file in root directory.
-// Copyright(c) 2022 Intel Corporation. All Rights Reserved.
+// Copyright(c) 2022-4 Intel Corporation. All Rights Reserved.
 
 #include "metadata-parser.h"
 #include "metadata.h"
@@ -24,7 +24,8 @@
 #include "proc/y8i-to-y8y8.h"
 #include "proc/y16i-to-y10msby10msb.h"
 
-#include <src/fourcc.h>
+#include <rsutils/type/fourcc.h>
+using rs_fourcc = rsutils::type::fourcc;
 
 #include <rsutils/string/hexdump.h>
 #include <rsutils/version.h>

diff --git a/src/ds/ds-motion-common.cpp b/src/ds/ds-motion-common.cpp
@@ -1,5 +1,5 @@
 // License: Apache 2.0. See LICENSE file in root directory.
-// Copyright(c) 2022 Intel Corporation. All Rights Reserved.
+// Copyright(c) 2022-4 Intel Corporation. All Rights Reserved.
 
 #include "ds-motion-common.h"
 
@@ -22,22 +22,23 @@
 #include "ds-options.h"
 #include "ds-private.h"
 #include <src/stream.h>
-#include <src/fourcc.h>
 #include <src/metadata-parser.h>
 
+#include <rsutils/type/fourcc.h>
+using rsutils::type::fourcc;
 #include <cstddef>
 
 namespace librealsense
 {
     using namespace ds;
 
-    const std::map<uint32_t, rs2_format> fisheye_fourcc_to_rs2_format = {
-        {rs_fourcc('R','A','W','8'), RS2_FORMAT_RAW8},
-        {rs_fourcc('G','R','E','Y'), RS2_FORMAT_RAW8},
+    const std::map<fourcc::value_type, rs2_format> fisheye_fourcc_to_rs2_format = {
+        {fourcc('R','A','W','8'), RS2_FORMAT_RAW8},
+        {fourcc('G','R','E','Y'), RS2_FORMAT_RAW8},
     };
-    const std::map<uint32_t, rs2_stream> fisheye_fourcc_to_rs2_stream = {
-        {rs_fourcc('R','A','W','8'), RS2_STREAM_FISHEYE},
-        {rs_fourcc('G','R','E','Y'), RS2_STREAM_FISHEYE},
+    const std::map<fourcc::value_type, rs2_stream> fisheye_fourcc_to_rs2_stream = {
+        {fourcc('R','A','W','8'), RS2_STREAM_FISHEYE},
+        {fourcc('G','R','E','Y'), RS2_STREAM_FISHEYE},
     };
 
     void fisheye_auto_exposure_roi_method::set(const region_of_interest& roi)

diff --git a/src/fourcc.h b/src/fourcc.h
diff --git a/src/hid-sensor.cpp b/src/hid-sensor.cpp
@@ -1,24 +1,26 @@
 // License: Apache 2.0. See LICENSE file in root directory.
-// Copyright(c) 2023 Intel Corporation. All Rights Reserved.
+// Copyright(c) 2023-4 Intel Corporation. All Rights Reserved.
 
 #include "hid-sensor.h"
 #include "device.h"
 #include "stream.h"
 #include "global_timestamp_reader.h"
 #include "metadata.h"
 #include "platform/stream-profile-impl.h"
-#include "fourcc.h"
 #include <src/metadata-parser.h>
 #include <src/core/time-service.h>
 
+#include <rsutils/type/fourcc.h>
+using rsutils::type::fourcc;
+
 
 namespace librealsense {
 
 
-static const std::map< rs2_stream, uint32_t > stream_and_fourcc
-    = { { RS2_STREAM_GYRO,  rs_fourcc( 'G', 'Y', 'R', 'O' ) },
-        { RS2_STREAM_ACCEL, rs_fourcc( 'A', 'C', 'C', 'L' ) },
-        { RS2_STREAM_GPIO,  rs_fourcc( 'G', 'P', 'I', 'O' ) } };
+static const std::map< rs2_stream, fourcc::value_type > stream_and_fourcc
+    = { { RS2_STREAM_GYRO,  fourcc( 'G', 'Y', 'R', 'O' ) },
+        { RS2_STREAM_ACCEL, fourcc( 'A', 'C', 'C', 'L' ) },
+        { RS2_STREAM_GPIO,  fourcc( 'G', 'P', 'I', 'O' ) } };
 
 /*For gyro sensitivity - FW gets 0 for 61 millidegree/s/LSB resolution
  0.1 for 30.5 millidegree/s/LSB 

diff --git a/src/mf/mf-uvc.cpp b/src/mf/mf-uvc.cpp
@@ -30,6 +30,8 @@ The library will be compiled without the metadata support!\n")
 #include <src/backend.h>  // monotonic_to_realtime
 
 #include <rsutils/string/from.h>
+#include <rsutils/type/fourcc.h>
+using rsutils::type::fourcc;
 
 #include "Shlwapi.h"
 #include <Windows.h>
@@ -970,10 +972,13 @@ namespace librealsense
                 throw std::runtime_error("Device must be powered to query supported profiles!");
 
             std::vector<stream_profile> results;
-            foreach_profile([&results](const mf_profile& mfp, CComPtr<IMFMediaType> media_type, bool& quit)
-            {
-                results.push_back(mfp.profile);
-            });
+            foreach_profile(
+                [&results]( const mf_profile & mfp, CComPtr< IMFMediaType > media_type, bool & quit )
+                {
+                    //LOG_DEBUG( mfp.profile.width << 'x' << mfp.profile.height << ' ' << fourcc( mfp.profile.format )
+                    //                             << " @ " << mfp.profile.fps << " Hz" );
+                    results.push_back( mfp.profile );
+                } );
 
             return results;
         }