Fix DVR start/stop logic

src/core/dvr.c

@@ -19,14 +19,15 @@
 #include "util/system.h"
 
 bool dvr_is_recording = false;
+bool record_pending = false;
 
 static time_t dvr_recording_start = 0;
 static pthread_mutex_t dvr_mutex;
 
 ///////////////////////////////////////////////////////////////////
 //-1=error;
 // 0=idle,1=recording,2=stopped,3=No SD card,4=recorf file path error,
-// 5=SD card Full,6=Encoder error
+// 5=SD card Full,6=Encoder error,7=Open Record File Failed
 void dvr_update_status() {
     pthread_mutex_lock(&dvr_mutex);
     if (dvr_is_recording) {
@@ -39,7 +40,8 @@ void dvr_update_status() {
         if (ret != 1) {
             dvr_is_recording = false;
             system_script(REC_STOP);
-            sleep(2); // wait for record process
+            record_pending = false;
+            sleep(2);                         // wait for record process
         }
     }
     pthread_mutex_unlock(&dvr_mutex);
@@ -311,16 +313,11 @@ static void dvr_update_record_conf() {
 void dvr_cmd(osd_dvr_cmd_t cmd) {
     LOGI("dvr_cmd: sdcard=%d, recording=%d, cmd=%d", g_sdcard_enable, dvr_is_recording, cmd);
 
-    if (!g_sdcard_enable)
-        return;
-
-    pthread_mutex_lock(&dvr_mutex);
-
     bool start_rec = dvr_is_recording;
 
     switch (cmd) {
     case DVR_TOGGLE:
-        start_rec = !dvr_is_recording;
+        start_rec = !dvr_is_recording && !record_pending;
         break;
     case DVR_STOP:
         start_rec = false;
@@ -330,14 +327,26 @@ void dvr_cmd(osd_dvr_cmd_t cmd) {
         break;
     }
 
+    if (!g_sdcard_enable) {
+        record_pending = start_rec;
+        return;
+    }
+
+    pthread_mutex_lock(&dvr_mutex);
+
     if (start_rec) {
         if (!dvr_is_recording && !sdcard_is_full()) {
             dvr_update_record_conf();
-            dvr_is_recording = true;
-            usleep(100 * 1000);
-            system_script(REC_START);
-            dvr_recording_start = time(NULL);
-            sleep(2); // wait for record process
+            if (g_sdcard_ready) {
+                dvr_is_recording = true;
+                record_pending = false;
+                usleep(100 * 1000);
+                system_script(REC_START);
+                dvr_recording_start = time(NULL);
+                sleep(2); // wait for record process
+            } else {
+                record_pending = true;
+            }
         }
     } else {
         if (dvr_is_recording) {

src/core/dvr.h

@@ -16,6 +16,7 @@ typedef enum {
 } osd_dvr_cmd_t;
 
 extern bool dvr_is_recording;
+extern bool record_pending;
 
 void dvr_update_status();
 void dvr_select_audio_source(uint8_t audio_source);

src/core/elrs.c

@@ -349,10 +349,23 @@ void msp_process_packet() {
             if (g_app_state == APP_STATE_VIDEO) {
                 record_state = packet.payload[0] == 0 ? 1 : 2;
                 uint32_t delay = packet.payload[1] | (uint32_t)packet.payload[2] << 8;
-                if (delay == 0)
+                if (delay == 0) {
+                    record_time = 0;
                     dvr_cmd(record_state);
-                else
-                    record_time = time(NULL) + delay;
+                }
+                else {
+                    switch (record_state) {
+                    case DVR_STOP:
+                        if (!dvr_is_recording && !record_pending) {
+                            // discard "timer off" if dvr not already started
+                            record_time = 0;
+                            break;
+                        }
+                    // fall thru' if dvr started
+                    case DVR_START:
+                        record_time = time(NULL) + delay;
+                    }
+                }
             }
         } break;
         case MSP_GET_VRX_MODE:

src/core/osd.c

@@ -174,7 +174,7 @@ void osd_rec_show(bool bShow) {
         return;
     }
 
-    if (!g_sdcard_enable) {
+    if (!g_sdcard_enable || !g_sdcard_ready) {
         osd_resource_path(buf, "%s", is_fhd, noSdcard_bmp);
         lv_img_set_src(g_osd_hdzero.sd_rec[is_fhd], buf);
         lv_obj_clear_flag(g_osd_hdzero.sd_rec[is_fhd], LV_OBJ_FLAG_HIDDEN);

src/core/thread.c

@@ -49,24 +49,34 @@ static void detect_sdcard(void) {
     // repair is not currently executing.
     if (ok_to_execute) {
         g_sdcard_enable = sdcard_mounted();
+        if (!g_sdcard_enable)
+            g_sdcard_ready = false;
 
         // General Runtime behavior
         if (-1 == g_bootup_sdcard_state) {
+            g_sdcard_ready = true;
             if ((g_sdcard_enable && !sdcard_enable_last) || g_sdcard_det_req) {
                 sdcard_update_free_size();
                 g_sdcard_det_req = 0;
+                g_sdcard_ready = false;
             }
 
             // Only repair sd card when inserted
             if (sdcard_init_scan && g_sdcard_enable) {
                 if (sdcard_ready_cb) {
                     sdcard_ready_cb();
+                    g_sdcard_ready = false;
                 }
                 sdcard_init_scan = false;
             } else if (!g_sdcard_enable && sdcard_enable_last) {
+                g_sdcard_ready = false;
                 sdcard_init_scan = true;
             }
 
+            if (record_pending && g_sdcard_ready && !sdcard_is_full()) {
+                dvr_cmd(DVR_START);
+            }
+
             sdcard_enable_last = g_sdcard_enable;
         }
         // SDCard detected at bootup

src/ui/page_common.c

@@ -10,6 +10,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 bool g_sdcard_enable = false;
+bool g_sdcard_ready = false;
 bool g_sdcard_det_req = false;
 bool g_autoscan_exit = true;
 bool g_scanning = false;

src/ui/page_common.h

@@ -135,6 +135,7 @@ enum {
 typedef uint8_t lv_menu_builder_variant_t;
 
 extern bool g_sdcard_enable;
+extern bool g_sdcard_ready;
 extern bool g_sdcard_det_req;
 extern bool g_autoscan_exit;
 extern bool g_scanning;