correctly handle bookmarks with underlying mode in receiver

docker/scripts/install-dependencies-sdrplay.sh

@@ -38,7 +38,7 @@ case $ARCH in
     ;;
 esac
 
-wget --no-http-keep-alive https://www.sdrplay.com/software/$BINARY
+wget https://www.sdrplay.com/software/$BINARY
 sh $BINARY --noexec --target sdrplay
 patch --verbose -Np0 < /install-lib.$ARCH.patch
 

htdocs/lib/BookmarkBar.js

@@ -11,7 +11,7 @@ function BookmarkBar() {
         if (!b || !b.frequency || !b.modulation) return;
         me.getDemodulator().set_offset_frequency(b.frequency - center_freq);
         if (b.modulation) {
-            me.getDemodulatorPanel().setMode(b.modulation);
+            me.getDemodulatorPanel().setMode(b.modulation, b.underlying);
         }
         $bookmark.addClass('selected');
     });

htdocs/lib/DemodulatorPanel.js

@@ -18,7 +18,12 @@ function DemodulatorPanel(el) {
     el.on('click', '.openwebrx-demodulator-button', function() {
         var modulation = $(this).data('modulation');
         if (modulation) {
+            if (self.mode && self.mode.type === 'digimode' && self.mode.underlying.indexOf(modulation) >= 0) {
+                // keep the mode, just switch underlying modulation
+                self.setMode(self.mode.modulation, modulation)
+            } else {
                 self.setMode(modulation);
+            }
         } else {
             self.disableDigiMode();
         }
@@ -80,12 +85,13 @@ DemodulatorPanel.prototype.render = function() {
     this.el.find(".openwebrx-modes").html(html);
 };
 
-DemodulatorPanel.prototype.setMode = function(requestedModulation) {
+DemodulatorPanel.prototype.setMode = function(requestedModulation, underlyingModulation) {
     var mode = Modes.findByModulation(requestedModulation);
     if (!mode) {
         return;
     }
-    if (this.mode === mode) {
+
+    if (this.mode === mode && this.underlyingModulation === underlyingModulation) {
         return;
     }
     if (!mode.isAvailable()) {
@@ -93,17 +99,16 @@ DemodulatorPanel.prototype.setMode = function(requestedModulation) {
         return;
     }
 
+    var modulation;
     if (mode.type === 'digimode') {
-        modulation = mode.underlying[0];
+        if (underlyingModulation) {
+            modulation = underlyingModulation
         } else {
-        if (this.mode && this.mode.type === 'digimode' && this.mode.underlying.indexOf(requestedModulation) >= 0) {
+            modulation = mode.underlying[0];
-            // keep the mode, just switch underlying modulation
+        }
-            mode = this.mode;
-            modulation = requestedModulation;
     } else {
         modulation = mode.modulation;
     }
-    }
 
     var current = this.collectParams();
     if (this.demodulator) {
@@ -142,6 +147,7 @@ DemodulatorPanel.prototype.setMode = function(requestedModulation) {
 
     this.demodulator.start();
     this.mode = mode;
+    this.underlyingModulation = modulation;
 
     this.updateButtons();
     this.updatePanels();
@@ -149,8 +155,6 @@ DemodulatorPanel.prototype.setMode = function(requestedModulation) {
 };
 
 DemodulatorPanel.prototype.disableDigiMode = function() {
-    // just a little trick to get out of the digimode
-    delete this.mode;
     this.setMode(this.getDemodulator().get_modulation());
 };
 
@@ -203,7 +207,11 @@ DemodulatorPanel.prototype.stopDemodulator = function() {
 }
 
 DemodulatorPanel.prototype._apply = function(params) {
+    if (params.secondary_mod) {
+        this.setMode(params.secondary_mod, params.mod)
+    } else {
         this.setMode(params.mod);
+    }
     this.getDemodulator().set_offset_frequency(params.offset_frequency);
     this.getDemodulator().setSquelch(params.squelch_level);
     this.updateButtons();
@@ -223,8 +231,9 @@ DemodulatorPanel.prototype.onHashChange = function() {
 
 DemodulatorPanel.prototype.transformHashParams = function(params) {
     var ret = {
-        mod: params.secondary_mod || params.mod
+        mod: params.mod
     };
+    if (typeof(params.secondary_mod) !== 'undefined') ret.secondary_mod = params.secondary_mod;
     if (typeof(params.offset_frequency) !== 'undefined') ret.offset_frequency = params.offset_frequency;
     if (typeof(params.sql) !== 'undefined') ret.squelch_level = parseInt(params.sql);
     return ret;
@@ -329,7 +338,7 @@ DemodulatorPanel.prototype.updateHash = function() {
         freq: demod.get_offset_frequency() + self.center_freq,
         mod: demod.get_modulation(),
         secondary_mod: demod.get_secondary_demod(),
-        sql: demod.getSquelch(),
+        sql: demod.getSquelch()
     }, function(value, key){
         if (typeof(value) === 'undefined' || value === false) return undefined;
         return key + '=' + value;

htdocs/openwebrx.js

@@ -831,7 +831,8 @@ function on_ws_recv(evt) {
                             return {
                                 name: d['mode'].toUpperCase(),
                                 modulation: d['mode'],
-                                frequency: d['frequency']
+                                frequency: d['frequency'],
+                                underlying: d['underlying']
                             };
                         });
                         bookmarks.replace_bookmarks(as_bookmarks, 'dial_frequencies');

owrx/bands.py

@@ -1,4 +1,4 @@
-from owrx.modes import Modes
+from owrx.modes import Modes, DigitalMode
 from datetime import datetime, timezone
 import json
 import os
@@ -9,14 +9,14 @@ logger = logging.getLogger(__name__)
 
 
 class Band(object):
-    def __init__(self, dict):
+    def __init__(self, b_dict):
-        self.name = dict["name"]
+        self.name = b_dict["name"]
-        self.lower_bound = dict["lower_bound"]
+        self.lower_bound = b_dict["lower_bound"]
-        self.upper_bound = dict["upper_bound"]
+        self.upper_bound = b_dict["upper_bound"]
         self.frequencies = []
-        if "frequencies" in dict:
+        if "frequencies" in b_dict:
             availableModes = [mode.modulation for mode in Modes.getAvailableModes()]
-            for (mode, freqs) in dict["frequencies"].items():
+            for (mode, freqs) in b_dict["frequencies"].items():
                 if mode not in availableModes:
                     logger.info(
                         'Modulation "{mode}" is not available, bandplan bookmark will not be displayed'.format(
@@ -27,14 +27,30 @@ class Band(object):
                 if not isinstance(freqs, list):
                     freqs = [freqs]
                 for f in freqs:
-                    if not self.inBand(f):
+                    f_dict = {"frequency": f} if not isinstance(f, dict) else f
+                    f_dict["mode"] = mode
+
+                    if not self.inBand(f_dict["frequency"]):
                         logger.warning(
                             "Frequency for {mode} on {band} is not within band limits: {frequency}".format(
-                                mode=mode, frequency=f, band=self.name
+                                mode=mode, frequency=f_dict["frequency"], band=self.name
                             )
                         )
                         continue
-                    self.frequencies.append({"mode": mode, "frequency": f})
+
+                    if "underlying" in f_dict:
+                        m = Modes.findByModulation(mode)
+                        if not isinstance(m, DigitalMode):
+                            logger.warning("%s is not a digital mode, cannot be used with \"underlying\" config", mode)
+                            continue
+                        if f_dict["underlying"] not in m.underlying:
+                            logger.warning(
+                                "%s is not a valid underlying mode for %s; skipping",
+                                f_dict["underlying"],
+                                mode
+                            )
+
+                    self.frequencies.append(f_dict)
 
     def inBand(self, freq):
         return self.lower_bound <= freq <= self.upper_bound

owrx/modes.py

@@ -55,6 +55,13 @@ class DigitalMode(Mode):
     def get_modulation(self):
         return self.get_underlying_mode().get_modulation()
 
+    def for_underlying(self, underlying: str):
+        if underlying not in self.underlying:
+            raise ValueError("{} is not a valid underlying mode for {}".format(underlying, self.modulation))
+        return DigitalMode(
+            self.modulation, self.name, [underlying], self.bandpass, self.requirements, self.service, self.squelch
+        )
+
 
 class AudioChopperMode(DigitalMode, metaclass=ABCMeta):
     def __init__(self, modulation, name, bandpass=None, requirements=None):

owrx/service/__init__.py

@@ -123,13 +123,11 @@ class ServiceHandler(SdrSourceEventClient):
 
     def updateServices(self):
         def addService(dial, source):
-            mode = dial["mode"]
-            frequency = dial["frequency"]
             try:
-                service = self.setupService(mode, frequency, source)
+                service = self.setupService(dial, source)
                 self.services.append(service)
             except Exception:
-                logger.exception("Error setting up service %s on frequency %d", mode, frequency)
+                logger.exception("Error setting up service {mode} on frequency {frequency}".format(**dial))
 
         with self.lock:
             logger.debug("re-scheduling services due to sdr changes")
@@ -247,23 +245,26 @@ class ServiceHandler(SdrSourceEventClient):
             return None
         return best["groups"]
 
-    def setupService(self, mode, frequency, source):
+    def setupService(self, dial, source):
-        logger.debug("setting up service {0} on frequency {1}".format(mode, frequency))
+        logger.debug("setting up service {mode} on frequency {frequency}".format(**dial))
 
-        modeObject = Modes.findByModulation(mode)
+        modeObject = Modes.findByModulation(dial["mode"])
         if not isinstance(modeObject, DigitalMode):
-            logger.warning("mode is not a digimode: %s", mode)
+            logger.warning("mode is not a digimode: %s", dial["mode"])
             return None
 
+        if "underlying" in dial:
+            modeObject = modeObject.for_underlying(dial["underlying"])
+
         demod = self._getDemodulator(modeObject.get_modulation())
         secondaryDemod = self._getSecondaryDemodulator(modeObject.modulation)
         center_freq = source.getProps()["center_freq"]
         sampleRate = source.getProps()["samp_rate"]
         bandpass = modeObject.get_bandpass()
         if isinstance(secondaryDemod, DialFrequencyReceiver):
-            secondaryDemod.setDialFrequency(frequency)
+            secondaryDemod.setDialFrequency(dial["frequency"])
 
-        chain = ServiceDemodulatorChain(demod, secondaryDemod, sampleRate, frequency - center_freq)
+        chain = ServiceDemodulatorChain(demod, secondaryDemod, sampleRate, dial["frequency"] - center_freq)
         chain.setBandPass(bandpass.low_cut, bandpass.high_cut)
         chain.setReader(source.getBuffer().getReader())