Use dynamic FEC (#69)

vertexodessa · web-flow · commit 46c19d9e9e7a · 2025-05-19T23:29:41.000+02:00
diff --git a/app/src/main/java/com/openipc/pixelpilot/VideoActivity.java b/app/src/main/java/com/openipc/pixelpilot/VideoActivity.java
@@ -717,6 +717,24 @@ private void setupAdaptiveLinkSubMenu(PopupMenu popup) {
                 return true;
             });
         }
+
+        // Adaptive use FEC submenu
+        boolean fecEnabled = prefs.getBoolean("custom_fec_enabled", true);
+
+        MenuItem fecEnable = adaptiveMenu.add("FEC");
+        fecEnable.setCheckable(true);
+        fecEnable.setChecked(fecEnabled);
+        fecEnable.setOnMenuItemClickListener(item -> {
+            boolean newState = !item.isChecked();
+            item.setChecked(newState);
+            SharedPreferences.Editor editor = getSharedPreferences("general", MODE_PRIVATE).edit();
+            editor.putBoolean("custom_fec_enabled", newState);
+            editor.apply();
+            // Call instance method on the WfbNgLink instance via the wfbLinkManager.
+            wfbLink.nativeSetUseFec(newState ? 1 : 0);
+            return true;
+        });
+
     }
 
     void initDefaultOptions(){
diff --git a/app/wfbngrtl8812/src/main/cpp/WfbngLink.cpp b/app/wfbngrtl8812/src/main/cpp/WfbngLink.cpp
@@ -33,6 +33,8 @@
 #undef TAG
 #define TAG "pixelpilot"
 
+#define CRASH() do{ int* i=0; *i = 42; }while(0)
+
 std::string generate_random_string(size_t length) {
     const std::string characters = "abcdefghijklmnopqrstuvwxyz";
     std::random_device rd;
@@ -266,10 +268,16 @@ int WfbngLink::run(JNIEnv *env, jobject context, jint wifiChannel, jint bw, jint
 }
 
 void WfbngLink::stop(JNIEnv *env, jobject context, jint fd) {
-    if (rtl_devices.find(fd) == rtl_devices.end()) return;
+    if (rtl_devices.find(fd) == rtl_devices.end()) {
+        __android_log_print(ANDROID_LOG_ERROR, TAG, "rtl_devices.find(%d) == rtl_devices.end()", fd);
+        CRASH();
+        return;
+    }
     auto dev = rtl_devices.at(fd).get();
     if (dev) {
         dev->should_stop = true;
+    } else {
+        __android_log_print(ANDROID_LOG_ERROR, TAG, "rtl_devices.at(%d) is nullptr", fd);
     }
     stop_adaptive_link();
 }
@@ -384,6 +392,76 @@ extern "C" JNIEXPORT void JNICALL Java_com_openipc_wfbngrtl8812_WfbNgLink_native
     native(wfbngLinkN)->initAgg();
 }
 
+
+class FecChangeController
+{
+public:
+    /// \brief Query the current (possibly decayed) fec_change value.
+    ///        Call this as often as you like; the class handles its own timing.
+    int value()
+    {
+        if (!mEnabled)
+            return 0;
+
+        std::lock_guard<std::mutex> lock(mx_);
+        decayLocked_();
+        return val_;
+    }
+
+    /// \brief Raise fec_change.  If newValue <= current, the call is ignored.
+    ///        A successful bump resets the 5-second “hold” timer.
+    void bump(int newValue)
+    {
+        std::lock_guard<std::mutex> lock(mx_);
+        if (newValue > val_) {
+            __android_log_print(ANDROID_LOG_ERROR, TAG, "bumping FEC: %d", newValue);
+
+            val_        = newValue;
+            lastChange_ = Clock::now();
+        }
+    }
+
+    void setEnabled(bool use){
+        mEnabled = use;
+    }
+
+private:
+    using Clock = std::chrono::steady_clock;
+    static constexpr std::chrono::seconds kTick{1};   // length of one hold/decay window
+
+    void decayLocked_()
+    {
+        if (val_ == 0) return;
+
+        auto now     = Clock::now();
+        auto elapsed = now - lastChange_;
+
+        // Still inside the mandatory 5-second hold?  Do nothing.
+        if (elapsed < kTick) return;
+
+        // How many *full* ticks have passed since lastChange_?
+        auto ticks = std::chrono::duration_cast<std::chrono::seconds>(elapsed).count() / kTick.count();
+        if (ticks == 0) return;   // safety net (shouldn’t hit)
+
+        int decayed = val_ - static_cast<int>(ticks);
+        if (decayed < 0) decayed = 0;
+
+        // Commit the decay and anchor lastChange_ on the most recent tick boundary
+        if (decayed != val_) {
+            val_        = decayed;
+            lastChange_ += kTick * ticks;
+        }
+    }
+
+    int                   val_        {0};
+    Clock::time_point     lastChange_ {Clock::now()};
+    std::mutex            mx_;
+    bool mEnabled = true;
+};
+
+
+FecChangeController fec;
+
 // Modified start_link_quality_thread: use adaptive_link_enabled and adaptive_tx_power
 void WfbngLink::start_link_quality_thread(int fd) {
     auto thread_func = [this, fd]() {
@@ -458,18 +536,34 @@ void WfbngLink::start_link_quality_thread(int fd) {
                     optional idr_request_code:  4 char unique code to request 1 keyframe (no need to send special extra
                    packets)
                  */
+
+                if (quality.lost_last_second > 2)
+                    fec.bump(5);
+                else {
+                    if(quality.recovered_last_second > 30)
+                        fec.bump(5);
+                    if (quality.recovered_last_second > 24)
+                        fec.bump(3);
+                    if (quality.recovered_last_second > 22)
+                        fec.bump(2);
+                    if (quality.recovered_last_second > 18)
+                        fec.bump(1);
+                    if (quality.recovered_last_second < 18)
+                        fec.bump(0);
+                }
+
                 snprintf(message + sizeof(len),
                          sizeof(message) - sizeof(len),
-                         "%ld:%d:%d:%d:%d:%d:%f:0:-1:0:%s\n",
+                         "%ld:%d:%d:%d:%d:%d:%f:0:-1:%d:%s\n",
                          static_cast<long>(currentEpoch),
                          quality.quality,
                          quality.quality,
                          quality.recovered_last_second,
                          quality.lost_last_second,
                          quality.quality,
                          quality.snr,
+                         fec.value(),
                          quality.idr_code.c_str());
-
                 len = strlen(message + sizeof(len));
                 len = htonl(len);
                 memcpy(message, &len, sizeof(len));
@@ -534,3 +628,10 @@ extern "C" JNIEXPORT void JNICALL Java_com_openipc_wfbngrtl8812_WfbNgLink_native
         }
     }
 }
+
+extern "C" JNIEXPORT void JNICALL Java_com_openipc_wfbngrtl8812_WfbNgLink_nativeSetUseFec(JNIEnv *env,
+                                                                                           jclass clazz,
+                                                                                          jlong wfbngLinkN,
+                                                                                          jint use) {
+    fec.setEnabled(use);
+}
diff --git a/app/wfbngrtl8812/src/main/java/com/openipc/wfbngrtl8812/WfbNgLink.java b/app/wfbngrtl8812/src/main/java/com/openipc/wfbngrtl8812/WfbNgLink.java
@@ -39,6 +39,7 @@ public class WfbNgLink implements WfbNGStatsChanged {
     public static native void nativeStartAdaptivelink(long nativeInstance);
     public static native void nativeSetAdaptiveLinkEnabled(long nativeInstance, boolean enabled);
     public static native void nativeSetTxPower(long nativeInstance, int power);
+    public static native void nativeSetUseFec(long nativeInstance, int use);
 
     public WfbNgLink(final AppCompatActivity parent) {
         this.context = parent;
@@ -70,6 +71,10 @@ public void nativeSetTxPower(int power) {
         nativeSetTxPower(nativeWfbngLink, power);
     }
 
+    public void nativeSetUseFec(int use) {
+        nativeSetUseFec(nativeWfbngLink, use);
+    }
+
     public synchronized void start(int wifiChannel, int bandWidth, UsbDevice usbDevice) {
         Log.d(TAG, "wfb-ng monitoring on " + usbDevice.getDeviceName() + " using wifi channel " + wifiChannel);
         UsbManager usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
