+#Receiver is operated by: Receiver Operator
+#Device: Receiver Device
+#Antenna: Receiver Antenna
+#Website: http://localhost +#""" + +# ==== Public receiver listings ==== +# You can publish your receiver on online receiver directories, like https://www.receiverbook.de +# You will receive a receiver key from the directory that will authenticate you as the operator of this receiver. +# Please note that you not share your receiver keys publicly since anyone that obtains your receiver key can take over +# your public listing. +# Your receiver keys should be placed into this array: +#receiver_keys = [] +# If you list your receiver on multiple sites, you can place all your keys into the array above, or you can append +# keys to the arraylike this: +# receiver_keys += ["my-receiver-key"] + +# If you're not sure, simply copy & paste the code you received from your listing site below this line: + +# ==== DSP/RX settings ==== +#fft_fps = 9 +#fft_size = 4096 # Should be power of 2 +#fft_voverlap_factor = ( +# 0.3 # If fft_voverlap_factor is above 0, multiple FFTs will be used for creating a line on the diagram. +#) + +#audio_compression = "adpcm" # valid values: "adpcm", "none" +#fft_compression = "adpcm" # valid values: "adpcm", "none" + +# Tau setting for WFM (broadcast FM) deemphasis\ +# Quote from wikipedia https://en.wikipedia.org/wiki/FM_broadcasting#Pre-emphasis_and_de-emphasis +# "In most of the world a 50 µs time constant is used. In the Americas and South Korea, 75 µs is used" +# Enable one of the following lines, depending on your location: +# wfm_deemphasis_tau = 75e-6 # for US and South Korea +#wfm_deemphasis_tau = 50e-6 # for the rest of the world + +#digimodes_fft_size = 2048 + +# enables lookup of DMR ids using the radioid api +#digital_voice_dmr_id_lookup = True + +""" +Note: if you experience audio underruns while CPU usage is 100%, you can: +- decrease `samp_rate`, +- set `fft_voverlap_factor` to 0, +- decrease `fft_fps` and `fft_size`, +- limit the number of users by decreasing `max_clients`. +""" + +# ==== I/Q sources ==== +# (Uncomment the appropriate by removing # characters at the beginning of the corresponding lines.) + +############################################################################### +# Is my SDR hardware supported? # +# Check here: https://github.com/jketterl/openwebrx/wiki/Supported-Hardware # +############################################################################### + +# Currently supported types of sdr receivers: +# "rtl_sdr", "rtl_sdr_soapy", "sdrplay", "hackrf", "airspy", "airspyhf", "fifi_sdr", +# "perseussdr", "lime_sdr", "pluto_sdr", "soapy_remote", "hpsdr", "uhd", +# "radioberry", "fcdpp", "rtl_tcp", "sddc", "runds" + +# For more details on specific types, please checkout the wiki: +# https://github.com/jketterl/openwebrx/wiki/Supported-Hardware#sdr-devices + +#sdrs = { +# "rtlsdr": { +# "name": "RTL-SDR USB Stick", +# "type": "rtl_sdr", +# "ppm": 0, +# # you can change this if you use an upconverter. formula is: +# # center_freq + lfo_offset = actual frequency on the sdr +# # "lfo_offset": 0, +# "profiles": { +# "70cm": { +# "name": "70cm Relais", +# "center_freq": 438800000, +# "rf_gain": 29, +# "samp_rate": 2400000, +# "start_freq": 439275000, +# "start_mod": "nfm", +# }, +# "2m": { +# "name": "2m komplett", +# "center_freq": 145000000, +# "rf_gain": 29, +# "samp_rate": 2048000, +# "start_freq": 145725000, +# "start_mod": "nfm", +# }, +# }, +# }, +# "airspy": { +# "name": "Airspy HF+", +# "type": "airspyhf", +# "ppm": 0, +# "rf_gain": "auto", +# "profiles": { +# "20m": { +# "name": "20m", +# "center_freq": 14150000, +# "samp_rate": 384000, +# "start_freq": 14070000, +# "start_mod": "usb", +# }, +# "30m": { +# "name": "30m", +# "center_freq": 10125000, +# "samp_rate": 192000, +# "start_freq": 10142000, +# "start_mod": "usb", +# }, +# "40m": { +# "name": "40m", +# "center_freq": 7100000, +# "samp_rate": 256000, +# "start_freq": 7070000, +# "start_mod": "lsb", +# }, +# "80m": { +# "name": "80m", +# "center_freq": 3650000, +# "samp_rate": 384000, +# "start_freq": 3570000, +# "start_mod": "lsb", +# }, +# "49m": { +# "name": "49m Broadcast", +# "center_freq": 6050000, +# "samp_rate": 384000, +# "start_freq": 6070000, +# "start_mod": "am", +# }, +# }, +# }, +# "sdrplay": { +# "name": "SDRPlay RSP2", +# "type": "sdrplay", +# "ppm": 0, +# "antenna": "Antenna A", +# "profiles": { +# "20m": { +# "name": "20m", +# "center_freq": 14150000, +# "rf_gain": 0, +# "samp_rate": 500000, +# "start_freq": 14070000, +# "start_mod": "usb", +# }, +# "30m": { +# "name": "30m", +# "center_freq": 10125000, +# "rf_gain": 0, +# "samp_rate": 250000, +# "start_freq": 10142000, +# "start_mod": "usb", +# }, +# "40m": { +# "name": "40m", +# "center_freq": 7100000, +# "rf_gain": 0, +# "samp_rate": 500000, +# "start_freq": 7070000, +# "start_mod": "lsb", +# }, +# "80m": { +# "name": "80m", +# "center_freq": 3650000, +# "rf_gain": 0, +# "samp_rate": 500000, +# "start_freq": 3570000, +# "start_mod": "lsb", +# }, +# "49m": { +# "name": "49m Broadcast", +# "center_freq": 6000000, +# "rf_gain": 0, +# "samp_rate": 500000, +# "start_freq": 6070000, +# "start_mod": "am", +# }, +# }, +# }, +#} + +# ==== Color themes ==== + +### google turbo colormap (see: https://ai.googleblog.com/2019/08/turbo-improved-rainbow-colormap-for.html) +#waterfall_scheme = "GoogleTurboWaterfall" + +### original theme by teejez: +#waterfall_scheme = "TeejeezWaterfall" + +### old theme by HA7ILM: +#waterfall_scheme = "Ha7ilmWaterfall" +##For the old colors, you might also want to set [fft_voverlap_factor] to 0. + +### custom waterfall schemes can be configured like this: +#waterfall_scheme = "CustomWaterfall" +#waterfall_colors = [0x0000FF, 0x00FF00, 0xFF0000] + +### Waterfall calibration +#waterfall_levels = {"min": -88, "max": -20} # in dB + +#waterfall_auto_levels = {"min": 3, "max": 10} +#waterfall_auto_min_range = 50 + +# Note: When the auto waterfall level button is clicked, the following happens: +# [waterfall_levels.min] = [current_min_power_level] - [waterfall_auto_levels["min"]] +# [waterfall_levels.max] = [current_max_power_level] + [waterfall_auto_levels["max"]] +# +# ___|__________________________________|____________________________________|__________________________________|___> signal power +# \_waterfall_auto_levels["min"]_/ |__ current_min_power_level | \_waterfall_auto_levels["max"]_/ +# current_max_power_level __| + +# This setting allows you to modify the precision of the frequency displays in OpenWebRX. +# Set this to exponent of 10 to select the most precise digit in Hz you'd like to see +# examples: +# a value of 2 selects 10^2 = 100Hz tuning precision (default): +#tuning_precision = 2 +# a value of 1 selects 10^1 = 10Hz tuning precision: +#tuning_precision = 1 + +# This setting tells the auto-squelch the offset to add to the current signal level to use as the new squelch level. +# Lowering this setting will give you a more sensitive squelch, but it may also cause unwanted squelch openings when +# using the auto squelch. +#squelch_auto_margin = 10 # in dB + +#google_maps_api_key = "" + +# how long should positions be visible on the map? +# they will start fading out after half of that +# in seconds; default: 2 hours +#map_position_retention_time = 2 * 60 * 60 + +# decoder queue configuration +# due to the nature of some operating modes (ft8, ft8, jt9, jt65, wspr and js8), the data is recorded for a given amount +# of time (6 seconds up to 2 minutes) and decoded at the end. this can lead to very high peak loads. +# to mitigate this, the recordings will be queued and processed in sequence. +# the number of workers will limit the total amount of work (one worker will losely occupy one cpu / thread) +#decoding_queue_workers = 2 +# the maximum queue length will cause decodes to be dumped if the workers cannot keep up +# if you are running background services, make sure this number is high enough to accept the task influx during peaks +# i.e. this should be higher than the number of decoding services running at the same time +#decoding_queue_length = 10 + +# wsjt decoding depth will allow more results, but will also consume more cpu +#wsjt_decoding_depth = 3 +# can also be set for each mode separately +# jt65 seems to be somewhat prone to erroneous decodes, this setting handles that to some extent +#wsjt_decoding_depths = {"jt65": 1} + +# FST4 can be transmitted in different intervals. This setting determines which intervals will be decoded. +# available values (in seconds): 15, 30, 60, 120, 300, 900, 1800 +#fst4_enabled_intervals = [15, 30] + +# FST4W can be transmitted in different intervals. This setting determines which intervals will be decoded. +# available values (in seconds): 120, 300, 900, 1800 +#fst4w_enabled_intervals = [120, 300] + +# Q65 allows many combinations of intervals and submodes. This setting determines which combinations will be decoded. +# Please use the mode letter followed by the decode interval in seconds to specify the combinations. For example: +#q65_enabled_combinations = ["A30", "E120", "C60"] + +# JS8 comes in different speeds: normal, slow, fast, turbo. This setting controls which ones are enabled. +#js8_enabled_profiles = ["normal", "slow"] +# JS8 decoding depth; higher value will get more results, but will also consume more cpu +#js8_decoding_depth = 3 + +# Enable background service for decoding digital data. You can find more information at: +# https://github.com/jketterl/openwebrx/wiki/Background-decoding +#services_enabled = False +#services_decoders = ["ft8", "ft4", "wspr", "packet"] + +# === aprs igate settings === +# If you want to share your APRS decodes with the aprs network, configure these settings accordingly. +# Make sure that you have set services_enabled to true and customize services_decoders to your needs. +#aprs_callsign = "N0CALL" +#aprs_igate_enabled = False +#aprs_igate_server = "euro.aprs2.net" +#aprs_igate_password = "" +# beacon uses the receiver_gps setting, so if you enable this, make sure the location is correct there +#aprs_igate_beacon = False + +# Uncomment the following to customize gateway beacon details reported to the aprs network +# Plese see Dire Wolf's documentation on PBEACON configuration for complete details: +# https://github.com/wb2osz/direwolf/raw/master/doc/User-Guide.pdf + +# Symbol in its two-character form as specified by the APRS spec at http://www.aprs.org/symbols/symbols-new.txt +# Default: Receive only IGate (do not send msgs back to RF) +# aprs_igate_symbol = "R&" + +# Custom comment about igate +# Default: OpenWebRX APRS gateway +# aprs_igate_comment = "OpenWebRX APRS gateway" + +# Antenna Height and Gain details +# Unspecified by default +# Antenna height above average terrain (HAAT) in meters +# aprs_igate_height = "5" +# Antenna gain in dBi +# aprs_igate_gain = "0" +# Antenna direction (N, NE, E, SE, S, SW, W, NW). Omnidirectional by default +# aprs_igate_dir = "NE" + +# === PSK Reporter settings === +# enable this if you want to upload all ft8, ft4 etc spots to pskreporter.info +# this also uses the receiver_gps setting from above, so make sure it contains a correct locator +#pskreporter_enabled = False +#pskreporter_callsign = "N0CALL" +# optional antenna information, uncomment to enable +#pskreporter_antenna_information = "Dipole" + +# === WSPRNet reporting settings +# enable this if you want to upload WSPR spots to wsprnet.ort +# in addition to these settings also make sure that receiver_gps contains your correct location +#wsprnet_enabled = False +#wsprnet_callsign = "N0CALL" diff --git a/openwebrx/csdr/__init__.py b/openwebrx/csdr/__init__.py new file mode 100644 index 0000000..32e2b09 --- /dev/null +++ b/openwebrx/csdr/__init__.py @@ -0,0 +1,837 @@ +""" +OpenWebRX csdr plugin: do the signal processing with csdr + + This file is part of OpenWebRX, + an open-source SDR receiver software with a web UI. + Copyright (c) 2013-2015 by Andras Retzler
+ ${breadcrumb}
+
+
+ ${breadcrumb}
+
+
\ No newline at end of file
diff --git a/openwebrx/htdocs/features.js b/openwebrx/htdocs/features.js
new file mode 100644
index 0000000..fef2817
--- /dev/null
+++ b/openwebrx/htdocs/features.js
@@ -0,0 +1,23 @@
+$(function(){
+ var converter = new showdown.Converter();
+ $.ajax('api/features').done(function(data){
+ var $table = $('table.features');
+ $.each(data, function(name, details) {
+ var requirements = $.map(details.requirements, function(r, name){
+ return 'OpenWebRX Feature Report
+| Feature | +Requirement | +Description | +Available | +
|---|
+
+
diff --git a/openwebrx/htdocs/index.html b/openwebrx/htdocs/index.html
new file mode 100644
index 0000000..e4ae6bd
--- /dev/null
+++ b/openwebrx/htdocs/index.html
@@ -0,0 +1,250 @@
+
+
+
+
+ 
+
+
+
+
+
+
+${photo_title}
+ ${photo_desc}
+
+ ${header}
+
+
+
+
+
diff --git a/openwebrx/htdocs/lib/AprsMarker.js b/openwebrx/htdocs/lib/AprsMarker.js
new file mode 100644
index 0000000..f6720c1
--- /dev/null
+++ b/openwebrx/htdocs/lib/AprsMarker.js
@@ -0,0 +1,91 @@
+function AprsMarker() {}
+
+AprsMarker.prototype = new google.maps.OverlayView();
+
+AprsMarker.prototype.draw = function() {
+ var div = this.div;
+ var overlay = this.overlay;
+ if (!div || !overlay) return;
+
+ if (this.symbol) {
+ var tableId = this.symbol.table === '/' ? 0 : 1;
+ div.style.background = 'url(aprs-symbols/aprs-symbols-24-' + tableId + '@2x.png)';
+ div.style['background-size'] = '384px 144px';
+ div.style['background-position-x'] = -(this.symbol.index % 16) * 24 + 'px';
+ div.style['background-position-y'] = -Math.floor(this.symbol.index / 16) * 24 + 'px';
+ }
+
+ if (this.course) {
+ if (this.course > 180) {
+ div.style.transform = 'scalex(-1) rotate(' + (270 - this.course) + 'deg)'
+ } else {
+ div.style.transform = 'rotate(' + (this.course - 90) + 'deg)';
+ }
+ } else {
+ div.style.transform = null;
+ }
+
+ if (this.symbol.table !== '/' && this.symbol.table !== '\\') {
+ overlay.style.display = 'block';
+ overlay.style['background-position-x'] = -(this.symbol.tableindex % 16) * 24 + 'px';
+ overlay.style['background-position-y'] = -Math.floor(this.symbol.tableindex / 16) * 24 + 'px';
+ } else {
+ overlay.style.display = 'none';
+ }
+
+ if (this.opacity) {
+ div.style.opacity = this.opacity;
+ } else {
+ div.style.opacity = null;
+ }
+
+ var point = this.getProjection().fromLatLngToDivPixel(this.position);
+
+ if (point) {
+ div.style.left = point.x - 12 + 'px';
+ div.style.top = point.y - 12 + 'px';
+ }
+};
+
+AprsMarker.prototype.setOptions = function(options) {
+ google.maps.OverlayView.prototype.setOptions.apply(this, arguments);
+ this.draw();
+};
+
+AprsMarker.prototype.onAdd = function() {
+ var div = this.div = document.createElement('div');
+
+ div.style.position = 'absolute';
+ div.style.cursor = 'pointer';
+ div.style.width = '24px';
+ div.style.height = '24px';
+
+ var overlay = this.overlay = document.createElement('div');
+ overlay.style.width = '24px';
+ overlay.style.height = '24px';
+ overlay.style.background = 'url(aprs-symbols/aprs-symbols-24-2@2x.png)';
+ overlay.style['background-size'] = '384px 144px';
+ overlay.style.display = 'none';
+
+ div.appendChild(overlay);
+
+ var self = this;
+ google.maps.event.addDomListener(div, "click", function(event) {
+ event.stopPropagation();
+ google.maps.event.trigger(self, "click", event);
+ });
+
+ var panes = this.getPanes();
+ panes.overlayImage.appendChild(div);
+};
+
+AprsMarker.prototype.remove = function() {
+ if (this.div) {
+ this.div.parentNode.removeChild(this.div);
+ this.div = null;
+ }
+};
+
+AprsMarker.prototype.getAnchorPoint = function() {
+ return new google.maps.Point(0, -12);
+};
diff --git a/openwebrx/htdocs/lib/AudioEngine.js b/openwebrx/htdocs/lib/AudioEngine.js
new file mode 100644
index 0000000..8a3df67
--- /dev/null
+++ b/openwebrx/htdocs/lib/AudioEngine.js
@@ -0,0 +1,447 @@
+// this controls if the new AudioWorklet API should be used if available.
+// the engine will still fall back to the ScriptProcessorNode if this is set to true but not available in the browser.
+var useAudioWorklets = true;
+
+function AudioEngine(maxBufferLength, audioReporter) {
+ this.audioReporter = audioReporter;
+ this.initStats();
+ this.resetStats();
+
+ this.onStartCallbacks = [];
+
+ this.started = false;
+ this.audioContext = this.buildAudioContext();
+ if (!this.audioContext) {
+ return;
+ }
+
+ var me = this;
+ this.audioContext.onstatechange = function() {
+ if (me.audioContext.state !== 'running') return;
+ me._start();
+ }
+
+ this.audioCodec = new ImaAdpcmCodec();
+ this.compression = 'none';
+
+ this.setupResampling();
+ this.resampler = new Interpolator(this.resamplingFactor);
+ this.hdResampler = new Interpolator(this.hdResamplingFactor);
+
+ this.maxBufferSize = maxBufferLength * this.getSampleRate();
+}
+
+AudioEngine.prototype.buildAudioContext = function() {
+ var ctxClass = window.AudioContext || window.webkitAudioContext;
+ if (!ctxClass) {
+ return;
+ }
+
+ // known good sample rates
+ var goodRates = [48000, 44100, 96000]
+
+ // let the browser chose the sample rate, if it is good, use it
+ var ctx = new ctxClass({latencyHint: 'playback'});
+ if (goodRates.indexOf(ctx.sampleRate) >= 0) {
+ return ctx;
+ }
+
+ // if that didn't work, try if any of the good rates work
+ if (goodRates.some(function(sr) {
+ try {
+ ctx = new ctxClass({sampleRate: sr, latencyHint: 'playback'});
+ return true;
+ } catch (e) {
+ return false;
+ }
+ }, this)) {
+ return ctx;
+ }
+
+ // fallback: let the browser decide
+ // this may cause playback problems down the line
+ return new ctxClass({latencyHint: 'playback'});
+}
+
+AudioEngine.prototype.resume = function(){
+ this.audioContext.resume();
+}
+
+AudioEngine.prototype._start = function() {
+ var me = this;
+
+ // if failed to find a valid resampling factor...
+ if (me.resamplingFactor === 0) {
+ return;
+ }
+
+ // been started before?
+ if (me.started) {
+ return;
+ }
+
+ // are we allowed to play audio?
+ if (!me.isAllowed()) {
+ return;
+ }
+ me.started = true;
+
+ var runCallbacks = function(workletType) {
+ var callbacks = me.onStartCallbacks;
+ me.onStartCallbacks = false;
+ callbacks.forEach(function(c) { c(workletType); });
+ };
+
+ me.gainNode = me.audioContext.createGain();
+ me.gainNode.connect(me.audioContext.destination);
+
+ if (useAudioWorklets && me.audioContext.audioWorklet) {
+ me.audioContext.audioWorklet.addModule('static/lib/AudioProcessor.js').then(function(){
+ me.audioNode = new AudioWorkletNode(me.audioContext, 'openwebrx-audio-processor', {
+ numberOfInputs: 0,
+ numberOfOutputs: 1,
+ outputChannelCount: [1],
+ processorOptions: {
+ maxBufferSize: me.maxBufferSize
+ }
+ });
+ me.audioNode.connect(me.gainNode);
+ me.audioNode.port.addEventListener('message', function(m){
+ var json = JSON.parse(m.data);
+ if (typeof(json.buffersize) !== 'undefined') {
+ me.audioReporter({
+ buffersize: json.buffersize
+ });
+ }
+ if (typeof(json.samplesProcessed) !== 'undefined') {
+ me.audioSamples.add(json.samplesProcessed);
+ }
+ });
+ me.audioNode.port.start();
+ runCallbacks('AudioWorklet');
+ });
+ } else {
+ me.audioBuffers = [];
+
+ if (!AudioBuffer.prototype.copyToChannel) { //Chrome 36 does not have it, Firefox does
+ AudioBuffer.prototype.copyToChannel = function (input, channel) //input is Float32Array
+ {
+ var cd = this.getChannelData(channel);
+ for (var i = 0; i < input.length; i++) cd[i] = input[i];
+ }
+ }
+
+ var bufferSize;
+ if (me.audioContext.sampleRate < 44100 * 2)
+ bufferSize = 4096;
+ else if (me.audioContext.sampleRate >= 44100 * 2 && me.audioContext.sampleRate < 44100 * 4)
+ bufferSize = 4096 * 2;
+ else if (me.audioContext.sampleRate > 44100 * 4)
+ bufferSize = 4096 * 4;
+
+
+ function audio_onprocess(e) {
+ var total = 0;
+ var out = new Float32Array(bufferSize);
+ while (me.audioBuffers.length) {
+ var b = me.audioBuffers.shift();
+ // not enough space to fit all data, so splice and put back in the queue
+ if (total + b.length > bufferSize) {
+ var spaceLeft = bufferSize - total;
+ var tokeep = b.subarray(0, spaceLeft);
+ out.set(tokeep, total);
+ var tobuffer = b.subarray(spaceLeft, b.length);
+ me.audioBuffers.unshift(tobuffer);
+ total += spaceLeft;
+ break;
+ } else {
+ out.set(b, total);
+ total += b.length;
+ }
+ }
+
+ e.outputBuffer.copyToChannel(out, 0);
+ me.audioSamples.add(total);
+
+ }
+
+ //on Chrome v36, createJavaScriptNode has been replaced by createScriptProcessor
+ var method = 'createScriptProcessor';
+ if (me.audioContext.createJavaScriptNode) {
+ method = 'createJavaScriptNode';
+ }
+ me.audioNode = me.audioContext[method](bufferSize, 0, 1);
+ me.audioNode.onaudioprocess = audio_onprocess;
+ me.audioNode.connect(me.gainNode);
+ runCallbacks('ScriptProcessorNode')
+ }
+
+ setInterval(me.reportStats.bind(me), 1000);
+};
+
+AudioEngine.prototype.onStart = function(callback) {
+ if (this.onStartCallbacks) {
+ this.onStartCallbacks.push(callback);
+ } else {
+ callback();
+ }
+};
+
+AudioEngine.prototype.isAllowed = function() {
+ return this.audioContext.state === 'running';
+};
+
+AudioEngine.prototype.reportStats = function() {
+ if (this.audioNode.port) {
+ this.audioNode.port.postMessage(JSON.stringify({cmd:'getStats'}));
+ } else {
+ this.audioReporter({
+ buffersize: this.getBuffersize()
+ });
+ }
+};
+
+AudioEngine.prototype.initStats = function() {
+ var me = this;
+ var buildReporter = function(key) {
+ return function(v){
+ var report = {};
+ report[key] = v;
+ me.audioReporter(report);
+ }
+
+ };
+
+ this.audioBytes = new Measurement();
+ this.audioBytes.report(10000, 1000, buildReporter('audioByteRate'));
+
+ this.audioSamples = new Measurement();
+ this.audioSamples.report(10000, 1000, buildReporter('audioRate'));
+};
+
+AudioEngine.prototype.resetStats = function() {
+ this.audioBytes.reset();
+ this.audioSamples.reset();
+};
+
+AudioEngine.prototype.setupResampling = function() { //both at the server and the client
+ var targetRate = this.audioContext.sampleRate;
+ var audio_params = this.findRate(8000, 12000);
+ if (!audio_params) {
+ this.resamplingFactor = 0;
+ this.outputRate = 0;
+ divlog('Your audio card sampling rate (' + targetRate + ') is not supported.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+ OpenWebRX client log
+
+ Author contact: Jakob Ketterl, DD5JFK |
+ OpenWebRX homepage
+
+ Support and information: Groups.io Mailinglist
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 0 dB
+
+
+
+
+
+ Please change your operating system default settings in order to fix this.', 1); + } else { + this.resamplingFactor = audio_params.resamplingFactor; + this.outputRate = audio_params.outputRate; + } + + var hd_audio_params = this.findRate(36000, 48000); + if (!hd_audio_params) { + this.hdResamplingFactor = 0; + this.hdOutputRate = 0; + divlog('Your audio card sampling rate (' + targetRate + ') is not supported for HD audio
Please change your operating system default settings in order to fix this.', 1); + } else { + this.hdResamplingFactor = hd_audio_params.resamplingFactor; + this.hdOutputRate = hd_audio_params.outputRate; + } +}; + +AudioEngine.prototype.findRate = function(low, high) { + var targetRate = this.audioContext.sampleRate; + var i = 1; + while (true) { + var audio_server_output_rate = Math.floor(targetRate / i); + if (audio_server_output_rate < low) { + return; + } else if (audio_server_output_rate >= low && audio_server_output_rate <= high) { + return { + resamplingFactor: i, + outputRate: audio_server_output_rate + } + } + i++; + }; +} + +AudioEngine.prototype.getOutputRate = function() { + return this.outputRate; +}; + +AudioEngine.prototype.getHdOutputRate = function() { + return this.hdOutputRate; +} + +AudioEngine.prototype.getSampleRate = function() { + return this.audioContext.sampleRate; +}; + +AudioEngine.prototype.processAudio = function(data, resampler) { + if (!this.audioNode) return; + this.audioBytes.add(data.byteLength); + var buffer; + if (this.compression === "adpcm") { + //resampling & ADPCM + buffer = this.audioCodec.decode(new Uint8Array(data)); + } else { + buffer = new Int16Array(data); + } + buffer = resampler.process(buffer); + if (this.audioNode.port) { + // AudioWorklets supported + this.audioNode.port.postMessage(buffer); + } else { + // silently drop excess samples + if (this.getBuffersize() + buffer.length <= this.maxBufferSize) { + this.audioBuffers.push(buffer); + } + } +} + +AudioEngine.prototype.pushAudio = function(data) { + this.processAudio(data, this.resampler); +}; + +AudioEngine.prototype.pushHdAudio = function(data) { + this.processAudio(data, this.hdResampler); +} + +AudioEngine.prototype.setCompression = function(compression) { + this.compression = compression; +}; + +AudioEngine.prototype.setVolume = function(volume) { + this.gainNode.gain.value = volume; +}; + +AudioEngine.prototype.getBuffersize = function() { + // only available when using ScriptProcessorNode + if (!this.audioBuffers) return 0; + return this.audioBuffers.map(function(b){ return b.length; }).reduce(function(a, b){ return a + b; }, 0); +}; + +function ImaAdpcmCodec() { + this.reset(); +} + +ImaAdpcmCodec.prototype.reset = function() { + this.stepIndex = 0; + this.predictor = 0; + this.step = 0; +}; + +ImaAdpcmCodec.imaIndexTable = [ -1, -1, -1, -1, 2, 4, 6, 8, -1, -1, -1, -1, 2, 4, 6, 8 ]; + +ImaAdpcmCodec.imaStepTable = [ + 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, + 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, + 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, + 130, 143, 157, 173, 190, 209, 230, 253, 279, 307, + 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, + 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, + 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, + 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899, + 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767 + ]; + +ImaAdpcmCodec.prototype.decode = function(data) { + var output = new Int16Array(data.length * 2); + for (var i = 0; i < data.length; i++) { + output[i * 2] = this.decodeNibble(data[i] & 0x0F); + output[i * 2 + 1] = this.decodeNibble((data[i] >> 4) & 0x0F); + } + return output; +}; + +ImaAdpcmCodec.prototype.decodeNibble = function(nibble) { + this.stepIndex += ImaAdpcmCodec.imaIndexTable[nibble]; + this.stepIndex = Math.min(Math.max(this.stepIndex, 0), 88); + + var diff = this.step >> 3; + if (nibble & 1) diff += this.step >> 2; + if (nibble & 2) diff += this.step >> 1; + if (nibble & 4) diff += this.step; + if (nibble & 8) diff = -diff; + + this.predictor += diff; + this.predictor = Math.min(Math.max(this.predictor, -32768), 32767); + + this.step = ImaAdpcmCodec.imaStepTable[this.stepIndex]; + + return this.predictor; +}; + +function Interpolator(factor) { + this.factor = factor; + this.lowpass = new Lowpass(factor) +} + +Interpolator.prototype.process = function(data) { + var output = new Float32Array(data.length * this.factor); + for (var i = 0; i < data.length; i++) { + output[i * this.factor] = (data[i] + 0.5) / 32768; + } + return this.lowpass.process(output); +}; + +function Lowpass(interpolation) { + this.interpolation = interpolation; + var transitionBandwidth = 0.05; + this.numtaps = Math.round(4 / transitionBandwidth); + if (this.numtaps % 2 == 0) this.numtaps += 1; + + var cutoff = 1 / interpolation; + this.coefficients = this.getCoefficients(cutoff / 2); + + this.delay = new Float32Array(this.numtaps); + for (var i = 0; i < this.numtaps; i++){ + this.delay[i] = 0; + } + this.delayIndex = 0; +} + +Lowpass.prototype.getCoefficients = function(cutoffRate) { + var middle = Math.floor(this.numtaps / 2); + // hamming window + var window_function = function(r){ + var rate = 0.5 + r / 2; + return 0.54 - 0.46 * Math.cos(2 * Math.PI * rate); + } + var output = []; + output[middle] = 2 * Math.PI * cutoffRate * window_function(0); + for (var i = 1; i <= middle; i++) { + output[middle - i] = output[middle + i] = (Math.sin(2 * Math.PI * cutoffRate * i) / i) * window_function(i / middle); + } + return this.normalizeCoefficients(output); +}; + +Lowpass.prototype.normalizeCoefficients = function(input) { + var sum = 0; + var output = []; + for (var i = 0; i < input.length; i++) { + sum += input[i]; + } + for (var i = 0; i < input.length; i++) { + output[i] = input[i] / sum; + } + return output; +}; + +Lowpass.prototype.process = function(input) { + output = new Float32Array(input.length); + for (var oi = 0; oi < input.length; oi++) { + this.delay[this.delayIndex] = input[oi]; + this.delayIndex = (this.delayIndex + 1) % this.numtaps; + + var acc = 0; + var index = this.delayIndex; + for (var i = 0; i < this.numtaps; ++i) { + var index = index != 0 ? index - 1 : this.numtaps - 1; + acc += this.delay[index] * this.coefficients[i]; + if (isNaN(acc)) debugger; + } + // gain by interpolation + output[oi] = this.interpolation * acc; + } + return output; +}; \ No newline at end of file diff --git a/openwebrx/htdocs/lib/AudioProcessor.js b/openwebrx/htdocs/lib/AudioProcessor.js new file mode 100644 index 0000000..a3e9abf --- /dev/null +++ b/openwebrx/htdocs/lib/AudioProcessor.js @@ -0,0 +1,61 @@ +class OwrxAudioProcessor extends AudioWorkletProcessor { + constructor(options){ + super(options); + // initialize ringbuffer, make sure it aligns with the expected buffer size of 128 + this.bufferSize = Math.round(options.processorOptions.maxBufferSize / 128) * 128; + this.audioBuffer = new Float32Array(this.bufferSize); + this.inPos = 0; + this.outPos = 0; + this.samplesProcessed = 0; + this.port.addEventListener('message', (m) => { + if (typeof(m.data) === 'string') { + const json = JSON.parse(m.data); + if (json.cmd && json.cmd === 'getStats') { + this.reportStats(); + } + } else { + // the ringbuffer size is aligned to the output buffer size, which means that the input buffers might + // need to wrap around the end of the ringbuffer, back to the start. + // it is better to have this processing here instead of in the time-critical process function. + if (this.inPos + m.data.length <= this.bufferSize) { + // we have enough space, so just copy data over. + this.audioBuffer.set(m.data, this.inPos); + } else { + // we don't have enough space, so we need to split the data. + const remaining = this.bufferSize - this.inPos; + this.audioBuffer.set(m.data.subarray(0, remaining), this.inPos); + this.audioBuffer.set(m.data.subarray(remaining)); + } + this.inPos = (this.inPos + m.data.length) % this.bufferSize; + } + }); + this.port.addEventListener('messageerror', console.error); + this.port.start(); + } + process(inputs, outputs) { + if (this.remaining() < 128) { + outputs[0].forEach(output => output.fill(0)); + return true; + } + outputs[0].forEach((output) => { + output.set(this.audioBuffer.subarray(this.outPos, this.outPos + 128)); + }); + this.outPos = (this.outPos + 128) % this.bufferSize; + this.samplesProcessed += 128; + return true; + } + remaining() { + const mod = (this.inPos - this.outPos) % this.bufferSize; + if (mod >= 0) return mod; + return mod + this.bufferSize; + } + reportStats() { + this.port.postMessage(JSON.stringify({ + buffersize: this.remaining(), + samplesProcessed: this.samplesProcessed + })); + this.samplesProcessed = 0; + } +} + +registerProcessor('openwebrx-audio-processor', OwrxAudioProcessor); \ No newline at end of file diff --git a/openwebrx/htdocs/lib/BookmarkBar.js b/openwebrx/htdocs/lib/BookmarkBar.js new file mode 100644 index 0000000..e0993a5 --- /dev/null +++ b/openwebrx/htdocs/lib/BookmarkBar.js @@ -0,0 +1,147 @@ +function BookmarkBar() { + var me = this; + me.localBookmarks = new BookmarkLocalStorage(); + me.$container = $("#openwebrx-bookmarks-container"); + me.bookmarks = {}; + + me.$container.on('click', '.bookmark', function(e){ + var $bookmark = $(e.target).closest('.bookmark'); + me.$container.find('.bookmark').removeClass('selected'); + var b = $bookmark.data(); + if (!b || !b.frequency || !b.modulation) return; + me.getDemodulator().set_offset_frequency(b.frequency - center_freq); + if (b.modulation) { + me.getDemodulatorPanel().setMode(b.modulation); + } + $bookmark.addClass('selected'); + }); + + me.$container.on('click', '.action[data-action=edit]', function(e){ + e.stopPropagation(); + var $bookmark = $(e.target).closest('.bookmark'); + me.showEditDialog($bookmark.data()); + }); + + me.$container.on('click', '.action[data-action=delete]', function(e){ + e.stopPropagation(); + var $bookmark = $(e.target).closest('.bookmark'); + me.localBookmarks.deleteBookmark($bookmark.data()); + me.loadLocalBookmarks(); + }); + + var $bookmarkButton = $('#openwebrx-panel-receiver').find('.openwebrx-bookmark-button'); + if (typeof(Storage) !== 'undefined') { + $bookmarkButton.show(); + } else { + $bookmarkButton.hide(); + } + $bookmarkButton.click(function(){ + me.showEditDialog(); + }); + + me.$dialog = $("#openwebrx-dialog-bookmark"); + me.$dialog.find('.openwebrx-button[data-action=cancel]').click(function(){ + me.$dialog.hide(); + }); + me.$dialog.find('.openwebrx-button[data-action=submit]').click(function(){ + me.storeBookmark(); + }); + me.$dialog.find('form').on('submit', function(e){ + e.preventDefault(); + me.storeBookmark(); + }); +} + +BookmarkBar.prototype.position = function(){ + var range = get_visible_freq_range(); + $('#openwebrx-bookmarks-container').find('.bookmark').each(function(){ + $(this).css('left', scale_px_from_freq($(this).data('frequency'), range)); + }); +}; + +BookmarkBar.prototype.loadLocalBookmarks = function(){ + var bwh = bandwidth / 2; + var start = center_freq - bwh; + var end = center_freq + bwh; + var bookmarks = this.localBookmarks.getBookmarks().filter(function(b){ + return b.frequency >= start && b.frequency <= end; + }); + this.replace_bookmarks(bookmarks, 'local', true); +}; + +BookmarkBar.prototype.replace_bookmarks = function(bookmarks, source, editable) { + editable = !!editable; + bookmarks = bookmarks.map(function(b){ + b.source = source; + b.editable = editable; + return b; + }); + this.bookmarks[source] = bookmarks; + this.render(); +}; + +BookmarkBar.prototype.render = function(){ + var bookmarks = Object.values(this.bookmarks).reduce(function(l, v){ return l.concat(v); }); + bookmarks = bookmarks.sort(function(a, b){ return a.frequency - b.frequency; }); + var elements = bookmarks.map(function(b){ + var $bookmark = $( + '
' +
+ '
'
+ );
+ $bookmark.data(b);
+ return $bookmark;
+ });
+ this.$container.find('.bookmark').remove();
+ this.$container.append(elements);
+ this.position();
+};
+
+BookmarkBar.prototype.showEditDialog = function(bookmark) {
+ if (!bookmark) {
+ bookmark = {
+ name: "",
+ frequency: center_freq + this.getDemodulator().get_offset_frequency(),
+ modulation: this.getDemodulator().get_secondary_demod() || this.getDemodulator().get_modulation()
+ }
+ }
+ this.$dialog.bookmarkDialog().setValues(bookmark);
+ this.$dialog.show();
+ this.$dialog.find('#name').focus();
+};
+
+BookmarkBar.prototype.storeBookmark = function() {
+ var me = this;
+ var bookmark = this.$dialog.bookmarkDialog().getValues();
+ if (!bookmark) return;
+ bookmark.frequency = Number(bookmark.frequency);
+
+ var bookmarks = me.localBookmarks.getBookmarks();
+
+ if (!bookmark.id) {
+ if (bookmarks.length) {
+ bookmark.id = 1 + Math.max.apply(Math, bookmarks.map(function(b){ return b.id || 0; }));
+ } else {
+ bookmark.id = 1;
+ }
+ }
+
+ bookmarks = bookmarks.filter(function(b) { return b.id !== bookmark.id; });
+ bookmarks.push(bookmark);
+
+ me.localBookmarks.setBookmarks(bookmarks);
+ me.loadLocalBookmarks();
+ me.$dialog.hide();
+};
+
+BookmarkBar.prototype.getDemodulatorPanel = function() {
+ return $('#openwebrx-panel-receiver').demodulatorPanel();
+};
+
+BookmarkBar.prototype.getDemodulator = function() {
+ return this.getDemodulatorPanel().getDemodulator();
+};
diff --git a/openwebrx/htdocs/lib/BookmarkDialog.js b/openwebrx/htdocs/lib/BookmarkDialog.js
new file mode 100644
index 0000000..4a0a184
--- /dev/null
+++ b/openwebrx/htdocs/lib/BookmarkDialog.js
@@ -0,0 +1,36 @@
+$.fn.bookmarkDialog = function() {
+ var $el = this;
+ return {
+ setModes: function(modes) {
+ $el.find('#modulation').html(modes.filter(function(m){
+ return m.isAvailable();
+ }).map(function(m) {
+ return '';
+ }).join(''));
+ return this;
+ },
+ setValues: function(bookmark) {
+ var $form = $el.find('form');
+ ['name', 'frequency', 'modulation'].forEach(function(key){
+ $form.find('#' + key).val(bookmark[key]);
+ });
+ $el.data('id', bookmark.id || false);
+ return this;
+ },
+ getValues: function() {
+ var bookmark = {};
+ var valid = true;
+ ['name', 'frequency', 'modulation'].forEach(function(key){
+ var $input = $el.find('#' + key);
+ valid = valid && $input[0].checkValidity();
+ bookmark[key] = $input.val();
+ });
+ if (!valid) {
+ $el.find("form :submit").click();
+ return;
+ }
+ bookmark.id = $el.data('id');
+ return bookmark;
+ }
+ }
+}
\ No newline at end of file
diff --git a/openwebrx/htdocs/lib/BookmarkLocalStorage.js b/openwebrx/htdocs/lib/BookmarkLocalStorage.js
new file mode 100644
index 0000000..edb4992
--- /dev/null
+++ b/openwebrx/htdocs/lib/BookmarkLocalStorage.js
@@ -0,0 +1,17 @@
+BookmarkLocalStorage = function(){
+};
+
+BookmarkLocalStorage.prototype.getBookmarks = function(){
+ return JSON.parse(window.localStorage.getItem("bookmarks")) || [];
+};
+
+BookmarkLocalStorage.prototype.setBookmarks = function(bookmarks){
+ window.localStorage.setItem("bookmarks", JSON.stringify(bookmarks));
+};
+
+BookmarkLocalStorage.prototype.deleteBookmark = function(data) {
+ if (data.id) data = data.id;
+ var bookmarks = this.getBookmarks();
+ bookmarks = bookmarks.filter(function(b) { return b.id !== data; });
+ this.setBookmarks(bookmarks);
+};
diff --git a/openwebrx/htdocs/lib/Demodulator.js b/openwebrx/htdocs/lib/Demodulator.js
new file mode 100644
index 0000000..352ebe1
--- /dev/null
+++ b/openwebrx/htdocs/lib/Demodulator.js
@@ -0,0 +1,362 @@
+function Filter(demodulator) {
+ this.demodulator = demodulator;
+ this.min_passband = 100;
+}
+
+Filter.prototype.getLimits = function() {
+ var max_bw;
+ if (['pocsag', 'packet'].indexOf(this.demodulator.get_secondary_demod()) >= 0) {
+ max_bw = 12500;
+ } else if (['dmr', 'dstar', 'nxdn', 'ysf', 'm17'].indexOf(this.demodulator.get_modulation()) >= 0) {
+ max_bw = 6250;
+ } else if (this.demodulator.get_modulation() === 'wfm') {
+ max_bw = 100000;
+ } else if (this.demodulator.get_modulation() === 'drm') {
+ max_bw = 50000;
+ } else {
+ max_bw = (audioEngine.getOutputRate() / 2) - 1;
+ }
+ return {
+ high: max_bw,
+ low: -max_bw
+ };
+};
+
+function Envelope(demodulator) {
+ this.demodulator = demodulator;
+ this.dragged_range = Demodulator.draggable_ranges.none;
+}
+
+Envelope.prototype.draw = function(visible_range){
+ this.visible_range = visible_range;
+ var line = center_freq + this.demodulator.offset_frequency;
+
+ // ____
+ // Draws a standard filter envelope like this: _/ \_
+ // Parameters are given in offset frequency (Hz).
+ // Envelope is drawn on the scale canvas.
+ // A "drag range" object is returned, containing information about the draggable areas of the envelope
+ // (beginning, ending and the line showing the offset frequency).
+ var env_bounding_line_w = 5; //
+ var env_att_w = 5; // _______ ___env_h2 in px ___|_____
+ var env_h1 = 17; // _/| \_ ___env_h1 in px _/ |_ \_
+ var env_h2 = 5; // |||env_att_line_w |_env_lineplus
+ var env_lineplus = 1; // ||env_bounding_line_w
+ var env_line_click_area = 6;
+ //range=get_visible_freq_range();
+ var from = center_freq + this.demodulator.offset_frequency + this.demodulator.low_cut;
+ var from_px = scale_px_from_freq(from, range);
+ var to = center_freq + this.demodulator.offset_frequency + this.demodulator.high_cut;
+ var to_px = scale_px_from_freq(to, range);
+ if (to_px < from_px) /* swap'em */ {
+ var temp_px = to_px;
+ to_px = from_px;
+ from_px = temp_px;
+ }
+
+ from_px -= (env_att_w + env_bounding_line_w);
+ to_px += (env_att_w + env_bounding_line_w);
+ // do drawing:
+ scale_ctx.lineWidth = 3;
+ var color = this.color || '#ffff00'; // yellow
+ scale_ctx.strokeStyle = color;
+ scale_ctx.fillStyle = color;
+ var drag_ranges = {envelope_on_screen: false, line_on_screen: false};
+ if (!(to_px < 0 || from_px > window.innerWidth)) // out of screen?
+ {
+ drag_ranges.beginning = {x1: from_px, x2: from_px + env_bounding_line_w + env_att_w};
+ drag_ranges.ending = {x1: to_px - env_bounding_line_w - env_att_w, x2: to_px};
+ drag_ranges.whole_envelope = {x1: from_px, x2: to_px};
+ drag_ranges.envelope_on_screen = true;
+ scale_ctx.beginPath();
+ scale_ctx.moveTo(from_px, env_h1);
+ scale_ctx.lineTo(from_px + env_bounding_line_w, env_h1);
+ scale_ctx.lineTo(from_px + env_bounding_line_w + env_att_w, env_h2);
+ scale_ctx.lineTo(to_px - env_bounding_line_w - env_att_w, env_h2);
+ scale_ctx.lineTo(to_px - env_bounding_line_w, env_h1);
+ scale_ctx.lineTo(to_px, env_h1);
+ scale_ctx.globalAlpha = 0.3;
+ scale_ctx.fill();
+ scale_ctx.globalAlpha = 1;
+ scale_ctx.stroke();
+ }
+ if (typeof line !== "undefined") // out of screen?
+ {
+ var line_px = scale_px_from_freq(line, range);
+ if (!(line_px < 0 || line_px > window.innerWidth)) {
+ drag_ranges.line = {x1: line_px - env_line_click_area / 2, x2: line_px + env_line_click_area / 2};
+ drag_ranges.line_on_screen = true;
+ scale_ctx.moveTo(line_px, env_h1 + env_lineplus);
+ scale_ctx.lineTo(line_px, env_h2 - env_lineplus);
+ scale_ctx.stroke();
+ }
+ }
+ this.drag_ranges = drag_ranges;
+};
+
+Envelope.prototype.drag_start = function(x, key_modifiers){
+ this.key_modifiers = key_modifiers;
+ this.dragged_range = this.where_clicked(x, this.drag_ranges, key_modifiers);
+ this.drag_origin = {
+ x: x,
+ low_cut: this.demodulator.low_cut,
+ high_cut: this.demodulator.high_cut,
+ offset_frequency: this.demodulator.offset_frequency
+ };
+ return this.dragged_range !== Demodulator.draggable_ranges.none;
+};
+
+Envelope.prototype.where_clicked = function(x, drag_ranges, key_modifiers) { // Check exactly what the user has clicked based on ranges returned by envelope_draw().
+ var in_range = function (x, range) {
+ return range.x1 <= x && range.x2 >= x;
+ };
+ var dr = Demodulator.draggable_ranges;
+
+ if (key_modifiers.shiftKey) {
+ //Check first: shift + center drag emulates BFO knob
+ if (drag_ranges.line_on_screen && in_range(x, drag_ranges.line)) return dr.bfo;
+ //Check second: shift + envelope drag emulates PBF knob
+ if (drag_ranges.envelope_on_screen && in_range(x, drag_ranges.whole_envelope)) return dr.pbs;
+ }
+ if (drag_ranges.envelope_on_screen) {
+ // For low and high cut:
+ if (in_range(x, drag_ranges.beginning)) return dr.beginning;
+ if (in_range(x, drag_ranges.ending)) return dr.ending;
+ // Last priority: having clicked anything else on the envelope, without holding the shift key
+ if (in_range(x, drag_ranges.whole_envelope)) return dr.anything_else;
+ }
+ return dr.none; //User doesn't drag the envelope for this demodulator
+};
+
+
+Envelope.prototype.drag_move = function(x) {
+ var dr = Demodulator.draggable_ranges;
+ var new_value;
+ if (this.dragged_range === dr.none) return false; // we return if user is not dragging (us) at all
+ var freq_change = Math.round(this.visible_range.hps * (x - this.drag_origin.x));
+
+ //dragging the line in the middle of the filter envelope while holding Shift does emulate
+ //the BFO knob on radio equipment: moving offset frequency, while passband remains unchanged
+ //Filter passband moves in the opposite direction than dragged, hence the minus below.
+ var minus = (this.dragged_range === dr.bfo) ? -1 : 1;
+ //dragging any other parts of the filter envelope while holding Shift does emulate the PBS knob
+ //(PassBand Shift) on radio equipment: PBS does move the whole passband without moving the offset
+ //frequency.
+ if (this.dragged_range === dr.beginning || this.dragged_range === dr.bfo || this.dragged_range === dr.pbs) {
+ //we don't let low_cut go beyond its limits
+ if ((new_value = this.drag_origin.low_cut + minus * freq_change) < this.demodulator.filter.getLimits().low) return true;
+ //nor the filter passband be too small
+ if (this.demodulator.high_cut - new_value < this.demodulator.filter.min_passband) return true;
+ //sanity check to prevent GNU Radio "firdes check failed: fa <= fb"
+ if (new_value >= this.demodulator.high_cut) return true;
+ this.demodulator.setLowCut(new_value);
+ }
+ if (this.dragged_range === dr.ending || this.dragged_range === dr.bfo || this.dragged_range === dr.pbs) {
+ //we don't let high_cut go beyond its limits
+ if ((new_value = this.drag_origin.high_cut + minus * freq_change) > this.demodulator.filter.getLimits().high) return true;
+ //nor the filter passband be too small
+ if (new_value - this.demodulator.low_cut < this.demodulator.filter.min_passband) return true;
+ //sanity check to prevent GNU Radio "firdes check failed: fa <= fb"
+ if (new_value <= this.demodulator.low_cut) return true;
+ this.demodulator.setHighCut(new_value);
+ }
+ if (this.dragged_range === dr.anything_else || this.dragged_range === dr.bfo) {
+ //when any other part of the envelope is dragged, the offset frequency is changed (whole passband also moves with it)
+ new_value = this.drag_origin.offset_frequency + freq_change;
+ if (new_value > bandwidth / 2 || new_value < -bandwidth / 2) return true; //we don't allow tuning above Nyquist frequency :-)
+ this.demodulator.set_offset_frequency(new_value);
+ }
+ //now do the actual modifications:
+ //mkenvelopes(this.visible_range);
+ //this.demodulator.set();
+ return true;
+};
+
+Envelope.prototype.drag_end = function(){
+ var to_return = this.dragged_range !== Demodulator.draggable_ranges.none; //this part is required for cliking anywhere on the scale to set offset
+ this.dragged_range = Demodulator.draggable_ranges.none;
+ return to_return;
+};
+
+
+//******* class Demodulator_default_analog *******
+// This can be used as a base for basic audio demodulators.
+// It already supports most basic modulations used for ham radio and commercial services: AM/FM/LSB/USB
+
+function Demodulator(offset_frequency, modulation) {
+ this.offset_frequency = offset_frequency;
+ this.envelope = new Envelope(this);
+ this.color = Demodulator.get_next_color();
+ this.modulation = modulation;
+ this.filter = new Filter(this);
+ this.squelch_level = -150;
+ this.dmr_filter = 3;
+ this.started = false;
+ this.state = {};
+ this.secondary_demod = false;
+ var mode = Modes.findByModulation(modulation);
+ if (mode) {
+ this.low_cut = mode.bandpass.low_cut;
+ this.high_cut = mode.bandpass.high_cut;
+ }
+ this.listeners = {
+ "frequencychange": [],
+ "squelchchange": []
+ };
+}
+
+//ranges on filter envelope that can be dragged:
+Demodulator.draggable_ranges = {
+ none: 0,
+ beginning: 1 /*from*/,
+ ending: 2 /*to*/,
+ anything_else: 3,
+ bfo: 4 /*line (while holding shift)*/,
+ pbs: 5
+}; //to which parameter these correspond in envelope_draw()
+
+Demodulator.color_index = 0;
+Demodulator.colors = ["#ffff00", "#00ff00", "#00ffff", "#058cff", "#ff9600", "#a1ff39", "#ff4e39", "#ff5dbd"];
+
+Demodulator.get_next_color = function() {
+ if (this.color_index >= this.colors.length) this.color_index = 0;
+ return (this.colors[this.color_index++]);
+}
+
+
+
+Demodulator.prototype.on = function(event, handler) {
+ this.listeners[event].push(handler);
+};
+
+Demodulator.prototype.emit = function(event, params) {
+ this.listeners[event].forEach(function(fn) {
+ fn(params);
+ });
+};
+
+Demodulator.prototype.set_offset_frequency = function(to_what) {
+ if (typeof(to_what) == 'undefined' || to_what > bandwidth / 2 || to_what < -bandwidth / 2) return;
+ to_what = Math.round(to_what);
+ if (this.offset_frequency === to_what) {
+ return;
+ }
+ this.offset_frequency = to_what;
+ this.set();
+ this.emit("frequencychange", to_what);
+ mkenvelopes(get_visible_freq_range());
+};
+
+Demodulator.prototype.get_offset_frequency = function() {
+ return this.offset_frequency;
+};
+
+Demodulator.prototype.get_modulation = function() {
+ return this.modulation;
+};
+
+Demodulator.prototype.start = function() {
+ this.started = true;
+ this.set();
+ ws.send(JSON.stringify({
+ "type": "dspcontrol",
+ "action": "start"
+ }));
+};
+
+// TODO check if this is actually used
+Demodulator.prototype.stop = function() {
+};
+
+Demodulator.prototype.send = function(params) {
+ ws.send(JSON.stringify({"type": "dspcontrol", "params": params}));
+}
+
+Demodulator.prototype.set = function () { //this function sends demodulator parameters to the server
+ if (!this.started) return;
+ var params = {
+ "low_cut": this.low_cut,
+ "high_cut": this.high_cut,
+ "offset_freq": this.offset_frequency,
+ "mod": this.modulation,
+ "dmr_filter": this.dmr_filter,
+ "squelch_level": this.squelch_level,
+ "secondary_mod": this.secondary_demod,
+ "secondary_offset_freq": this.secondary_offset_freq
+ };
+ var to_send = {};
+ for (var key in params) {
+ if (!(key in this.state) || params[key] !== this.state[key]) {
+ to_send[key] = params[key];
+ }
+ }
+ if (Object.keys(to_send).length > 0) {
+ this.send(to_send);
+ for (var key in to_send) {
+ this.state[key] = to_send[key];
+ }
+ }
+ mkenvelopes(get_visible_freq_range());
+};
+
+Demodulator.prototype.setSquelch = function(squelch) {
+ if (this.squelch_level == squelch) {
+ return;
+ }
+ this.squelch_level = squelch;
+ this.set();
+ this.emit("squelchchange", squelch);
+};
+
+Demodulator.prototype.getSquelch = function() {
+ return this.squelch_level;
+};
+
+Demodulator.prototype.setDmrFilter = function(dmr_filter) {
+ this.dmr_filter = dmr_filter;
+ this.set();
+};
+
+Demodulator.prototype.setBandpass = function(bandpass) {
+ this.bandpass = bandpass;
+ this.low_cut = bandpass.low_cut;
+ this.high_cut = bandpass.high_cut;
+ this.set();
+};
+
+Demodulator.prototype.setLowCut = function(low_cut) {
+ this.low_cut = low_cut;
+ this.set();
+};
+
+Demodulator.prototype.setHighCut = function(high_cut) {
+ this.high_cut = high_cut;
+ this.set();
+};
+
+Demodulator.prototype.getBandpass = function() {
+ return {
+ low_cut: this.low_cut,
+ high_cut: this.high_cut
+ };
+};
+
+Demodulator.prototype.set_secondary_demod = function(secondary_demod) {
+ if (this.secondary_demod === secondary_demod) {
+ return;
+ }
+ this.secondary_demod = secondary_demod;
+ this.set();
+};
+
+Demodulator.prototype.get_secondary_demod = function() {
+ return this.secondary_demod;
+};
+
+Demodulator.prototype.set_secondary_offset_freq = function(secondary_offset) {
+ if (this.secondary_offset_freq === secondary_offset) {
+ return;
+ }
+ this.secondary_offset_freq = secondary_offset;
+ this.set();
+};
diff --git a/openwebrx/htdocs/lib/DemodulatorPanel.js b/openwebrx/htdocs/lib/DemodulatorPanel.js
new file mode 100644
index 0000000..8c10ff3
--- /dev/null
+++ b/openwebrx/htdocs/lib/DemodulatorPanel.js
@@ -0,0 +1,370 @@
+function DemodulatorPanel(el) {
+ var self = this;
+ self.el = el;
+ self.demodulator = null;
+ self.mode = null;
+ self.squelchMargin = 10;
+ self.initialParams = {};
+
+ var displayEl = el.find('.webrx-actual-freq')
+ this.tuneableFrequencyDisplay = displayEl.tuneableFrequencyDisplay();
+ displayEl.on('frequencychange', function(event, freq) {
+ self.getDemodulator().set_offset_frequency(freq - self.center_freq);
+ });
+
+ this.mouseFrequencyDisplay = el.find('.webrx-mouse-freq').frequencyDisplay();
+
+ Modes.registerModePanel(this);
+ el.on('click', '.openwebrx-demodulator-button', function() {
+ var modulation = $(this).data('modulation');
+ if (modulation) {
+ self.setMode(modulation);
+ } else {
+ self.disableDigiMode();
+ }
+ });
+ el.on('change', '.openwebrx-secondary-demod-listbox', function() {
+ var value = $(this).val();
+ if (value === 'none') {
+ self.disableDigiMode();
+ } else {
+ self.setMode(value);
+ }
+ });
+ el.on('click', '.openwebrx-squelch-auto', function() {
+ if (!self.squelchAvailable()) return;
+ el.find('.openwebrx-squelch-slider').val(getLogSmeterValue(smeter_level) + self.getSquelchMargin());
+ self.updateSquelch();
+ });
+ el.on('change', '.openwebrx-squelch-slider', function() {
+ self.updateSquelch();
+ });
+ window.addEventListener('hashchange', function() {
+ self.onHashChange();
+ });
+};
+
+DemodulatorPanel.prototype.render = function() {
+ var available = Modes.getModes().filter(function(m){ return m.isAvailable(); });
+ var normalModes = available.filter(function(m){ return m.type === 'analog'; });
+ var digiModes = available.filter(function(m){ return m.type === 'digimode'; });
+
+ var html = []
+
+ var buttons = normalModes.map(function(m){
+ return $(
+ '' +
+ '' +
+ '' +
+ '
' +
+ '' + b.name + '
' +
+ '' + m.name + '
'
+ );
+ });
+
+ var $modegrid = $('');
+ $modegrid.append.apply($modegrid, buttons);
+ html.push($modegrid);
+
+ html.push($(
+ '' +
+ '' +
+ '' +
+ '
'
+ ));
+
+ this.el.find(".openwebrx-modes").html(html);
+};
+
+DemodulatorPanel.prototype.setMode = function(requestedModulation) {
+ var mode = Modes.findByModulation(requestedModulation);
+ if (!mode) {
+ return;
+ }
+ if (this.mode === mode) {
+ return;
+ }
+ if (!mode.isAvailable()) {
+ divlog('Modulation "' + mode.name + '" not supported. Please check requirements', true);
+ return;
+ }
+
+ if (mode.type === 'digimode') {
+ modulation = mode.underlying[0];
+ } else {
+ if (this.mode && this.mode.type === 'digimode' && this.mode.underlying.indexOf(requestedModulation) >= 0) {
+ // keep the mode, just switch underlying modulation
+ mode = this.mode;
+ modulation = requestedModulation;
+ } else {
+ modulation = mode.modulation;
+ }
+ }
+
+ var current = this.collectParams();
+ if (this.demodulator) {
+ current.offset_frequency = this.demodulator.get_offset_frequency();
+ current.squelch_level = this.demodulator.getSquelch();
+ }
+
+ this.stopDemodulator();
+ this.demodulator = new Demodulator(current.offset_frequency, modulation);
+ this.demodulator.setSquelch(current.squelch_level);
+
+ var self = this;
+ var updateFrequency = function(freq) {
+ self.tuneableFrequencyDisplay.setFrequency(self.center_freq + freq);
+ self.updateHash();
+ };
+ this.demodulator.on("frequencychange", updateFrequency);
+ updateFrequency(this.demodulator.get_offset_frequency());
+ var updateSquelch = function(squelch) {
+ self.el.find('.openwebrx-squelch-slider')
+ .val(squelch)
+ .attr('title', 'Squelch (' + squelch + ' dB)');
+ self.updateHash();
+ };
+ this.demodulator.on('squelchchange', updateSquelch);
+ updateSquelch(this.demodulator.getSquelch());
+
+ if (mode.type === 'digimode') {
+ this.demodulator.set_secondary_demod(mode.modulation);
+ if (mode.bandpass) {
+ this.demodulator.setBandpass(mode.bandpass);
+ }
+ } else {
+ this.demodulator.set_secondary_demod(false);
+ }
+
+ this.demodulator.start();
+ this.mode = mode;
+
+ this.updateButtons();
+ this.updatePanels();
+ this.updateHash();
+};
+
+DemodulatorPanel.prototype.disableDigiMode = function() {
+ // just a little trick to get out of the digimode
+ delete this.mode;
+ this.setMode(this.getDemodulator().get_modulation());
+};
+
+DemodulatorPanel.prototype.updatePanels = function() {
+ var modulation = this.getDemodulator().get_secondary_demod();
+ $('#openwebrx-panel-digimodes').attr('data-mode', modulation);
+ toggle_panel("openwebrx-panel-digimodes", !!modulation);
+ toggle_panel("openwebrx-panel-wsjt-message", ['ft8', 'wspr', 'jt65', 'jt9', 'ft4', 'fst4', 'fst4w', "q65"].indexOf(modulation) >= 0);
+ toggle_panel("openwebrx-panel-js8-message", modulation == "js8");
+ toggle_panel("openwebrx-panel-packet-message", modulation === "packet");
+ toggle_panel("openwebrx-panel-pocsag-message", modulation === "pocsag");
+
+ modulation = this.getDemodulator().get_modulation();
+ var showing = 'openwebrx-panel-metadata-' + modulation;
+ var metaPanels = $(".openwebrx-meta-panel");
+ metaPanels.each(function (_, p) {
+ toggle_panel(p.id, p.id === showing);
+ });
+ metaPanels.metaPanel().each(function() {
+ this.clear();
+ });
+};
+
+DemodulatorPanel.prototype.getDemodulator = function() {
+ return this.demodulator;
+};
+
+DemodulatorPanel.prototype.collectParams = function() {
+ var defaults = {
+ offset_frequency: 0,
+ squelch_level: -150,
+ mod: 'nfm'
+ }
+ return $.extend(new Object(), defaults, this.validateInitialParams(this.initialParams), this.transformHashParams(this.parseHash()));
+};
+
+DemodulatorPanel.prototype.startDemodulator = function() {
+ if (!Modes.initComplete() || !this.center_freq) return;
+ var params = this.collectParams();
+ this._apply(params);
+};
+
+DemodulatorPanel.prototype.stopDemodulator = function() {
+ if (!this.demodulator) {
+ return;
+ }
+ this.demodulator.stop();
+ this.demodulator = null;
+ this.mode = null;
+}
+
+DemodulatorPanel.prototype._apply = function(params) {
+ this.setMode(params.mod);
+ this.getDemodulator().set_offset_frequency(params.offset_frequency);
+ this.getDemodulator().setSquelch(params.squelch_level);
+ this.updateButtons();
+};
+
+DemodulatorPanel.prototype.setInitialParams = function(params) {
+ $.extend(this.initialParams, params);
+};
+
+DemodulatorPanel.prototype.resetInitialParams = function() {
+ this.initialParams = {};
+};
+
+DemodulatorPanel.prototype.onHashChange = function() {
+ this._apply(this.transformHashParams(this.parseHash()));
+};
+
+DemodulatorPanel.prototype.transformHashParams = function(params) {
+ var ret = {
+ mod: params.secondary_mod || params.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;
+};
+
+DemodulatorPanel.prototype.squelchAvailable = function () {
+ return this.mode && this.mode.squelch;
+}
+
+DemodulatorPanel.prototype.updateButtons = function() {
+ var $buttons = this.el.find(".openwebrx-demodulator-button");
+ $buttons.removeClass("highlighted").removeClass('same-mod');
+ var demod = this.getDemodulator()
+ if (!demod) return;
+ this.el.find('[data-modulation=' + demod.get_modulation() + ']').addClass("highlighted");
+ var secondary_demod = demod.get_secondary_demod()
+ if (secondary_demod) {
+ this.el.find(".openwebrx-button-dig").addClass("highlighted");
+ this.el.find('.openwebrx-secondary-demod-listbox').val(secondary_demod);
+ var mode = Modes.findByModulation(secondary_demod);
+ if (mode) {
+ var self = this;
+ mode.underlying.filter(function(m) {
+ return m !== demod.get_modulation();
+ }).forEach(function(m) {
+ self.el.find('[data-modulation=' + m + ']').addClass('same-mod')
+ });
+ }
+ } else {
+ this.el.find('.openwebrx-secondary-demod-listbox').val('none');
+ }
+ var squelch_disabled = !this.squelchAvailable();
+ this.el.find('.openwebrx-squelch-slider').prop('disabled', squelch_disabled);
+ this.el.find('.openwebrx-squelch-auto')[squelch_disabled ? 'addClass' : 'removeClass']('disabled');
+}
+
+DemodulatorPanel.prototype.setCenterFrequency = function(center_freq) {
+ var me = this;
+ if (me.centerFreqTimeout) {
+ clearTimeout(me.centerFreqTimeout);
+ me.centerFreqTimeout = false;
+ }
+ this.centerFreqTimeout = setTimeout(function() {
+ me.stopDemodulator();
+ me.center_freq = center_freq;
+ me.startDemodulator();
+ me.centerFreqTimeout = false;
+ }, 50);
+};
+
+DemodulatorPanel.prototype.parseHash = function() {
+ if (!window.location.hash) {
+ return {};
+ }
+ var params = window.location.hash.substring(1).split(",").map(function(x) {
+ var harr = x.split('=');
+ return [harr[0], harr.slice(1).join('=')];
+ }).reduce(function(params, p){
+ params[p[0]] = p[1];
+ return params;
+ }, {});
+
+ return this.validateHash(params);
+};
+
+DemodulatorPanel.prototype.validateHash = function(params) {
+ var self = this;
+ params = Object.keys(params).filter(function(key) {
+ if (key == 'freq' || key == 'mod' || key == 'secondary_mod' || key == 'sql') {
+ return params.freq && Math.abs(params.freq - self.center_freq) <= bandwidth / 2;
+ }
+ return true;
+ }).reduce(function(p, key) {
+ p[key] = params[key];
+ return p;
+ }, {});
+
+ if (params['freq']) {
+ params['offset_frequency'] = params['freq'] - self.center_freq;
+ delete params['freq'];
+ }
+
+ return params;
+};
+
+DemodulatorPanel.prototype.validateInitialParams = function(params) {
+ return Object.fromEntries(
+ Object.entries(params).filter(function(a) {
+ if (a[0] == "offset_frequency") {
+ return Math.abs(a[1]) <= bandwidth / 2;
+ }
+ return true;
+ })
+ );
+};
+
+DemodulatorPanel.prototype.updateHash = function() {
+ var demod = this.getDemodulator();
+ if (!demod) return;
+ var self = this;
+ window.location.hash = $.map({
+ freq: demod.get_offset_frequency() + self.center_freq,
+ mod: demod.get_modulation(),
+ secondary_mod: demod.get_secondary_demod(),
+ sql: demod.getSquelch(),
+ }, function(value, key){
+ if (typeof(value) === 'undefined' || value === false) return undefined;
+ return key + '=' + value;
+ }).filter(function(v) {
+ return !!v;
+ }).join(',');
+};
+
+DemodulatorPanel.prototype.updateSquelch = function() {
+ var sliderValue = parseInt(this.el.find(".openwebrx-squelch-slider").val());
+ var demod = this.getDemodulator();
+ if (demod) demod.setSquelch(sliderValue);
+};
+
+DemodulatorPanel.prototype.setSquelchMargin = function(margin) {
+ if (typeof(margin) === 'undefined' || this.squelchMargin == margin) return;
+ this.squelchMargin = margin;
+};
+
+DemodulatorPanel.prototype.getSquelchMargin = function() {
+ return this.squelchMargin;
+};
+
+DemodulatorPanel.prototype.setMouseFrequency = function(freq) {
+ this.mouseFrequencyDisplay.setFrequency(freq);
+};
+
+DemodulatorPanel.prototype.setTuningPrecision = function(precision) {
+ this.tuneableFrequencyDisplay.setTuningPrecision(precision);
+ this.mouseFrequencyDisplay.setTuningPrecision(precision);
+};
+
+$.fn.demodulatorPanel = function(){
+ if (!this.data('panel')) {
+ this.data('panel', new DemodulatorPanel(this));
+ };
+ return this.data('panel');
+};
\ No newline at end of file
diff --git a/openwebrx/htdocs/lib/FrequencyDisplay.js b/openwebrx/htdocs/lib/FrequencyDisplay.js
new file mode 100644
index 0000000..b24ebca
--- /dev/null
+++ b/openwebrx/htdocs/lib/FrequencyDisplay.js
@@ -0,0 +1,183 @@
+function FrequencyDisplay(element) {
+ this.suffixes = {
+ '': 0,
+ 'k': 3,
+ 'M': 6,
+ 'G': 9,
+ 'T': 12
+ };
+ this.element = $(element);
+ this.digits = [];
+ this.precision = 2;
+ this.setupElements();
+ this.setFrequency(0);
+}
+
+FrequencyDisplay.prototype.setupElements = function() {
+ this.displayContainer = $('');
+ this.digitContainer = $('');
+ this.unitContainer = $(' Hz');
+ this.displayContainer.html([this.digitContainer, this.unitContainer]);
+ this.element.html(this.displayContainer);
+};
+
+FrequencyDisplay.prototype.getSuffix = function() {
+ var me = this;
+ return Object.keys(me.suffixes).filter(function(key){
+ return me.suffixes[key] == me.exponent;
+ })[0] || "";
+};
+
+FrequencyDisplay.prototype.setFrequency = function(freq) {
+ this.frequency = freq;
+ if (this.frequency === 0 || Number.isNaN(this.frequency)) {
+ this.exponent = 0
+ } else {
+ this.exponent = Math.floor(Math.log10(this.frequency) / 3) * 3;
+ }
+
+ var digits = Math.max(0, this.exponent - this.precision);
+ var formatted = (freq / 10 ** this.exponent).toLocaleString(
+ undefined,
+ {maximumFractionDigits: digits, minimumFractionDigits: digits}
+ );
+ var children = this.digitContainer.children();
+ for (var i = 0; i < formatted.length; i++) {
+ if (!this.digits[i]) {
+ this.digits[i] = $('');
+ var before = children[i];
+ if (before) {
+ $(before).after(this.digits[i]);
+ } else {
+ this.digitContainer.append(this.digits[i]);
+ }
+ }
+ this.digits[i][(isNaN(formatted[i]) ? 'remove' : 'add') + 'Class']('digit');
+ this.digits[i].html(formatted[i]);
+ }
+ while (this.digits.length > formatted.length) {
+ this.digits.pop().remove();
+ }
+ this.unitContainer.text(' ' + this.getSuffix() + 'Hz');
+};
+
+FrequencyDisplay.prototype.setTuningPrecision = function(precision) {
+ if (typeof(precision) == 'undefined') return;
+ this.precision = precision;
+ this.setFrequency(this.frequency);
+};
+
+function TuneableFrequencyDisplay(element) {
+ FrequencyDisplay.call(this, element);
+ this.setupEvents();
+}
+
+TuneableFrequencyDisplay.prototype = new FrequencyDisplay();
+
+TuneableFrequencyDisplay.prototype.setupElements = function() {
+ FrequencyDisplay.prototype.setupElements.call(this);
+ this.input = $('');
+ this.suffixInput = $('