C internal: Changing k4a_fps_t enum values from 0, 1, 2, 3 to 0, 5, 1…

…5, 30 to reflect the actual fps values.
microsoft · JonathanESantos · Nov 6, 2020 · Nov 11, 2020 · Nov 11, 2020 · Nov 11, 2020
commit b2e267e38c6126a6bac229e0abc6df189d20eb29
diff --git a/include/k4a/k4atypes.h b/include/k4a/k4atypes.h
@@ -271,6 +271,29 @@ typedef enum
     K4A_LOG_LEVEL_OFF,          /**< No logging is performed */
 } k4a_log_level_t;
 
+/** Device capabilities.
+ *
+ * \remarks
+ * Used by \p k4a_device_info_t to store whether a device has a color camera, a depth camera, and IMU.
+ *
+ * \note
+ * These are used in a bitmap, so the values should be unique powers of 2. These values should not be
+ * modified; if a new capability is available, a new enum field should be defined.
+ *
+ * \xmlonly
+ * <requirements>
+ *   <requirement name="Header">k4atypes.h (include k4a/k4a.h)</requirement>
+ * </requirements>
+ * \endxmlonly
+ */
+typedef enum
+{
+    K4A_CAPABILITY_DEPTH = 1,
+    K4A_CAPABILITY_COLOR = 2,
+    K4A_CAPABILITY_IMU = 4,
+    K4A_CAPABILITY_MICROPHONE = 8,
+} device_capabilities;
+
 /** Image format type.
  *
  * \remarks
@@ -859,29 +882,6 @@ typedef uint8_t *(k4a_memory_allocate_cb_t)(int size, void **context);
  * @{
  */
 
-/** Device capabilities.
- *
- * \remarks
- * Used by \p k4a_device_info_t to store whether a device has a color camera, a depth camera, and IMU.
- *
- * \note
- * These are used in a bitmap, so the values should be unique powers of 2. These values should not be
- * modified; if a new capability is available, a new enum field should be defined.
- *
- * \xmlonly
- * <requirements>
- *   <requirement name="Header">k4atypes.h (include k4a/k4a.h)</requirement>
- * </requirements>
- * \endxmlonly
- */
-typedef enum
-{
-    K4A_CAPABILITY_DEPTH = 1,
-    K4A_CAPABILITY_COLOR = 2,
-    K4A_CAPABILITY_IMU = 4,
-    K4A_CAPABILITY_MICROPHONE = 8,
-} k4a_device_capabilities_t;
-
 /** Stores the vendor id, the device id and device capabilities.
  *
  * \sa device_capabilities

diff --git a/include/k4ainternal/modes.h b/include/k4ainternal/modes.h
@@ -78,87 +78,12 @@ typedef enum
 // Be sure to update k4a_fps_to_string in k4a.c if enum values are added.
 typedef enum
 {
-    K4A_FRAMES_PER_SECOND_0 = 0, /**< 0 FPS */
-    K4A_FRAMES_PER_SECOND_5,     /**< 5 FPS */
-    K4A_FRAMES_PER_SECOND_15,    /**< 15 FPS */
-    K4A_FRAMES_PER_SECOND_30,    /**< 30 FPS */
-    K4A_FRAMES_PER_SECOND_COUNT, /**< Must be last entry. */
+    K4A_FRAMES_PER_SECOND_0 = 0,   /**< 0 FPS */
+    K4A_FRAMES_PER_SECOND_5 = 5,   /**< 5 FPS */
+    K4A_FRAMES_PER_SECOND_15 = 15, /**< 15 FPS */
+    K4A_FRAMES_PER_SECOND_30 = 30, /**< 30 FPS */
 } k4a_fps_t;
 
-/** Convert k4a_fps_t enum to the actual frame rate value.
- *
- * \remarks
- * K4A_FRAMES_PER_SECOND_30 will be converted to 30.
- *
- * \xmlonly
- * <requirements>
- *   <requirement name="Header">modes.h (include k4ainternal/modes.h)</requirement>
- * </requirements>
- * \endxmlonly
- */
-inline static uint32_t k4a_convert_fps_to_uint(k4a_fps_t fps)
-{
-    uint32_t fps_int = 0;
-
-    switch (fps)
-    {
-    case K4A_FRAMES_PER_SECOND_0:
-        fps_int = 0;
-        break;
-    case K4A_FRAMES_PER_SECOND_5:
-        fps_int = 5;
-        break;
-    case K4A_FRAMES_PER_SECOND_15:
-        fps_int = 15;
-        break;
-    case K4A_FRAMES_PER_SECOND_30:
-        fps_int = 30;
-        break;
-    default:
-        fps_int = 0;
-        break;
-    }
-
-    return fps_int;
-}
-
-/** Convert frame rate value to the corresponding k4a_fps_t enum.
- *
- * \remarks
- * 30 will be converted to K4A_FRAMES_PER_SECOND_30.
- *
- * \xmlonly
- * <requirements>
- *   <requirement name="Header">modes.h (include k4ainternal/modes.h)</requirement>
- * </requirements>
- * \endxmlonly
- */
-inline static k4a_fps_t k4a_convert_uint_to_fps(uint32_t fps_in)
-{
-    k4a_fps_t fps_t = K4A_FRAMES_PER_SECOND_0;
-
-    switch (fps_in)
-    {
-    case 0:
-        fps_t = K4A_FRAMES_PER_SECOND_0;
-        break;
-    case 5:
-        fps_t = K4A_FRAMES_PER_SECOND_5;
-        break;
-    case 15:
-        fps_t = K4A_FRAMES_PER_SECOND_15;
-        break;
-    case 30:
-        fps_t = K4A_FRAMES_PER_SECOND_30;
-        break;
-    default:
-        fps_t = K4A_FRAMES_PER_SECOND_0;
-        break;
-    }
-
-    return fps_t;
-}
-
 /** Return the image width and height for the corresponding k4a_color_resolution_t enum.
  *
  * \xmlonly
@@ -212,6 +137,7 @@ inline static bool k4a_convert_resolution_to_width_height(k4a_color_resolution_t
         break;
     default:
         resolutionFound = false;
+        break;
     }
 
     if (resolutionFound)
@@ -308,6 +234,7 @@ inline static bool k4a_convert_resolution_to_fov(k4a_color_resolution_t resoluti
         break;
     default:
         resolutionFound = false;
+        break;
     }
 
     if (resolutionFound)
@@ -400,6 +327,7 @@ inline static bool k4a_convert_depth_mode_to_width_height(k4a_depth_mode_t mode_
         break;
     default:
         modeFound = false;
+        break;
     }
 
     if (modeFound)
@@ -490,6 +418,7 @@ inline static bool k4a_convert_depth_mode_to_fov(k4a_depth_mode_t mode_id, float
         break;
     default:
         modeFound = false;
+        break;
     }
 
     if (modeFound)
@@ -582,6 +511,7 @@ inline static bool k4a_convert_depth_mode_to_min_max_range(k4a_depth_mode_t mode
         break;
     default:
         modeFound = false;
+        break;
     }
 
     if (modeFound)

diff --git a/include/k4ainternal/queue.h b/include/k4ainternal/queue.h
@@ -29,7 +29,7 @@ extern "C" {
 
 /** Default queue depth for 30 FPS.
  */
-#define QUEUE_DEFAULT_SIZE QUEUE_CALC_DEPTH(k4a_convert_fps_to_uint(K4A_FRAMES_PER_SECOND_30), QUEUE_DEFAULT_DEPTH_USEC)
+#define QUEUE_DEFAULT_SIZE QUEUE_CALC_DEPTH((uint32_t)K4A_FRAMES_PER_SECOND_30, QUEUE_DEFAULT_DEPTH_USEC)
 
 /** Handle to the queue module.
  *

diff --git a/src/capturesync/capturesync.c b/src/capturesync/capturesync.c
@@ -491,7 +491,7 @@ k4a_result_t capturesync_start(capturesync_t capturesync_handle, const k4a_devic
     sync->waiting_for_clean_depth_ts = true;
     sync->synchronized_images_only = config->synchronized_images_only;
 
-    sync->fps_period = HZ_TO_PERIOD_US(k4a_convert_fps_to_uint(config->fps_mode_id));
+    sync->fps_period = HZ_TO_PERIOD_US(config->fps_mode_id);
     sync->fps_1_quarter_period = sync->fps_period / 4;
     sync->depth_delay_off_color_usec = config->depth_delay_off_color_usec;
     sync->sync_captures = true;

diff --git a/src/color/color.cpp b/src/color/color.cpp
@@ -144,7 +144,7 @@ k4a_result_t color_start(color_t color_handle, const k4a_device_configuration_t
         return K4A_RESULT_FAILED;
     }
 
-    fps = k4a_convert_fps_to_uint(static_cast<k4a_fps_t>(config->fps_mode_id));
+    fps = static_cast<uint32_t>(config->fps_mode_id);
     if (fps == 0)
     {
         LOG_ERROR("camera_fps %d is invalid", config->fps_mode_id);

diff --git a/src/depth_mcu/depth_mcu.c b/src/depth_mcu/depth_mcu.c
@@ -292,7 +292,7 @@ k4a_result_t depthmcu_depth_set_fps(depthmcu_t depthmcu_handle, uint32_t fps_mod
     depthmcu_context_t *depthmcu = depthmcu_t_get_context(depthmcu_handle);
 
     // Translate FPS to values understood by sensor module
-    uint32_t fps = k4a_convert_fps_to_uint((k4a_fps_t)fps_mode_id);
+    uint32_t fps = (uint32_t)fps_mode_id;
     if (fps == 0)
     {
         LOG_ERROR("Invalid FPS %d", fps_mode_id);

diff --git a/src/dewrapper/dewrapper.c b/src/dewrapper/dewrapper.c
@@ -138,7 +138,7 @@ static k4a_result_t depth_engine_start_helper(dewrapper_context_t *dewrapper,
     assert(dewrapper->calibration_memory != NULL);
 
     // Max comput time is the configured FPS
-    *depth_engine_max_compute_time_ms = HZ_TO_PERIOD_MS(k4a_convert_fps_to_uint(fps_mode_id));
+    *depth_engine_max_compute_time_ms = HZ_TO_PERIOD_MS((uint32_t)fps_mode_id);
     result = K4A_RESULT_FROM_BOOL(*depth_engine_max_compute_time_ms != 0);
 
     if (K4A_SUCCEEDED(result))

diff --git a/src/record/internal/matroska_read.cpp b/src/record/internal/matroska_read.cpp
@@ -613,7 +613,7 @@ k4a_result_t parse_recording_config(k4a_playback_context_t *context)
     context->sync_period_ns = frame_period_ns;
     if (frame_period_ns > 0)
     {
-        k4a_fps_t fps_t = k4a_convert_uint_to_fps(static_cast<uint32_t>(1_s / frame_period_ns));
+        k4a_fps_t fps_t = static_cast<k4a_fps_t>(static_cast<uint32_t>(1_s / frame_period_ns));
         if (fps_t == K4A_FRAMES_PER_SECOND_0)
         {
             LOG_ERROR("Unsupported recording frame period: %llu ns (%llu fps)",

diff --git a/src/record/sdk/record.cpp b/src/record/sdk/record.cpp
@@ -49,7 +49,7 @@ k4a_result_t k4a_record_create(const char *path,
     {
         context->device_config = device_config;
         context->timecode_scale = MATROSKA_TIMESCALE_NS;
-        context->camera_fps = k4a_convert_fps_to_uint(static_cast<k4a_fps_t>(device_config.fps_mode_id));
+        context->camera_fps = static_cast<uint32_t>(device_config.fps_mode_id);
         if (context->camera_fps == 0)
         {
             // Set camera FPS to 30 if no cameras are enabled so IMU can still be written.

diff --git a/src/sdk/k4a.c b/src/sdk/k4a.c
@@ -681,7 +681,7 @@ static k4a_result_t validate_configuration(k4a_context_t *device, const k4a_devi
         if (config->wired_sync_mode == K4A_WIRED_SYNC_MODE_SUBORDINATE &&
             config->subordinate_delay_off_master_usec != 0)
         {
-            uint32_t fps_in_usec = HZ_TO_PERIOD_US(k4a_convert_fps_to_uint((k4a_fps_t)config->fps_mode_id));
+            uint32_t fps_in_usec = HZ_TO_PERIOD_US((uint32_t)config->fps_mode_id);
             if (config->subordinate_delay_off_master_usec > fps_in_usec)
             {
                 result = K4A_RESULT_FAILED;
@@ -716,7 +716,7 @@ static k4a_result_t validate_configuration(k4a_context_t *device, const k4a_devi
 
         if (depth_enabled && color_enabled)
         {
-            int64_t fps = HZ_TO_PERIOD_US(k4a_convert_fps_to_uint((k4a_fps_t)config->fps_mode_id));
+            int64_t fps = HZ_TO_PERIOD_US((uint32_t)config->fps_mode_id);
             if (config->depth_delay_off_color_usec < -fps || config->depth_delay_off_color_usec > fps)
             {
                 result = K4A_RESULT_FAILED;

diff --git a/tests/ColorTests/FunctionalTest/color_ft.cpp b/tests/ColorTests/FunctionalTest/color_ft.cpp
@@ -754,7 +754,7 @@ int32_t color_control_test::map_manual_exposure(int32_t value, bool sixty_hertz)
 // Limit exposure setting based on FPS setting.
 int32_t color_control_test::limit_exposure_to_fps_setting(int32_t value, bool sixty_hertz, k4a_fps_t fps)
 {
-    int fps_usec = HZ_TO_PERIOD_US(k4a_convert_fps_to_uint(fps));
+    int fps_usec = HZ_TO_PERIOD_US((uint32_t)fps);
     int last_exposure;
 
     if (value < fps_usec)

diff --git a/tests/RecordTests/UnitTest/playback_ut.cpp b/tests/RecordTests/UnitTest/playback_ut.cpp
@@ -91,7 +91,7 @@ TEST_F(playback_ut, open_large_file)
     k4a_capture_t capture = NULL;
     k4a_stream_result_t stream_result = K4A_STREAM_RESULT_FAILED;
     uint64_t timestamps[3] = { 0, 1000, 1000 };
-    uint64_t timestamp_delta = HZ_TO_PERIOD_US(k4a_convert_fps_to_uint((k4a_fps_t)config.fps_mode_info.mode_id));
+    uint64_t timestamp_delta = HZ_TO_PERIOD_US(config.fps_mode_info.mode_id);
     size_t i = 0;
     for (; i < 50; i++)
     {
@@ -176,7 +176,7 @@ TEST_F(playback_ut, open_delay_offset_file)
     k4a_capture_t capture = NULL;
     k4a_stream_result_t stream_result = K4A_STREAM_RESULT_FAILED;
     uint64_t timestamps[3] = { 0, 10000, 10000 };
-    uint64_t timestamp_delta = HZ_TO_PERIOD_US(k4a_convert_fps_to_uint((k4a_fps_t)config.fps_mode_info.mode_id));
+    uint64_t timestamp_delta = HZ_TO_PERIOD_US(config.fps_mode_info.mode_id);
 
     // Read forward
     for (size_t i = 0; i < test_frame_count; i++)
@@ -283,7 +283,7 @@ TEST_F(playback_ut, playback_seek_test)
     k4a_capture_t capture = NULL;
     k4a_stream_result_t stream_result = K4A_STREAM_RESULT_FAILED;
     uint64_t timestamps[3] = { 0, 1000, 1000 };
-    uint64_t timestamp_delta = HZ_TO_PERIOD_US(k4a_convert_fps_to_uint((k4a_fps_t)config.fps_mode_info.mode_id));
+    uint64_t timestamp_delta = HZ_TO_PERIOD_US(config.fps_mode_info.mode_id);
 
     k4a_imu_sample_t imu_sample = { 0 };
     uint64_t imu_timestamp = 1150;
@@ -551,7 +551,7 @@ TEST_F(playback_ut, open_skipped_frames_file)
     k4a_capture_t capture = NULL;
     k4a_stream_result_t stream_result = K4A_STREAM_RESULT_FAILED;
     uint64_t timestamps[3] = { 1000000, 1001000, 1001000 };
-    uint64_t timestamp_delta = HZ_TO_PERIOD_US(k4a_convert_fps_to_uint((k4a_fps_t)config.fps_mode_info.mode_id));
+    uint64_t timestamp_delta = HZ_TO_PERIOD_US(config.fps_mode_info.mode_id);
 
     // Test initial state
     stream_result = k4a_playback_get_previous_capture(handle, &capture);
@@ -843,7 +843,7 @@ TEST_F(playback_ut, open_start_offset_file)
     k4a_stream_result_t stream_result = K4A_STREAM_RESULT_FAILED;
     uint64_t timestamps[3] = { 1000000, 1000000, 1000000 };
     uint64_t imu_timestamp = 1001150;
-    uint64_t timestamp_delta = HZ_TO_PERIOD_US(k4a_convert_fps_to_uint((k4a_fps_t)config.fps_mode_info.mode_id));
+    uint64_t timestamp_delta = HZ_TO_PERIOD_US(config.fps_mode_info.mode_id);
     uint64_t last_timestamp = k4a_playback_get_recording_length_usec(handle) +
                               (uint64_t)config.start_timestamp_offset_usec;
     ASSERT_EQ(last_timestamp, (uint64_t)config.start_timestamp_offset_usec + 3333150);

diff --git a/tests/RecordTests/UnitTest/sample_recordings.cpp b/tests/RecordTests/UnitTest/sample_recordings.cpp
@@ -64,7 +64,7 @@ void SampleRecordings::SetUp()
 
         uint64_t timestamps[3] = { 0, 1000, 1000 }; // Offset the Depth and IR tracks by 1ms to test
         uint64_t imu_timestamp = 1150;
-        uint32_t timestamp_delta = HZ_TO_PERIOD_US(k4a_convert_fps_to_uint((k4a_fps_t)record_config_full.fps_mode_id));
+        uint32_t timestamp_delta = HZ_TO_PERIOD_US((uint32_t)record_config_full.fps_mode_id);
         k4a_capture_t capture = NULL;
         for (size_t i = 0; i < test_frame_count; i++)
         {
@@ -107,7 +107,7 @@ void SampleRecordings::SetUp()
         uint64_t timestamps[3] = { 0,
                                    (uint64_t)record_config_delay.depth_delay_off_color_usec,
                                    (uint64_t)record_config_delay.depth_delay_off_color_usec };
-        uint32_t timestamp_delta = HZ_TO_PERIOD_US(k4a_convert_fps_to_uint((k4a_fps_t)record_config_delay.fps_mode_id));
+        uint32_t timestamp_delta = HZ_TO_PERIOD_US((uint32_t)record_config_delay.fps_mode_id);
         k4a_capture_t capture = NULL;
         for (size_t i = 0; i < test_frame_count; i++)
         {
@@ -168,7 +168,7 @@ void SampleRecordings::SetUp()
         }
 
         uint64_t timestamps[3] = { 1000000, 1001000, 1001000 }; // Start recording at 1s
-        uint32_t timestamp_delta = HZ_TO_PERIOD_US(k4a_convert_fps_to_uint((k4a_fps_t)record_config_full.fps_mode_id));
+        uint32_t timestamp_delta = HZ_TO_PERIOD_US((uint32_t)record_config_full.fps_mode_id);
         for (size_t i = 0; i < test_frame_count; i++)
         {
             // Create a known pattern of dropped / missing frames that can be tested against
@@ -234,7 +234,7 @@ void SampleRecordings::SetUp()
 
         uint64_t timestamps[3] = { 1000000, 1000000, 1000000 };
         uint64_t imu_timestamp = 1001150;
-        uint32_t timestamp_delta = HZ_TO_PERIOD_US(k4a_convert_fps_to_uint((k4a_fps_t)record_config_delay.fps_mode_id));
+        uint32_t timestamp_delta = HZ_TO_PERIOD_US((uint32_t)record_config_delay.fps_mode_id);
         k4a_capture_t capture = NULL;
         for (size_t i = 0; i < test_frame_count; i++)
         {

diff --git a/tests/RecordTests/UnitTest/test_helpers.h b/tests/RecordTests/UnitTest/test_helpers.h
@@ -20,7 +20,8 @@ static const char *const resolution_names[] = { "K4A_COLOR_RESOLUTION_OFF",   "K
 static const char *const depth_names[] = { "K4A_DEPTH_MODE_OFF",           "K4A_DEPTH_MODE_NFOV_2X2BINNED",
                                            "K4A_DEPTH_MODE_NFOV_UNBINNED", "K4A_DEPTH_MODE_WFOV_2X2BINNED",
                                            "K4A_DEPTH_MODE_WFOV_UNBINNED", "K4A_DEPTH_MODE_PASSIVE_IR" };
-static const char *const fps_names[] = { "K4A_FRAMES_PER_SECOND_5",
+static const char *const fps_names[] = { "K4A_FRAMES_PER_SECOND_0",
+                                         "K4A_FRAMES_PER_SECOND_5",
                                          "K4A_FRAMES_PER_SECOND_15",
                                          "K4A_FRAMES_PER_SECOND_30" };
 
@@ -35,6 +36,7 @@ k4a_capture_t create_test_capture(uint64_t timestamp_us[3],
                                   k4a_image_format_t color_format,
                                   uint32_t color_mode_id,
                                   uint32_t depth_mode_id);
+
 bool validate_test_capture(k4a_capture_t capture,
                            uint64_t timestamp_us[3],
                            k4a_image_format_t color_format,

diff --git a/tests/latency/latency_perf.cpp b/tests/latency/latency_perf.cpp
@@ -737,7 +737,7 @@ TEST_P(latency_perf, testTest)
                      disable_synchronization ? disable_synchronization : "0",
                      get_string_from_color_format(as.color_format),
                      get_string_from_color_resolution(as.color_resolution),
-                     k4a_convert_fps_to_uint(as.fps),
+                     (uint32_t)as.fps,
                      get_string_from_depth_mode(as.depth_mode),
                      g_capture_count,
                      g_manual_exposure,